Overview

Sample Code

Programming Guide

API Reference

Support

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 };
90 
91 namespace HPS
92 {
93 
94  // unimplemented
95 
96 
97 //Begin Info
99 class HPS_API Info
100 {
101 public:
102 
105  enum class Code
106  {
107  Unknown,
108  Exchange,
109  Publish,
110  Data,
111  Key,
112  Geometry,
113  Database,
114  Driver,
115  Internal,
116  Memory,
117  System,
118  Unsupported,
119  DX9DeviceReset,
120  DWG,
121  };
122 
123 private:
124  Info() {}
125 };
126 
127 
128 //Begin Info
130 class HPS_API Emergency
131 {
132 public:
133 
136  enum class Code
137  {
138  Unknown,
139  Fatal,
140  SoftMemoryLimit,
141  HardMemoryLimit,
142  };
143 
144 private:
145  Emergency() {}
146 };
147 
148 
149 //Begin Window
151 class HPS_API Window
152 {
153 public:
154 
159  enum class Driver
160  {
161  Default3D,
162  OpenGL,
163  OpenGL2,
164  DirectX9,
165  DirectX11,
166  };
167 
170  enum class UpdateStatus
171  {
172  InProgress,
173  Completed,
174  TimedOut,
175  Interrupted,
176  Failed
177  };
178 
181  enum class UpdateType
182  {
184  Default,
185 
190  Complete,
191 
193  Refresh,
194 
196  CompileOnly,
197 
201  Exhaustive,
202  };
203 
206  enum class Mobility
207  {
208  Locked,
209  Floating,
210  FixedRatio,
211  Free
212  };
213 
216  enum class FrameSize
217  {
218  Single,
219  Double
220  };
221 
224  enum class FrameOptions
225  {
226  Inset,
227  Overlay
228  };
229 
232  enum class ImageFormat
233  {
234  Default,
235  RGBA,
236  RGB,
237  Jpeg,
238  Png
239  };
240 
241 private:
242  Window() {}
243 };
244 
245 //Begin Subwindow
247 class HPS_API Subwindow
248 {
249 public:
250  enum class Background
251  {
252  SolidColor,
253  Image,
254  Cubemap,
255  Blend,
256  Transparent,
257  Interactive,
258 
259  GradientTopToBottom,
260  GradientBottomToTop,
261  GradientLeftToRight,
262  GradientRightToLeft,
263  GradientTopLeftToBottomRight,
264  GradientTopRightToBottomLeft,
265  GradientBottomLeftToTopRight,
266  GradientBottomRightToTopLeft,
267  };
268 
269  enum class Type
270  {
271  Standard,
272  Lightweight
273  };
274 
275  enum class Border
276  {
277  None,
278  Inset,
279  InsetBold,
280  Overlay,
281  OverlayBold
282  };
283 
284 
287  {
290  ZBuffer,
291 
297  HiddenLine,
298 
304  FastHiddenLine,
305 
318  Priority
319  };
320 
321 private:
322  Subwindow() {}
323 };
324 //End Subwindow
325 
327 class HPS_API Style
328 {
329 public:
330 
333  enum class Type
334  {
335  Segment,
336  Named
337  };
338 
341  enum class AppendMode
342  {
343  None,
344  And,
345  Or
346  };
347 
348 private:
349  Style() {}
350 };
351 
352 
354 class HPS_API Shell
355 {
356 public:
357 
360  enum class Component
361  {
362  Faces,
363  Edges,
364  Vertices
365  };
366 
367  /* \enum ToleranceUnits
368  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
369  enum class ToleranceUnits
370  {
371  ObjectSpace,
372  FeatureSizePercentage
373  };
374 
375  /* \enum HandednessOptimization
376  * Enumerates the shell optimization options with regards to handedness. */
378  {
379  None,
380  Fix,
381  Reverse
382  };
383 
384  /* \enum RelationResults
385  * Enumerates the results of a shell relation computation. */
386  enum class Relation
387  {
388  On,
389  Off,
390  In,
391  Out
392  };
393 
394  /* \enum RelationTest
395  * Enumerates the test options for a shell relation computation. */
396  enum class RelationTest
397  {
398  Simple,
399  Enclosure,
400  Distance
401  };
402 
403 private:
404  Shell() {}
405 };
406 
407 
409 class HPS_API Mesh
410 {
411 public:
412 
415  enum class Component
416  {
417  Faces,
418  Edges,
419  Vertices
420  };
421 
422 private:
423  Mesh() {}
424 };
425 
426 
428 class HPS_API InfiniteLine
429 {
430 public:
431 
434  enum class Type
435  {
436  Line,
437  Ray
438  };
439 
440 private:
441  InfiniteLine() {}
442 };
443 
444 
446 class HPS_API Trim
447 {
448 public:
449 
452  enum class Type
453  {
454  Line,
455  Curve
456  };
457 
461  enum class Operation
462  {
463  Keep,
464  Remove
465  };
466 
467 private:
468  Trim() {}
469 };
470 
471 
473 class HPS_API Spotlight
474 {
475 public:
476 
479  enum class OuterConeUnits
480  {
484  Degrees,
488  FieldRadius
489  };
490 
493  enum class InnerConeUnits
494  {
498  Degrees,
502  FieldRadius,
505  Percent
506  };
507 
508 private:
509  Spotlight() {}
510 };
511 
512 
514 class HPS_API Cylinder
515 {
516 public:
517 
520  enum class Component
521  {
522  Faces,
523  Edges,
524  };
525 
528  enum class Capping
529  {
530  None,
531  First,
532  Last,
533  Both
534  };
535 
538  enum class Orientation
539  {
540  Default,
541  DefaultRadii,
542  InvertRadii,
543  InvertRadiiOnly,
544  DefaultColors,
545  InvertColors,
546  InvertColorsOnly,
547  InvertAll
548  };
549 
550 private:
551  Cylinder() {}
552 };
553 
554 
556 class HPS_API Search
557 {
558 public:
559 
562  enum class Space
563  {
564  SegmentOnly,
565  Subsegments,
566  SubsegmentsAndIncludes
567  };
568 
571  enum class Behavior
572  {
573  Exhaustive,
574  FirstMatch
575  };
576 
579  enum class Type : uint32_t
580  {
581  None = 0x00000000,
582  Everything = 0x00ffffff,
583 
584  Include = 0x00000042,
585  Segment = 0x00000043,
586 
587  Includer = 0x00000100,
588 
589  // Geometry
590  Geometry = 0x10000000,
591 
592  CuttingSection = 0x10000026,
593  Shell = 0x10000028,
594  Mesh = 0x10000029,
595  Grid = 0x1000002a,
596  NURBSSurface = 0x1000002b,
597  Cylinder = 0x1000002d,
598  Sphere = 0x1000002e,
599  Polygon = 0x1000002f,
600  Circle = 0x10000030,
601  //unused = 0x10000031,
602  CircularWedge = 0x10000032,
603  Ellipse = 0x10000033,
604  Line = 0x10000034,
605  NURBSCurve = 0x10000037,
606  CircularArc = 0x10000038,
607  EllipticalArc = 0x10000039,
608  InfiniteLine = 0x1000003a,
609  //unused = 0x1000003b,
610  Marker = 0x1000003c,
611  Text = 0x1000003e,
612  Reference = 0x10000040,
613 
614  DistantLight = 0x10000100,
615  Spotlight = 0x10000101,
616  InfiniteRay = 0x10000102,
617 
618  // Attributes
619  Attribute = 0x20000000,
620 
621  Priority = 0x20000001,
622 
623  // Simple Attributes
624  Material = 0x2000000a,
625  Camera = 0x2000000e,
626  ModellingMatrix = 0x20000010,
627  UserData = 0x20000021,
628  TextureMatrix = 0x20000023,
629 
630  // Complex Attributes
631  Culling = 0x20001000,
632  CullingBackFace = 0x20001001,
633  CullingExtent = 0x20001002,
634  CullingVector = 0x20001003,
635  CullingVectorTolerance = 0x20001004,
636  CullingFrustum = 0x20001005,
637  CullingDeferralExtent = 0x20001006,
638 
639  CurveAttribute = 0x20002000,
640  CurveAttributeBudget = 0x20002001,
641  CurveAttributeContinuedBudget = 0x20002002,
642  CurveAttributeViewDependent = 0x20002003,
643  CurveAttributeMaximumDeviation = 0x20002004,
644  CurveAttributeMaximumAngle = 0x20002005,
645  CurveAttributeMaximumLength = 0x20002006,
646 
647  CylinderAttribute = 0x20003000,
648  CylinderAttributeTessellation = 0x20003001,
649  CylinderAttributeOrientation = 0x20003002,
650 
651  EdgeAttribute = 0x20004000,
652  EdgeAttributePattern = 0x20004015,
653  EdgeAttributeWeight = 0x20004016,
654  EdgeAttributeHardAngle = 0x20004017,
655 
656  LightingAttribute = 0x20005000,
657  LightingAttributeInterpolation = 0x20005001,
658 
659  LineAttribute = 0x20006000,
660  LineAttributePattern = 0x20006019,
661  LineAttributeWeight = 0x2000601a,
662 
663  MarkerAttribute = 0x20007000,
664  MarkerAttributeSize = 0x2000701b,
665  MarkerAttributeSymbol = 0x2000701c,
666 
667  SurfaceAttribute = 0x20008000,
668  SurfaceAttributeBudget = 0x20008001,
669  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
670  SurfaceAttributeMaximumFacetAngle = 0x20008003,
671  SurfaceAttributeMaximumFacetWidth = 0x20008004,
672  SurfaceAttributeTrimCurveBudget = 0x20008005,
673  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
674 
675  Selectability = 0x20009000,
676  SelectabilityWindows = 0x20009001,
677  SelectabilityEdges = 0x20009002,
678  SelectabilityFaces = 0x20009003,
679  SelectabilityLights = 0x20009004,
680  SelectabilityLines = 0x20009005,
681  SelectabilityMarkers = 0x20009006,
682  SelectabilityVertices = 0x20009007,
683  SelectabilityText = 0x20009008,
684 
685  SphereAttribute = 0x2000a000,
686  SphereAttributeTessellation = 0x2000a001,
687 
688  Subwindow = 0x2000b000,
689  SubwindowEitherType = 0x2000b001,
690  SubwindowStandard = 0x2000b00d,
691  SubwindowLightweight = 0x2000b002,
692  SubwindowBackground = 0x2000b003,
693  SubwindowBorder = 0x2000b004,
694  SubwindowRenderingAlgorithm = 0x2000b005,
695 
696  TextAttribute = 0x2000c000,
697  TextAttributeAlignment = 0x2000c01d,
698  TextAttributeBold = 0x2000c002,
699  TextAttributeItalic = 0x2000c003,
700  TextAttributeOverline = 0x2000c004,
701  TextAttributeStrikethrough = 0x2000c005,
702  TextAttributeUnderline = 0x2000c006,
703  TextAttributeSlant = 0x2000c007,
704  TextAttributeLineSpacing = 0x2000c008,
705  TextAttributeRotation = 0x2000c00a,
706  TextAttributeExtraSpace = 0x2000c00b,
707  TextAttributeGreeking = 0x2000c00c,
708  TextAttributeSizeTolerance = 0x2000c00d,
709  TextAttributeSize = 0x2000c00e,
710  TextAttributeFont = 0x2000c00f,
711  TextAttributeTransform = 0x2000c010,
712  TextAttributeRenderer = 0x2000c011,
713  TextAttributePreference = 0x2000c012,
714  TextAttributePath = 0x2000c01f,
715  TextAttributeSpacing = 0x2000c020,
716 
717  Transparency = 0x2000d000,
718  TransparencyMethod = 0x2000d001,
719  TransparencyAlgorithm = 0x2000d002,
720  TransparencyDepthPeelingLayers = 0x2000d004,
721  TransparencyDepthPeelingMinimumArea = 0x2000d005,
722  TransparencyDepthWriting = 0x2000d006,
723 
724  Visibility = 0x2000e000,
725  VisibilityCuttingSections = 0x2000e001,
726  VisibilityCutEdges = 0x2000e002,
727  VisibilityCutFaces = 0x2000e003,
728  VisibilityWindows = 0x2000e004,
729  VisibilityText = 0x2000e005,
730  VisibilityLines = 0x2000e006,
731  VisibilityEdgeLights = 0x2000e007,
732  VisibilityMarkerLights = 0x2000e008,
733  VisibilityFaceLights = 0x2000e009,
734  VisibilityGenericEdges = 0x2000e00a,
735  VisibilityHardEdges = 0x2000e00b,
736  VisibilityAdjacentEdges = 0x2000e00c,
737  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
738  VisibilityShadowEmitting = 0x2000e00e,
739  VisibilityShadowReceiving = 0x2000e00f,
740  VisibilityShadowCasting = 0x2000e010,
741  VisibilityMarkers = 0x2000e011,
742  VisibilityVertices = 0x2000e012,
743  VisibilityFaces = 0x2000e013,
744  VisibilityPerimeterEdges = 0x2000e014,
745  VisibilityNonCulledEdges = 0x2000e015,
746  VisibilityMeshQuadEdges = 0x2000e016,
747 
748  VisualEffects = 0x2000f000,
749  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
750  VisualEffectsAntiAliasing = 0x2000f002,
751  VisualEffectsShadowMaps = 0x2000f003,
752  VisualEffectsSimpleShadow = 0x2000f004,
753  VisualEffectsSimpleShadowPlane = 0x2000f005,
754  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
755  VisualEffectsSimpleShadowColor = 0x2000f007,
756  VisualEffectsSimpleReflection = 0x2000f008,
757  VisualEffectsSimpleReflectionPlane = 0x2000f009,
758  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
759 
760  Performance = 0x20010000,
761  PerformanceDisplayLists = 0x20010001,
762  PerformanceStaticModel = 0x20010002,
763  StaticModelSegment = 0x40000043,
764 
765  DrawingAttribute = 0x20011000,
766  DrawingAttributePolygonHandedness = 0x20011001,
767  DrawingAttributeDepthRange = 0x20011002,
768  DrawingAttributeFaceDisplacement = 0x20011003,
769  DrawingAttributeGeneralDisplacement = 0x20011004,
770  DrawingAttributeVertexDisplacement = 0x20011005,
771  DrawingAttributeOverlay = 0x20011006,
772  DrawingAttributeDeferral = 0x20011007,
773  DrawingAttributeClipRegion = 0x20011012,
774  DrawingAttributeWorldHandedness = 0x20011018,
775 
776  HiddenLineAttribute = 0x20012000,
777  HiddenLineAttributeColor = 0x20012001,
778  HiddenLineAttributeDimFactor = 0x20012002,
779  HiddenLineAttributeFaceDisplacement = 0x20012003,
780  HiddenLineAttributeLinePattern = 0x20012005,
781  HiddenLineAttributeRenderFaces = 0x20012006,
782  HiddenLineAttributeRenderText = 0x20012007,
783  HiddenLineAttributeAlgorithm = 0x20012008,
784  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
785  HiddenLineAttributeVisibility = 0x2001200a,
786  HiddenLineAttributeWeight = 0x2001200b,
787  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
788 
789  SegmentStyle = 0x20013001,
790  NamedStyle = 0x20013002,
791  MaterialPalette = 0x20013003,
792  Portfolio = 0x20013004,
793 
794  ContourLine = 0x20014000,
795  ContourLineVisibility = 0x20014001,
796  ContourLinePosition = 0x20014002,
797  ContourLineColor = 0x20014003,
798  ContourLinePattern = 0x20014004,
799  ContourLineWeight = 0x20014005,
800  ContourLineLighting = 0x20014006,
801 
802  Condition = 0x20015000,
803 
804  Bounding = 0x20016000,
805  BoundingVolume = 0x20016001,
806  BoundingExclusion = 0x20016002,
807 
808  AttributeLock = 0x20017000,
809  AttributeLockSetting = 0x20017001,
810  AttributeLockSubsegmentOverride = 0x20017002,
811 
812  TransformMask = 0x20018000,
813  TransformMaskCamera = 0x20018001,
814  TransformMaskCameraTranslation = 0x20018002,
815  TransformMaskCameraScale = 0x20018003,
816  TransformMaskCameraOffset = 0x20018004,
817  TransformMaskCameraRotation = 0x20018005,
818  TransformMaskCameraPerspectiveScale = 0x20018006,
819  TransformMaskCameraProjection = 0x20018007,
820  TransformMaskModellingMatrix = 0x20018008,
821  TransformMaskModellingMatrixTranslation = 0x20018009,
822  TransformMaskModellingMatrixScale = 0x20018010,
823  TransformMaskModellingMatrixOffset = 0x20018011,
824  TransformMaskModellingMatrixRotation = 0x20018012,
825 
826  ColorInterpolation = 0x20019000,
827  ColorInterpolationFaceColor = 0x20019001,
828  ColorInterpolationEdgeColor = 0x20019002,
829  ColorInterpolationMarkerColor = 0x20019003,
830  ColorInterpolationFaceIndex = 0x20019004,
831  ColorInterpolationEdgeIndex = 0x20019005,
832  ColorInterpolationMarkerIndex = 0x20019006,
833 
834  CuttingSectionAttribute = 0x2001a000,
835  CuttingSectionAttributeCuttingLevel = 0x2001a001,
836  CuttingSectionAttributeCappingLevel = 0x2001a002,
837  CuttingSectionAttributeMaterialPreference = 0x2001a003,
838 
839  };
840 
841 private:
842  Search() {}
843 };
844 
845 
847 class HPS_API Material
848 {
849 public:
850 
853  enum class Type
854  {
855  None = 0,
856  FullMaterial,
857  RGBColor,
858  RGBAColor,
859  MaterialIndex,
860  TextureName,
861  ModulatedTexture,
862  CubeMapName,
863  ModulatedCubeMap,
864  GlossValue,
865  DiffuseChannelAlpha
866  };
867 
870  enum class Channel
871  {
872  DiffuseColor = 1,
873  DiffuseTexture = 2,
874  Specular = 3,
875  Emission = 4,
876  Transmission = 5,
877  Mirror = 6,
878  Bump = 7,
879  EnvironmentTexture = 8,
880  EnvironmentCubeMap = 9,
881  Gloss = 10
882  };
883 
885  class HPS_API Color
886  {
887  public:
888 
891  enum class Channel
892  {
893  DiffuseColor = 1,
894  Specular = 3,
895  Emission = 4,
896  Mirror = 6
897  };
898 
899  private:
900  Color() {}
901  };
902 
904  class HPS_API Texture
905  {
906  public:
907 
910  enum class Channel
911  {
912  DiffuseTexture = 2,
913  Specular = 3,
914  Emission = 4,
915  Transmission = 5,
916  Mirror = 6,
917  Bump = 7,
918  EnvironmentTexture = 8,
919  EnvironmentCubeMap = 9
920  };
921 
924  enum class Parameterization
925  {
927  Cylinder,
928 
930  PhysicalReflection,
931 
933  Object,
934 
940  NaturalUV,
941 
943  ReflectionVector,
944 
946  SurfaceNormal,
947 
949  Sphere,
950 
952  UV,
953 
955  World
956  };
957 
960  enum class Tiling
961  {
964  Clamp,
965 
967  Repeat,
968 
970  Reflect,
971 
974  Trim
975  };
976 
979  enum class Interpolation
980  {
982  None,
983 
985  Bilinear
986  };
987 
990  enum class Decimation
991  {
993  None,
994 
997  Anisotropic,
998 
1000  Mipmap
1001  };
1002 
1006  enum class ChannelMapping
1007  {
1008  Red,
1009  Green,
1010  Blue,
1011  Alpha,
1012  Zero,
1013  One,
1014  Luminance
1015  };
1016 
1017  private:
1018  Texture() {}
1019  };
1020 
1021 private:
1022  Material() {}
1023 };
1024 
1025 
1026 class HPS_API PostProcessEffects
1027 {
1028 public:
1029 
1030  class HPS_API AmbientOcclusion
1031  {
1032  public:
1033 
1036  enum class Quality
1037  {
1038  Fastest,
1039  Nicest
1040  };
1041 
1042  private:
1043  AmbientOcclusion() {}
1044  };
1045 
1046  class HPS_API Bloom
1047  {
1048  public:
1052  enum class Shape
1053  {
1054  Star,
1055  Radial
1056  };
1057 
1058  private:
1059  Bloom() {}
1060  };
1061 
1062 private:
1063  PostProcessEffects() {}
1064 };
1065 
1066 class HPS_API Performance
1067 {
1068 public:
1069 
1073  enum class DisplayLists
1074  {
1076  None,
1077 
1080  Geometry,
1081 
1084  Segment
1085  };
1086 
1095  enum class StaticModel
1096  {
1097 
1098  None,
1099  Attribute,
1100  AttributeSpatial
1101  };
1102 
1103 
1104 private:
1105  Performance() {}
1106 };
1107 
1108 
1109 class HPS_API AttributeLock
1110 {
1111 public:
1112 
1114  enum class Type : uint32_t
1115  {
1116  Everything = 0x01000000,
1117 
1118  Visibility = 0x02000000,
1119 
1120  VisibilityCuttingSections,
1121  VisibilityCutEdges,
1122  VisibilityCutFaces,
1123  VisibilityWindows,
1124  VisibilityText,
1125  VisibilityLines,
1126  VisibilityEdgeLights,
1127  VisibilityMarkerLights,
1128  VisibilityFaceLights,
1129  VisibilityGenericEdges,
1130  VisibilityHardEdges,
1131  VisibilityAdjacentEdges,
1132  VisibilityInteriorSilhouetteEdges,
1133  VisibilityShadowEmitting,
1134  VisibilityShadowReceiving,
1135  VisibilityShadowCasting,
1136  VisibilityMarkers,
1137  VisibilityVertices,
1138  VisibilityFaces,
1139  VisibilityPerimeterEdges,
1140  VisibilityNonCulledEdges,
1141  VisibilityMeshQuadEdges,
1142  VisibilityCutGeometry,
1143  VisibilityEdges,
1144  VisibilityGeometry,
1145  VisibilityLights,
1146  VisibilityShadows,
1147 
1148  Material = 0x03000000,
1149 
1150  MaterialGeometry,
1151  MaterialCutGeometry,
1152 
1153  MaterialAmbientLightUpColor,
1154  MaterialAmbientLightDownColor,
1155  MaterialAmbientLightColor,
1156 
1157  MaterialWindowColor,
1158  MaterialWindowContrastColor,
1159 
1160  MaterialLightColor,
1161  MaterialLineColor,
1162  MaterialMarkerColor,
1163  MaterialTextColor,
1164  MaterialCutEdgeColor,
1165 
1166  MaterialVertex,
1167  MaterialVertexDiffuse,
1168  MaterialVertexDiffuseColor,
1169  MaterialVertexDiffuseAlpha,
1170  MaterialVertexDiffuseTexture,
1171  MaterialVertexSpecular,
1172  MaterialVertexMirror,
1173  MaterialVertexTransmission,
1174  MaterialVertexEmission,
1175  MaterialVertexEnvironment,
1176  MaterialVertexBump,
1177  MaterialVertexGloss,
1178 
1179  MaterialEdge,
1180  MaterialEdgeDiffuse,
1181  MaterialEdgeDiffuseColor,
1182  MaterialEdgeDiffuseAlpha,
1183  MaterialEdgeDiffuseTexture,
1184  MaterialEdgeSpecular,
1185  MaterialEdgeMirror,
1186  MaterialEdgeTransmission,
1187  MaterialEdgeEmission,
1188  MaterialEdgeEnvironment,
1189  MaterialEdgeBump,
1190  MaterialEdgeGloss,
1191 
1192  MaterialFace,
1193  MaterialFaceDiffuse,
1194  MaterialFaceDiffuseColor,
1195  MaterialFaceDiffuseAlpha,
1196  MaterialFaceDiffuseTexture,
1197  MaterialFaceSpecular,
1198  MaterialFaceMirror,
1199  MaterialFaceTransmission,
1200  MaterialFaceEmission,
1201  MaterialFaceEnvironment,
1202  MaterialFaceBump,
1203  MaterialFaceGloss,
1204 
1205  MaterialBackFace,
1206  MaterialBackFaceDiffuse,
1207  MaterialBackFaceDiffuseColor,
1208  MaterialBackFaceDiffuseAlpha,
1209  MaterialBackFaceDiffuseTexture,
1210  MaterialBackFaceSpecular,
1211  MaterialBackFaceMirror,
1212  MaterialBackFaceTransmission,
1213  MaterialBackFaceEmission,
1214  MaterialBackFaceEnvironment,
1215  MaterialBackFaceBump,
1216  MaterialBackFaceGloss,
1217 
1218  MaterialFrontFace,
1219  MaterialFrontFaceDiffuse,
1220  MaterialFrontFaceDiffuseColor,
1221  MaterialFrontFaceDiffuseAlpha,
1222  MaterialFrontFaceDiffuseTexture,
1223  MaterialFrontFaceSpecular,
1224  MaterialFrontFaceMirror,
1225  MaterialFrontFaceTransmission,
1226  MaterialFrontFaceEmission,
1227  MaterialFrontFaceEnvironment,
1228  MaterialFrontFaceBump,
1229  MaterialFrontFaceGloss,
1230 
1231  MaterialCutFace,
1232  MaterialCutFaceDiffuse,
1233  MaterialCutFaceDiffuseColor,
1234  MaterialCutFaceDiffuseAlpha,
1235  MaterialCutFaceDiffuseTexture,
1236  MaterialCutFaceSpecular,
1237  MaterialCutFaceMirror,
1238  MaterialCutFaceTransmission,
1239  MaterialCutFaceEmission,
1240  MaterialCutFaceEnvironment,
1241  MaterialCutFaceBump,
1242  MaterialCutFaceGloss,
1243 
1244  Camera = 0x04000000,
1245  };
1246 
1247 private:
1248  AttributeLock() {}
1249 };
1250 
1251 class HPS_API Drawing
1252 {
1253 public:
1254 
1257  enum class Handedness
1258  {
1259  None,
1260  Left,
1261  Right
1262  };
1263 
1266  enum class Overlay
1267  {
1269  None,
1270 
1273  Default,
1274 
1277  WithZValues,
1278 
1283  InPlace,
1284  };
1285 
1288  enum class ClipOperation
1289  {
1290  Keep,
1291  Remove,
1292  };
1293 
1296  enum class ClipSpace
1297  {
1298  Window,
1299  World,
1300  Object,
1301  };
1302 
1303 private:
1304  Drawing() {}
1305 };
1306 
1307 
1308 class HPS_API HiddenLine
1309 {
1310 public:
1311 
1315  enum class Algorithm
1316  {
1317  None,
1318  ZBuffer,
1319  ZSort,
1320  };
1321 
1322 private:
1323  HiddenLine() {}
1324 };
1325 
1326 
1328 class HPS_API Selection
1329 {
1330 public:
1331 
1334  enum class Level
1335  {
1336  Segment,
1337  Entity,
1338  Subentity,
1339  };
1340 
1343  enum class Algorithm
1344  {
1349  Visual,
1350 
1355  Analytic
1356  };
1357 
1360  enum class Granularity
1361  {
1362  General,
1363  Detailed
1364  };
1365 
1366 private:
1367  Selection() {}
1368 };
1369 
1370 
1374 
1376 class HPS_API Camera
1377 {
1378 public:
1379 
1382  enum class Projection
1383  {
1384  Default = 1 ,
1385  Perspective,
1386  Orthographic,
1387  Stretched,
1388  };
1389 
1390 private:
1391  Camera() {}
1392 };
1393 
1394 
1396 class HPS_API Selectability
1397 {
1398 public:
1402  enum class Value
1403  {
1404  Off = 0,
1405  On,
1406  ForcedOn
1407  };
1408 
1409 private:
1410  Selectability() {}
1411 };
1412 
1413 
1415 class HPS_API Transparency
1416 {
1417 public:
1418 
1421  enum class Method
1422  {
1423  None,
1424  Blended,
1425  ScreenDoor
1426  };
1427 
1430  enum class Algorithm
1431  {
1432  None,
1433  Painters,
1434  ZSortNicest,
1435  ZSortFastest,
1436  DepthPeeling,
1437  WeightedBlended
1438  };
1439 
1443  enum class AreaUnits
1444  {
1445  Percent,
1446  Pixels
1447  };
1448 
1449 private:
1450  Transparency() {}
1451 };
1452 
1453 
1455 class HPS_API Marker
1456 {
1457 public:
1458 
1461  enum class SizeUnits
1462  {
1463  ScaleFactor,
1464  ObjectSpace,
1465  SubscreenRelative,
1466  WindowRelative,
1467  WorldSpace,
1468  Points,
1469  Pixels
1470  };
1471 
1472 private:
1473  Marker() {}
1474 };
1475 
1476 
1478 class HPS_API Lighting
1479 {
1480 public:
1481 
1485  {
1486  Phong,
1487  Gouraud,
1488  Flat
1489  };
1490 
1491 private:
1492  Lighting() {}
1493 };
1494 
1496 class HPS_API Text
1497 {
1498 public:
1499 
1502  enum class Alignment
1503  {
1504  TopLeft,
1505  CenterLeft,
1506  BottomLeft,
1507  TopCenter,
1508  Center,
1509  BottomCenter,
1510  TopRight,
1511  CenterRight,
1512  BottomRight
1513  };
1514 
1517  enum class ReferenceFrame
1518  {
1519  WorldAligned,
1520  PathAligned
1521  };
1522 
1525  enum class Justification
1526  {
1527  Left,
1528  Right,
1529  Center
1530  };
1531 
1534  enum class Transform
1535  {
1537  Transformable,
1540  NonTransformable,
1542  CharacterPositionOnly,
1545  CharacterPositionAdjusted
1546  };
1547 
1550  enum class Renderer
1551  {
1552  Default,
1553  Driver,
1554  Truetype,
1555  };
1556 
1559  enum class Preference
1560  {
1561  Default,
1562  Vector,
1563  Raster,
1564  Exterior
1565  };
1566 
1569  enum class Rotation
1570  {
1571  None,
1572  Rotate,
1573  FollowPath
1574  };
1575 
1576 
1579  enum class SizeUnits
1580  {
1581  ObjectSpace,
1582  SubscreenRelative,
1583  WindowRelative,
1584  WorldSpace,
1585  Points,
1586  Pixels
1587  };
1588 
1592  {
1593  ObjectSpace,
1594  SubscreenRelative,
1595  WindowRelative,
1596  WorldSpace,
1597  Points,
1598  Pixels,
1599  Percent
1600  };
1601 
1604  enum class GreekingUnits
1605  {
1606  ObjectSpace,
1607  SubscreenRelative,
1608  WindowRelative,
1609  WorldSpace,
1610  Points,
1611  Pixels
1612  };
1613 
1616  enum class GreekingMode
1617  {
1618  Nothing,
1619  Lines,
1620  Box
1621  };
1622 
1625  enum class RegionAlignment
1626  {
1627  Top,
1628  Center,
1629  Bottom
1630  };
1631 
1632 private:
1633  Text() {}
1634 };
1635 
1636 
1638 class HPS_API Line
1639 {
1640 public:
1641 
1645  enum class SizeUnits
1646  {
1647  ScaleFactor,
1648  ObjectSpace,
1649  SubscreenRelative,
1650  WindowRelative,
1651  WorldSpace,
1652  Points,
1653  Pixels
1654  };
1655 
1656 private:
1657  Line() {}
1658 };
1659 
1660 
1662 class HPS_API Edge
1663 {
1664 public:
1665 
1668  enum class SizeUnits
1669  {
1670  ScaleFactor,
1671  ObjectSpace,
1672  SubscreenRelative,
1673  WindowRelative,
1674  WorldSpace,
1675  Points,
1676  Pixels
1677  };
1678 
1679 private:
1680  Edge() {}
1681 };
1682 
1683 
1685 class HPS_API CuttingSection
1686 {
1687 public:
1688 
1691  enum class Mode
1692  {
1693  None,
1694  Round,
1695  Square,
1696  Plane
1697  };
1698 
1701  enum class CappingLevel
1702  {
1703  Entity,
1704  Segment,
1705  SegmentTree
1706  };
1707 
1710  enum class CuttingLevel
1711  {
1712  Global,
1713  Local,
1714  };
1715 
1719  {
1720  Explicit,
1721  Implicit,
1722  };
1723 
1726  enum class GatheringLevel
1727  {
1728  Segment,
1729  SegmentTree
1730  };
1731 
1732 private:
1733  CuttingSection() {}
1734 };
1735 
1737 class HPS_API ContourLine
1738 {
1739 public:
1740 
1744  enum class Mode
1745  {
1746  Repeating,
1747  Explicit,
1748  };
1749 
1750 private:
1751  ContourLine() {}
1752 };
1753 
1756 enum class IOResult
1757 {
1758  Success,
1759  Failure,
1760  FileNotFound,
1761  UnableToOpenFile,
1762  InvalidOptions,
1763  InvalidSegment,
1764  InProgress,
1765  Canceled,
1766  UnableToLoadLibraries,
1767  VersionIncompatibility,
1768  InitializationFailed,
1769  UnsupportedFormat,
1770 };
1771 
1773 class HPS_API LinePattern
1774 {
1775 public:
1776 
1779  enum class SizeUnits
1780  {
1781  ObjectSpace,
1782  SubscreenRelative,
1783  WindowRelative,
1784  WorldSpace,
1785  Points,
1786  Pixels,
1787  ScaleFactor
1788  };
1789 
1792  enum class InsetBehavior
1793  {
1794  Overlap,
1795  Trim,
1796  Inline
1797  };
1798 
1802  enum class Join
1803  {
1804  Mitre,
1805  Round,
1806  Bevel
1807  };
1808 
1811  enum class Cap
1812  {
1815  Butt,
1818  Square,
1821  Round,
1823  Mitre
1824  };
1825 
1828  enum class Justification
1829  {
1832  Center,
1834  Stretch
1835  };
1836 
1839  enum class Modifier
1840  {
1841  GlyphName,
1842  Enumerated
1843  };
1844 
1845 
1859  enum class Default
1860  {
1861  Solid,
1862  DashDot,
1863  Dashed,
1864  Dotted,
1865  Dash2Dot,
1866  Dash3Dot,
1867  LongDash,
1868  LongDashShortDash,
1869  LongDash2ShortDash,
1870  FineDot,
1871  };
1872 
1873 private:
1874  LinePattern() {}
1875 };
1876 
1877 
1878 //Begin Glyphs
1880 class HPS_API Glyph
1881 {
1882 public:
1883 
1886  enum class Fill
1887  {
1888  None,
1889  Continuous,
1890  New
1891  };
1892 
1895  enum class ColorSource
1896  {
1897  Default,
1898  Explicit,
1899  Indexed
1900  };
1901 
1905  enum class Default
1906  {
1907  Circle,
1908  CircleWithDot,
1909  CircleWithPlus,
1910  CircleWithTimes,
1911  CircleWithCircle,
1912  SolidCircle,
1913  Dot,
1914  Plus,
1915  Times,
1916  Splat,
1917  Box,
1918  BoxWithDot,
1919  BoxWithTimes,
1920  SolidBox,
1921  Diamond,
1922  DiamondWithDot,
1923  DiamondWithPlus,
1924  SolidDiamond,
1925  TriangleUp,
1926  TriangleUpWithDot,
1927  SolidTriangleUp,
1928  TriangleDown,
1929  TriangleDownWithDot,
1930  SolidTriangleDown,
1931  TriangleRight,
1932  TriangleRightWithDot,
1933  SolidTriangleRight,
1934  TriangleLeft,
1935  TriangleLeftWithDot,
1936  SolidTriangleLeft,
1937  TriangleUpV,
1938  SolidTriangleUpV,
1939  TriangleDownV,
1940  SolidTriangleDownV,
1941  TriangleRightV,
1942  SolidTriangleRightV,
1943  TriangleLeftV,
1944  SolidTriangleLeftV,
1945  LetterY,
1946  LetterZ,
1947  CircleLetterY,
1948  CircleLetterZ,
1949  VerticalBar,
1950  HorizontalBar,
1951  SlantLeft,
1952  SlantRight,
1953  WidePlus,
1954  SolidWidePlus,
1955  WideTimes,
1956  SolidWideTimes,
1957  Pound,
1958  Sphere,
1959  };
1960 
1961 private:
1962  Glyph() {}
1963 };
1964 
1965 
1967 class HPS_API Bounding
1968 {
1969 public:
1970 
1973  enum class Type
1974  {
1975  None,
1976  Sphere,
1977  Cuboid
1978  };
1979 
1980 private:
1981  Bounding() {}
1982 };
1983 
1984 
1986 class HPS_API Condition
1987 {
1988 public:
1989 
1990  enum class Intrinsic
1991  {
1992  Extent,
1993  DrawPass
1994  };
1995 
1996 private:
1997  Condition() {}
1998 };
1999 
2000 
2002 class HPS_API Grid
2003 {
2004 public:
2005 
2008  enum class Type
2009  {
2010  Quadrilateral,
2011  Radial
2012  };
2013 
2014 private:
2015  Grid() {}
2016 };
2017 
2018 
2020 {
2021 public:
2022 
2023  enum class UserData
2024  {
2025  None,
2026  Discard,
2027  Preserve,
2028  Merge,
2029  Localize,
2030  };
2031 
2032  enum class Scope
2033  {
2034  SubSegments,
2035  SubsegmentsAndIncludes,
2036  };
2037 
2038  enum class Expansion
2039  {
2040  None,
2041  Includes,
2042  References,
2043  IncludesAndReferences,
2044  };
2045 
2046  enum class Matrix
2047  {
2048  None,
2049  Localize,
2050  Collapse,
2051  };
2052 
2053  enum class Reorganization
2054  {
2055  None,
2056  Attribute,
2057  Spatial,
2058  AttributeSpatial,
2059  };
2060 
2061 private:
2063 };
2064 
2065 
2067 class HPS_API Coordinate
2068 {
2069 public:
2070 
2074  enum class Space
2075  {
2076  Object,
2077  World,
2078  Camera,
2079  Normalized,
2080  ScreenRange,
2081  InnerWindow,
2082  InnerPixel,
2083  Window,
2084  Pixel,
2085  NormalizedInnerWindow,
2086  NormalizedInnerPixel,
2087  NormalizedWindow,
2088  NormalizedPixel,
2089  };
2090 
2091 private:
2092  Coordinate() {}
2093 };
2094 
2095 
2096  typedef double Time;
2097 
2098 #ifdef _MSC_VER
2099 # ifndef HPS_INLINE
2100 # define HPS_INLINE __forceinline
2101 # endif
2102 #else
2103 # define HPS_INLINE inline
2104 #endif
2105 
2106 #ifndef HPS_UNREFERENCED
2107 #define HPS_UNREFERENCED(param) ((void)(param))
2108 #endif
2109 
2110 
2111 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2112 
2113 template<typename T>
2114 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2115 {
2116  return degrees * (T)(PI / 180.0);
2117 }
2118 
2119 template<typename T>
2120 HPS_INLINE T Radians_To_Degrees(T const & radians)
2121 {
2122  return radians * (T)(180.0 / PI);
2123 }
2124 
2125 template<typename T>
2126 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2127  T a = Degrees_To_Radians(angle);
2128  cosine = cos(a);
2129  sine = sin(a);
2130 }
2131 
2132 template<typename T>
2133 HPS_INLINE T Cos(T const & angle) {
2134  return cos (Degrees_To_Radians(angle));
2135 }
2136 
2137 template<typename T>
2138 HPS_INLINE T Sin(T const & angle) {
2139  return sin (Degrees_To_Radians(angle));
2140 }
2141 
2142 template<typename T>
2143 HPS_INLINE T ACos(T const & x) {
2144  if (x > 1)
2145  return 0;
2146  if (x < -1)
2147  return 180;
2148  return Radians_To_Degrees(acos(x));
2149 }
2150 
2151 template<typename T>
2152 HPS_INLINE T ATan2(T const & y, T const & x) {
2153  if (x == 0 && y == 0)
2154  return 0;
2155  return Radians_To_Degrees(atan2(y, x));
2156 }
2157 
2158 
2159 template <typename F> struct Float_Traits {};
2160 template <> struct Float_Traits<float> {
2161  typedef double Alternative;
2162  static const int Type = 1;
2163  static float Epsilon () { return 1.0e-30f; }
2164 };
2165 template <> struct Float_Traits<double> {
2166  typedef float Alternative;
2167  static const int Type = 2;
2168  static double Epsilon () { return 1.0e-300; }
2169 };
2170 
2171 
2172 
2174 class HPS_API Float {
2175 private:
2176  enum Parts {
2177 # if HOOPS_BIGENDIAN
2178  High, Low
2179 # else
2180  Low, High
2181 # endif
2182  };
2183 
2184  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2185  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2186  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2187  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2188  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2189 
2190  static HPS_INLINE bool is_nan(int32_t const & v) {
2191  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2192  return exp == 0x7F800000 && mantissa != 0;
2193  }
2194  static HPS_INLINE bool is_nan(uint32_t const & v) {
2195  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2196  return exp == 0x7F800000 && mantissa != 0;
2197  }
2198  static HPS_INLINE bool is_nan(int32_t const * v) {
2199  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2200  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2201  }
2202  static HPS_INLINE bool is_nan(uint32_t const * v) {
2203  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2204  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2205  }
2206 
2207  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2208  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2209  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2210  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2211 public:
2212 
2214  static const float Infinity;
2216  static const float NegativeInfinity;
2217 
2219  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2220  static HPS_INLINE bool IsInfinite(double const & a) {
2221  uint32_t v[2];
2222  memcpy (v, &a, sizeof(double));
2223  return is_infinite (v);
2224  }
2225 
2227  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2228  static HPS_INLINE bool IsNAN(double const & a) {
2229  uint32_t v[2];
2230  memcpy (v, &a, sizeof(double));
2231  return is_nan (v);
2232  }
2233 
2235  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2236  static HPS_INLINE bool IsAbnormal(double const & a) {
2237  uint32_t v[2];
2238  memcpy (v, &a, sizeof(double));
2239  return is_special (v);
2240  }
2241 
2244  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2245  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2246 
2247 #ifndef HOOPS_DEFINED
2248  template <typename Alloc>
2249  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2250  {
2251  if (a.size() != b.size())
2252  return false;
2253 
2254  auto it1 = a.begin();
2255  auto it2 = b.begin();
2256  auto const end = a.end();
2257  for ( ; it1 != end; ++it1, ++it2)
2258  {
2259  if (!Equals(*it1, *it2, tolerance))
2260  return false;
2261  }
2262  return true;
2263  }
2264 #endif
2265 
2266  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2267  return extract_uint32_t(a) & 0x80000000;
2268  }
2269  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2270  uint32_t v[2];
2271  memcpy (v, &a, sizeof(double));
2272  return v[High] & 0x80000000;
2273  }
2274 
2275  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2276  uint32_t v = extract_uint32_t(a);
2277  v &= 0x7FFFFFFF;
2278  v |= sign_bit;
2279  inject_uint32_t(a, v);
2280  }
2281  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2282  uint32_t v[2];
2283  memcpy (v, &a, sizeof(double));
2284  v[High] &= 0x7FFFFFFF;
2285  v[High] |= sign_bit;
2286  memcpy (&a, v, sizeof(double));
2287  }
2288 
2289 
2290  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2291  uint32_t v = extract_uint32_t(a);
2292 
2293  v &= 0x7FFFFFFF;
2294  if (v < 0x3B800000)
2295  return 0;
2296 
2297  v--;
2298 
2299  uint32_t exp = v >> 23;
2300  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2301 
2302  return (unsigned char) (man >> (16 + 126 - exp));
2303  }
2304 
2305  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2306  uint32_t v = extract_uint32_t(a);
2307 
2308  v &= 0x7FFFFFFF;
2309  if (v < 0x3B800000)
2310  return 0;
2311 
2312  v--;
2313 
2314  uint32_t exp = v >> 23;
2315  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2316 
2317  uint32_t x = (man >> (16 + 126 - exp));
2318 
2319  return (unsigned char) ((x * (mix+1)) >> 8);
2320  }
2321 
2322 
2323  static HPS_INLINE bool match(float const & a, float const & b) {
2324  uint32_t va = extract_uint32_t(a);
2325  uint32_t vb = extract_uint32_t(b);
2326 
2327  if (((va | vb) & 0x7FFFFFFF) == 0)
2328  return true;
2329 
2330  return va == vb;
2331  }
2332  static HPS_INLINE bool match(double const & a, double const & b) {
2333  return a == b;
2334  }
2335 
2336 
2337  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2338  uint32_t va = extract_uint32_t(a);
2339  uint32_t vb = extract_uint32_t(b);
2340 
2341  uint32_t a_sign = va & 0x80000000;
2342  uint32_t b_sign = vb & 0x80000000;
2343 
2344  (int32_t&)a_sign >>= 31;
2345  (int32_t&)b_sign >>= 31;
2346 
2347  uint32_t mash = (a_sign&b_sign);
2348 
2349  va ^= mash;
2350  vb ^= mash;
2351 
2352  if ((int32_t&)vb < (int32_t&)va)
2353  memcpy(&a, &b, sizeof(float));
2354  }
2355  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2356  if (b < a)
2357  a = b;
2358  }
2359 
2360  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2361  uint32_t va = extract_uint32_t(a);
2362  uint32_t vb = extract_uint32_t(b);
2363 
2364  uint32_t a_sign = va & 0x80000000;
2365  uint32_t b_sign = vb & 0x80000000;
2366 
2367  (int32_t&)a_sign >>= 31;
2368  (int32_t&)b_sign >>= 31;
2369 
2370  uint32_t mash = (a_sign&b_sign);
2371 
2372  va ^= mash;
2373  vb ^= mash;
2374 
2375  if ((int32_t&)vb > (int32_t&)va)
2376  memcpy(&a, &b, sizeof(float));
2377  }
2378  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2379  if (b > a)
2380  a = b;
2381  }
2382 
2383 
2384  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2385  uint32_t i;
2386  memcpy(&i, &a, sizeof(float));
2387  return i;
2388  }
2389 
2390  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2391  memcpy(&a, &i, sizeof(float));
2392  }
2393 
2394  static HPS_INLINE float C2F(unsigned char x) {
2395  //return (float)x * (1.0f/255.0f);
2396  return char_to_float[x];
2397  }
2398 
2399 
2400  // SSE convenience functions
2401  static HPS_INLINE void pack_4(float const & f, float * m) {
2402  memcpy(&m[0], &f, sizeof(float));
2403  memcpy(&m[1], &f, sizeof(float));
2404  memcpy(&m[2], &f, sizeof(float));
2405  memcpy(&m[3], &f, sizeof(float));
2406  }
2407 
2408  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2409  memcpy(&m[0], &f0, sizeof(float));
2410  memcpy(&m[1], &f1, sizeof(float));
2411  memcpy(&m[2], &f2, sizeof(float));
2412  memcpy(&m[3], &f3, sizeof(float));
2413  }
2414 
2415  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2416  memcpy(f0, m, sizeof(float)*4);
2417  }
2418 
2419  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2420  memcpy(&f0, &m[0], sizeof(float));
2421  memcpy(&f1, &m[1], sizeof(float));
2422  memcpy(&f2, &m[2], sizeof(float));
2423  memcpy(&f3, &m[3], sizeof(float));
2424  }
2425 
2426 private:
2427  static const float char_to_float[256];
2428 
2429  Float();
2430 };
2431 
2432 
2434 
2435 
2436 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2437 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2438 
2439 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2440 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2441 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2442 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2443 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2444 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2445 
2446 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2447 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2448 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); }
2449 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); }
2450 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); }
2451 
2452 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2453 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2454 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); }
2455 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); }
2456 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); }
2457 
2458 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; }
2459 
2460 
2461 template <> HPS_INLINE float Abs<float> (float const & a) {
2462  uint32_t v = Float::extract_uint32_t(a);
2463  v &= 0x7FFFFFFF;
2464  float f;
2465  Float::inject_uint32_t(f,v);
2466  return f;
2467 }
2468 
2469 template <> HPS_INLINE int Sign<float> (float const & a) {
2470  uint32_t v = Float::extract_uint32_t(a);
2471 
2472  if ((v & 0x7FFFFFFF) == 0)
2473  return 0;
2474 
2475  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2476 }
2477 
2478 template <> HPS_INLINE int Compare<float> (float const & a, float const & b) {
2479  int a_sign = Sign(a);
2480  int b_sign = Sign(b);
2481 
2482  if (a_sign != b_sign)
2483  return Compare(a_sign, b_sign);
2484 
2485  uint32_t v = Float::extract_uint32_t(a);
2486  uint32_t u = Float::extract_uint32_t(b);
2487 
2488  return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2489 }
2490 
2491 template <> HPS_INLINE float const & Min<float> (float const & a, float const & b) {
2492  if (Compare(a,b)>0)
2493  return b;
2494  return a;
2495 }
2496 
2497 template <> HPS_INLINE float const & Max<float> (float const & a, float const & b) {
2498  if (Compare(a,b)>0)
2499  return a;
2500  return b;
2501 }
2502 
2503 
2505 
2506 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2507  int32_t va = Float::extract_uint32_t(a);
2508  int32_t vb = Float::extract_uint32_t(b);
2509 
2510  if (is_special(va) || is_special(vb)) {
2511  if (is_infinite(va) || is_infinite(vb))
2512  return va == vb; // final check is for sign bits same
2513  if (is_nan(va) || is_nan(vb))
2514  return false;
2515  }
2516 
2517  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2518  if ((va & 0x7FFFFFFF) == 0)
2519  return (vb & 0x7FFFFFFF) < close_to_zero;
2520  else if ((vb & 0x7FFFFFFF) == 0)
2521  return (va & 0x7FFFFFFF) < close_to_zero;
2522 
2523  uint32_t sign_mask = va ^ vb;
2524  (int32_t &)sign_mask >>= 31;
2525 
2526  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2527  int32_t v1 = tolerance + diff;
2528  int32_t v2 = tolerance - diff;
2529  return (v1|v2) >= 0;
2530 }
2531 
2532 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2533  int32_t va[2], vb[2];
2534  memcpy (va, &a, sizeof(double));
2535  memcpy (vb, &b, sizeof(double));
2536 
2537  if (is_special(va) || is_special(vb)) {
2538  if (is_infinite(va) || is_infinite(vb))
2539  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2540  if (is_nan(va) || is_nan(vb))
2541  return false;
2542  }
2543 
2544  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2545  return Abs(a - b) < 0.000000000000005;
2546 
2547  if (extract_sign_bit(a) != extract_sign_bit(b))
2548  return a == b; //-V550
2549 
2550  if (va[High] != vb[High])
2551  return false;
2552 
2553  return Abs(va[Low] - vb[Low]) <= tolerance;
2554 }
2555 
2557 
2558 
2559 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2560 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2561 
2562 template <typename T>
2563 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2564  while (count-- > 0)
2565  if (Is_Abnormal (*t++))
2566  return true;
2567  return false;
2568 }
2569 
2570 template <typename T>
2571 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2572  return count >= 0 && Is_Abnormal((size_t)count, t);
2573 }
2574 
2575 
2577 
2578 
2579 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2580 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2581 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2582 template <typename F> class HPS_TEMPLATE_API Point_2D;
2583 
2584 
2585 template <typename F>
2586 class HPS_TEMPLATE_API Point_3D {
2587  public:
2588  F x;
2589  F y;
2590  F z;
2591 
2592  Point_3D () {}
2593  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2594 
2595  template <typename D>
2596  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2597 
2598  explicit Point_3D (Vector_3D<F> const & v);
2599  explicit Point_3D (Vector_2D<F> const & v);
2600  explicit Point_3D (Point_2D<F> const & that);
2601 
2602  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2603 
2604  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2605  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2606 
2607  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2608  return Float::Equals(x, p.x, in_tolerance) &&
2609  Float::Equals(y, p.y, in_tolerance) &&
2610  Float::Equals(z, p.z, in_tolerance);
2611  }
2612 
2613 
2614  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2615  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2616  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2617  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2618 
2619  F & operator[] (size_t i) { return (&x)[i]; }
2620  F const & operator[] (size_t i) const { return (&x)[i]; }
2621 
2622  Point_3D & operator+= (Vector_3D<F> const & v);
2623  Point_3D & operator-= (Vector_3D<F> const & v);
2624  Point_3D & operator*= (Vector_3D<F> const & v);
2625  Point_3D & operator/= (Vector_3D<F> const & v);
2626  Point_3D const operator* (Vector_3D<F> const & v) const;
2627  Point_3D const operator/ (Vector_3D<F> const & v) const;
2628 
2629  Point_3D & operator+= (Vector_2D<F> const & v);
2630  Point_3D & operator-= (Vector_2D<F> const & v);
2631  Point_3D & operator*= (Vector_2D<F> const & v);
2632  Point_3D & operator/= (Vector_2D<F> const & v);
2633  Point_3D const operator* (Vector_2D<F> const & v) const;
2634  Point_3D const operator/ (Vector_2D<F> const & v) const;
2635 
2636  Vector_3D<F> const operator- (Point_3D const & p) const;
2637 
2638  Point_3D const operator+ (Vector_3D<F> const & v) const;
2639  Point_3D const operator- (Vector_3D<F> const & v) const;
2640 
2641  Point_3D const operator+ (Vector_2D<F> const & v) const;
2642  Point_3D const operator- (Vector_2D<F> const & v) const;
2643 
2644  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2645  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2646 };
2647 
2648 typedef Point_3D<float> Point;
2649 typedef Point_3D<double> DPoint;
2650 
2651 
2652 
2653 template <typename F, typename S>
2654 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)); }
2655 
2656 template <typename F>
2657 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2658  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2659 }
2660 
2661 template <typename F>
2662 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2663  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);
2664 }
2665 
2666 template <typename F>
2667 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2668  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2669 }
2670 
2671 
2672 template <typename F>
2673 class HPS_TEMPLATE_API Point_2D {
2674 public:
2675  F x;
2676  F y;
2677 
2678  Point_2D () {}
2679  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2680 
2681  template <typename D>
2682  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2683 
2684  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2685  explicit Point_2D (Vector_2D<F> const & v);
2686 
2687  Point_2D const operator- () const { return Point_2D (-x, -y); }
2688 
2689  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2690  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2691 
2692  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2693  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2694  }
2695 
2696 
2697  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2698  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2699  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2700  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2701 
2702  F & operator[] (size_t i) { return (&x)[i]; }
2703  F const & operator[] (size_t i) const { return (&x)[i]; }
2704 
2705  Point_2D & operator+= (Vector_2D<F> const & v);
2706  Point_2D & operator-= (Vector_2D<F> const & v);
2707  Point_2D & operator*= (Vector_2D<F> const & v);
2708  Point_2D & operator/= (Vector_2D<F> const & v);
2709  Point_2D const operator* (Vector_2D<F> const & v) const;
2710  Point_2D const operator/ (Vector_2D<F> const & v) const;
2711 
2712  Vector_2D<F> const operator- (Point_2D const & p) const;
2713 
2714  Point_2D const operator+ (Vector_2D<F> const & v) const;
2715  Point_2D const operator- (Vector_2D<F> const & v) const;
2716 
2717  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2718  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2719 };
2720 
2721 typedef Point_2D<float> Point2D;
2722 typedef Point_2D<double> DPoint2D;
2723 
2724 template <typename F>
2725 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2726 
2727 template <typename F, typename S>
2728 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)); }
2729 
2730 template <typename F>
2731 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2732  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2733 }
2734 
2735 template <typename F>
2736 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2737  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);
2738 }
2739 
2740 template <typename F>
2741 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2742  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2743 }
2744 
2745 
2746 template <typename F>
2747 class HPS_TEMPLATE_API Vector_3D {
2748  public:
2749  F x;
2750  F y;
2751  F z;
2752 
2753  Vector_3D () {}
2754  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2755  template <typename D>
2756  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2757  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2758  explicit Vector_3D(Plane_3D<F> const & p);
2759 
2760  explicit Vector_3D (Vector_2D<F> const & that);
2761 
2762  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2763 
2764  bool operator== (Vector_3D const & v) const {
2765  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2766  }
2767  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2768 
2769  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2770  return Float::Equals(x, v.x, in_tolerance) &&
2771  Float::Equals(y, v.y, in_tolerance) &&
2772  Float::Equals(z, v.z, in_tolerance);
2773  }
2774 
2775  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2776  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2777  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2778  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2779 
2780  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2781  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2782  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2783  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2784 
2785  F & operator[] (size_t i) { return (&x)[i]; }
2786  F const & operator[] (size_t i) const { return (&x)[i]; }
2787 
2788  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2789 
2790  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2791 
2792  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2793 
2794  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2795 
2796  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2797  if (check_range) {
2798  F range = Max (Abs (x), Abs (y), Abs (z));
2799  if (range > F(1.0e10))
2800  operator/= (range);
2801  }
2802 
2803  F len = (F)Length();
2804  if (len > epsilon)
2805  operator/= (len);
2806  else
2807  *this = Zero();
2808  return *this;
2809  }
2810  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2811 
2812  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2813  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2814 
2815  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2816 
2817  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2818  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2819  }
2820 
2821 
2822  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2823  return Vector_3D (x * v.x, y * v.y, z * v.z);
2824  }
2825 
2826  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2827  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2828  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2829  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2830  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2831 };
2832 
2833 typedef Vector_3D<float> Vector;
2834 typedef Vector_3D<double> DVector;
2835 
2836 
2837 template <typename F, typename S>
2838 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)); }
2839 
2840 template <typename F>
2841 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2842  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2843 }
2844 
2845 
2846 template <typename F>
2847 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2848 
2849 template <typename F>
2850 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; }
2851 template <typename F>
2852 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; }
2853 
2854 template <typename F>
2855 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); }
2856 
2857 template <typename F>
2858 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); }
2859 template <typename F>
2860 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); }
2861 
2862 template <typename F>
2863 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; }
2864 template <typename F>
2865 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; }
2866 template <typename F>
2867 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); }
2868 template <typename F>
2869 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); }
2870 
2871 
2872 
2873 template <typename F>
2874 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2875  return a + (b - a) * t;
2876 }
2877 
2878 template <typename F>
2879 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2880  return Vector_3D<F>(a + (b - a) * t).Normalize();
2881 }
2882 
2883 
2884 
2885 template <typename F>
2886 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2887  return (p2 - p1).Length();
2888 }
2889 
2890 template <typename F>
2891 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2892  return (p2 - p1).LengthSquared();
2893 }
2894 
2895 template <typename F>
2896 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2897  F p = static_cast<F>((c - b).LengthSquared());
2898  F q = static_cast<F>((c - a).LengthSquared());
2899  F r = static_cast<F>((b - a).LengthSquared());
2900 
2901  return Point_3D<F>(
2902  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2903  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2904 }
2905 
2906 
2907 
2908 template <typename F>
2909 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2910  bool success = true;
2911  for (size_t i = 0; i < count; ++i) {
2912  if (vectors->Normalize() == Vector_3D<F>::Zero())
2913  success = false;
2914  vectors++;
2915  }
2916  return success;
2917 }
2918 
2919 
2920 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2921 
2922 template <typename F>
2923 class HPS_TEMPLATE_API Vector_2D {
2924 public:
2925  F x;
2926  F y;
2927 
2928  Vector_2D () {}
2929  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2930  template <typename D>
2931  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2932 
2933  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2934  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2935  explicit Vector_2D (Plane_2D<F> const & p);
2936 
2937  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2938 
2939  bool operator== (Vector_2D const & v) const {
2940  return Float::match(x, v.x) && Float::match(y, v.y);
2941  }
2942  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2943 
2944  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2945  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2946  }
2947 
2948  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2949  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2950  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2951  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2952 
2953  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2954  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
2955  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
2956  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
2957 
2958  F & operator[] (size_t i) { return (&x)[i]; }
2959  F const & operator[] (size_t i) const { return (&x)[i]; }
2960 
2961  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2962 
2963  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
2964 
2965  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2966  if (check_range) {
2967  F range = Max (Abs (x), Abs (y));
2968  if (range > F(1.0e10))
2969  operator/= (range);
2970  }
2971 
2972  F len = (F)Length();
2973  if (len > epsilon)
2974  operator/= (len);
2975  else
2976  *this = Zero();
2977  return *this;
2978  }
2979  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2980 
2981  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
2982  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
2983 
2984  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
2985 
2986 
2987  HPS_INLINE float Cross (Vector_2D const & v) const {
2988  return x * v.y - y * v.x;
2989  }
2990 
2991  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
2992  return Vector_2D (x * v.x, y * v.y);
2993  }
2994 
2995  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
2996  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
2997 
2998  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
2999  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
3000 };
3001 
3002 typedef Vector_2D<float> Vector2D;
3004 
3005 template <typename F, typename S>
3006 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)); }
3007 
3008 template <typename F>
3009 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
3010  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
3011 }
3012 
3013 
3014 template <typename F>
3015 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
3016 
3017 template <typename F>
3018 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
3019 
3020 template <typename F>
3021 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3022 template <typename F>
3023 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3024 
3025 template <typename F>
3026 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); }
3027 template <typename F>
3028 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); }
3029 
3030 template <typename F>
3031 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3032 template <typename F>
3033 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3034 
3035 template <typename F>
3036 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); }
3037 template <typename F>
3038 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); }
3039 
3040 
3041 template <typename F>
3042 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3043 template <typename F>
3044 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3045 
3046 template <typename F>
3047 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); }
3048 
3049 template <typename F>
3050 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); }
3051 template <typename F>
3052 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); }
3053 
3054 template <typename F>
3055 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3056 template <typename F>
3057 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3058 template <typename F>
3059 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); }
3060 template <typename F>
3061 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); }
3062 
3063 
3064 
3065 
3066 
3067 template <typename F>
3068 class HPS_TEMPLATE_API Plane_3D {
3069  public:
3070  F a;
3071  F b;
3072  F c;
3073  F d;
3074 
3075  Plane_3D () {}
3076  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3077  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3078  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)) {}
3079  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)) {}
3080  template <typename D>
3081  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3082 
3083  Plane_3D (size_t count, Point_3D<F> const * points) {
3084  if (count >= 3) {
3085  // The 3 coefficients A, B, and C are proportional to the areas of the
3086  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3087 
3088  // run around the polygon, collecting trapezoidal areas
3089  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3090 
3091  // take care of the swing point first
3092  Point_3D<F> const * p0 = &points[count-1];
3093 
3095  Vector_3D<F> normal = Vector_3D<F>::Zero();
3096 
3097  for (size_t i=0; i<count; ++i) {
3098  Point_3D<F> const * p1 = &points[i];
3099 
3100  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3101  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3102  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3103 
3104  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3105 
3106  p0 = p1;
3107  }
3108 
3109  // ("should" always be != 0)
3110  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3111  /* finish finding the average */
3112  double inv_count = 1.0 / (double)count;
3113  ctr *= inv_count;
3114 
3115  *this = Plane_3D(normal, Point_3D<F>(ctr));
3116  return;
3117  }
3118  }
3119 
3120  *this = Plane_3D::Zero();
3121  }
3122 
3123 
3124  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3125 
3126  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3127  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3128 
3129  F & operator[] (size_t i) { return (&a)[i]; }
3130  F const & operator[] (size_t i) const { return (&a)[i]; }
3131 
3132  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3133  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3134  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3135  }
3136 
3137  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3138  F len = (F)Vector_3D<F>(*this).Length();
3139  if (len > epsilon)
3140  operator/= (len);
3141  else
3142  *this = Zero();
3143  return *this;
3144  }
3145 
3146  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3147  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3148  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3149 
3150  if (val1 >= eps) {
3151  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3152  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3153  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3154  }
3155  else
3156  return p1;
3157  }
3158 
3159  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3160  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3161  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3162 
3163  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));
3164  }
3165 
3166  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3167 
3168 
3169  private:
3170  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3171  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3172  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3173  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3174 };
3175 
3176 typedef Plane_3D<float> Plane;
3177 typedef Plane_3D<double> DPlane;
3178 
3179 
3180 template <typename F>
3181 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3182  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3183 }
3184 
3185 
3186 template <typename F>
3187 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3188  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3189 }
3190 template <typename F>
3191 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3192  return plane * point;
3193 }
3194 
3195 template <typename F>
3196 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3197  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);
3198 }
3199 
3200 template <typename F>
3201 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3202 
3203 
3204 
3205 
3206 
3207 
3208 template <typename F>
3209 class HPS_TEMPLATE_API Plane_2D {
3210 public:
3211  F a;
3212  F b;
3213  F c;
3214 
3215  Plane_2D () {}
3216  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3217  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3218  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)) {}
3219  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)) {}
3220  template <typename D>
3221  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3222 
3223  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3224 
3225  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3226  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3227 
3228  F & operator[] (size_t i) { return (&a)[i]; }
3229  F const & operator[] (size_t i) const { return (&a)[i]; }
3230 
3231  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3232  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3233  }
3234 
3235  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3236  F len = (F)Vector_2D<F>(*this).Length();
3237  if (len > epsilon)
3238  operator/= (len);
3239  else
3240  *this = Zero();
3241  return *this;
3242  }
3243 
3244  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3245 
3246 
3247 private:
3248  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3249  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3250  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3251  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3252 };
3253 
3254 typedef Plane_2D<float> Plane2D;
3255 typedef Plane_2D<double> DPlane2D;
3256 
3257 
3258 template <typename F>
3259 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3260  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3261 }
3262 
3263 
3264 template <typename F>
3265 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3266  return plane.a * point.x + plane.b * point.y + plane.c;
3267 }
3268 template <typename F>
3269 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3270  return plane * point;
3271 }
3272 
3273 template <typename F>
3274 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3275  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);
3276 }
3277 
3278 template <typename F>
3279 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3280 
3281 
3282 
3283 
3284 struct Rectangle;
3285 
3286 struct HPS_API IntRectangle {
3287  int left;
3288  int right;
3289  int bottom;
3290  int top;
3291 
3292  IntRectangle()
3293  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3294  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3295 
3296  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3297  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3298 
3299  IntRectangle(IntRectangle const & that)
3300  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3301 
3302  explicit IntRectangle(Rectangle const & that);
3303 
3304  bool operator==(IntRectangle const & rect) const {
3305  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3306  }
3307 
3308  bool operator!=(IntRectangle const & rect) const {
3309  return !(*this == rect);
3310  }
3311 
3312  HPS_INLINE int PixelWidth() const {
3313  return right - left + 1;
3314  }
3315 
3316  HPS_INLINE int PixelHeight() const {
3317  return top - bottom + 1;
3318  }
3319 
3320  HPS_INLINE int Width() const {
3321  return right - left;
3322  }
3323 
3324  HPS_INLINE int Height() const {
3325  return top - bottom;
3326  }
3327 
3328  HPS_INLINE int Area() const {
3329  return Width() * Height();
3330  }
3331 
3332  HPS_INLINE Point2D Center() const {
3333  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3334  }
3335 
3336  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3337  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3338  }
3339 
3340  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3341  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3342  }
3343 
3344  HPS_INLINE IntRectangle & Expand(int border) {
3345  left -= border;
3346  right += border;
3347  bottom -= border;
3348  top += border;
3349  return *this;
3350  }
3351 
3352  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3353  left -= rect.left;
3354  right += rect.right;
3355  bottom -= rect.bottom;
3356  top += rect.top;
3357  return *this;
3358  }
3359 
3360  HPS_INLINE IntRectangle & Contract(int border) {
3361  left += border;
3362  right -= border;
3363  bottom += border;
3364  top -= border;
3365  return *this;
3366  }
3367 
3368  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3369  left += rect.left;
3370  right -= rect.right;
3371  bottom += rect.bottom;
3372  top -= rect.top;
3373  return *this;
3374  }
3375 
3376  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3377  left = Max(left, rect.left);
3378  right = Min(right, rect.right);
3379  bottom = Max(bottom, rect.bottom);
3380  top = Min(top, rect.top);
3381  return *this;
3382  }
3383 
3384  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3385  left = Min(left, rect.left);
3386  right = Max(right, rect.right);
3387  bottom = Min(bottom, rect.bottom);
3388  top = Max(top, rect.top);
3389  return *this;
3390  }
3391 
3392 
3393  static HPS_INLINE IntRectangle Invalid() {
3394  return IntRectangle();
3395  }
3396 
3397  static HPS_INLINE IntRectangle Zero() {
3398  return IntRectangle(0, 0, 0, 0);
3399  }
3400 
3401 };
3402 
3403 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3404  IntRectangle temp = a;
3405  return temp.Expand(border);
3406 }
3407 
3408 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3409  IntRectangle temp = a;
3410  return temp.Expand(border);
3411 }
3412 
3413 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3414  IntRectangle temp = a;
3415  return temp.Contract(border);
3416 }
3417 
3418 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3419  IntRectangle temp = a;
3420  return temp.Contract(border);
3421 }
3422 
3423 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3424  IntRectangle temp = a;
3425  return temp.Intersect(b);
3426 }
3427 
3428 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3429  IntRectangle temp = a;
3430  return temp.Union(b);
3431 }
3432 
3433 struct HPS_API Rectangle {
3434  float left;
3435  float right;
3436  float bottom;
3437  float top;
3438 
3439  Rectangle()
3440  : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3441  bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3442 
3443  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3444  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3445 
3446  Rectangle(Rectangle const & that)
3447  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3448 
3449  explicit Rectangle(IntRectangle const & that)
3450  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3451 
3452  HPS_INLINE Rectangle(size_t count, Point const * points) {
3453  left = points->x;
3454  right = points->x;
3455  top = points->y;
3456  bottom = points->y;
3457  --count;
3458  if (count > 0) {
3459  ++points;
3460  Merge(count, points);
3461  }
3462  }
3463 
3464  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3465  left = points->x;
3466  right = points->x;
3467  top = points->y;
3468  bottom = points->y;
3469  --count;
3470  if (count > 0) {
3471  ++points;
3472  Merge(count, points);
3473  }
3474  }
3475 
3476  HPS_INLINE float Width() const {
3477  return right - left;
3478  }
3479 
3480  HPS_INLINE float Height() const {
3481  return top - bottom;
3482  }
3483 
3484  HPS_INLINE float Area() const {
3485  return Width() * Height();
3486  }
3487 
3488  HPS_INLINE Point2D Center() const {
3489  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3490  }
3491 
3492  HPS_INLINE void Merge(size_t count, Point const * points) {
3493 
3494  while (count > 1) {
3495  if (Compare(points[0].x, points[1].x)>0) {
3496  Float::replace_if_smaller(left, points[1].x);
3497  Float::replace_if_larger(right, points[0].x);
3498  }
3499  else {
3500  Float::replace_if_smaller(left, points[0].x);
3501  Float::replace_if_larger(right, points[1].x);
3502  }
3503 
3504  if (Compare(points[0].y, points[1].y)>0) {
3505  Float::replace_if_smaller(bottom, points[1].y);
3506  Float::replace_if_larger(top, points[0].y);
3507  }
3508  else {
3509  Float::replace_if_smaller(bottom, points[0].y);
3510  Float::replace_if_larger(top, points[1].y);
3511  }
3512 
3513  points += 2;
3514  count -= 2;
3515  }
3516 
3517  if (count > 0)
3518  Merge(*points);
3519  }
3520 
3521  HPS_INLINE void Merge(Point const & point) {
3522  Float::replace_if_smaller(left, point.x);
3523  Float::replace_if_smaller(bottom, point.y);
3524  Float::replace_if_larger(right, point.x);
3525  Float::replace_if_larger(top, point.y);
3526  }
3527 
3528  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3529 
3530  while (count > 1) {
3531  if (Compare(points[0].x, points[1].x)>0) {
3532  Float::replace_if_smaller(left, points[1].x);
3533  Float::replace_if_larger(right, points[0].x);
3534  }
3535  else {
3536  Float::replace_if_smaller(left, points[0].x);
3537  Float::replace_if_larger(right, points[1].x);
3538  }
3539 
3540  if (Compare(points[0].y, points[1].y)>0) {
3541  Float::replace_if_smaller(bottom, points[1].y);
3542  Float::replace_if_larger(top, points[0].y);
3543  }
3544  else {
3545  Float::replace_if_smaller(bottom, points[0].y);
3546  Float::replace_if_larger(top, points[1].y);
3547  }
3548 
3549  points += 2;
3550  count -= 2;
3551  }
3552 
3553  if (count > 0)
3554  Merge(*points);
3555  }
3556 
3557  HPS_INLINE void Merge(Point2D const & point) {
3558  Float::replace_if_smaller(left, point.x);
3559  Float::replace_if_smaller(bottom, point.y);
3560  Float::replace_if_larger(right, point.x);
3561  Float::replace_if_larger(top, point.y);
3562  }
3563 
3564  bool operator==(Rectangle const & rect) const {
3565  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3566  }
3567 
3568  bool operator!=(Rectangle const & rect) const {
3569  return !(*this == rect);
3570  }
3571 
3572  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3573  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3574  }
3575 
3576  HPS_INLINE bool Contains(Point const & contained) const {
3577  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3578  }
3579 
3580  HPS_INLINE bool Contains(Point2D const & contained) const {
3581  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3582  }
3583 
3584  HPS_INLINE bool Contains(Rectangle const & rect) {
3585  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3586  }
3587 
3588  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3589  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3590  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3591  }
3592 
3593  HPS_INLINE Rectangle & Expand(float border) {
3594  left -= border;
3595  right += border;
3596  bottom -= border;
3597  top += border;
3598  return *this;
3599  }
3600 
3601  HPS_INLINE Rectangle & Expand(int border) {
3602  Expand((float)border);
3603  return *this;
3604  }
3605 
3606  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3607  left -= rect.left;
3608  right += rect.right;
3609  bottom -= rect.bottom;
3610  top += rect.top;
3611  return *this;
3612  }
3613 
3614  HPS_INLINE Rectangle & Contract(int border) {
3615  left += border;
3616  right -= border;
3617  bottom += border;
3618  top -= border;
3619  return *this;
3620  }
3621 
3622  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3623  left += rect.left;
3624  right -= rect.right;
3625  bottom += rect.bottom;
3626  top -= rect.top;
3627  return *this;
3628  }
3629 
3630  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3631  left = Max(left, rect.left);
3632  right = Min(right, rect.right);
3633  bottom = Max(bottom, rect.bottom);
3634  top = Min(top, rect.top);
3635  return *this;
3636  }
3637 
3638  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3639  left = Min(left, rect.left);
3640  right = Max(right, rect.right);
3641  bottom = Min(bottom, rect.bottom);
3642  top = Max(top, rect.top);
3643  return *this;
3644  }
3645 
3646  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3647  float scale = (scope.right - scope.left) * 0.5f;
3648  float trans = (scope.right + scope.left) * 0.5f;
3649 
3650  left = left * scale + trans;
3651  right = right * scale + trans;
3652 
3653  scale = (scope.top - scope.bottom) * 0.5f;
3654  trans = (scope.top + scope.bottom) * 0.5f;
3655 
3656  bottom = bottom * scale + trans;
3657  top = top * scale + trans;
3658  return *this;
3659  }
3660 
3661  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3662  float tmp = 2.0f/(scope.right - scope.left);
3663  right = (right - scope.left) * tmp - 1.0f;
3664  left = (left - scope.left) * tmp - 1.0f;
3665 
3666  tmp = 2.0f/(scope.top - scope.bottom);
3667  top = (top - scope.bottom) * tmp - 1.0f;
3668  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3669  return *this;
3670  }
3671 
3672  static HPS_INLINE Rectangle FullScope() {
3673  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3674  }
3675 
3676  static HPS_INLINE Rectangle InvalidScope() {
3677  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3678  }
3679 
3680  static HPS_INLINE Rectangle Zero() {
3681  return Rectangle(0, 0, 0, 0);
3682  }
3683 
3684 };
3685 
3686 
3687 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3688  IntRectangle temp;
3689  temp.left = Floor (a.left);
3690  temp.right = Floor (a.right);
3691  temp.bottom = Floor (a.bottom);
3692  temp.top = Floor (a.top);
3693  return temp;
3694 }
3695 
3696 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3697  Rectangle temp = a;
3698  return temp.Expand(border);
3699 }
3700 
3701 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3702  Rectangle temp = a;
3703  return temp.Expand(border);
3704 }
3705 
3706 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3707  Rectangle temp = a;
3708  return temp.Contract(border);
3709 }
3710 
3711 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3712  Rectangle temp = a;
3713  return temp.Contract(border);
3714 }
3715 
3716 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3717  Rectangle temp = a;
3718  return temp.Intersect(b);
3719 }
3720 
3721 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3722  Rectangle temp = a;
3723  return temp.Union(b);
3724 }
3725 
3726 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3727  Rectangle temp = a;
3728  return temp.Inscribe_Scope(scope);
3729 }
3730 
3731 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3732  Rectangle temp = a;
3733  return temp.Circumscribe_Scope(scope);
3734 }
3735 
3736 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3737  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3738 
3739 
3740 
3741 
3742 template <typename F>
3743 struct Sphere_3D;
3744 
3745 template <typename F>
3746 struct HPS_TEMPLATE_API Cuboid_3D {
3751 
3752 
3756  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3757 
3758  template <typename D>
3759 
3764  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3765 
3766 
3771  Cuboid_3D (Sphere_3D<F> const & that);
3772 
3778  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3779 
3785  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3786  if (count == 0) {
3787  min = Limit_Point();
3788  max = -Limit_Point();
3789  return;
3790  }
3791  min = max = *points++;
3792  --count;
3793  if (count>0)
3794  Merge(count, points);
3795  }
3796 
3801  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3802 
3806  HPS_INLINE bool IsValid() const {
3807  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3808  }
3809 
3813  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3814 
3818  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3819 
3824  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3825 
3830  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3831 
3836  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3837  points[0] = Point_3D<F> (min.x, min.y, min.z);
3838  points[1] = Point_3D<F> (min.x, min.y, max.z);
3839  points[2] = Point_3D<F> (min.x, max.y, min.z);
3840  points[3] = Point_3D<F> (min.x, max.y, max.z);
3841  points[4] = Point_3D<F> (max.x, min.y, min.z);
3842  points[5] = Point_3D<F> (max.x, min.y, max.z);
3843  points[6] = Point_3D<F> (max.x, max.y, min.z);
3844  points[7] = Point_3D<F> (max.x, max.y, max.z);
3845  }
3846 
3850  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3851 
3855  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3856 
3862  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3863  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3864  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3865  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3866  }
3867 
3873  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3874  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3875  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3876  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3877  }
3878 
3885  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3886  //ASSERT (0 <= dimension && dimension <= 2);
3887  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3888  }
3889 
3897  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3898  //ASSERT (0 <= dimension && dimension <= 2);
3899  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3900  }
3901 
3908  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
3909  return LineIntersecting(start, direction, true);
3910  }
3911 
3918  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
3919  Vector_3D<F> const direction = point2 - point1;
3920  return LineIntersecting(point1, direction, false);
3921  }
3922 
3928  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3929  Float::replace_if_smaller(min.x, cuboid.min.x);
3930  Float::replace_if_smaller(min.y, cuboid.min.y);
3931  Float::replace_if_smaller(min.z, cuboid.min.z);
3932  Float::replace_if_larger(max.x, cuboid.max.x);
3933  Float::replace_if_larger(max.y, cuboid.max.y);
3934  Float::replace_if_larger(max.z, cuboid.max.z);
3935  }
3936 
3942  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
3943 
3949  HPS_INLINE void Merge(Point_3D<F> const & point) {
3950  Float::replace_if_smaller(min.x, point.x);
3951  Float::replace_if_smaller(min.y, point.y);
3952  Float::replace_if_smaller(min.z, point.z);
3953  Float::replace_if_larger(max.x, point.x);
3954  Float::replace_if_larger(max.y, point.y);
3955  Float::replace_if_larger(max.z, point.z);
3956  }
3957 
3964  void Merge(size_t count, Point_3D<F> const * points) {
3965  while (count > 1) {
3966  if (Compare(points[0].x, points[1].x)>0) {
3967  Float::replace_if_smaller(min.x, points[1].x);
3968  Float::replace_if_larger(max.x, points[0].x);
3969  }
3970  else {
3971  Float::replace_if_smaller(min.x, points[0].x);
3972  Float::replace_if_larger(max.x, points[1].x);
3973  }
3974 
3975  if (Compare(points[0].y, points[1].y)>0) {
3976  Float::replace_if_smaller(min.y, points[1].y);
3977  Float::replace_if_larger(max.y, points[0].y);
3978  }
3979  else {
3980  Float::replace_if_smaller(min.y, points[0].y);
3981  Float::replace_if_larger(max.y, points[1].y);
3982  }
3983 
3984  if (Compare(points[0].z, points[1].z)>0) {
3985  Float::replace_if_smaller(min.z, points[1].z);
3986  Float::replace_if_larger(max.z, points[0].z);
3987  }
3988  else {
3989  Float::replace_if_smaller(min.z, points[0].z);
3990  Float::replace_if_larger(max.z, points[1].z);
3991  }
3992 
3993  points += 2;
3994  count -= 2;
3995  }
3996 
3997  if (count > 0)
3998  Merge(*points);
3999  }
4000 
4006  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
4007  return (contained.min.x >= min.x &&
4008  contained.min.y >= min.y &&
4009  contained.min.z >= min.z &&
4010  contained.max.x <= max.x &&
4011  contained.max.y <= max.y &&
4012  contained.max.z <= max.z);
4013  }
4014 
4020  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
4021  return (contained.x >= min.x &&
4022  contained.y >= min.y &&
4023  contained.z >= min.z &&
4024  contained.x <= max.x &&
4025  contained.y <= max.y &&
4026  contained.z <= max.z);
4027  }
4028 
4035  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4036  return (contained.x >= min.x - epsilon &&
4037  contained.y >= min.y - epsilon &&
4038  contained.z >= min.z - epsilon &&
4039  contained.x <= max.x + epsilon &&
4040  contained.y <= max.y + epsilon &&
4041  contained.z <= max.z + epsilon);
4042  }
4043 
4049  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4050  Float::replace_if_larger(min.x, cuboid.min.x);
4051  Float::replace_if_larger(min.y, cuboid.min.y);
4052  Float::replace_if_larger(min.z, cuboid.min.z);
4053  Float::replace_if_smaller(max.x, cuboid.max.x);
4054  Float::replace_if_smaller(max.y, cuboid.max.y);
4055  Float::replace_if_smaller(max.z, cuboid.max.z);
4056  return *this;
4057  }
4058 
4064  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4065  Float::replace_if_smaller(min.x, cuboid.min.x);
4066  Float::replace_if_smaller(min.y, cuboid.min.y);
4067  Float::replace_if_smaller(min.z, cuboid.min.z);
4068  Float::replace_if_larger(max.x, cuboid.max.x);
4069  Float::replace_if_larger(max.y, cuboid.max.y);
4070  Float::replace_if_larger(max.z, cuboid.max.z);
4071  return *this;
4072  }
4073 
4079  HPS_INLINE Cuboid_3D & Expand(F border) {
4080  Vector_3D<F> delta (border, border, border);
4081  min -= delta;
4082  max += delta;
4083  return *this;
4084  }
4085 
4091  HPS_INLINE Cuboid_3D & Contract(F border) {
4092  Vector_3D<F> delta (border, border, border);
4093  min += delta;
4094  max -= delta;
4095  return *this;
4096  }
4097 
4098 private:
4099  HPS_INLINE static Point_3D<F> Limit_Point () {
4100  F const limit = std::numeric_limits<F>::max();
4101  return Point_3D<F> (limit, limit, limit);
4102  }
4103 
4104  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4105 };
4106 
4107 typedef Cuboid_3D<float> SimpleCuboid;
4108 typedef Cuboid_3D<double> DSimpleCuboid;
4109 
4110 
4111 template <typename F>
4112 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4113  Cuboid_3D<F> temp = a;
4114  return temp.Intersect(b);
4115 }
4116 
4117 template <typename F>
4118 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4119  Cuboid_3D<F> temp = a;
4120  return temp.Union(b);
4121 }
4122 
4123 template <typename F>
4124 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4125  Cuboid_3D<F> temp = a;
4126  return temp.Expand(border);
4127 }
4128 
4129 template <typename F>
4130 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4131  Cuboid_3D<F> temp = a;
4132  return temp.Contract(border);
4133 }
4134 
4135 
4136 
4137 template <typename F>
4138 struct HPS_TEMPLATE_API Sphere_3D {
4139  Point_3D<F> center;
4140  F radius;
4141 
4142  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4143 
4144  template <typename D>
4145  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4146 
4147  Sphere_3D (Cuboid_3D<F> const & cuboid) :
4148  center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4149 
4150  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4151 
4152  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4153  Cuboid_3D<F> cuboid(count, points);
4154  center = Midpoint(cuboid.min, cuboid.max);
4155  Engulf (count, points);
4156  }
4157 
4158  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4159  Engulf (count, points);
4160  }
4161 
4162  HPS_INLINE bool IsValid() const {
4163  return radius >= 0;
4164  }
4165 
4166  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4167 
4168  void Invalidate() {radius = -1;}
4169 
4170  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4171  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4172 
4173  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4174 
4175  HPS_INLINE void Merge(Point_3D<F> const & point) {
4176  Vector_3D<F> dir = point - center;
4177  F distance = (F)dir.Length();
4178 
4179  if (distance > radius) {
4180  F t = F(0.5) * (distance - radius);
4181  center += t * dir.Normalize();
4182  radius += t;
4183  }
4184  }
4185 
4186  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4187 
4188  for (size_t i = 0; i < count; ++i) {
4189  Vector_3D<F> dir = *points - center;
4190  F distance = (F)dir.Length();
4191 
4192  if (distance > radius) {
4193  F t = F(0.5) * (distance - radius);
4194  center += t * dir.Normalize();
4195  radius += t;
4196  }
4197 
4198  ++points;
4199  }
4200  }
4201 
4202  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4203  Vector_3D<F> dir = sphere.center - center;
4204  F distance = (F)dir.Length();
4205 
4206  if (distance + sphere.radius > radius) {
4207  if (distance + radius > sphere.radius) {
4208  F t = F(0.5 * (sphere.radius + distance - radius));
4209  center += t * dir.Normalize();
4210  radius += t;
4211  }
4212  else {
4213  center = sphere.center;
4214  radius = sphere.radius;
4215  }
4216  }
4217  }
4218 
4219  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4220 
4221 private:
4222  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4223  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4224  for (size_t i = 0; i < count; ++i) {
4225  double dsq = (*points++ - center).LengthSquared();
4226  if ((F)dsq > radius * radius)
4227  radius = (F)sqrt(dsq);
4228  }
4229  }
4230 };
4231 
4232 typedef Sphere_3D<float> SimpleSphere;
4233 typedef Sphere_3D<double> DSimpleSphere;
4234 
4235 
4236 template <typename F>
4237 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4238  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4239  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4240 }
4241 
4242 
4243 
4244 
4245 class RGB24Color;
4246 class RGBA32Color;
4247 class RGBAS32Color;
4248 class RGBAColor;
4249 
4250 class HPS_API RGBColor {
4251 public:
4252  float red;
4253  float green;
4254  float blue;
4255 
4256  HPS_INLINE RGBColor () {}
4257  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4258  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4259  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4260  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4261  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4262  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4263 
4264  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4265  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4266  float Distance(RGBColor const & other_color) const;
4267  HPS_INLINE bool IsValid() const {
4268  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4269  }
4270 
4271  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4272  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4273 
4274  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4275  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4276 
4277  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4278  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4279  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4280  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4281  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4282  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4283 
4284  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4285  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4286  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4287  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4288  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4289  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4290  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4291  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4292 
4293  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4294  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4295  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4296 
4297  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4298  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4299  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4300 
4301  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4302  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4303  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4304 };
4305 
4306 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4307 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4308 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4309 
4310 
4311 class HPS_API RGBAColor {
4312 public:
4313 
4314  float red;
4315  float green;
4316  float blue;
4317  float alpha;
4319  HPS_INLINE RGBAColor () {}
4320  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4321  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4322 
4323  HPS_INLINE RGBAColor (RGBColor const & c) {
4324  memcpy(this, &c, sizeof(RGBColor)); //-V512
4325  alpha = 1.0f;
4326  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4327  }
4328  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4329  memcpy(this, &c, sizeof(RGBColor));
4330  memcpy(&alpha, &a, sizeof(float));
4331  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4332  }
4333  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4334  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4335 
4336  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4337  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4338  HPS_INLINE bool IsValid() const {
4339  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4340  }
4341 
4348  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4349 
4356  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4357 
4358  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4359  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4360  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4361  }
4362 
4363  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4364  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4365  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4366  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4367  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4368  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4369 
4370  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4371  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4372  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4373  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4374  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4375  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4376  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4377  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4378 
4379  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4380  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4381  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4382  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4383  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4384  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4385 
4386  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4387  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4388  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4389  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4390 };
4391 
4392 
4393 
4395 public:
4396  enum Order {
4397  Order_ABGR,
4398  Order_RGBA,
4399  Order_BGRA
4400  };
4401 
4402 #ifdef _MSC_VER
4403  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4404  unsigned char b, g, r, a;
4405 #endif
4406 
4407 #ifdef __linux__
4408  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4409  unsigned char r, g, b, a;
4410 #endif
4411 
4412 #ifdef __APPLE_CC__
4413  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4414  unsigned char r, g, b, a;
4415 #endif
4416 };
4417 
4418 
4419 
4421 public:
4422 
4423  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4424  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4425  r = gray;
4426  g = gray;
4427  b = gray;
4428  a = aa;
4429  }
4430  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4431  r = rr;
4432  g = gg;
4433  b = bb;
4434  a = aa;
4435  }
4436  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4437 
4438  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4439  {
4440  r = Float::unit_to_byte(c.red);
4441  g = Float::unit_to_byte(c.green);
4442  b = Float::unit_to_byte(c.blue);
4443  a = 255;
4444  }
4445 
4446  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4447 
4448  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4449 
4450  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4451  {
4452  r = Float::unit_to_byte(c.red);
4453  g = Float::unit_to_byte(c.green);
4454  b = Float::unit_to_byte(c.blue);
4455  a = Float::unit_to_byte(alpha);
4456  }
4457  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4458  {
4459  r = Float::unit_to_byte(c.red);
4460  g = Float::unit_to_byte(c.green);
4461  b = Float::unit_to_byte(c.blue);
4462  a = aa;
4463  }
4464  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4465  {
4466  r = Float::unit_to_byte(c.red);
4467  g = Float::unit_to_byte(c.green);
4468  b = Float::unit_to_byte(c.blue);
4469  a = Float::unit_to_byte(c.alpha);
4470  }
4471  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4472  {
4473  r = Float::unit_to_byte(c.red);
4474  g = Float::unit_to_byte(c.green);
4475  b = Float::unit_to_byte(c.blue);
4476  a = Float::unit_to_byte_scaled(c.alpha, mix);
4477  }
4478 
4479  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4480  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4481  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4482 
4483  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4484  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4485 
4486  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4487  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4488  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4489 
4490  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4491 };
4492 
4494 public:
4495  unsigned char r;
4496  unsigned char g;
4497  unsigned char b;
4498  unsigned char a;
4499 
4500  HPS_INLINE RGBA32Color () {}
4501  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4502  : r (gray), g (gray), b (gray), a (aa) {}
4503  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4504  : r (rr), g (gg), b (bb), a (aa) {}
4505  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4506  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4507  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4508  r = Float::unit_to_byte(c.red);
4509  g = Float::unit_to_byte(c.green);
4510  b = Float::unit_to_byte(c.blue);
4511  a = 255;
4512  }
4513  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
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 = Float::unit_to_byte(alpha);
4518  }
4519  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4520  r = Float::unit_to_byte(c.red);
4521  g = Float::unit_to_byte(c.green);
4522  b = Float::unit_to_byte(c.blue);
4523  a = aa;
4524  }
4525  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
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(c.alpha);
4530  }
4531  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4532  r = Float::unit_to_byte(c.red);
4533  g = Float::unit_to_byte(c.green);
4534  b = Float::unit_to_byte(c.blue);
4535  a = Float::unit_to_byte_scaled(c.alpha, mix);
4536  }
4537 
4538  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4539  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4540 
4541  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4542  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4543 
4544  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4545  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4546 
4547  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4548 };
4549 
4550 
4552 {
4553 public:
4554  unsigned char r;
4555  unsigned char g;
4556  unsigned char b;
4557 
4558  HPS_INLINE RGB24Color () {}
4559  explicit HPS_INLINE RGB24Color (unsigned char gray)
4560  : r (gray), g (gray), b (gray) {}
4561  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4562  : r (rr), g (gg), b (bb) {}
4563  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4564  r = Float::unit_to_byte(c.red);
4565  g = Float::unit_to_byte(c.green);
4566  b = Float::unit_to_byte(c.blue);
4567  }
4568 
4569  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4570  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4571 
4572  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4573  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4574 };
4575 
4576 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4577  red = Float::C2F(c32.r);
4578  green = Float::C2F(c32.g);
4579  blue = Float::C2F(c32.b);
4580 }
4581 
4582 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4583  red = Float::C2F(c32.r);
4584  green = Float::C2F(c32.g);
4585  blue = Float::C2F(c32.b);
4586 }
4587 
4588 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4589  red = c.red;
4590  green = c.green;
4591  blue = c.blue;
4592 }
4593 
4594 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4595  red = Float::C2F(c24.r);
4596  green = Float::C2F(c24.g);
4597  blue = Float::C2F(c24.b);
4598 }
4599 
4600 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4601 {
4602  r = c.r;
4603  g = c.g;
4604  b = c.b;
4605  a = 255;
4606 }
4607 
4608 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4609 {
4610  r = c.r;
4611  g = c.g;
4612  b = c.b;
4613  a = c.a;
4614 }
4615 
4616 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4617  red = Float::C2F(c32.r);
4618  green = Float::C2F(c32.g);
4619  blue = Float::C2F(c32.b);
4620  alpha = Float::C2F(c32.a);
4621 }
4622 
4623 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4624  red = Float::C2F(c32.r);
4625  green = Float::C2F(c32.g);
4626  blue = Float::C2F(c32.b);
4627  alpha = Float::C2F(c32.a);
4628 }
4629 
4630 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4631  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4632 }
4633 
4634 
4635 
4636 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4637  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4638 }
4639 
4640 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4641  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);
4642 }
4643 
4644 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4645  return RGBAS32Color(
4646  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4647  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4648  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4649  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4650 }
4651 
4652 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4653  return RGBA32Color(
4654  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4655  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4656  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4657  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4658 }
4659 
4660 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4661  return RGB24Color(
4662  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4663  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4664  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4665 }
4666 
4667 
4668 
4669 class HPS_API Quaternion {
4670 public:
4671  float w;
4672  float x;
4673  float y;
4674  float z;
4675 
4676  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4677 
4678  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) { }
4679 
4680  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4681 
4682  Quaternion const & Normalize() {
4683  float mag = Norm();
4684 
4685  if (mag > 0) {
4686  w /= mag;
4687  x /= mag;
4688  y /= mag;
4689  z /= mag;
4690  }
4691  return *this;
4692  }
4693 
4694 
4695  Quaternion operator* (Quaternion const & in_right) const {
4696  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4697  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4698  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4699  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4700  }
4701 
4702  Quaternion operator* (float in_right) const {
4703  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4704  }
4705 
4706  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4707  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4708  }
4709 
4710  Quaternion operator/ (float in_right) const {
4711  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4712  }
4713 
4714  Quaternion operator- (Quaternion const & in_right) const {
4715  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4716  }
4717 
4718  Quaternion operator+ (Quaternion const & in_right) const {
4719  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4720  }
4721 
4722  inline float Norm() const {
4723  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4724  }
4725 
4726 
4727  Quaternion Log() const {
4728  Quaternion ret;
4729  float mag_q = Norm();
4730  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4731 
4732  ret.w = static_cast<float>(log(mag_q));
4733 
4734  if (mag_V > 0) {
4735  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4736 
4737  ret.x = x * scale;
4738  ret.y = y * scale;
4739  ret.z = z * scale;
4740  }
4741  else
4742  ret.x = ret.y = ret.z = 0;
4743 
4744  return ret;
4745  }
4746 
4747  Quaternion Exp() const {
4748  Quaternion ret;
4749  float ea = static_cast<float>(exp(w));
4750  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4751  float scale = ea * sin(mag_V) / mag_V;
4752 
4753  ret.w = ea * cos(mag_V);
4754  ret.x = scale * x;
4755  ret.y = scale * y;
4756  ret.z = scale * z;
4757 
4758  return ret;
4759  }
4760 
4761  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4762  Quaternion ret = *this + in_fraction * (in_right - *this);
4763  return ret.Normalize();
4764  }
4765 
4766 
4767  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4768  Quaternion q3;
4769  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4770 
4771  if (in_shortest_path_only && dot < 0) {
4772  dot = -dot;
4773  q3 = -1 * in_right;
4774  }
4775  else
4776  q3 = in_right;
4777 
4778  if (dot > -0.95f && dot < 0.95f) {
4779  float angle = static_cast<float>(acos(dot));
4780  float sina = static_cast<float>(sin(angle));
4781  float sinat = static_cast<float>(sin(angle*in_fraction));
4782  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4783 
4784  return (*this * sinaomt + q3 * sinat) / sina;
4785  }
4786  else //if the angle is small, we use linear interpolation
4787  return Lerp(q3, in_fraction);
4788  }
4789 
4790 
4791  /*
4792  Spherical cubic interpolation between two Quaternions
4793  \param in_right The Quaternion for interpolation.
4794  \param in_control1 The first control point.
4795  \param in_control2 The second control point.
4796  \param in_fraction Interpolation distance (0 - 1).
4797  \return Result of interpolation.
4798  */
4799  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4800  Quaternion q1 = Slerp(in_right , in_fraction, false);
4801  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4802 
4803  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4804  }
4805 
4812  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4813  Quaternion qni(w, -x, -y, -z);
4814 
4815  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4816  }
4817 
4818 };
4819 
4821 {
4822  size_t dot_dc_count;
4823  size_t dot_3d_count;
4824  size_t line_dc_count;
4825  size_t line_3d_count;
4838  size_t raster_count;
4839  size_t segment_count;
4846 };
4847 
4848 typedef unsigned char byte;
4849 typedef signed char sbyte;
4850 typedef intptr_t WindowHandle;
4851 typedef int64_t TouchID;
4852 typedef intptr_t PlatformData;
4853 typedef intptr_t OpaqueHandle;
4854 
4855 /*
4856 HPS Lexicon:
4857 
4858 Concept Class -- A class that contains only enums and possibly static functions. The
4859  constructor is usually private because they are not intended to be instantiated.
4860 
4861 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4862  database objects is subject to locking to prevent threading deadlocks. (2) The class
4863  of the same name, offering static functions to initiate operations that take place
4864  within the database.
4865 
4866 Key -- A reference counted smart pointer to an object in the database. The
4867 
4868 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4869  option group, or other type. Modifying a kit has no effect on the database unless
4870  and until it is applied. Kits should generally be passed by reference because they
4871  are potentially very large and copying them can be arduous.
4872 
4873 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4874  pointers should generally be passed by value to ensure the reference count is
4875  correct.
4876 
4877 User Space -- The external space occupied by all user code. User space objects are not
4878  in the database and are not subject to locking.
4879 
4880 */
4881 
4885 class SegmentKey;
4886 class AttributesControl;
4887 class LineKit;
4888 class LineKey;
4889 class TextKey;
4890 class TextKit;
4891 class Key;
4892 class VisibilityControl;
4893 class CameraControl;
4894 class SelectabilityControl;
4895 class TransparencyKit;
4896 class TransparencyControl;
4897 class CullingKit;
4898 class CullingControl;
4899 class GlyphKit;
4901 class GlyphDefinition;
4902 class GeometryInsertControl;
4903 class GlyphElement;
4904 class TextAttributeControl;
4905 class TextAttributeKit;
4906 class LineAttributeKit;
4907 class LineAttributeControl;
4908 class EdgeAttributeKit;
4909 class EdgeAttributeControl;
4910 class CurveAttributeKit;
4911 class CurveAttributeControl;
4912 class GlyphPoint;
4913 class MatrixKit;
4915 class TextureMatrixControl;
4916 class TextureDefinition;
4917 class MaterialMappingKit;
4919 class MaterialKit;
4920 class MarkerKit;
4921 class MarkerKey;
4922 class DistantLightKit;
4923 class DistantLightKey;
4924 class CuttingSectionKit;
4925 class CuttingSectionKey;
4928 class CylinderAttributeKit;
4930 class Cylinder;
4931 class CylinderKey;
4932 class CylinderKit;
4933 class SphereKey;
4934 class SphereKit;
4935 class SphereAttributeKit;
4937 class PolygonKit;
4938 class PolygonKey;
4939 class CircleKey;
4940 class CircleKit;
4941 class CircularArcKey;
4942 class CircularArcKit;
4943 class CircularWedgeKey;
4944 class CircularWedgeKit;
4945 class IncludeKey;
4946 class InfiniteLineKey;
4947 class InfiniteLineKit;
4948 class SpotlightKey;
4949 class SpotlightKit;
4950 class NURBSCurveKey;
4951 class NURBSCurveKit;
4952 class NURBSSurfaceKey;
4953 class NURBSSurfaceKit;
4954 class TrimKit;
4955 class TrimElement;
4956 class EllipseKey;
4957 class EllipseKit;
4958 class EllipticalArcKey;
4959 class EllipticalArcKit;
4960 class ShellKit;
4961 class ShellKey;
4962 class Shell;
4963 class MeshKit;
4964 class MeshKey;
4965 class WindowKey;
4966 class Database;
4969 class Driver;
4970 class Search;
4971 class PerformanceKit;
4972 class PerformanceControl;
4975 class DrawingAttributeKit;
4977 class PortfolioKey;
4978 class Selection;
4979 class SelectionOptionsKit;
4980 class SelectionResults;
4981 class SelectionItem;
4982 class SelectionControl;
4983 class HighlightControl;
4984 class HighlightOptionsKit;
4985 class ImageDefinition;
4986 class ImageKit;
4987 class TextureDefinition;
4988 class TextureOptionsKit;
4989 class NamedStyleDefinition;
4991 class GlyphDefinition;
4992 class LinePatternOptionsKit;
4993 class LinePatternDefinition;
4994 class LinePatternKit;
4995 class LinePatternElement;
4997 class CubeMapDefinition;
4998 class ShaderKit;
4999 class ShaderDefinition;
5000 class EmergencyHandler;
5001 class EventDispatcher;
5002 class EventHandler;
5003 class Event;
5004 class StandAloneWindowKey;
5006 class ApplicationWindowKey;
5008 class OffScreenWindowKey;
5011 class VisualEffectsControl;
5014 class ObjectPoint;
5015 class WorldPoint;
5016 class CameraPoint;
5017 class NormalizedPoint;
5018 class ScreenRangePoint;
5019 class InnerWindowPoint;
5020 class InnerPixelPoint;
5021 class WindowPoint;
5022 class PixelPoint;
5023 class VisibilityKit;
5024 class CameraKit;
5025 class SelectabilityKit;
5026 class MarkerAttributeKit;
5027 class LightingAttributeKit;
5028 class VisualEffectsKit;
5029 class PostProcessEffectsKit;
5030 class Portfolio;
5031 class SubwindowControl;
5032 class SubwindowKit;
5033 class World;
5034 class DebuggingControl;
5035 class DebuggingKit;
5036 class KeyPath;
5037 class ContourLineKit;
5038 class ContourLineControl;
5039 class UTF8;
5040 class StyleControl;
5041 class PortfolioControl;
5042 class ConditionalExpression;
5043 class ConditionControl;
5044 class WindowInfoKit;
5045 class WindowInfoControl;
5046 class FontInfoState;
5047 class FontInfoControl;
5048 class SearchOptionsKit;
5049 class AttributeLockControl;
5050 class AttributeLockKit;
5051 class ReferenceKey;
5052 class StyleKey;
5053 class BoundingKit;
5054 class BoundingControl;
5055 class TransformMaskKit;
5056 class TransformMaskControl;
5057 class ColorInterpolationKit;
5059 class UpdateOptionsKit;
5060 class UpdateOptionsControl;
5061 class GeometryKey;
5062 class TreeContext;
5065 class GridKit;
5066 class GridKey;
5069 
5073 
5074 
5077 class HPS_API GlyphPoint
5078 {
5079 public:
5080 
5082  GlyphPoint();
5083 
5088  GlyphPoint(sbyte in_x, sbyte in_y);
5089 
5094  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5095 
5100  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5101 
5106  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5107 
5108  sbyte x;
5109  sbyte y;
5110 };
5111 
5114 enum class Type : uint32_t
5115 {
5116  None = 0x00000000,
5117  GenericMask = 0xffffff00,
5118 
5119  World = 0x00000001,
5120  UTF8 = 0x00000002,
5121  EventDispatcher = 0x00000003,
5122  EventHandler = 0x00000004,
5123  EventNotifier = 0x00000005,
5124  UpdateNotifier = 0x00000006,
5125  SearchResults = 0x00000008,
5126  FontSearchResults = 0x00000009,
5127  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
5128  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5129  SelectionResults = 0x0000000c,
5130  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5131  SelectionItem = 0x0000000e,
5132  TreeContext = 0x0000000f,
5133  StreamToolkit = 0x00000010,
5134  DriverEventHandler = 0x00000011,
5135 
5136  IONotifier = 0x04000100,
5137  StreamImportNotifier = 0x04000101,
5138  STLImportNotifier = 0x04000102,
5139  OBJImportNotifier = 0x04000103,
5140  ExchangeImportNotifier = 0x04000104,
5141  SketchupImportNotifier = 0x04000105,
5142  ParasolidImportNotifier = 0x04000106,
5143  ExchangeTranslationNotifier = 0x04000107,
5144  ExchangeExportNotifier = 0x04000108,
5145  StreamExportNotifier = 0x04000109,
5146  ExchangeReloadNotifier = 0x0400010a,
5147  DWGImportNotifier = 0x0400010b,
5148  ExchangeParasolidImportNotifier = 0x0400010c,
5149 
5150  Kit = 0x01000000,
5151  MarkerKit = 0x01000010,
5152  SphereAttributeKit = 0x01000011,
5153  TextAttributeKit = 0x01000012,
5154  TransparencyKit = 0x01000013,
5155  VisibilityKit = 0x01000014,
5156  VisualEffectsKit = 0x01000015,
5157  CuttingSectionAttributeKit = 0x01000016,
5158  CircleKit = 0x01000017,
5159  CircularArcKit = 0x01000018,
5160  CircularWedgeKit = 0x01000019,
5161  CuttingSectionKit = 0x0100001a,
5162  CylinderKit = 0x0100001b,
5163  DistantLightKit = 0x0100001c,
5164  EllipseKit = 0x0100001d,
5165  EllipticalArcKit = 0x0100001e,
5166  InfiniteLineKit = 0x0100001f,
5167  LineKit = 0x01000020,
5168  NURBSCurveKit = 0x01000021,
5169  MeshKit = 0x01000022,
5170  NURBSSurfaceKit = 0x01000023,
5171  PolygonKit = 0x01000024,
5172  SphereKit = 0x01000025,
5173  SpotlightKit = 0x01000026,
5174  ShellKit = 0x01000027,
5175  TextKit = 0x01000028,
5176  MaterialKit = 0x01000029,
5177  TrimKit = 0x0100002a,
5178  TextureOptionsKit = 0x0100002c,
5179  LinePatternKit = 0x0100002d,
5180  GlyphKit = 0x0100002e,
5181  ImageKit = 0x0100002f,
5182  LinePatternOptionsKit = 0x01000030,
5183  CameraKit = 0x01000031,
5184  BoundingKit = 0x01000032,
5185  CullingKit = 0x01000033,
5186  CurveAttributeKit = 0x01000034,
5187  CylinderAttributeKit = 0x01000035,
5188  EdgeAttributeKit = 0x01000036,
5189  LightingAttributeKit = 0x01000037,
5190  LineAttributeKit = 0x01000038,
5191  MarkerAttributeKit = 0x01000039,
5192  MaterialMappingKit = 0x0100003a,
5193  MatrixKit = 0x0100003b,
5194  NURBSSurfaceAttributeKit = 0x0100003c,
5195  PostProcessEffectsKit = 0x0100003d,
5196  SelectabilityKit = 0x0100003e,
5197  SelectionOptionsKit = 0x0100003f,
5198  StandAloneWindowOptionsKit = 0x01000040,
5199  OffScreenWindowOptionsKit = 0x01000041,
5200  ApplicationWindowOptionsKit = 0x01000042,
5201  HighlightOptionsKit = 0x01000043,
5202  LinePatternParallelKit = 0x01000044,
5203  SubwindowKit = 0x01000045,
5204  PerformanceKit = 0x01000046,
5205  HiddenLineAttributeKit = 0x01000047,
5206  DrawingAttributeKit = 0x01000048,
5207  ShaderKit = 0x01000049,
5208  DebuggingKit = 0x0100004a,
5209  ContourLineKit = 0x0100004b,
5210  StreamImportOptionsKit = 0x0100004c,
5211  StreamImportResultsKit = 0x0100004d,
5212  StreamExportOptionsKit = 0x0100004e,
5213  StreamExportResultsKit = 0x0100004f,
5214  WindowInfoKit = 0x01000050,
5215  ImageImportOptionsKit = 0x01000051,
5216  SearchOptionsKit = 0x01000052,
5217  ShaderImportOptionsKit = 0x01000053,
5218  HardcopyExportOptionsKit = 0x01000055,
5219  AttributeLockKit = 0x01000056,
5220  TransformMaskKit = 0x01000057,
5221  ColorInterpolationKit = 0x01000058,
5222  UpdateOptionsKit = 0x01000059,
5223  ImageExportOptionsKit = 0x0100005a,
5224  OBJImportOptionsKit = 0x0100005b,
5225  OBJImportResultsKit = 0x0100005c,
5226  STLImportOptionsKit = 0x0100005d,
5227  STLImportResultsKit = 0x0100005e,
5228  ShellOptimizationOptionsKit = 0x0100005f,
5229  ShellRelationOptionsKit = 0x01000060,
5230  ShellRelationResultsKit = 0x01000061,
5231  GridKit = 0x01000062,
5232  CutGeometryGatheringOptionsKit = 0x01000063,
5233  SegmentOptimizationOptionsKit = 0x01000064,
5234 
5235 
5236  LinePatternElement = 0x03000000,
5237  SolidLinePatternElement = 0x03000001,
5238  BlankLinePatternElement = 0x03000002,
5239  GlyphLinePatternElement = 0x03000003,
5240 
5241  GlyphElement = 0x05000000,
5242  DotGlyphElement = 0x05000001,
5243  LineGlyphElement = 0x05000002,
5244  EllipseGlyphElement = 0x05000003,
5245  CircularArcGlyphElement = 0x05000004,
5246  InfiniteLineGlyphElement = 0x05000005,
5247  SphereGlyphElement = 0x05000006,
5248 
5249  TrimElement = 0x07000000,
5250 
5251  ConditionalExpression = 0x09000000,
5252  NOTCondition = 0x09000001,
5253  ANDCondition = 0x09000002,
5254  ORCondition = 0x09000003,
5255  XORCondition = 0x09000004,
5256  EQCondition = 0x09000005,
5257  NEQCondition = 0x09000006,
5258  GTCondition = 0x09000007,
5259  LTCondition = 0x09000008,
5260  GTEQCondition = 0x09000009,
5261  LTEQCondition = 0x0900000A,
5262 
5263  MouseState = 0x01001001,
5264  TouchState = 0x01001002,
5265  KeyboardState = 0x01001003,
5266  FontInfoState = 0x01001004,
5267 
5268  KeyPath = 0x01000F01,
5269 
5270  Key = 0x10000000,
5271  IncludeKey = 0x10000001,
5272  PortfolioKey = 0x10000002,
5273  StyleKey = 0x10000003,
5274 
5275  SegmentKey = 0x10200000,
5276  WindowKey = 0x10600000,
5277  StandAloneWindowKey = 0x10600001,
5278  OffScreenWindowKey = 0x10600002,
5279  ApplicationWindowKey = 0x10600003,
5280 
5281  GeometryKey = 0x10100000,
5282  ReferenceKey = 0x10100001,
5283  CircleKey = 0x10100002,
5284  CircularArcKey = 0x10100003,
5285  CircularWedgeKey = 0x10100004,
5286  CuttingSectionKey = 0x10100005,
5287  CylinderKey = 0x10100006,
5288  EllipseKey = 0x10100007,
5289  EllipticalArcKey = 0x10100008,
5290  InfiniteLineKey = 0x10100009,
5291  LineKey = 0x1010000a,
5292  DistantLightKey = 0x1010000b,
5293  SpotlightKey = 0x1010000c,
5294  MarkerKey = 0x1010000d,
5295  MeshKey = 0x1010000e,
5296  NURBSCurveKey = 0x1010000f,
5297  NURBSSurfaceKey = 0x10100010,
5298  PolygonKey = 0x10100011,
5299  ShellKey = 0x10100012,
5300  SphereKey = 0x10100013,
5301  TextKey = 0x10100014,
5302  GridKey = 0x10100015,
5303 
5304  Definition = 0x20000000,
5305  NamedStyleDefinition = 0x20000001,
5306  TextureDefinition = 0x20000002,
5307  LinePatternDefinition = 0x20000003,
5308  GlyphDefinition = 0x20000004,
5309  CubeMapDefinition = 0x20000005,
5310  ImageDefinition = 0x20000006,
5311  MaterialPaletteDefinition = 0x20000007,
5312  ShaderDefinition = 0x20000008,
5313 
5314  Control = 0x50000000,
5315  CameraControl = 0x50000001,
5316  SelectabilityControl = 0x50000002,
5317  MarkerAttributeControl = 0x50000003,
5318  SphereAttributeControl = 0x50000004,
5319  LightingAttributeControl = 0x50000005,
5320  CylinderAttributeControl = 0x50000006,
5321  TextAttributeControl = 0x50000007,
5322  LineAttributeControl = 0x50000008,
5323  EdgeAttributeControl = 0x50000009,
5324  CurveAttributeControl = 0x5000000a,
5325  ModellingMatrixControl = 0x5000000b,
5326  TextureMatrixControl = 0x5000000c,
5327  CullingControl = 0x5000000d,
5328  TransparencyControl = 0x5000000e,
5329  MaterialMappingControl = 0x5000000f,
5330  NURBSSurfaceAttributeControl = 0x50000010,
5331  PostProcessEffectsControl = 0x50000011,
5332  BoundingControl = 0x50000012,
5333  VisualEffectsControl = 0x50000013,
5334  SelectionOptionsControl = 0x50000014,
5335  HighlightOptionsControl = 0x50000015,
5336  DefinitionControl = 0x50000016,
5337  SelectionControl = 0x50000017,
5338  HighlightControl = 0x50000018,
5339  StandAloneWindowOptionsControl = 0x50000019,
5340  OffScreenWindowOptionsControl = 0x5000001a,
5341  ApplicationWindowOptionsControl = 0x5000001b,
5342  VisibilityControl = 0x5000001c,
5343  SubwindowControl = 0x5000001d,
5344  PerformanceControl = 0x5000001e,
5345  HiddenLineAttributeControl = 0x5000001f,
5346  DrawingAttributeControl = 0x50000020,
5347  DebuggingControl = 0x50000021,
5348  ContourLineControl = 0x50000022,
5349  StyleControl = 0x50000023,
5350  ConditionControl = 0x50000024,
5351  PortfolioControl = 0x50000025,
5352  WindowInfoControl = 0x50000026,
5353  AttributeLockControl = 0x50000027,
5354  TransformMaskControl = 0x50000028,
5355  ColorInterpolationControl = 0x50000029,
5356  UpdateOptionsControl = 0x50000030,
5357  CuttingSectionAttributeControl = 0x50000031,
5358 
5359  LibraryMask = 0x80FF0000,
5360 
5361  Sprocket = 0x80000000,
5362  Canvas = 0x80000001,
5363  Layout = 0x80000002,
5364  View = 0x80000003,
5365  Model = 0x80000004,
5366  Operator = 0x80000005,
5367  SprocketPath = 0x80000007,
5368 
5369  SprocketControl = 0xD0000000,
5370  OperatorControl = 0xD0000008,
5371  NavigationCubeControl = 0xD0000009,
5372  AxisTriadControl = 0xD000000A,
5373 
5374  Metadata = 0x80001000,
5375  IntegerMetadata = 0x80001001,
5376  UnsignedIntegerMetadata = 0x80001002,
5377  DoubleMetadata = 0x80001003,
5378  StringMetadata = 0x80001004,
5379  TimeMetadata = 0x80001005,
5380  BooleanMetadata = 0x80001006,
5381 
5382  Component = 0x80000200,
5383  Filter = 0x80000600,
5384  Capture = 0x80000a00,
5385  CADModel = 0x80000300,
5386  ComponentPath = 0x81001000,
5387 
5388  ExchangeMask = 0x80020000,
5389  ExchangeComponent = 0x80021200,
5390  ExchangeSheet = 0x80021201,
5391  ExchangeProductOccurrence = 0x80021202,
5392  ExchangeFilter = 0x80020601,
5393  ExchangeCapture = 0x80020a01,
5394  ExchangeCADModel = 0x80020301,
5395  ExchangeConfiguration = 0x81020001,
5396  ExchangeImportOptionsKit = 0x81020002,
5397  ExchangeExportACISOptionsKit = 0x81020003,
5398  ExchangeExportIGESOptionsKit = 0x81020004,
5399  ExchangeExportJTOptionsKit = 0x81020005,
5400  ExchangeExportParasolidOptionsKit = 0x81020006,
5401  ExchangeExportPRCOptionsKit = 0x81020007,
5402  ExchangeExportSTEPOptionsKit = 0x81020008,
5403  ExchangeExportSTLOptionsKit = 0x81020009,
5404  ExchangeExportU3DOptionsKit = 0x8102000a,
5405  ExchangeExportXMLOptionsKit = 0x8102000b,
5406  ExchangeTessellationOptionsKit = 0x8102000c,
5407  ExchangeModelFileImportOptionsKit = 0x8102000d,
5408  ExchangeTranslationOptionsKit = 0x8102000e,
5409 
5410  PublishMask = 0x80040000,
5411  PublishDocumentKit = 0x81040001,
5412  PublishPageKit = 0x81040002,
5413  PublishTemplateKit = 0x81040003,
5414  PublishAnnotationKit = 0x81040004,
5415  PublishArtworkKit = 0x81040005,
5416  PublishViewKit = 0x81040006,
5417  PublishTextKit = 0x81040007,
5418  PublishImageKit = 0x81040008,
5419  PublishTableKit = 0x81040009,
5420  PublishExportOptionsKit = 0x8104000a,
5421  PublishLinkKit = 0x8104000b,
5422  PublishButtonKit = 0x8104000c,
5423  PublishTextFieldKit = 0x8104000d,
5424  PublishSlideTableKit = 0x8104000e,
5425  PublishCheckBoxKit = 0x8104000f,
5426  PublishRadioButtonKit = 0x81040010,
5427  PublishListBoxKit = 0x81040011,
5428  PublishDropDownListKit = 0x81040012,
5429  PublishSignatureFieldKit = 0x81040013,
5430 
5431  PublishDocumentKey = 0x80040001,
5432  PublishPageControl = 0x80040002,
5433 
5434  ExchangeParasolidMask = 0x80080000,
5435 
5436  SceneTree = 0x80008001,
5437  SceneTreeItem = 0x80008002,
5438 
5439  ComponentTree = 0x80008003,
5440  ComponentTreeItem = 0x80008004,
5441 
5442  SketchupMask = 0x80100000,
5443  SketchupImportOptionsKit = 0x81100001,
5444  SketchupImportResultsKit = 0x81100002,
5445 
5446  ParasolidMask = 0x80200000,
5447  ParasolidComponent = 0x80201201,
5448  ParasolidCADModel = 0x80200302,
5449  ParasolidImportOptionsKit = 0x81200003,
5450  ParasolidFacetTessellationKit = 0x81200004,
5451  ParasolidLineTessellationKit = 0x81200005,
5452  ParasolidExportOptionsKit = 0x81200006,
5453 
5454  DWGMask = 0x80400000,
5455  DWGComponent = 0x80401201,
5456  DWGLayer = 0x80401202,
5457  DWGLayout = 0x80400a03,
5458  DWGCADModel = 0x80400304,
5459  DWGImportOptionsKit = 0x81400005,
5460 
5461  IONotifierData = 0x84000200,
5462  StreamImportNotifierData = 0x84000201,
5463  STLImportNotifierData = 0x84000202,
5464  OBJImportNotifierData = 0x84000203,
5465  ExchangeImportNotifierData = 0x84020204,
5466  SketchupImportNotifierData = 0x84100205,
5467  ParasolidImportNotifierData = 0x84200206,
5468  ExchangeTranslationNotifierData = 0x84020207,
5469  ExchangeExportNotifierData = 0x84020208,
5470  StreamExportNotifierData = 0x84000209,
5471  DWGImportNotifierData = 0x8440020a,
5472  ExchangeParasolidImportNotifierData = 0x8408020b,
5473 };
5474 
5476 class HPS_API Memory
5477 {
5478 public:
5484  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5485 
5486 
5491  static void Free(void * in_pointer);
5492 
5493 private:
5495  Memory();
5496 };
5497 
5498 
5500 template <typename T>
5501 class NO_HPS_API Allocator
5502 {
5503 public:
5504  typedef T value_type;
5505  typedef value_type * pointer;
5506  typedef value_type const * const_pointer;
5507  typedef value_type & reference;
5508  typedef value_type const & const_reference;
5509  typedef size_t size_type;
5510  typedef ptrdiff_t difference_type;
5511 
5512 
5513  Allocator() {}
5514  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5515  ~Allocator() {}
5516 
5517  template <typename U> Allocator(Allocator<U> const &) {}
5518 
5519  template <typename U>
5520  struct rebind
5521  {
5522  typedef Allocator<U> other;
5523  };
5524 
5525 
5526  pointer address(reference x) const { return &x; }
5527  const_pointer address(const_reference x) const { return &x; }
5528 
5529  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5530  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5531 
5532 #if defined(_MSC_VER) || defined (__APPLE__)
5533  void construct(pointer p, const_reference x) { new(p) T(x); }
5534  void construct(pointer p, value_type && x) { new(p) T(std::move(x)); }
5535 #else
5536  template<typename U, typename... Args>
5537  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5538 #endif
5539  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5540 
5541  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5542 };
5543 
5544 template <typename T, typename U>
5545 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5546 
5547 template <typename T, typename U>
5548 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5549 
5551 class Exception : public std::runtime_error
5552 {
5553 public:
5554  Exception(char const * in_info) : std::runtime_error(in_info) { }
5555 };
5556 
5557 
5560 {
5561 public:
5562  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5563  Exception(in_info) {}
5564 };
5565 
5566 
5570 {
5571 public:
5572  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5573  Exception(in_info) {}
5574 };
5575 
5576 
5579 {
5580 public:
5581  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5582  Exception(in_info) {}
5583 };
5584 
5585 
5588 {
5589 public:
5590  InvalidLicenseException(char const * in_info) :
5591  Exception(in_info) {}
5592 };
5593 
5594 
5597 {
5598 public:
5599  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5600  Exception(in_info) {}
5601 };
5602 
5604 class IOException : public Exception
5605 {
5606 public:
5610  IOException(char const * in_info, IOResult in_result)
5611  : Exception(in_info), result(in_result) {}
5612 
5613  IOResult result;
5614 };
5615 
5616 
5618 class HPS_API Object
5619 {
5620 public:
5621 
5622  Object();
5623 
5624  Object(Object const & that);
5625 
5626  virtual ~Object();
5627 
5628  Object & operator=(Object const & other_object);
5629 
5633  Object(Object && in_that);
5634 
5635 
5639  Object & operator=(Object && in_that);
5640 
5644  HPS::Type Type() const;
5645 
5649  virtual HPS::Type ObjectType() const { return HPS::Type::None; }
5650 
5653  virtual bool Empty() const {return (impl_ == 0);};
5654 
5656  virtual void Reset();
5657 
5661  bool HasType(HPS::Type in_mask) const;
5662 
5665  intptr_t GetClassID() const;
5666 
5670  intptr_t GetInstanceID() const;
5671 
5674  template <typename T>
5675  static intptr_t ClassID()
5676  {
5677  static const intptr_t ret = T().GetClassID();
5678  return ret;
5679  }
5680 private:
5681 
5682  friend class HPSI::Impl;
5683  friend class HPSI::KeyImpl;
5684  friend class HPSI::TicketImpl;
5685 
5686  HPSI::Impl * impl_;
5687 };
5688 
5689 
5691 class HPS_API Control : public Object
5692 {
5693  HPS::Type ObjectType() const {return HPS::Type::Control;}
5694 
5695 public:
5696 
5697 #if !defined(_MSC_VER) || _MSC_VER >= 1900
5698  Control(Control const & in_that) = default;
5699 #endif
5700 
5701 protected:
5702  Control() {}
5703 
5707  Control(Control && in_that) : Object(std::move(in_that)) {}
5708 
5712  Control & operator=(Control && in_that)
5713  {
5714  this->Object::operator=(std::move(in_that));
5715  return *this;
5716  }
5717 
5718 };
5719 
5720 
5722 class HPS_API ObjectPoint : public Point
5723 {
5724 public:
5725 
5727  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5728 
5730  ObjectPoint(Point const & in_point):Point(in_point){}
5731 
5733  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5734 
5736  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5737 
5739  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5740 
5742  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5743 
5745  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5746 
5748  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5749 
5751  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5752 
5754  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5755 
5757  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5758 
5759 private:
5760 
5761  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5762  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5763  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5764  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5765  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5766  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5767  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5768  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5769 
5770 };
5771 
5773 class HPS_API WorldPoint : public Point
5774 {
5775 public:
5777  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5778 
5780  WorldPoint(Point const & in_point):Point(in_point){}
5781 
5783  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5784 
5786  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5787 
5789  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5790 
5792  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5793 
5795  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5796 
5798  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5799 
5801  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5802 
5804  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5805 
5807  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5808 
5809 private:
5810 
5811  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5812  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5813  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5814  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5815  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5816  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5817  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5818  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5819 
5820 };
5821 
5823 class HPS_API CameraPoint : public Point
5824 {
5825 public:
5827  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5828 
5830  CameraPoint(Point const & in_point):Point(in_point){}
5831 
5833  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5834 
5836  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5837 
5839  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5840 
5842  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5843 
5845  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5846 
5848  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5849 
5851  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5852 
5854  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5855 
5857  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5858 
5859 private:
5860  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5861  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5862  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5863  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5864  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5865  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5866  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5867  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5868 
5869 };
5870 
5872 class HPS_API NormalizedPoint : public Point
5873 {
5874 public:
5875 
5877  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5878 
5880  NormalizedPoint(Point const & in_point):Point(in_point){}
5881 
5883  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5884 
5886  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5887 
5889  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5890 
5892  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5893 
5895  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5896 
5898  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5899 
5901  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5902 
5904  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5905 
5907  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5908 
5909 private:
5910  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5911  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5912  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5913  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5914  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5915  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5916  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5917  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5918 };
5919 
5921 class HPS_API ScreenRangePoint : public Point
5922 {
5923 public:
5925  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5926 
5928  ScreenRangePoint(Point const & in_point):Point(in_point){}
5929 
5931  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5932 
5934  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5935 
5937  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5938 
5940  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5941 
5943  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5944 
5946  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5947 
5949  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5950 
5952  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5953 
5955  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5956 
5957 private:
5958  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5959  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5960  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5961  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5962  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5963  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5964  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5965  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5966 
5967 };
5968 
5970 class HPS_API InnerWindowPoint : public Point
5971 {
5972 public:
5973 
5975  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5976 
5978  InnerWindowPoint(Point const & in_point):Point(in_point){}
5979 
5981  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5982 
5984  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5985 
5987  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5988 
5990  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5991 
5993  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5994 
5996  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5997 
5999  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6000 
6002  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6003 
6005  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6006 
6007 private:
6008  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6009  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6010  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6011  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6012  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6013  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6014  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6015  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6016 };
6017 
6019 class HPS_API InnerPixelPoint : public Point
6020 {
6021 public:
6022 
6024  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6025 
6027  InnerPixelPoint(Point const & in_point):Point(in_point){}
6028 
6030  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6031 
6033  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6034 
6036  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6037 
6039  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6040 
6042  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6043 
6045  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6046 
6048  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6049 
6051  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6052 
6054  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6055 
6056 private:
6057  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6058  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6059  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6060  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6061  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6062  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6063  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6064  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6065 
6066 };
6067 
6069 class HPS_API WindowPoint : public Point
6070 {
6071 public:
6072 
6074  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6075 
6077  WindowPoint(Point const & in_point):Point(in_point){}
6078 
6080  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6081 
6083  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6084 
6086  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6087 
6089  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6090 
6092  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6093 
6095  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6096 
6098  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6099 
6101  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6102 
6104  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6105 
6106 private:
6107  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6108  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6109  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6110  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6111  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6112  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6113  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6114  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6115 };
6116 
6117 
6119 class HPS_API PixelPoint : public Point
6120 {
6121 public:
6123  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6124 
6126  PixelPoint(Point const & in_point):Point(in_point){}
6127 
6129  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6130 
6132  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6133 
6135  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6136 
6138  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6139 
6141  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6142 
6144  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6145 
6147  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6148 
6150  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6151 
6153  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6154 
6155 private:
6156  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6157  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6158  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6159  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6160  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6161  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6162  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6163  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6164 
6165 };
6166 
6169 class HPS_API Event
6170 {
6171 public:
6175  enum class Status
6176  {
6177  InProgress,
6178  Completed,
6179  Failed
6180  };
6181 
6183  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6184 
6185  virtual ~Event();
6186 
6188  intptr_t GetClassID() const;
6189 
6192  virtual Event * Clone() const=0;
6193 
6195  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6196 
6199  virtual intptr_t Freshen() const { return 0; }
6200 
6202  intptr_t GetChannel() const { return channel; }
6203 
6205  Time GetTimeStamp() const { return time_stamp; }
6206 
6208  bool IsConsumable() const { return consumable; }
6209 
6210  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6211  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6212 
6213 protected:
6214  intptr_t channel;
6215  bool consumable;
6216 
6217 private:
6218  friend class HPSI::EventDispatcherImpl;
6219  Time time_stamp;
6220 };
6221 
6222 
6225 class HPS_API EventNotifier : public Object
6226 {
6227 public:
6228 
6230  EventNotifier();
6231 
6234  EventNotifier(EventNotifier const & in_that);
6235 
6239  EventNotifier(EventNotifier && in_that);
6240 
6244  EventNotifier & operator=(EventNotifier && in_that);
6245 
6246  virtual ~EventNotifier();
6247 
6248  HPS::Type ObjectType() const {return HPS::Type::EventNotifier;};
6249 
6253  EventNotifier & operator=(EventNotifier const & in_that);
6254 
6257  virtual void Assign(EventNotifier const & in_that);
6258 
6260  void Wait() const;
6261 
6264  Event::Status Status() const;
6265 };
6266 
6268 enum class KeyboardCode
6269 {
6270  None = 0,
6271 
6272  Backspace = 8,
6273  Tab = 9,
6274  Clear = 11,
6275  Return = 13,
6276  Shift = 16,
6277  Control = 17,
6278  Alt = 18,
6279  Pause = 19,
6280  Escape = 27,
6281 
6282  Space = 32,
6283  ExclamationMark,
6284  DoubleQuote,
6285  Number,
6286  Dollar,
6287  Percent,
6288  Ampersand,
6289  SingleQuote,
6290  OpenParen,
6291  CloseParen,
6292 
6293  Asterisk,
6294  Plus,
6295  Comma,
6296  Hyphen,
6297  Period,
6298  Slash,
6299 
6300  D0,
6301  D1,
6302  D2,
6303  D3,
6304  D4,
6305  D5,
6306  D6,
6307  D7,
6308  D8,
6309  D9,
6310 
6311  Colon,
6312  Semicolon,
6313  LessThan,
6314  Equal,
6315  GreaterThan,
6316  QuestionMark,
6317  AtSymbol,
6318 
6319  A,
6320  B,
6321  C,
6322  D,
6323  E,
6324  F,
6325  G,
6326  H,
6327  I,
6328  J,
6329  K,
6330  L,
6331  M,
6332  N,
6333  O,
6334  P,
6335  Q,
6336  R,
6337  S,
6338  T,
6339  U,
6340  V,
6341  W,
6342  X,
6343  Y,
6344  Z,
6345 
6346  OpenBrackets,
6347  Backslash,
6348  CloseBrackets,
6349  Caret,
6350  Underscore,
6351  Backtick,
6352 
6353  a,
6354  b,
6355  c,
6356  d,
6357  e,
6358  f,
6359  g,
6360  h,
6361  i,
6362  j,
6363  k,
6364  l,
6365  m,
6366  n,
6367  o,
6368  p,
6369  q,
6370  r,
6371  s,
6372  t,
6373  u,
6374  v,
6375  w,
6376  x,
6377  y,
6378  z,
6379 
6380  OpenBrace,
6381  VerticalBar,
6382  ClosingBrace,
6383  Tilde,
6384  Delete,
6385 
6386  Insert=1024,
6387  Home,
6388  End,
6389  PageUp,
6390  PageDown,
6391 
6392  Help,
6393 
6394  Left,
6395  Up,
6396  Right,
6397  Down,
6398 
6399  NumPad0,
6400  NumPad1,
6401  NumPad2,
6402  NumPad3,
6403  NumPad4,
6404  NumPad5,
6405  NumPad6,
6406  NumPad7,
6407  NumPad8,
6408  NumPad9,
6409 
6410  F1,
6411  F2,
6412  F3,
6413  F4,
6414  F5,
6415  F6,
6416  F7,
6417  F8,
6418  F9,
6419  F10,
6420  F11,
6421  F12,
6422  F13,
6423  F14,
6424  F15,
6425  F16,
6426  F17,
6427  F18,
6428  F19,
6429  F20,
6430  F21,
6431  F22,
6432  F23,
6433  F24,
6434 
6435  // these are not implemented
6436 // CapsLock, //!< The Caps Lock key.
6437 //
6438 // NumLock, //!< The Num Lock key.
6439 // ScrollLock, //!< The Scroll Lock key.
6440 // LeftShift, //!< The left Shift key.
6441 // RightShift, //!< The right Shift key.
6442 // LeftCtrl, //!< The left CTRL key.
6443 // RightCtrl, //!< The right CTRL key.
6444 // LeftAlt, //!< The left ALT key.
6445 // RightAlt, //!< The right ALT key.
6446 //
6447 // Select, //!< The Select key.
6448 // Print, //!< The Print key.
6449 // Execute, //!< The Execute key.
6450 // PrintScreen, //!< The Print Screen key.
6451 };
6452 
6453 
6455 class NO_HPS_API Touch
6456 {
6457 public:
6458 
6461  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6462 
6467  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6468  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6469 
6473  inline bool operator==(Touch const & in_that) const
6474  {
6475  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6476  }
6477 
6481  inline bool operator!=(Touch const & in_that) const
6482  {
6483  return !(*this == in_that);
6484  }
6485 
6486  TouchID ID;
6488  size_t TapCount;
6489 };
6490 
6491 
6492 typedef std::vector<Point, Allocator<Point> > PointArray;
6493 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6494 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6495 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6496 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6497 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6498 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6499 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6500 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6501 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6502 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6503 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6504 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6505 typedef std::vector<int, Allocator<int> > IntArray;
6506 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6507 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6508 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6509 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6510 typedef std::vector<float, Allocator<float> > FloatArray;
6511 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6512 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6513 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6514 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6515 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6516 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6517 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6518 typedef std::vector<bool, Allocator<bool> > BoolArray;
6519 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6520 typedef std::vector<Key, Allocator<Key> > KeyArray;
6521 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6522 typedef std::vector<char, Allocator<char> > CharArray;
6523 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6524 typedef std::vector<byte, Allocator<byte> > ByteArray;
6525 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6526 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6527 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6528 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6529 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6530 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6531 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6532 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6533 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6534 typedef std::vector<ConditionalExpression, Allocator<ConditionalExpression> > ConditionalExpressionArray;
6535 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6536 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6537 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6538 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6539 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6540 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6541 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6542 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6543 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6544 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6545 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6546 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6547 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6548 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6549 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6550 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6551 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6552 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6553 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6554 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6555 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6556 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6557 
6558 
6560 class HPS_API SearchResultsIterator : public Object
6561 {
6562 public:
6563 
6566 
6570  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6571 
6576 
6580  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6581 
6583 
6584  HPS::Type ObjectType() const {return HPS::Type::SearchResultsIterator;}
6585 
6590  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6591 
6596  void Set(SearchResultsIterator const & in_search_results_iterator);
6597 
6599  void Next();
6600 
6603  SearchResultsIterator & operator++();
6604 
6607  SearchResultsIterator operator++(int in_val);
6608 
6611  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6612 
6615  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6616 
6620  bool IsValid() const;
6621 
6623  void Reset();
6624 
6628  Key GetItem() const;
6629 
6632  Key operator*() const;
6633 
6636  SearchTypeArray GetResultTypes() const;
6637 };
6638 
6640 class HPS_API SearchResults : public Object
6641 {
6642 public:
6644  SearchResults();
6645 
6648  SearchResults(SearchResults const & in_search_results);
6649 
6653  SearchResults(SearchResults && in_that);
6654 
6658  SearchResults & operator=(SearchResults && in_that);
6659 
6661  virtual void Reset();
6662 
6664  ~SearchResults();
6665 
6666  HPS::Type ObjectType() const {return HPS::Type::SearchResults;}
6667 
6671  void Assign(SearchResults const & in_search_results);
6672 
6676  SearchResults & operator=(SearchResults const & in_search_results);
6677 
6680  size_t GetCount() const;
6681 
6684  SearchResultsIterator GetIterator() const;
6685 };
6686 
6688 class HPS_API FontSearchResultsIterator : public Object
6689 {
6690 public:
6691 
6694 
6698  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6699 
6704 
6709  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6710 
6711 
6715  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6716 
6718 
6719  HPS::Type ObjectType() const {return HPS::Type::FontSearchResultsIterator;}
6720 
6721 
6726  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6727 
6729  void Next();
6730 
6733  FontSearchResultsIterator & operator++();
6734 
6737  FontSearchResultsIterator operator++(int in_val);
6738 
6741  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6742 
6745  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6746 
6750  bool IsValid() const;
6751 
6753  void Reset();
6754 
6758  FontInfoState GetItem() const;
6759 
6762  FontInfoState operator*() const;
6763 
6764 };
6765 
6767 class HPS_API FontSearchResults : public Object
6768 {
6769 public:
6770 
6773 
6776  FontSearchResults(FontSearchResults const & in_search_results);
6777 
6782 
6786  FontSearchResults & operator=(FontSearchResults && in_that);
6787 
6789  virtual void Reset();
6790 
6792  ~FontSearchResults();
6793 
6794  HPS::Type ObjectType() const {return HPS::Type::FontSearchResults;}
6795 
6799  void Assign(FontSearchResults const & in_search_results);
6800 
6801 
6805  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6806 
6809  size_t GetCount() const;
6810 
6813  FontSearchResultsIterator GetIterator() const;
6814 };
6815 
6817 class HPS_API UTF8
6818 {
6819 public:
6820 
6822  UTF8();
6823 
6825  ~UTF8();
6826 
6833  UTF8(char const * in_string, char const * in_locale = 0);
6834 
6837  UTF8(wchar_t const * in_string);
6838 
6841  UTF8(UTF8 const & in_that);
6842 
6845  UTF8(UTF8 && in_that);
6846 
6850  UTF8 & Assign(UTF8 && in_utf8);
6851 
6854  inline UTF8 & operator= (UTF8 && in_utf8)
6855  {
6856  return Assign(std::move(in_utf8));
6857  }
6858 
6863  size_t ToWStr(wchar_t * out_wide_string) const;
6864 
6868  size_t ToWStr(WCharArray & out_wide_string) const;
6869 
6872  inline bool IsValid() const
6873  {
6874  return (_length > 0);
6875  }
6876 
6879  inline bool Empty() const
6880  {
6881  return (_length == 0);
6882  }
6883 
6885  void Clear();
6886 
6888  void Reset() { Clear(); }
6889 
6893  inline size_t GetLength() const
6894  {
6895  return _length;
6896  }
6897 
6901  inline size_t GetWStrLength() const
6902  {
6903  return ToWStr(0);
6904  }
6905 
6908  inline char const * GetBytes() const
6909  {
6910  return _text;
6911  }
6912 
6915  inline operator char const * () const
6916  {
6917  return _text;
6918  }
6919 
6922  char At(size_t in_index) const
6923  {
6924  if(!IsValid())
6925  throw InvalidObjectException();
6926  else if(in_index >= _length)
6927  throw IndexOutOfRangeException();
6928  else
6929  return _text[in_index];
6930  }
6931 
6935  UTF8 & Assign(UTF8 const & in_utf8);
6936 
6940  inline UTF8 & operator= (UTF8 const & in_utf8)
6941  {
6942  return Assign(in_utf8);
6943  }
6944 
6948  UTF8 & operator+= (UTF8 const & in_utf8);
6949 
6953  UTF8 & operator+= (char const * in_utf8);
6954 
6958  UTF8 operator+ (UTF8 const & in_utf8) const;
6959 
6963  UTF8 operator+ (char const * in_utf8) const;
6964 
6968  bool operator== (UTF8 const & in_utf8) const;
6969 
6973  bool operator!= (UTF8 const & in_utf8) const
6974  {
6975  return !(*this == in_utf8);
6976  }
6977 
6981  bool operator== (char const * in_utf8) const;
6982 
6986  bool operator!= (char const * in_utf8) const
6987  {
6988  return !(*this == in_utf8);
6989  }
6990 
6995  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
6996  {
6997  return in_right == in_left;
6998  }
6999 
7004  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
7005  {
7006  return in_right != in_left;
7007  }
7008 
7013  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
7014  {
7015  return in_right == UTF8(in_left);
7016  }
7017 
7022  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
7023  {
7024  return in_right != UTF8(in_left);
7025  }
7026 
7031  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
7032  {
7033  return UTF8(in_left) + in_right;
7034  }
7035 
7040  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
7041  {
7042  return UTF8(in_left) + in_right;
7043  }
7044 
7045 
7048  size_t GetHash() const;
7049 
7050 private:
7051 
7052  size_t internal_encode(wchar_t const * in_wide_string);
7053  size_t internal_decode(wchar_t * out_wide_string) const;
7054 
7055  char * _text;
7056  size_t _length;
7057  mutable size_t _hash_key;
7058  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7059  char _buffer[_buffer_size];
7060 };
7061 
7063 struct UTF8Hasher {
7064  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7065  {
7066  return in_utf8.GetHash();
7067  }
7068 };
7069 
7072 class HPS_API ConditionalExpression : public Object
7073 {
7074 public:
7075 
7078 
7081  ConditionalExpression(char const * in_utf8);
7082 
7085  ConditionalExpression(float in_number);
7086 
7089  ConditionalExpression(HPS::Condition::Intrinsic in_special);
7090 
7094 
7099 
7103  ConditionalExpression & operator=(ConditionalExpression && in_that);
7104 
7105  HPS::Type ObjectType() const { return HPS::Type::ConditionalExpression; }
7106 
7110  bool ShowCondition(UTF8 & out_condition) const;
7111 
7115  bool ShowNumber(float & out_number) const;
7116 
7120  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7121 
7125  bool ShowOperands(ConditionalExpressionArray & out_operands) const;
7126 
7130  ConditionalExpression & operator=(ConditionalExpression const & in_that);
7131 
7135  bool Equals(ConditionalExpression const & in_that) const;
7136 
7140  bool operator==(ConditionalExpression const & in_that) const;
7141 
7145  bool operator!=(ConditionalExpression const & in_that) const;
7146 
7150  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7151 
7155  bool IsSatisfiedBy(char const * in_condition) const;
7156 
7160  ConditionalExpression OR(ConditionalExpression const & in_operand2) const;
7161 
7165  ConditionalExpression XOR(ConditionalExpression const & in_operand2) const;
7166 
7170  ConditionalExpression AND(ConditionalExpression const & in_operand2) const;
7171 
7175  ConditionalExpression EQ(ConditionalExpression const & in_operand2) const;
7176 
7180  ConditionalExpression NEQ(ConditionalExpression const & in_operand2) const;
7181 
7185  ConditionalExpression GT(ConditionalExpression const & in_operand2) const;
7186 
7190  ConditionalExpression LT(ConditionalExpression const & in_operand2) const;
7191 
7195  ConditionalExpression GTEQ(ConditionalExpression const & in_operand2) const;
7196 
7200  ConditionalExpression LTEQ(ConditionalExpression const & in_operand2) const;
7201 
7204  ConditionalExpression operator !() const;
7205 
7209  ConditionalExpression operator ||(ConditionalExpression const & in_operand2) const;
7210 
7214  ConditionalExpression operator ^(ConditionalExpression const & in_operand2) const;
7215 
7219  ConditionalExpression operator &&(ConditionalExpression const & in_operand2) const;
7220 
7221 
7225  static ConditionalExpression NOT(ConditionalExpression const & in_operand);
7226 
7231  static ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7232 
7233 
7238  static ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7239 
7244  static ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7245 
7250  static ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7251 
7256  static ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7257 
7262  static ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7263 
7268  static ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7269 
7274  static ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7275 
7280  static ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7281 
7282  friend HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7283  friend HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7284  friend HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7285  friend HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7286 
7287  friend HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7288  friend HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7289  friend HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7290  friend HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7291  friend HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7292  friend HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7293 };
7294 
7295 
7299 HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7300 
7305 HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7306 
7311 HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7312 
7317 HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7318 
7323 HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7324 
7329 HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7330 
7335 HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7336 
7341 HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7342 
7347 HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7348 
7353 HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7354 
7355 
7356 
7360 class HPS_API Key : public Object
7361 {
7362 public:
7363 
7365  Key();
7366 
7368  Key(Key const & in_that);
7369 
7371  explicit Key(Control const & in_control);
7372 
7376  Key(Key && in_that);
7377 
7381  Key & operator=(Key && in_that);
7382 
7384  virtual ~Key();
7385 
7386  HPS::Type ObjectType() const {return HPS::Type::Key;};
7387 
7389  bool HasOwner() const;
7390 
7392  SegmentKey Up() const;
7393 
7395  SegmentKey Owner() const;
7396 
7398  void Delete();
7399 
7401  void MoveTo(SegmentKey const & in_new_owner);
7402 
7405  Key CopyTo(SegmentKey const & in_destination) const;
7406 
7410  Key & operator=(Key const & in_that);
7411 
7414  virtual void Assign(Key const & in_that);
7415 
7417  bool Equals(Key const & in_that) const;
7418 
7420  bool operator!= (Key const & in_that) const;
7421 
7423  bool operator== (Key const & in_that) const;
7424 
7427  size_t GetHash() const;
7428 };
7429 
7431 struct KeyHasher {
7432  inline size_t operator()(const HPS::Key & in_key) const
7433  {
7434  return in_key.GetHash();
7435  }
7436 };
7437 
7438 
7441 class HPS_API SegmentKey : public Key
7442 {
7443 public:
7445  SegmentKey();
7446 
7448  SegmentKey(SegmentKey const & in_that);
7449 
7451  SegmentKey & operator=(SegmentKey const & other);
7452 
7456  SegmentKey(SegmentKey && in_that);
7457 
7461  SegmentKey & operator=(SegmentKey && in_that);
7462 
7464  explicit SegmentKey(Key const & in_that);
7465 
7467  ~SegmentKey();
7468 
7469  HPS::Type ObjectType() const {return HPS::Type::SegmentKey;};
7470 
7472  UTF8 Name() const;
7473 
7476  SegmentKey & SetName(char const * in_name);
7477 
7480  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7481 
7484  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7485 
7487  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7488 
7490  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7491 
7493  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7494 
7495 
7496 
7498  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7499 
7501  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7502 
7504  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7505 
7506 
7508  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7509 
7511  size_t Find(SearchOptionsKit const & in_options) const;
7512 
7513 
7516  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7517 
7521  IncludeKey IncludeSegment(SegmentKey const & in_seg, ConditionalExpression const & in_conditional);
7522 
7523 
7529  ReferenceKey ReferenceGeometry(Key const & in_key);
7530 
7538  ReferenceKey ReferenceGeometry(Key const & in_key, ConditionalExpression const & in_conditional);
7539 
7540 
7542  size_t ShowSubsegments() const;
7543 
7545  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7546 
7550  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7551 
7555  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7556 
7560  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7561 
7565  size_t ShowStylers(StyleKeyArray & out_styles) const;
7566 
7570  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7571 
7575  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7576 
7577 
7578 
7580  StyleControl GetStyleControl();
7581 
7583  StyleControl const GetStyleControl() const;
7584 
7585 
7587  PortfolioControl GetPortfolioControl();
7588 
7590  PortfolioControl const GetPortfolioControl() const;
7591 
7592 
7594  SegmentKey & SetCondition(char const * in_condition);
7595 
7597  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7598 
7600  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7601 
7603  SegmentKey & UnsetConditions();
7604 
7606  bool ShowConditions(UTF8Array & out_conditions) const;
7607 
7609  ConditionControl GetConditionControl();
7610 
7612  ConditionControl const GetConditionControl() const;
7613 
7614 
7616  SegmentKey & SetMaterialPalette(char const * in_name);
7617 
7619  SegmentKey & UnsetMaterialPalette();
7620 
7622  bool ShowMaterialPalette(UTF8 & out_name) const;
7623 
7624 
7631  SegmentKey & SetPriority(int in_priority);
7632 
7635  SegmentKey & UnsetPriority();
7636 
7640  bool ShowPriority(int & out_priority) const;
7641 
7646  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7647 
7653  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7654 
7659  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7660 
7664  SegmentKey & UnsetUserData(intptr_t in_index);
7665 
7670  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7671 
7675  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
7676 
7679  SegmentKey & UnsetAllUserData();
7680 
7682  size_t ShowUserDataCount() const;
7683 
7688  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
7689 
7693  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7694 
7699  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7700 
7701 
7703  LineKey InsertLine(LineKit const & in_kit);
7704 
7706  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7707 
7709  LineKey InsertLine(PointArray const & in_pts);
7710 
7712  LineKey InsertLine(Point const & pt1, Point const & pt2);
7713 
7714 
7716  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7717 
7719  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);
7720 
7722  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7723 
7725  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7726 
7727 
7732  SphereKey InsertSphere(SphereKit const & in_kit);
7733 
7741  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));
7742 
7744  CircleKey InsertCircle(CircleKit const & in_kit);
7745 
7747  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7748 
7750  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7751 
7752 
7754  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7755 
7757  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7758 
7759 
7761  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7762 
7764  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7765 
7766 
7768  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7769 
7771  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7772 
7773 
7775  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7776 
7778  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float in_start, float in_end);
7779 
7780 
7782  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7783 
7785  PolygonKey InsertPolygon(PointArray const & in_points);
7786 
7788  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7789 
7790 
7792  ShellKey InsertShell(ShellKit const & in_kit);
7793 
7795  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7796 
7798  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7799 
7801  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
7802 
7804  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
7805 
7807  MeshKey InsertMesh(MeshKit const & in_kit);
7808 
7810  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7811 
7813  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7814 
7815 
7817  MarkerKey InsertMarker(Point const & in_position);
7818 
7820  MarkerKey InsertMarker(MarkerKit const & in_kit);
7821 
7822 
7824  DistantLightKey InsertDistantLight(Vector const & in_direction);
7825 
7827  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7828 
7829 
7831  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7832 
7834  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7835 
7837  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7838 
7840  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7841 
7842 
7844  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7845 
7847  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7848 
7849 
7851  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7852 
7854  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7855 
7856 
7858  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7859 
7861  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);
7862 
7864  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);
7865 
7866 
7868  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7869 
7871  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);
7872 
7874  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[]);
7875 
7877  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);
7878 
7880  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[]);
7881 
7882 
7884  TextKey InsertText(TextKit const & in_kit);
7885 
7890  TextKey InsertText(Point const & in_position, char const * in_text);
7891 
7892 
7893 
7895  GridKey InsertGrid(GridKit const & in_kit);
7896 
7898  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);
7899 
7900 
7901 
7908  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7909 
7917  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7918 
7926  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7927 
7935  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7936 
7944  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7945 
7953  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7954 
7959  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7960 
7965  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7966 
7971  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7972 
7977  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7978 
7983  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7984 
7989  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7990 
7991 
7993  SegmentKey & SetAttributeLock(AttributeLockKit const & in_kit);
7994 
7996  SegmentKey & UnsetAttributeLock();
7997 
8001  bool ShowAttributeLock(AttributeLockKit & out_kit) const;
8002 
8004  AttributeLockControl GetAttributeLockControl();
8005 
8007  AttributeLockControl const GetAttributeLockControl() const;
8008 
8009 
8011  SegmentKey & SetBounding(BoundingKit const & in_kit);
8012 
8014  SegmentKey & UnsetBounding();
8015 
8019  bool ShowBounding(BoundingKit & out_kit) const;
8020 
8022  BoundingControl GetBoundingControl();
8023 
8025  BoundingControl const GetBoundingControl() const;
8026 
8027 
8029  SegmentKey & SetCamera(CameraKit const & in_kit);
8030 
8032  SegmentKey & UnsetCamera();
8033 
8035  bool ShowCamera(CameraKit & out_kit) const;
8036 
8038  CameraControl GetCameraControl();
8039 
8041  CameraControl const GetCameraControl() const;
8042 
8043 
8045  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
8046 
8048  SegmentKey & UnsetColorInterpolation();
8049 
8051  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
8052 
8054  ColorInterpolationControl GetColorInterpolationControl();
8055 
8057  ColorInterpolationControl const GetColorInterpolationControl() const;
8058 
8059 
8061  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8062 
8064  SegmentKey & UnsetContourLine();
8065 
8067  bool ShowContourLine(ContourLineKit & out_kit) const;
8068 
8070  ContourLineControl GetContourLineControl();
8071 
8073  ContourLineControl const GetContourLineControl() const;
8074 
8075 
8077  SegmentKey & SetCulling(CullingKit const & in_kit);
8078 
8080  SegmentKey & UnsetCulling();
8081 
8085  bool ShowCulling(CullingKit & out_kit) const;
8086 
8088  CullingControl GetCullingControl();
8089 
8091  CullingControl const GetCullingControl() const;
8092 
8093 
8095  SegmentKey & SetCurveAttribute(CurveAttributeKit const & in_kit);
8096 
8098  SegmentKey & UnsetCurveAttribute();
8099 
8101  bool ShowCurveAttribute(CurveAttributeKit & out_kit) const;
8102 
8104  CurveAttributeControl GetCurveAttributeControl();
8105 
8107  CurveAttributeControl const GetCurveAttributeControl() const;
8108 
8109 
8111  SegmentKey & SetCuttingSectionAttribute(CuttingSectionAttributeKit const & in_kit);
8112 
8114  SegmentKey & UnsetCuttingSectionAttribute();
8115 
8117  bool ShowCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
8118 
8120  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8121 
8123  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8124 
8125 
8127  SegmentKey & SetCylinderAttribute(CylinderAttributeKit const & in_kit);
8128 
8130  SegmentKey & UnsetCylinderAttribute();
8131 
8133  bool ShowCylinderAttribute(CylinderAttributeKit & out_kit) const;
8134 
8136  CylinderAttributeControl GetCylinderAttributeControl();
8137 
8139  CylinderAttributeControl const GetCylinderAttributeControl() const;
8140 
8141 
8143  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8144 
8146  SegmentKey & UnsetDrawingAttribute();
8147 
8149  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8150 
8152  DrawingAttributeControl GetDrawingAttributeControl();
8153 
8155  DrawingAttributeControl const GetDrawingAttributeControl() const;
8156 
8157 
8159  SegmentKey & SetEdgeAttribute(EdgeAttributeKit const & in_kit);
8160 
8162  SegmentKey & UnsetEdgeAttribute();
8163 
8165  bool ShowEdgeAttribute(EdgeAttributeKit & out_kit) const;
8166 
8168  EdgeAttributeControl GetEdgeAttributeControl();
8169 
8171  EdgeAttributeControl const GetEdgeAttributeControl() const;
8172 
8173 
8175  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8176 
8178  SegmentKey & UnsetHiddenLineAttribute();
8179 
8181  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8182 
8184  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8185 
8187  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8188 
8189 
8191  SegmentKey & SetLightingAttribute(LightingAttributeKit const & in_kit);
8192 
8194  SegmentKey & UnsetLightingAttribute();
8195 
8197  bool ShowLightingAttribute(LightingAttributeKit & out_kit) const;
8198 
8200  LightingAttributeControl GetLightingAttributeControl();
8201 
8203  LightingAttributeControl const GetLightingAttributeControl() const;
8204 
8205 
8207  SegmentKey & SetLineAttribute(LineAttributeKit const & in_kit);
8208 
8210  SegmentKey & UnsetLineAttribute();
8211 
8213  bool ShowLineAttribute(LineAttributeKit & out_kit) const;
8214 
8216  LineAttributeControl GetLineAttributeControl();
8217 
8219  LineAttributeControl const GetLineAttributeControl() const;
8220 
8221 
8223  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8224 
8226  SegmentKey & UnsetMaterialMapping();
8227 
8229  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8230 
8232  MaterialMappingControl GetMaterialMappingControl();
8233 
8235  MaterialMappingControl const GetMaterialMappingControl() const;
8236 
8237 
8239  SegmentKey & SetMarkerAttribute(MarkerAttributeKit const & in_kit);
8240 
8242  SegmentKey & UnsetMarkerAttribute();
8243 
8245  bool ShowMarkerAttribute(MarkerAttributeKit & out_kit) const;
8246 
8248  MarkerAttributeControl GetMarkerAttributeControl();
8249 
8251  MarkerAttributeControl const GetMarkerAttributeControl() const;
8252 
8253 
8255  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8256 
8258  SegmentKey & UnsetModellingMatrix();
8259 
8261  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8262 
8264  ModellingMatrixControl GetModellingMatrixControl();
8265 
8267  ModellingMatrixControl const GetModellingMatrixControl() const;
8268 
8269 
8271  SegmentKey & SetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit const & in_kit);
8272 
8274  SegmentKey & UnsetNURBSSurfaceAttribute();
8275 
8277  bool ShowNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
8278 
8280  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8281 
8283  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8284 
8285 
8287  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8288 
8290  SegmentKey & UnsetPerformance();
8291 
8293  bool ShowPerformance(PerformanceKit & out_kit) const;
8294 
8296  PerformanceControl GetPerformanceControl();
8297 
8299  PerformanceControl const GetPerformanceControl() const;
8300 
8301 
8303  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8304 
8306  SegmentKey & UnsetSelectability();
8307 
8311  bool ShowSelectability(SelectabilityKit & out_kit) const;
8312 
8314  SelectabilityControl GetSelectabilityControl();
8315 
8317  SelectabilityControl const GetSelectabilityControl() const;
8318 
8319 
8321  SegmentKey & SetSphereAttribute(SphereAttributeKit const & in_kit);
8322 
8324  SegmentKey & UnsetSphereAttribute();
8325 
8328  bool ShowSphereAttribute(SphereAttributeKit & out_kit) const;
8329 
8331  SphereAttributeControl GetSphereAttributeControl();
8332 
8334  SphereAttributeControl const GetSphereAttributeControl() const;
8335 
8336 
8338  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8339 
8341  SegmentKey & UnsetSubwindow();
8342 
8345  bool ShowSubwindow(SubwindowKit & out_kit) const;
8346 
8348  SubwindowControl GetSubwindowControl();
8349 
8351  SubwindowControl const GetSubwindowControl() const;
8352 
8353 
8355  SegmentKey & SetTextAttribute(TextAttributeKit const & in_kit);
8356 
8358  SegmentKey & UnsetTextAttribute();
8359 
8361  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
8362 
8364  TextAttributeControl GetTextAttributeControl();
8365 
8367  TextAttributeControl const GetTextAttributeControl() const;
8368 
8369 
8371  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8372 
8374  SegmentKey & UnsetTextureMatrix();
8375 
8378  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8379 
8381  TextureMatrixControl GetTextureMatrixControl();
8382 
8384  TextureMatrixControl const GetTextureMatrixControl() const;
8385 
8386 
8388  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8389 
8391  SegmentKey & UnsetTransformMask();
8392 
8395  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8396 
8398  TransformMaskControl GetTransformMaskControl();
8399 
8401  TransformMaskControl const GetTransformMaskControl() const;
8402 
8403 
8405  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8406 
8408  SegmentKey & UnsetTransparency();
8409 
8412  bool ShowTransparency(TransparencyKit & out_kit) const;
8413 
8415  TransparencyControl GetTransparencyControl();
8416 
8418  TransparencyControl const GetTransparencyControl() const;
8419 
8420 
8422  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8423 
8425  SegmentKey & UnsetVisibility();
8426 
8429  bool ShowVisibility(VisibilityKit & out_kit) const;
8430 
8432  VisibilityControl GetVisibilityControl();
8433 
8435  VisibilityControl const GetVisibilityControl() const;
8436 
8437 
8439  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8440 
8442  SegmentKey & UnsetVisualEffects();
8443 
8447  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8448 
8450  VisualEffectsControl GetVisualEffectsControl();
8451 
8453  VisualEffectsControl const GetVisualEffectsControl() const;
8454 
8455  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8456 };
8457 
8458 
8461 {
8462 public:
8463 
8466 
8470 
8474 
8475  virtual ~SegmentOptimizationOptionsKit();
8476 
8477  HPS::Type ObjectType() const { return HPS::Type::SegmentOptimizationOptionsKit; }
8478 
8481  void Consume(SegmentOptimizationOptionsKit & in_kit);
8482 
8485  void Set(SegmentOptimizationOptionsKit const & in_kit);
8486 
8489  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8490 
8495 
8500 
8503  bool Empty() const;
8504 
8508  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8509 
8513  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8514 
8518  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8519 
8523  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8524 
8528  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8529 
8533  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8534 
8538  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8539 
8543  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8544 
8548  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8549 
8553  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8554 
8558  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8559 
8561  SegmentOptimizationOptionsKit & UnsetUserData();
8562 
8564  SegmentOptimizationOptionsKit & UnsetMatrix();
8565 
8567  SegmentOptimizationOptionsKit & UnsetExpansion();
8568 
8570  SegmentOptimizationOptionsKit & UnsetScope();
8571 
8573  SegmentOptimizationOptionsKit & UnsetReorganization();
8574 
8576  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8577 
8579  SegmentOptimizationOptionsKit & UnsetShellMerging();
8580 
8582  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8583 
8586  SegmentOptimizationOptionsKit & UnsetEverything();
8587 
8588  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8589 
8590  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8591 
8592  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8593 
8594  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8595 
8596  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8597 
8598  bool ShowShellInstancing(bool & out_shell_instancing) const;
8599 
8600  bool ShowShellMerging(bool & out_shell_merging) const;
8601 
8602  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
8603 };
8604 
8605 
8608 class HPS_API UpdateNotifier : public Object
8609 {
8610 public:
8611 
8612  UpdateNotifier();
8613 
8614  UpdateNotifier(UpdateNotifier const & in_that);
8615 
8619  UpdateNotifier(UpdateNotifier && in_that);
8620 
8624  UpdateNotifier & operator=(UpdateNotifier && in_that);
8625 
8626  virtual ~UpdateNotifier();
8627 
8628  HPS::Type ObjectType() const {return HPS::Type::UpdateNotifier;};
8629 
8633  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8634 
8637  void Assign(UpdateNotifier const & in_that);
8638 
8639  void Wait() const;
8640 
8641  Window::UpdateStatus Status() const;
8642 
8643 };
8644 
8647 class HPS_API DriverEvent
8648 {
8649 public:
8650 
8651  virtual ~DriverEvent();
8652 
8654  intptr_t GetClassID() const;
8655 
8656 protected:
8657 
8658  DriverEvent(OpaqueHandle in_nr) : nr(in_nr)
8659  {
8660 
8661  }
8662 
8663  OpaqueHandle nr;
8664 };
8665 
8668 class HPS_API FinishPictureEvent : public DriverEvent
8669 {
8670 public:
8671  FinishPictureEvent(OpaqueHandle in_nr = 0);
8672  virtual ~FinishPictureEvent();
8673 };
8674 
8676 class HPS_API DrawWindowEvent : public DriverEvent
8677 {
8678 public:
8679  DrawWindowEvent(OpaqueHandle in_nr = 0);
8680  virtual ~DrawWindowEvent();
8681 
8683  Rectangle Extent;
8684 
8689  void DrawTexturedBackground(OpaqueHandle in_texture, MatrixKit const & in_matrix, Rectangle const & in_extent) const;
8690 
8691 private:
8692 
8693  mutable HPS::FloatArray matrix_elements;
8694 };
8695 
8697 class HPS_API DriverEventHandler : public Object
8698 {
8699 public:
8700 
8701  HPS::Type ObjectType() const OVERRIDE { return HPS::Type::DriverEventHandler; };
8702 
8704 
8705  DriverEventHandler(DriverEventHandler const & that);
8706 
8707  virtual ~DriverEventHandler();
8708 
8712  virtual void Handle(DriverEvent const * in_event)
8713  {
8714  HPS_UNREFERENCED(in_event);
8715  }
8716 };
8717 
8718 
8719 
8720 
8724 class HPS_API WindowKey : public SegmentKey
8725 {
8726 public:
8727 
8729  WindowKey();
8730 
8732  WindowKey(WindowKey const & in_window);
8733 
8735  WindowKey & operator=(WindowKey const & other);
8736 
8740  WindowKey(WindowKey && in_that);
8741 
8745  WindowKey & operator=(WindowKey && in_that);
8746 
8748  WindowKey(Key const & in_key);
8749 
8751  ~WindowKey();
8752 
8753  HPS::Type ObjectType() const {return HPS::Type::WindowKey;};
8754 
8756  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8757 
8762  size_t FindFonts(FontSearchResults & out_results) const;
8763 
8765  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8766 
8768  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8769 
8771  PostProcessEffectsControl GetPostProcessEffectsControl();
8772 
8774  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8775 
8776 
8778  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8779 
8783  WindowKey & SetDriverEventHandler(DriverEventHandler const & in_handler, intptr_t in_type);
8784 
8787  WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8788 
8792  bool ShowDebugging(DebuggingKit & out_kit) const;
8793 
8795  DebuggingControl GetDebuggingControl();
8796 
8798  DebuggingControl const GetDebuggingControl() const;
8799 
8801  WindowInfoControl const GetWindowInfoControl() const;
8802 
8803  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8804 
8806  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8807 
8809  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8810 
8812  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
8813 
8815  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
8816 
8817 
8819  SelectionOptionsControl GetSelectionOptionsControl();
8820 
8822  SelectionOptionsControl const GetSelectionOptionsControl() const;
8823 
8824 
8826  SelectionControl GetSelectionControl();
8827 
8829  SelectionControl const GetSelectionControl() const;
8830 
8832  HighlightControl GetHighlightControl();
8833 
8835  HighlightControl const GetHighlightControl() const;
8836 
8838  UpdateOptionsControl GetUpdateOptionsControl();
8839 
8841  UpdateOptionsControl const GetUpdateOptionsControl() const;
8842 
8844  void Update();
8845 
8850  void Update(UpdateOptionsKit const & in_kit);
8851 
8866  void Update(Window::UpdateType in_type, Time in_time_limit=-1);
8867 
8871  UpdateNotifier UpdateWithNotifier();
8872 
8876  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
8877 
8883  UpdateNotifier UpdateWithNotifier(Window::UpdateType in_type, Time in_time_limit=-1);
8884 
8886  EventDispatcher & GetEventDispatcher();
8887 
8889  EventDispatcher const & GetEventDispatcher() const;
8890 
8894  bool ShowSnapshot(ImageKit & out_kit) const;
8895 
8896 private:
8897 
8899  SegmentKey & UnsetAttributeLock();
8900  SegmentKey & UnsetCamera();
8901  SegmentKey & UnsetColorInterpolation();
8902  SegmentKey & UnsetContourLine();
8903  SegmentKey & UnsetCulling();
8904  SegmentKey & UnsetCurveAttribute();
8905  SegmentKey & UnsetCuttingSectionAttribute();
8906  SegmentKey & UnsetCylinderAttribute();
8907  SegmentKey & UnsetDrawingAttribute();
8908  SegmentKey & UnsetEdgeAttribute();
8909  SegmentKey & UnsetHiddenLineAttribute();
8910  SegmentKey & UnsetLightingAttribute();
8911  SegmentKey & UnsetLineAttribute();
8912  SegmentKey & UnsetMaterialMapping();
8913  SegmentKey & UnsetMarkerAttribute();
8914  SegmentKey & UnsetModellingMatrix();
8915  SegmentKey & UnsetNURBSSurfaceAttribute();
8916  SegmentKey & UnsetPerformance();
8917  SegmentKey & UnsetSelectability();
8918  SegmentKey & UnsetSphereAttribute();
8919  SegmentKey & UnsetSubwindow();
8920  SegmentKey & UnsetTextAttribute();
8921  SegmentKey & UnsetTextureMatrix();
8922  SegmentKey & UnsetTransformMask();
8923  SegmentKey & UnsetTransparency();
8924  SegmentKey & UnsetVisibility();
8925  SegmentKey & UnsetVisualEffects();
8926 
8928  void MoveTo(SegmentKey const & in_new_owner);
8929 
8931  Key CopyTo(SegmentKey const & in_destination) const;
8932 };
8933 
8934 
8935 
8938 class HPS_API KeyPath : public Object
8939 {
8940 public:
8941 
8943  KeyPath();
8944 
8947  KeyPath(KeyArray const & in_path);
8948 
8952  KeyPath(size_t in_path_count, Key const in_path []);
8953 
8955  KeyPath(KeyPath const & in_that);
8956 
8960  KeyPath(KeyPath && in_that);
8961 
8965  KeyPath & operator=(KeyPath && in_that);
8966 
8968  virtual ~KeyPath();
8969 
8970  HPS::Type ObjectType() const { return HPS::Type::KeyPath; }
8971 
8975  KeyPath & operator+=(Key const & in_key);
8976 
8980  KeyPath & operator+=(KeyPath const & in_key_path);
8981 
8985  KeyPath & operator+=(KeyArray const & in_key_array);
8986 
8990  KeyPath & Append(Key const & in_key);
8991 
8995  KeyPath & Append(KeyPath const & in_key_path);
8996 
9000  KeyPath & Append(KeyArray const & in_key_array);
9001 
9005  KeyPath & operator=(KeyPath const & in_that);
9006 
9010  KeyPath & operator=(KeyArray const & in_path);
9011 
9014  void Set(KeyPath const & in_that);
9015 
9019  bool Equals(KeyPath const & in_that) const;
9020 
9024  bool operator!= (KeyPath const & in_that) const;
9025 
9029  bool operator== (KeyPath const & in_that) const;
9030 
9031 
9035  KeyPath & SetKeys(KeyArray const & in_keys);
9036 
9041  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
9042 
9043 
9046  KeyPath & UnsetKeys();
9047 
9048 
9051  bool ShowKeys(KeyArray & out_keys) const;
9052 
9053 
9060  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9061 
9068  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
9069 
9075  bool ComputeTextExtent(char const * in_text, float & out_xfrac, float & out_yfrac) const;
9076 
9077 
9083  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
9084 
9085 
9088  bool ShowNetVisibility(VisibilityKit & out_kit) const;
9089 
9092  bool ShowNetBounding(BoundingKit & out_kit) const;
9093 
9096  bool ShowNetCamera(CameraKit & out_kit) const;
9097 
9100  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
9101 
9104  bool ShowNetContourLine(ContourLineKit & out_kit) const;
9105 
9108  bool ShowNetPerformance(PerformanceKit & out_kit) const;
9109 
9112  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9113 
9116  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9117 
9120  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9121 
9124  bool ShowNetMarkerAttribute(MarkerAttributeKit & out_kit) const;
9125 
9128  bool ShowNetSphereAttribute(SphereAttributeKit & out_kit) const;
9129 
9132  bool ShowNetLightingAttribute(LightingAttributeKit & out_kit) const;
9133 
9136  bool ShowNetCylinderAttribute(CylinderAttributeKit & out_kit) const;
9137 
9140  bool ShowNetCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
9141 
9144  bool ShowNetTextAttribute(TextAttributeKit & out_kit) const;
9145 
9148  bool ShowNetLineAttribute(LineAttributeKit & out_kit) const;
9149 
9152  bool ShowNetEdgeAttribute(EdgeAttributeKit & out_kit) const;
9153 
9156  bool ShowNetCurveAttribute(CurveAttributeKit & out_kit) const;
9157 
9160  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9161 
9164  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9165 
9168  bool ShowNetCulling(CullingKit & out_kit) const;
9169 
9172  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9173 
9176  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9177 
9180  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9181 
9184  bool ShowNetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
9185 
9188  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9189 
9192  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9193 
9196  bool ShowNetAttributeLock(AttributeLockKit & out_kit) const;
9197 
9200  bool ShowNetConditions(UTF8Array & out_conditions) const;
9201 
9207  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9208 
9211  bool ShowNetMaterialPalette(UTF8 & out_name) const;
9212 
9217  bool ShowEffectiveMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_def) const;
9218 
9223  bool ShowEffectiveGlyphDefinition(char const * in_name, GlyphDefinition & out_def) const;
9224 
9229  bool ShowEffectiveLinePatternDefinition(char const * in_name, LinePatternDefinition & out_def) const;
9230 
9235  bool ShowEffectiveShaderDefinition(char const * in_name, ShaderDefinition & out_def) const;
9236 
9241  bool ShowEffectiveTextureDefinition(char const * in_name, TextureDefinition & out_def) const;
9242 
9247  bool ShowEffectiveImageDefinition(char const * in_name, ImageDefinition & out_def) const;
9248 };
9249 
9250 
9255 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9256 {
9257  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9258 }
9259 
9264 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9265 {
9266  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9267 }
9268 
9273 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9274 {
9275  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9276 }
9277 
9282 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9283 {
9284  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9285 }
9286 
9291 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9292 {
9293  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9294 }
9295 
9300 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9301 {
9302  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9303 }
9304 
9309 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9310 {
9311  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9312 }
9313 
9318 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9319 {
9320  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9321 }
9322 
9327 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9328 {
9329  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9330 }
9331 
9332 
9336 
9338 class HPS_API BoundingKit : public Object
9339 {
9340 public:
9341 
9343  BoundingKit();
9344 
9347  BoundingKit(BoundingKit const & in_kit);
9348 
9352  BoundingKit(BoundingKit && in_that);
9353 
9357  BoundingKit & operator=(BoundingKit && in_that);
9358 
9360  virtual ~BoundingKit();
9361 
9362  HPS::Type ObjectType() const {return HPS::Type::BoundingKit;};
9363 
9367  static BoundingKit GetDefault();
9368 
9371  void Set(BoundingKit const & in_kit);
9372 
9375  void Show(BoundingKit & out_kit) const;
9376 
9380  BoundingKit & operator=(BoundingKit const & in_kit);
9381 
9384  bool Empty() const;
9385 
9389  bool Equals(BoundingKit const & in_kit) const;
9390 
9394  bool operator==(BoundingKit const & in_kit) const;
9395 
9399  bool operator!=(BoundingKit const & in_kit) const;
9400 
9401 
9405  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
9406 
9410  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
9411 
9415  BoundingKit & SetExclusion(bool in_exclude);
9416 
9417 
9420  BoundingKit & UnsetVolume();
9421 
9424  BoundingKit & UnsetExclusion();
9425 
9428  BoundingKit & UnsetEverything();
9429 
9430 
9435  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9436 
9440  bool ShowExclusion(bool & out_exclusion) const;
9441 
9442 };
9443 
9444 
9447 class HPS_API BoundingControl : public Control
9448 {
9449 public:
9450 
9452  explicit BoundingControl(SegmentKey & in_seg);
9453 
9455  BoundingControl(BoundingControl const & in_that);
9456 
9460  BoundingControl(BoundingControl && in_that);
9461 
9465  BoundingControl & operator=(BoundingControl && in_that);
9466 
9468  ~BoundingControl();
9469 
9470  HPS::Type ObjectType() const {return HPS::Type::BoundingControl;};
9471 
9475  BoundingControl & operator=(BoundingControl const & in_that);
9476 
9481  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
9482 
9486  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
9487 
9491  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
9492 
9496  BoundingControl & SetExclusion(bool in_exclusion);
9497 
9498 
9501  BoundingControl & UnsetVolume();
9502 
9505  BoundingControl & UnsetExclusion();
9506 
9509  BoundingControl & UnsetEverything();
9510 
9511 
9516  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9517 
9521  bool ShowExclusion(bool & out_exclusion) const;
9522 
9523 private:
9525  BoundingControl();
9526 };
9527 
9528 
9530 class HPS_API VisibilityKit : public Object
9531 {
9532 public:
9533 
9535  VisibilityKit();
9536 
9539  VisibilityKit(VisibilityKit const & in_kit);
9540 
9544  VisibilityKit(VisibilityKit && in_that);
9545 
9549  VisibilityKit & operator=(VisibilityKit && in_that);
9550 
9552  virtual ~VisibilityKit();
9553 
9554  HPS::Type ObjectType() const {return HPS::Type::VisibilityKit;};
9555 
9559  static VisibilityKit GetDefault();
9560 
9563  void Set(VisibilityKit const & in_kit);
9564 
9567  void Show(VisibilityKit & out_kit) const;
9568 
9572  VisibilityKit & operator=(VisibilityKit const & in_kit);
9573 
9576  bool Empty() const;
9577 
9581  bool Equals(VisibilityKit const & in_kit) const;
9582 
9586  bool operator==(VisibilityKit const & in_kit) const;
9587 
9591  bool operator!=(VisibilityKit const & in_kit) const;
9592 
9593 
9597  VisibilityKit & SetCuttingSections(bool in_state);
9598 
9602  VisibilityKit & SetCutEdges(bool in_state);
9603 
9607  VisibilityKit & SetCutFaces(bool in_state);
9608 
9612  VisibilityKit & SetWindows(bool in_state);
9613 
9617  VisibilityKit & SetText(bool in_state);
9618 
9622  VisibilityKit & SetLines(bool in_state);
9623 
9627  VisibilityKit & SetEdgeLights(bool in_state);
9628 
9632  VisibilityKit & SetMarkerLights(bool in_state);
9633 
9637  VisibilityKit & SetFaceLights(bool in_state);
9638 
9642  VisibilityKit & SetGenericEdges(bool in_state);
9643 
9647  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9648 
9655  VisibilityKit & SetAdjacentEdges(bool in_state);
9656 
9660  VisibilityKit & SetHardEdges(bool in_state);
9661 
9665  VisibilityKit & SetMeshQuadEdges(bool in_state);
9666 
9670  VisibilityKit & SetNonCulledEdges(bool in_state);
9671 
9675  VisibilityKit & SetPerimeterEdges(bool in_state);
9676 
9680  VisibilityKit & SetFaces(bool in_state);
9681 
9685  VisibilityKit & SetVertices(bool in_state);
9686 
9690  VisibilityKit & SetMarkers(bool in_state);
9691 
9695  VisibilityKit & SetShadowCasting(bool in_state);
9696 
9700  VisibilityKit & SetShadowReceiving(bool in_state);
9701 
9705  VisibilityKit & SetShadowEmitting(bool in_state);
9706 
9707 
9711  VisibilityKit & SetCutGeometry(bool in_state);
9712 
9716  VisibilityKit & SetEdges(bool in_state);
9717 
9721  VisibilityKit & SetGeometry(bool in_state);
9722 
9726  VisibilityKit & SetLights(bool in_state);
9727 
9731  VisibilityKit & SetShadows(bool in_state);
9732 
9736  VisibilityKit & SetEverything(bool in_state);
9737 
9738 
9741  VisibilityKit & UnsetCuttingSections();
9742 
9745  VisibilityKit & UnsetCutEdges();
9746 
9749  VisibilityKit & UnsetCutFaces();
9750 
9753  VisibilityKit & UnsetWindows();
9754 
9757  VisibilityKit & UnsetText();
9758 
9761  VisibilityKit & UnsetLines();
9762 
9765  VisibilityKit & UnsetEdgeLights();
9766 
9769  VisibilityKit & UnsetMarkerLights();
9770 
9773  VisibilityKit & UnsetFaceLights();
9774 
9777  VisibilityKit & UnsetGenericEdges();
9778 
9781  VisibilityKit & UnsetInteriorSilhouetteEdges();
9782 
9785  VisibilityKit & UnsetAdjacentEdges();
9786 
9789  VisibilityKit & UnsetHardEdges();
9790 
9793  VisibilityKit & UnsetMeshQuadEdges();
9794 
9797  VisibilityKit & UnsetNonCulledEdges();
9798 
9801  VisibilityKit & UnsetPerimeterEdges();
9802 
9805  VisibilityKit & UnsetFaces();
9806 
9809  VisibilityKit & UnsetVertices();
9810 
9813  VisibilityKit & UnsetMarkers();
9814 
9817  VisibilityKit & UnsetShadowCasting();
9818 
9821  VisibilityKit & UnsetShadowReceiving();
9822 
9825  VisibilityKit & UnsetShadowEmitting();
9826 
9827 
9830  VisibilityKit & UnsetCutGeometry();
9831 
9834  VisibilityKit & UnsetEdges();
9835 
9838  VisibilityKit & UnsetGeometry();
9839 
9842  VisibilityKit & UnsetLights();
9843 
9846  VisibilityKit & UnsetShadows();
9847 
9850  VisibilityKit & UnsetEverything();
9851 
9852 
9856  bool ShowCuttingSections(bool & out_state) const;
9857 
9861  bool ShowCutEdges(bool & out_state) const;
9862 
9866  bool ShowCutFaces(bool & out_state) const;
9867 
9871  bool ShowWindows(bool & out_state) const;
9872 
9876  bool ShowText(bool & out_state) const;
9877 
9881  bool ShowLines(bool & out_state) const;
9882 
9886  bool ShowEdgeLights(bool & out_state) const;
9887 
9891  bool ShowMarkerLights(bool & out_state) const;
9892 
9896  bool ShowFaceLights(bool & out_state) const;
9897 
9901  bool ShowGenericEdges(bool & out_state) const;
9902 
9906  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9907 
9911  bool ShowAdjacentEdges(bool & out_state) const;
9912 
9916  bool ShowHardEdges(bool & out_state) const;
9917 
9921  bool ShowMeshQuadEdges(bool & out_state) const;
9922 
9926  bool ShowNonCulledEdges(bool & out_state) const;
9927 
9931  bool ShowPerimeterEdges(bool & out_state) const;
9932 
9936  bool ShowFaces(bool & out_state) const;
9937 
9941  bool ShowVertices(bool & out_state) const;
9942 
9946  bool ShowMarkers(bool & out_state) const;
9947 
9951  bool ShowShadowCasting(bool & out_state) const;
9952 
9956  bool ShowShadowReceiving(bool & out_state) const;
9957 
9961  bool ShowShadowEmitting(bool & out_state) const;
9962 };
9963 
9964 
9970 class HPS_API VisibilityControl : public Control
9971 {
9972 public:
9973 
9975  explicit VisibilityControl(SegmentKey & in_seg);
9976 
9978  VisibilityControl(VisibilityControl const & in_that);
9979 
9984 
9988  VisibilityControl & operator=(VisibilityControl && in_that);
9989 
9991  ~VisibilityControl();
9992 
9993  HPS::Type ObjectType() const {return HPS::Type::VisibilityControl;};
9994 
9998  VisibilityControl & operator=(VisibilityControl const & in_that);
9999 
10003  VisibilityControl & SetCuttingSections(bool in_state);
10004 
10008  VisibilityControl & SetCutEdges(bool in_state);
10009 
10013  VisibilityControl & SetCutFaces(bool in_state);
10014 
10018  VisibilityControl & SetWindows(bool in_state);
10019 
10023  VisibilityControl & SetText(bool in_state);
10024 
10028  VisibilityControl & SetLines(bool in_state);
10029 
10033  VisibilityControl & SetEdgeLights(bool in_state);
10034 
10038  VisibilityControl & SetMarkerLights(bool in_state);
10039 
10043  VisibilityControl & SetFaceLights(bool in_state);
10044 
10048  VisibilityControl & SetGenericEdges(bool in_state);
10049 
10053  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
10054 
10058  VisibilityControl & SetAdjacentEdges(bool in_state);
10059 
10063  VisibilityControl & SetHardEdges(bool in_state);
10064 
10068  VisibilityControl & SetMeshQuadEdges(bool in_state);
10069 
10073  VisibilityControl & SetNonCulledEdges(bool in_state);
10074 
10078  VisibilityControl & SetPerimeterEdges(bool in_state);
10079 
10083  VisibilityControl & SetFaces(bool in_state);
10084 
10088  VisibilityControl & SetVertices(bool in_state);
10089 
10093  VisibilityControl & SetMarkers(bool in_state);
10094 
10098  VisibilityControl & SetShadowCasting(bool in_state);
10099 
10103  VisibilityControl & SetShadowReceiving(bool in_state);
10104 
10108  VisibilityControl & SetShadowEmitting(bool in_state);
10109 
10110 
10114  VisibilityControl & SetCutGeometry(bool in_state);
10115 
10119  VisibilityControl & SetEdges(bool in_state);
10120 
10124  VisibilityControl & SetGeometry(bool in_state);
10125 
10129  VisibilityControl & SetLights(bool in_state);
10130 
10134  VisibilityControl & SetShadows(bool in_state);
10135 
10139  VisibilityControl & SetEverything(bool in_state);
10140 
10141 
10144  VisibilityControl & UnsetCuttingSections();
10145 
10148  VisibilityControl & UnsetCutEdges();
10149 
10152  VisibilityControl & UnsetCutFaces();
10153 
10156  VisibilityControl & UnsetWindows();
10157 
10160  VisibilityControl & UnsetText();
10161 
10164  VisibilityControl & UnsetLines();
10165 
10168  VisibilityControl & UnsetEdgeLights();
10169 
10172  VisibilityControl & UnsetMarkerLights();
10173 
10176  VisibilityControl & UnsetFaceLights();
10177 
10180  VisibilityControl & UnsetGenericEdges();
10181 
10184  VisibilityControl & UnsetInteriorSilhouetteEdges();
10185 
10188  VisibilityControl & UnsetAdjacentEdges();
10189 
10192  VisibilityControl & UnsetHardEdges();
10193 
10196  VisibilityControl & UnsetMeshQuadEdges();
10197 
10200  VisibilityControl & UnsetNonCulledEdges();
10201 
10204  VisibilityControl & UnsetPerimeterEdges();
10205 
10208  VisibilityControl & UnsetFaces();
10209 
10212  VisibilityControl & UnsetVertices();
10213 
10216  VisibilityControl & UnsetMarkers();
10217 
10220  VisibilityControl & UnsetShadowCasting();
10221 
10224  VisibilityControl & UnsetShadowReceiving();
10225 
10228  VisibilityControl & UnsetShadowEmitting();
10229 
10230 
10233  VisibilityControl & UnsetCutGeometry();
10234 
10237  VisibilityControl & UnsetEdges();
10238 
10241  VisibilityControl & UnsetGeometry();
10242 
10245  VisibilityControl & UnsetLights();
10246 
10249  VisibilityControl & UnsetShadows();
10250 
10253  VisibilityControl & UnsetEverything();
10254 
10255 
10259  bool ShowCuttingSections(bool & out_state) const;
10260 
10264  bool ShowCutEdges(bool & out_state) const;
10265 
10269  bool ShowCutFaces(bool & out_state) const;
10270 
10274  bool ShowWindows(bool & out_state) const;
10275 
10279  bool ShowText(bool & out_state) const;
10280 
10284  bool ShowLines(bool & out_state) const;
10285 
10289  bool ShowEdgeLights(bool & out_state) const;
10290 
10294  bool ShowMarkerLights(bool & out_state) const;
10295 
10299  bool ShowFaceLights(bool & out_state) const;
10300 
10304  bool ShowGenericEdges(bool & out_state) const;
10305 
10309  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10310 
10314  bool ShowAdjacentEdges(bool & out_state) const;
10315 
10319  bool ShowHardEdges(bool & out_state) const;
10320 
10324  bool ShowMeshQuadEdges(bool & out_state) const;
10325 
10329  bool ShowNonCulledEdges(bool & out_state) const;
10330 
10334  bool ShowPerimeterEdges(bool & out_state) const;
10335 
10339  bool ShowFaces(bool & out_state) const;
10340 
10344  bool ShowVertices(bool & out_state) const;
10345 
10349  bool ShowMarkers(bool & out_state) const;
10350 
10354  bool ShowShadowCasting(bool & out_state) const;
10355 
10359  bool ShowShadowReceiving(bool & out_state) const;
10360 
10364  bool ShowShadowEmitting(bool & out_state) const;
10365 
10366 private:
10369 };
10370 
10371 
10372 
10375 class HPS_API CameraKit : public Object
10376 {
10377 public:
10378 
10380  CameraKit();
10381 
10384  CameraKit(const CameraKit & in_kit);
10385 
10389  CameraKit(CameraKit && in_that);
10390 
10394  CameraKit & operator=(CameraKit && in_that);
10395 
10397  virtual ~CameraKit();
10398 
10399  HPS::Type ObjectType() const {return HPS::Type::CameraKit;};
10400 
10404  static CameraKit GetDefault();
10405 
10408  void Set(CameraKit const & in_kit);
10409 
10412  void Show(CameraKit & out_kit) const;
10413 
10417  CameraKit & operator=(CameraKit const & in_kit);
10418 
10421  bool Empty() const;
10422 
10426  bool Equals(CameraKit const & in_kit) const;
10427 
10431  bool operator==(CameraKit const & in_kit) const;
10432 
10436  bool operator!=(CameraKit const & in_kit) const;
10437 
10441  CameraKit & SetUpVector(Vector const & in_up);
10442 
10446  CameraKit & SetPosition(Point const & in_position);
10447 
10451  CameraKit & SetTarget(Point const & in_target);
10452 
10459  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
10460 
10466  CameraKit & SetField(float in_width, float in_height);
10467 
10477  CameraKit & SetNearLimit(float const in_limit);
10478 
10481  CameraKit & UnsetUpVector();
10482 
10485  CameraKit & UnsetPosition();
10486 
10489  CameraKit & UnsetTarget();
10490 
10493  CameraKit & UnsetProjection();
10494 
10497  CameraKit & UnsetField();
10498 
10501  CameraKit & UnsetNearLimit();
10502 
10505  CameraKit & UnsetEverything();
10506 
10507 
10511  bool ShowUpVector(Vector & out_up_vector) const;
10512 
10516  bool ShowPosition(Point & out_position) const;
10517 
10521  bool ShowTarget(Point & out_target) const;
10522 
10526  bool ShowProjection(Camera::Projection & out_type) const;
10527 
10533  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
10534 
10538  bool ShowWidth(float & out_width) const;
10539 
10543  bool ShowHeight(float & out_height) const;
10544 
10549  bool ShowField(float & out_width, float & out_height) const;
10550 
10554  bool ShowNearLimit(float & out_near_limit) const;
10555 
10562  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
10563 
10570  CameraKit & Orbit(float in_theta, float in_phi);
10571 
10578  CameraKit & Pan(float in_theta, float in_phi);
10579 
10585  CameraKit & Roll(float in_theta);
10586 
10592  CameraKit & Zoom(float in_zoom);
10593 };
10594 
10598 class HPS_API CameraControl : public Control
10599 {
10600 public:
10602  explicit CameraControl(SegmentKey & in_seg);
10603 
10605  CameraControl(CameraControl const & in_that);
10606 
10610  CameraControl(CameraControl && in_that);
10611 
10615  CameraControl & operator=(CameraControl && in_that);
10616 
10618  ~CameraControl();
10619 
10620  HPS::Type ObjectType() const {return HPS::Type::CameraControl;};
10621 
10625  CameraControl & operator=(CameraControl const & in_that);
10626 
10631  CameraControl & SetUpVector(Vector const & in_up);
10632 
10637  CameraControl & SetPosition(Point const & in_position);
10638 
10643  CameraControl & SetTarget(Point const & in_target);
10644 
10651  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10652 
10658  CameraControl & SetField(float in_width, float in_height);
10659 
10670  CameraControl & SetNearLimit(float in_double);
10671 
10675  CameraControl & UnsetEverything();
10676 
10677 
10681  bool ShowUpVector(Vector & out_up_vector) const;
10682 
10686  bool ShowPosition(Point & out_position) const;
10687 
10691  bool ShowTarget(Point & out_target) const;
10692 
10696  bool ShowProjection(Camera::Projection & out_type) const;
10697 
10703  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10704 
10708  bool ShowWidth(float & out_width) const;
10709 
10713  bool ShowHeight(float & out_height) const;
10714 
10719  bool ShowField(float & out_width, float & out_height) const;
10720 
10724  bool ShowNearLimit(float & out_width) const;
10725 
10732  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10733 
10740  CameraControl & Orbit(float in_theta, float in_phi);
10741 
10748  CameraControl & Pan(float in_theta, float in_phi);
10749 
10755  CameraControl & Roll(float in_theta);
10756 
10762  CameraControl & Zoom(float in_zoom);
10763 
10764 private:
10766  CameraControl();
10767 };
10768 
10769 
10770 
10772 class HPS_API SelectabilityKit : public Object
10773 {
10774 public:
10775 
10777  SelectabilityKit();
10778 
10781  SelectabilityKit(SelectabilityKit const & in_kit);
10782 
10786  SelectabilityKit(SelectabilityKit && in_that);
10787 
10791  SelectabilityKit & operator=(SelectabilityKit && in_that);
10792 
10794  virtual ~SelectabilityKit();
10795 
10796  HPS::Type ObjectType() const {return HPS::Type::SelectabilityKit;};
10797 
10801  static SelectabilityKit GetDefault();
10802 
10805  void Set(SelectabilityKit const & in_kit);
10806 
10809  void Show(SelectabilityKit & out_kit) const;
10810 
10814  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10815 
10818  bool Empty() const;
10819 
10823  bool Equals(SelectabilityKit const & in_kit) const;
10824 
10828  bool operator==(SelectabilityKit const & in_kit) const;
10829 
10833  bool operator!=(SelectabilityKit const & in_kit) const;
10834 
10835 
10839  SelectabilityKit & SetWindows(Selectability::Value in_val);
10840 
10844  SelectabilityKit & SetWindows(bool in_val);
10845 
10849  SelectabilityKit & SetEdges(Selectability::Value in_val);
10850 
10854  SelectabilityKit & SetEdges(bool in_val);
10855 
10859  SelectabilityKit & SetFaces(Selectability::Value in_val);
10860 
10864  SelectabilityKit & SetFaces(bool in_val);
10865 
10869  SelectabilityKit & SetLights(Selectability::Value in_val);
10870 
10874  SelectabilityKit & SetLights(bool in_val);
10875 
10879  SelectabilityKit & SetLines(Selectability::Value in_val);
10880 
10884  SelectabilityKit & SetLines(bool in_val);
10885 
10889  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10890 
10894  SelectabilityKit & SetMarkers(bool in_val);
10895 
10899  SelectabilityKit & SetVertices(Selectability::Value in_val);
10900 
10904  SelectabilityKit & SetVertices(bool in_val);
10905 
10909  SelectabilityKit & SetText(Selectability::Value in_val);
10910 
10914  SelectabilityKit & SetText(bool in_val);
10915 
10919  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10920 
10924  SelectabilityKit & SetGeometry(bool in_val);
10925 
10929  SelectabilityKit & SetEverything(Selectability::Value in_val);
10930 
10934  SelectabilityKit & SetEverything(bool in_val);
10935 
10936 
10939  SelectabilityKit & UnsetWindows();
10940 
10943  SelectabilityKit & UnsetEdges();
10944 
10947  SelectabilityKit & UnsetFaces();
10948 
10951  SelectabilityKit & UnsetLights();
10952 
10955  SelectabilityKit & UnsetLines();
10956 
10959  SelectabilityKit & UnsetMarkers();
10960 
10963  SelectabilityKit & UnsetVertices();
10964 
10967  SelectabilityKit & UnsetText();
10968 
10971  SelectabilityKit & UnsetGeometry();
10972 
10975  SelectabilityKit & UnsetEverything();
10976 
10977 
10981  bool ShowWindows(Selectability::Value & out_val) const;
10982 
10986  bool ShowEdges(Selectability::Value & out_val) const;
10987 
10991  bool ShowFaces(Selectability::Value & out_val) const;
10992 
10996  bool ShowLights(Selectability::Value & out_val) const;
10997 
11001  bool ShowLines(Selectability::Value & out_val) const;
11002 
11006  bool ShowMarkers(Selectability::Value & out_val) const;
11007 
11011  bool ShowVertices(Selectability::Value & out_val) const;
11012 
11016  bool ShowText(Selectability::Value & out_val) const;
11017 };
11018 
11024 class HPS_API SelectabilityControl : public Control
11025 {
11026 public:
11027 
11029  explicit SelectabilityControl(SegmentKey & in_seg);
11030 
11032  SelectabilityControl(SelectabilityControl const & in_that);
11033 
11038 
11042  SelectabilityControl & operator=(SelectabilityControl && in_that);
11043 
11046 
11047  HPS::Type ObjectType() const {return HPS::Type::SelectabilityControl;};
11048 
11052  SelectabilityControl & operator=(SelectabilityControl const & in_that);
11053 
11057  SelectabilityControl & SetWindows(Selectability::Value in_val);
11058 
11062  SelectabilityControl & SetWindows(bool in_val);
11063 
11067  SelectabilityControl & SetEdges(Selectability::Value in_val);
11068 
11072  SelectabilityControl & SetEdges(bool in_val);
11073 
11077  SelectabilityControl & SetFaces(Selectability::Value in_val);
11078 
11082  SelectabilityControl & SetFaces(bool in_val);
11083 
11087  SelectabilityControl & SetLights(Selectability::Value in_val);
11088 
11092  SelectabilityControl & SetLights(bool in_val);
11093 
11097  SelectabilityControl & SetLines(Selectability::Value in_val);
11098 
11102  SelectabilityControl & SetLines(bool in_val);
11103 
11107  SelectabilityControl & SetMarkers(Selectability::Value in_val);
11108 
11112  SelectabilityControl & SetMarkers(bool in_val);
11113 
11117  SelectabilityControl & SetVertices(Selectability::Value in_val);
11118 
11122  SelectabilityControl & SetVertices(bool in_val);
11123 
11127  SelectabilityControl & SetText(Selectability::Value in_val);
11128 
11132  SelectabilityControl & SetText(bool in_val);
11133 
11137  SelectabilityControl & SetGeometry(Selectability::Value in_val);
11138 
11142  SelectabilityControl & SetGeometry(bool in_val);
11143 
11147  SelectabilityControl & SetEverything(Selectability::Value in_val);
11148 
11152  SelectabilityControl & SetEverything(bool in_val);
11153 
11154 
11157  SelectabilityControl & UnsetWindows();
11158 
11161  SelectabilityControl & UnsetEdges();
11162 
11165  SelectabilityControl & UnsetFaces();
11166 
11169  SelectabilityControl & UnsetLights();
11170 
11173  SelectabilityControl & UnsetLines();
11174 
11177  SelectabilityControl & UnsetMarkers();
11178 
11181  SelectabilityControl & UnsetVertices();
11182 
11185  SelectabilityControl & UnsetText();
11186 
11189  SelectabilityControl & UnsetGeometry();
11190 
11193  SelectabilityControl & UnsetEverything();
11194 
11195 
11199  bool ShowWindows(Selectability::Value & out_val) const;
11200 
11204  bool ShowEdges(Selectability::Value & out_val) const;
11205 
11209  bool ShowFaces(Selectability::Value & out_val) const;
11210 
11214  bool ShowLights(Selectability::Value & out_val) const;
11215 
11219  bool ShowLines(Selectability::Value & out_val) const;
11220 
11224  bool ShowMarkers(Selectability::Value & out_val) const;
11225 
11229  bool ShowVertices(Selectability::Value & out_val) const;
11230 
11234  bool ShowText(Selectability::Value & out_val) const;
11235 
11236 private:
11239 };
11240 
11241 
11243 class HPS_API TransparencyKit : public Object
11244 {
11245 public:
11246 
11248  TransparencyKit();
11249 
11252  TransparencyKit(TransparencyKit const & in_kit);
11253 
11257  TransparencyKit(TransparencyKit && in_that);
11258 
11262  TransparencyKit & operator=(TransparencyKit && in_that);
11263 
11265  virtual ~TransparencyKit();
11266 
11267  HPS::Type ObjectType() const {return HPS::Type::TransparencyKit;};
11268 
11272  static TransparencyKit GetDefault();
11273 
11276  void Set(TransparencyKit const & in_kit);
11277 
11280  void Show(TransparencyKit & out_kit) const;
11281 
11285  TransparencyKit & operator=(TransparencyKit const & in_kit);
11286 
11289  bool Empty() const;
11290 
11294  bool Equals(TransparencyKit const & in_kit) const;
11295 
11299  bool operator==(TransparencyKit const & in_kit) const;
11300 
11304  bool operator!=(TransparencyKit const & in_kit) const;
11305 
11306 
11310  TransparencyKit & SetMethod(Transparency::Method in_style);
11311 
11315  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
11316 
11321  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
11322 
11328  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11329 
11334  TransparencyKit & SetDepthWriting(bool in_state);
11335 
11336 
11339  TransparencyKit & UnsetMethod();
11340 
11343  TransparencyKit & UnsetAlgorithm();
11344 
11347  TransparencyKit & UnsetDepthPeelingLayers();
11348 
11351  TransparencyKit & UnsetDepthPeelingMinimumArea();
11352 
11355  TransparencyKit & UnsetDepthWriting();
11356 
11359  TransparencyKit & UnsetEverything();
11360 
11361 
11365  bool ShowMethod(Transparency::Method & out_style) const;
11366 
11370  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11371 
11375  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11376 
11381  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11382 
11386  bool ShowDepthWriting(bool & out_state) const;
11387 };
11388 
11394 class HPS_API TransparencyControl : public Control
11395 {
11396 public:
11397 
11399  explicit TransparencyControl(SegmentKey & in_seg);
11400 
11402  TransparencyControl(TransparencyControl const & in_that);
11403 
11408 
11412  TransparencyControl & operator=(TransparencyControl && in_that);
11413 
11416 
11417  HPS::Type ObjectType() const {return HPS::Type::TransparencyControl;};
11418 
11422  TransparencyControl & operator=(TransparencyControl const & in_that);
11423 
11427  TransparencyControl & SetMethod(Transparency::Method in_style);
11428 
11432  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
11433 
11438  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
11439 
11445  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11446 
11451  TransparencyControl & SetDepthWriting(bool in_state);
11452 
11453 
11456  TransparencyControl & UnsetMethod();
11457 
11460  TransparencyControl & UnsetAlgorithm();
11461 
11464  TransparencyControl & UnsetDepthPeelingLayers();
11465 
11468  TransparencyControl & UnsetDepthPeelingMinimumArea();
11469 
11472  TransparencyControl & UnsetDepthWriting();
11473 
11476  TransparencyControl & UnsetEverything();
11477 
11478 
11482  bool ShowMethod(Transparency::Method & out_style) const;
11483 
11487  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11488 
11492  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11493 
11498  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11499 
11503  bool ShowDepthWriting(bool & out_state) const;
11504 
11505 private:
11508 };
11509 
11511 class HPS_API ColorInterpolationKit : public Object
11512 {
11513 public:
11514 
11517 
11520 
11525 
11529  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
11530 
11532  virtual ~ColorInterpolationKit();
11533 
11534  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationKit;};
11535 
11536  static ColorInterpolationKit GetDefault();
11537 
11539  void Set(ColorInterpolationKit const & in_kit);
11540 
11542  void Show(ColorInterpolationKit & out_kit) const;
11543 
11545  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
11546 
11548  bool Empty() const;
11549 
11551  bool Equals(ColorInterpolationKit const & in_kit) const;
11552 
11554  bool operator==(ColorInterpolationKit const & in_kit) const;
11555 
11557  bool operator!=(ColorInterpolationKit const & in_kit) const;
11558 
11559 
11563  ColorInterpolationKit & SetFaceColor(bool in_state);
11564 
11568  ColorInterpolationKit & SetEdgeColor(bool in_state);
11569 
11573  ColorInterpolationKit & SetVertexColor(bool in_state);
11574 
11578  ColorInterpolationKit & SetFaceIndex(bool in_state);
11579 
11583  ColorInterpolationKit & SetEdgeIndex(bool in_state);
11584 
11588  ColorInterpolationKit & SetVertexIndex(bool in_state);
11589 
11590 
11593  ColorInterpolationKit & UnsetFaceColor();
11594 
11597  ColorInterpolationKit & UnsetEdgeColor();
11598 
11601  ColorInterpolationKit & UnsetVertexColor();
11602 
11605  ColorInterpolationKit & UnsetFaceIndex();
11606 
11609  ColorInterpolationKit & UnsetEdgeIndex();
11610 
11613  ColorInterpolationKit & UnsetVertexIndex();
11614 
11617  ColorInterpolationKit & UnsetEverything();
11618 
11619 
11623  bool ShowFaceColor(bool & out_state) const;
11624 
11628  bool ShowEdgeColor(bool & out_state) const;
11629 
11633  bool ShowVertexColor(bool & out_state) const;
11634 
11638  bool ShowFaceIndex(bool & out_state) const;
11639 
11643  bool ShowEdgeIndex(bool & out_state) const;
11644 
11648  bool ShowVertexIndex(bool & out_state) const;
11649 };
11650 
11651 
11655 class HPS_API ColorInterpolationControl : public Control
11656 {
11657 public:
11658 
11660  explicit ColorInterpolationControl(SegmentKey & in_seg);
11661 
11664 
11669 
11673  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11674 
11677 
11678  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationControl;};
11679 
11683  ColorInterpolationControl & operator=(ColorInterpolationControl const & in_that);
11684 
11688  ColorInterpolationControl & SetFaceColor(bool in_state);
11689 
11693  ColorInterpolationControl & SetEdgeColor(bool in_state);
11694 
11698  ColorInterpolationControl & SetVertexColor(bool in_state);
11699 
11703  ColorInterpolationControl & SetFaceIndex(bool in_state);
11704 
11708  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11709 
11713  ColorInterpolationControl & SetVertexIndex(bool in_state);
11714 
11715 
11718  ColorInterpolationControl & UnsetFaceColor();
11719 
11722  ColorInterpolationControl & UnsetEdgeColor();
11723 
11726  ColorInterpolationControl & UnsetVertexColor();
11727 
11730  ColorInterpolationControl & UnsetFaceIndex();
11731 
11734  ColorInterpolationControl & UnsetEdgeIndex();
11735 
11738  ColorInterpolationControl & UnsetVertexIndex();
11739 
11742  ColorInterpolationControl & UnsetEverything();
11743 
11744 
11748  bool ShowFaceColor(bool & out_state) const;
11749 
11753  bool ShowEdgeColor(bool & out_state) const;
11754 
11758  bool ShowVertexColor(bool & out_state) const;
11759 
11763  bool ShowFaceIndex(bool & out_state) const;
11764 
11768  bool ShowEdgeIndex(bool & out_state) const;
11769 
11773  bool ShowVertexIndex(bool & out_state) const;
11774 
11775 private:
11778 };
11779 
11780 
11782 class HPS_API CullingKit : public Object
11783 {
11784 public:
11785 
11787  CullingKit();
11788 
11791  CullingKit(CullingKit const & in_kit);
11792 
11796  CullingKit(CullingKit && in_that);
11797 
11801  CullingKit & operator=(CullingKit && in_that);
11802 
11804  virtual ~CullingKit();
11805 
11806  HPS::Type ObjectType() const {return HPS::Type::CullingKit;};
11807 
11811  static CullingKit GetDefault();
11812 
11815  void Set(CullingKit const & in_kit);
11816 
11819  void Show(CullingKit & out_kit) const;
11820 
11824  CullingKit & operator=(CullingKit const & in_kit);
11825 
11828  bool Empty() const;
11829 
11833  bool Equals(CullingKit const & in_kit) const;
11834 
11838  bool operator==(CullingKit const & in_kit) const;
11839 
11843  bool operator!=(CullingKit const & in_kit) const;
11844 
11849  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11850 
11855  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11856 
11861  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11862 
11867  CullingKit & SetExtent(unsigned int in_pixels);
11868 
11872  CullingKit & SetBackFace(bool in_state);
11873 
11880  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11881 
11888  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11889 
11896  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11897 
11903  CullingKit & SetVector(HPS::Vector const & in_vector);
11904 
11908  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11909 
11913  CullingKit & SetFrustum(bool in_state);
11914 
11917  CullingKit & UnsetDeferralExtent();
11918 
11921  CullingKit & UnsetExtent();
11922 
11925  CullingKit & UnsetBackFace();
11926 
11929  CullingKit & UnsetVector();
11930 
11933  CullingKit & UnsetVectorTolerance();
11934 
11937  CullingKit & UnsetFrustum();
11938 
11941  CullingKit & UnsetEverything();
11942 
11947  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11948 
11953  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11954 
11958  bool ShowBackFace(bool & out_state) const;
11959 
11965  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11966 
11970  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11971 
11975  bool ShowFrustum(bool & out_state) const;
11976 };
11977 
11981 class HPS_API CullingControl : public Control
11982 {
11983 public:
11984 
11986  explicit CullingControl(SegmentKey & in_seg);
11987 
11989  CullingControl(CullingControl const & in_that);
11990 
11992  ~CullingControl();
11993 
11997  CullingControl(CullingControl && in_that);
11998 
12002  CullingControl & operator=(CullingControl && in_that);
12003 
12004  HPS::Type ObjectType() const {return HPS::Type::CullingControl;};
12005 
12009  CullingControl & operator=(CullingControl const & in_that);
12010 
12017  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
12018 
12025  CullingControl & SetDeferralExtent(unsigned int in_pixels);
12026 
12031  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
12032 
12037  CullingControl & SetExtent(unsigned int in_pixels);
12038 
12043  CullingControl & SetBackFace(bool in_state);
12044 
12051  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
12052 
12059  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
12060 
12067  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
12068 
12074  CullingControl & SetVector(HPS::Vector const & in_vector);
12075 
12079  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
12080 
12084  CullingControl & SetFrustum(bool in_state);
12085 
12088  CullingControl & UnsetDeferralExtent();
12089 
12092  CullingControl & UnsetExtent();
12093 
12096  CullingControl & UnsetBackFace();
12097 
12100  CullingControl & UnsetVector();
12101 
12104  CullingControl & UnsetVectorTolerance();
12105 
12108  CullingControl & UnsetFrustum();
12109 
12112  CullingControl & UnsetEverything();
12113 
12118  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
12119 
12124  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
12125 
12129  bool ShowBackFace(bool & out_state) const;
12130 
12136  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
12137 
12141  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
12142 
12146  bool ShowFrustum(bool & out_state) const;
12147 
12148 private:
12150  CullingControl();
12151 };
12152 
12153 
12154 
12155 
12157 class HPS_API MarkerAttributeKit : public Object
12158 {
12159 public:
12160 
12163 
12166  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
12167 
12172 
12176  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
12177 
12179  virtual ~MarkerAttributeKit();
12180 
12181  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeKit;};
12182 
12186  static MarkerAttributeKit GetDefault();
12187 
12190  void Set(MarkerAttributeKit const & in_kit);
12191 
12194  void Show(MarkerAttributeKit & out_kit) const;
12195 
12199  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
12200 
12203  bool Empty() const;
12204 
12208  bool Equals(MarkerAttributeKit const & in_kit) const;
12209 
12213  bool operator==(MarkerAttributeKit const & in_kit) const;
12214 
12218  bool operator!=(MarkerAttributeKit const & in_kit) const;
12219 
12220 
12224  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
12225 
12230  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12231 
12232 
12235  MarkerAttributeKit & UnsetSymbol();
12236 
12239  MarkerAttributeKit & UnsetSize();
12240 
12243  MarkerAttributeKit & UnsetEverything();
12244 
12245 
12249  bool ShowSymbol(UTF8 & out_glyph_name) const;
12250 
12255  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12256 };
12257 
12263 class HPS_API MarkerAttributeControl : public Control
12264 {
12265 public:
12266 
12268  explicit MarkerAttributeControl(SegmentKey & in_seg);
12269 
12272 
12277 
12281  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
12282 
12285 
12286  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeControl;};
12287 
12291  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
12292 
12296  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
12297 
12302  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12303 
12304 
12307  MarkerAttributeControl & UnsetSymbol();
12308 
12311  MarkerAttributeControl & UnsetSize();
12312 
12315  MarkerAttributeControl & UnsetEverything();
12316 
12317 
12321  bool ShowSymbol(UTF8 & out_glyph_name) const;
12322 
12327  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12328 
12329 private:
12332 };
12333 
12334 
12336 class HPS_API SphereAttributeKit : public Object
12337 {
12338 public:
12339 
12342 
12345  SphereAttributeKit(SphereAttributeKit const & in_kit);
12346 
12351 
12355  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
12356 
12358  virtual ~SphereAttributeKit();
12359 
12360  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeKit;};
12361 
12365  static SphereAttributeKit GetDefault();
12366 
12369  void Set(SphereAttributeKit const & in_kit);
12370 
12373  void Show(SphereAttributeKit & out_kit) const;
12374 
12378  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
12379 
12382  bool Empty() const;
12383 
12387  bool Equals(SphereAttributeKit const & in_kit) const;
12388 
12392  bool operator==(SphereAttributeKit const & in_kit) const;
12393 
12397  bool operator!=(SphereAttributeKit const & in_kit) const;
12398 
12399 
12403  SphereAttributeKit & SetTessellation(size_t in_facets);
12404 
12405 
12408  SphereAttributeKit & UnsetTessellation();
12409 
12412  SphereAttributeKit & UnsetEverything();
12413 
12414 
12418  bool ShowTessellation(size_t & out_facets) const;
12419 };
12420 
12421 
12424 class HPS_API SphereAttributeControl : public Control
12425 {
12426 public:
12427 
12429  explicit SphereAttributeControl(SegmentKey const & in_seg);
12430 
12433 
12438 
12442  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
12443 
12446 
12447  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeControl;};
12448 
12452  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
12453 
12458  SphereAttributeControl & SetTessellation(size_t in_facets);
12459 
12460 
12463  SphereAttributeControl & UnsetTessellation();
12464 
12467  SphereAttributeControl & UnsetEverything();
12468 
12469 
12473  bool ShowTessellation(size_t & out_facets) const;
12474 
12475 private:
12478 };
12479 
12480 
12482 class HPS_API LightingAttributeKit : public Object
12483 {
12484 public:
12485 
12488 
12492 
12497 
12501  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
12502 
12504  virtual ~LightingAttributeKit();
12505 
12506  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeKit;};
12507 
12511  static LightingAttributeKit GetDefault();
12512 
12515  void Set(LightingAttributeKit const & in_kit);
12516 
12519  void Show(LightingAttributeKit & out_kit) const;
12520 
12524  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
12525 
12528  bool Empty() const;
12529 
12533  bool Equals(LightingAttributeKit const & in_kit) const;
12534 
12538  bool operator==(LightingAttributeKit const & in_kit) const;
12539 
12543  bool operator!=(LightingAttributeKit const & in_kit) const;
12544 
12545 
12549  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12550 
12551 
12554  LightingAttributeKit & UnsetInterpolationAlgorithm();
12555 
12558  LightingAttributeKit & UnsetEverything();
12559 
12560 
12564  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12565 };
12566 
12567 
12568 
12574 class HPS_API LightingAttributeControl : public Control
12575 {
12576 public:
12577 
12579  explicit LightingAttributeControl(SegmentKey & in_seg);
12580 
12583 
12588 
12592  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
12593 
12596 
12597  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeControl;};
12598 
12602  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
12603 
12607  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12608 
12609 
12612  LightingAttributeControl & UnsetInterpolationAlgorithm();
12613 
12616  LightingAttributeControl & UnsetEverything();
12617 
12618 
12622  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12623 
12624 private:
12627 };
12628 
12629 
12630 
12632 class HPS_API CylinderAttributeKit : public Object
12633 {
12634 public:
12635 
12638 
12642 
12647 
12651  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
12652 
12654  virtual ~CylinderAttributeKit();
12655 
12656  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeKit;};
12657 
12661  static CylinderAttributeKit GetDefault();
12662 
12665  void Set(CylinderAttributeKit const & in_kit);
12666 
12669  void Show(CylinderAttributeKit & out_kit) const;
12670 
12674  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
12675 
12678  bool Empty() const;
12679 
12683  bool Equals(CylinderAttributeKit const & in_kit) const;
12684 
12688  bool operator==(CylinderAttributeKit const & in_kit) const;
12689 
12693  bool operator!=(CylinderAttributeKit const & in_kit) const;
12694 
12695 
12699  CylinderAttributeKit & SetTessellation(size_t in_facets);
12700 
12705  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12706 
12707 
12710  CylinderAttributeKit & UnsetTessellation();
12711 
12714  CylinderAttributeKit & UnsetOrientation();
12715 
12718  CylinderAttributeKit & UnsetEverything();
12719 
12720 
12724  bool ShowTessellation(size_t & out_facets) const;
12725 
12729  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12730 };
12731 
12732 
12733 
12737 class HPS_API CylinderAttributeControl : public Control
12738 {
12739 public:
12740 
12742  explicit CylinderAttributeControl(SegmentKey & in_seg);
12743 
12746 
12751 
12755  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12756 
12759 
12760  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeControl;};
12761 
12765  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12766 
12770  CylinderAttributeControl & SetTessellation(size_t in_facets);
12771 
12776  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12777 
12778 
12781  CylinderAttributeControl & UnsetTessellation();
12782 
12785  CylinderAttributeControl & UnsetOrientation();
12786 
12789  CylinderAttributeControl & UnsetEverything();
12790 
12791 
12795  bool ShowTessellation(size_t & out_facets) const;
12796 
12800  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12801 
12802 private:
12805 };
12806 
12807 
12808 
12810 class HPS_API CuttingSectionAttributeKit : public Object
12811 {
12812 public:
12813 
12816 
12820 
12825 
12830 
12832  virtual ~CuttingSectionAttributeKit();
12833 
12834  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeKit;};
12835 
12839  static CuttingSectionAttributeKit GetDefault();
12840 
12843  void Set(CuttingSectionAttributeKit const & in_kit);
12844 
12847  void Show(CuttingSectionAttributeKit & out_kit) const;
12848 
12852  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12853 
12856  bool Empty() const;
12857 
12861  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12862 
12866  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12867 
12871  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12872 
12873 
12877  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12878 
12882  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12883 
12887  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12888 
12889 
12892  CuttingSectionAttributeKit & UnsetCuttingLevel();
12893 
12896  CuttingSectionAttributeKit & UnsetCappingLevel();
12897 
12900  CuttingSectionAttributeKit & UnsetMaterialPreference();
12901 
12904  CuttingSectionAttributeKit & UnsetEverything();
12905 
12906 
12910  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12911 
12915  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12916 
12920  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12921 };
12922 
12923 
12924 
12929 {
12930 public:
12931 
12933  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12934 
12937 
12942 
12947 
12950 
12951  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeControl;};
12952 
12957 
12962 
12967 
12971  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12972 
12973 
12976  CuttingSectionAttributeControl & UnsetCuttingLevel();
12977 
12980  CuttingSectionAttributeControl & UnsetCappingLevel();
12981 
12984  CuttingSectionAttributeControl & UnsetMaterialPreference();
12985 
12988  CuttingSectionAttributeControl & UnsetEverything();
12989 
12990 
12994  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12995 
12999  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
13000 
13004  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
13005 
13006 private:
13009 };
13010 
13011 
13012 
13014 class HPS_API TextAttributeKit : public Object
13015 {
13016 public:
13017 
13019  TextAttributeKit();
13020 
13023  TextAttributeKit(TextAttributeKit const & in_kit);
13024 
13028  TextAttributeKit(TextAttributeKit && in_that);
13029 
13033  TextAttributeKit & operator=(TextAttributeKit && in_that);
13034 
13036  virtual ~TextAttributeKit();
13037 
13038  HPS::Type ObjectType() const {return HPS::Type::TextAttributeKit;};
13039 
13043  static TextAttributeKit GetDefault();
13044 
13047  void Set(TextAttributeKit const & in_kit);
13048 
13051  void Show(TextAttributeKit & out_kit) const;
13052 
13056  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
13057 
13060  bool Empty() const;
13061 
13065  bool Equals(TextAttributeKit const & in_kit) const;
13066 
13070  bool operator==(TextAttributeKit const & in_kit) const;
13071 
13075  bool operator!=(TextAttributeKit const & in_kit) const;
13076 
13077 
13084 
13089  TextAttributeKit & SetBold(bool in_state);
13090 
13095  TextAttributeKit & SetItalic(bool in_state);
13096 
13100  TextAttributeKit & SetOverline(bool in_state);
13101 
13105  TextAttributeKit & SetStrikethrough(bool in_state);
13106 
13110  TextAttributeKit & SetUnderline(bool in_state);
13111 
13117  TextAttributeKit & SetSlant(float in_angle);
13118 
13123  TextAttributeKit & SetLineSpacing(float in_multiplier);
13124 
13129  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13130 
13135  TextAttributeKit & SetRotation(float in_angle);
13136 
13142  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13143 
13149  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13150 
13157  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13158 
13165 
13175  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13176 
13186  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13187 
13192  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
13193 
13200  TextAttributeKit & SetFont(char const * in_name);
13201 
13205  TextAttributeKit & SetTransform(Text::Transform in_trans);
13206 
13210  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
13211 
13216  TextAttributeKit & SetPreference(Text::Preference in_pref);
13217 
13225  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13226 
13231  TextAttributeKit & SetPath(Vector const & in_path);
13232 
13240  TextAttributeKit & SetSpacing(float in_multiplier);
13241 
13242 
13245  TextAttributeKit & UnsetAlignment();
13246 
13249  TextAttributeKit & UnsetBold();
13250 
13253  TextAttributeKit & UnsetItalic();
13254 
13257  TextAttributeKit & UnsetOverline();
13258 
13261  TextAttributeKit & UnsetStrikethrough();
13262 
13265  TextAttributeKit & UnsetUnderline();
13266 
13269  TextAttributeKit & UnsetSlant();
13270 
13273  TextAttributeKit & UnsetLineSpacing();
13274 
13277  TextAttributeKit & UnsetRotation();
13278 
13281  TextAttributeKit & UnsetExtraSpace();
13282 
13285  TextAttributeKit & UnsetGreeking();
13286 
13289  TextAttributeKit & UnsetSizeTolerance();
13290 
13293  TextAttributeKit & UnsetSize();
13294 
13297  TextAttributeKit & UnsetFont();
13298 
13301  TextAttributeKit & UnsetTransform();
13302 
13305  TextAttributeKit & UnsetRenderer();
13306 
13309  TextAttributeKit & UnsetPreference();
13310 
13313  TextAttributeKit & UnsetPath();
13314 
13317  TextAttributeKit & UnsetSpacing();
13318 
13321  TextAttributeKit & UnsetEverything();
13322 
13323 
13329  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13330 
13334  bool ShowBold(bool & out_state) const;
13335 
13339  bool ShowItalic(bool & out_state) const;
13340 
13344  bool ShowOverline(bool & out_state) const;
13345 
13349  bool ShowStrikethrough(bool & out_state) const;
13350 
13354  bool ShowUnderline(bool & out_state) const;
13355 
13359  bool ShowSlant(float & out_angle) const;
13360 
13364  bool ShowLineSpacing(float & out_multiplier) const;
13365 
13370  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13371 
13377  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13378 
13385  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13386 
13392  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13393 
13398  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13399 
13403  bool ShowFont(UTF8 & out_name) const;
13404 
13408  bool ShowTransform(Text::Transform & out_trans) const;
13409 
13413  bool ShowRenderer(Text::Renderer & out_rend) const;
13414 
13421  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13422 
13426  bool ShowPath(Vector & out_path) const;
13427 
13431  bool ShowSpacing(float & out_multiplier) const;
13432 };
13433 
13439 class HPS_API TextAttributeControl : public Control
13440 {
13441 public:
13442 
13444  explicit TextAttributeControl(SegmentKey & in_seg);
13445 
13447  TextAttributeControl(TextAttributeControl const & in_that);
13448 
13453 
13457  TextAttributeControl & operator=(TextAttributeControl && in_that);
13458 
13461 
13462  HPS::Type ObjectType() const {return HPS::Type::TextAttributeControl;};
13463 
13467  TextAttributeControl & operator=(TextAttributeControl const & in_that);
13468 
13475 
13480  TextAttributeControl & SetBold(bool in_state);
13481 
13486  TextAttributeControl & SetItalic(bool in_state);
13487 
13491  TextAttributeControl & SetOverline(bool in_state);
13492 
13496  TextAttributeControl & SetStrikethrough(bool in_state);
13497 
13501  TextAttributeControl & SetUnderline(bool in_state);
13502 
13508  TextAttributeControl & SetSlant(float in_angle);
13509 
13514  TextAttributeControl & SetLineSpacing(float in_multiplier);
13515 
13520  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13521 
13526  TextAttributeControl & SetRotation(float in_angle);
13527 
13533  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13534 
13540  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13541 
13548  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13549 
13556 
13566  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13567 
13577  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13578 
13583  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
13584 
13591  TextAttributeControl & SetFont(char const * in_name);
13592 
13596  TextAttributeControl & SetTransform(Text::Transform in_trans);
13597 
13601  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
13602 
13607  TextAttributeControl & SetPreference(Text::Preference in_pref);
13608 
13616  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13617 
13622  TextAttributeControl & SetPath(Vector const & in_path);
13623 
13631  TextAttributeControl & SetSpacing(float in_multiplier);
13632 
13633 
13636  TextAttributeControl & UnsetAlignment();
13637 
13640  TextAttributeControl & UnsetBold();
13641 
13644  TextAttributeControl & UnsetItalic();
13645 
13648  TextAttributeControl & UnsetOverline();
13649 
13652  TextAttributeControl & UnsetStrikethrough();
13653 
13656  TextAttributeControl & UnsetUnderline();
13657 
13660  TextAttributeControl & UnsetSlant();
13661 
13664  TextAttributeControl & UnsetLineSpacing();
13665 
13668  TextAttributeControl & UnsetRotation();
13669 
13672  TextAttributeControl & UnsetExtraSpace();
13673 
13676  TextAttributeControl & UnsetGreeking();
13677 
13680  TextAttributeControl & UnsetSizeTolerance();
13681 
13684  TextAttributeControl & UnsetSize();
13685 
13688  TextAttributeControl & UnsetFont();
13689 
13692  TextAttributeControl & UnsetTransform();
13693 
13696  TextAttributeControl & UnsetRenderer();
13697 
13700  TextAttributeControl & UnsetPreference();
13701 
13704  TextAttributeControl & UnsetPath();
13705 
13708  TextAttributeControl & UnsetSpacing();
13709 
13712  TextAttributeControl & UnsetEverything();
13713 
13714 
13720  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13721 
13725  bool ShowBold(bool & out_state) const;
13726 
13730  bool ShowItalic(bool & out_state) const;
13731 
13735  bool ShowOverline(bool & out_state) const;
13736 
13740  bool ShowStrikethrough(bool & out_state) const;
13741 
13745  bool ShowUnderline(bool & out_state) const;
13746 
13750  bool ShowSlant(float & out_angle) const;
13751 
13755  bool ShowLineSpacing(float & out_multiplier) const;
13756 
13761  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13762 
13768  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13769 
13776  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13777 
13783  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13784 
13789  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13790 
13794  bool ShowFont(UTF8 & out_name) const;
13795 
13799  bool ShowTransform(Text::Transform & out_trans) const;
13800 
13804  bool ShowRenderer(Text::Renderer & out_rend) const;
13805 
13812  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13813 
13817  bool ShowPath(Vector & out_path) const;
13818 
13822  bool ShowSpacing(float & out_multiplier) const;
13823 
13824 private:
13827 };
13828 
13829 
13830 
13831 
13832 
13834 class HPS_API LineAttributeKit : public Object
13835 {
13836 public:
13837 
13839  LineAttributeKit();
13840 
13843  LineAttributeKit(LineAttributeKit const & in_kit);
13844 
13848  LineAttributeKit(LineAttributeKit && in_that);
13849 
13853  LineAttributeKit & operator=(LineAttributeKit && in_that);
13854 
13856  virtual ~LineAttributeKit();
13857 
13858  HPS::Type ObjectType() const {return HPS::Type::LineAttributeKit;};
13859 
13863  static LineAttributeKit GetDefault();
13864 
13867  void Set(LineAttributeKit const & in_kit);
13868 
13871  void Show(LineAttributeKit & out_kit) const;
13872 
13876  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13877 
13880  bool Empty() const;
13881 
13885  bool Equals(LineAttributeKit const & in_kit) const;
13886 
13890  bool operator==(LineAttributeKit const & in_kit) const;
13891 
13895  bool operator!=(LineAttributeKit const & in_kit) const;
13896 
13897 
13901  LineAttributeKit & SetPattern(char const * in_name);
13902 
13907  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13908 
13913  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13914 
13915 
13918  LineAttributeKit & UnsetPattern();
13919 
13922  LineAttributeKit & UnsetWeight();
13923 
13926  LineAttributeKit & UnsetEverything();
13927 
13928 
13933  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13934 
13939  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13940 };
13941 
13947 class HPS_API LineAttributeControl : public Control
13948 {
13949 public:
13950 
13952  explicit LineAttributeControl(SegmentKey & in_seg);
13953 
13955  LineAttributeControl(LineAttributeControl const & in_that);
13956 
13961 
13965  LineAttributeControl & operator=(LineAttributeControl && in_that);
13966 
13969 
13970  HPS::Type ObjectType() const {return HPS::Type::LineAttributeControl;};
13971 
13975  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13976 
13980  LineAttributeControl & SetPattern(char const * in_pattern);
13981 
13986  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13987 
13992  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13993 
13994 
13997  LineAttributeControl & UnsetPattern();
13998 
14001  LineAttributeControl & UnsetWeight();
14002 
14005  LineAttributeControl & UnsetEverything();
14006 
14007 
14012  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
14013 
14018  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
14019 
14020 private:
14023 };
14024 
14025 
14026 
14028 class HPS_API EdgeAttributeKit : public Object
14029 {
14030 public:
14031 
14033  EdgeAttributeKit();
14034 
14037  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
14038 
14042  EdgeAttributeKit(EdgeAttributeKit && in_that);
14043 
14047  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
14048 
14050  virtual ~EdgeAttributeKit();
14051 
14052  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeKit;};
14053 
14057  static EdgeAttributeKit GetDefault();
14058 
14061  void Set(EdgeAttributeKit const & in_kit);
14062 
14065  void Show(EdgeAttributeKit & out_kit) const;
14066 
14070  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
14071 
14074  bool Empty() const;
14075 
14079  bool Equals(EdgeAttributeKit const & in_kit) const;
14080 
14084  bool operator==(EdgeAttributeKit const & in_kit) const;
14085 
14089  bool operator!=(EdgeAttributeKit const & in_kit) const;
14090 
14091 
14095  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
14096 
14101  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
14102 
14106  EdgeAttributeKit & SetHardAngle(float in_angle);
14107 
14108 
14111  EdgeAttributeKit & UnsetPattern();
14112 
14115  EdgeAttributeKit & UnsetWeight();
14116 
14119  EdgeAttributeKit & UnsetHardAngle();
14120 
14123  EdgeAttributeKit & UnsetEverything();
14124 
14125 
14129  bool ShowPattern(UTF8 & out_pattern_name) const;
14130 
14135  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14136 
14140  bool ShowHardAngle(float & out_angle) const;
14141 
14142 };
14143 
14149 class HPS_API EdgeAttributeControl : public Control
14150 {
14151 public:
14152 
14154  explicit EdgeAttributeControl(SegmentKey & in_seg);
14155 
14157  EdgeAttributeControl(EdgeAttributeControl const & in_that);
14158 
14163 
14167  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
14168 
14171 
14172  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeControl;};
14173 
14177  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
14178 
14182  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
14183 
14188  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
14189 
14193  EdgeAttributeControl & SetHardAngle(float in_angle);
14194 
14195 
14198  EdgeAttributeControl & UnsetPattern();
14199 
14202  EdgeAttributeControl & UnsetWeight();
14203 
14206  EdgeAttributeControl & UnsetHardAngle();
14207 
14210  EdgeAttributeControl & UnsetEverything();
14211 
14212 
14216  bool ShowPattern(UTF8 & out_pattern_name) const;
14217 
14222  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14223 
14227  bool ShowHardAngle(float & out_angle) const;
14228 
14229 private:
14232 };
14233 
14234 
14236 class HPS_API CurveAttributeKit : public Object
14237 {
14238 public:
14239 
14242 
14245  CurveAttributeKit(CurveAttributeKit const & in_kit);
14246 
14251 
14255  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
14256 
14258  virtual ~CurveAttributeKit();
14259 
14260  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeKit;};
14261 
14265  static CurveAttributeKit GetDefault();
14266 
14269  void Set(CurveAttributeKit const & in_kit);
14270 
14273  void Show(CurveAttributeKit & out_kit) const;
14274 
14278  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
14279 
14282  bool Empty() const;
14283 
14287  bool Equals(CurveAttributeKit const & in_kit) const;
14288 
14292  bool operator==(CurveAttributeKit const & in_kit) const;
14293 
14297  bool operator!=(CurveAttributeKit const & in_kit) const;
14298 
14299  //Set
14300  CurveAttributeKit & SetBudget(size_t in_budget);
14301 
14308  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14309 
14316  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
14317 
14318 
14325  CurveAttributeKit & SetViewDependent(bool in_state);
14326 
14330  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
14331 
14336  CurveAttributeKit & SetMaximumAngle(float in_degrees);
14337 
14342  CurveAttributeKit & SetMaximumLength(float in_length);
14343 
14344 
14347  CurveAttributeKit & UnsetBudget();
14348 
14351  CurveAttributeKit & UnsetContinuedBudget();
14352 
14355  CurveAttributeKit & UnsetViewDependent();
14356 
14359  CurveAttributeKit & UnsetMaximumDeviation();
14360 
14363  CurveAttributeKit & UnsetMaximumAngle();
14364 
14367  CurveAttributeKit & UnsetMaximumLength();
14368 
14371  CurveAttributeKit & UnsetEverything();
14372 
14373 
14377  bool ShowBudget(size_t & out_budget) const;
14378 
14383  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14384 
14388  bool ShowViewDependent(bool & out_state) const;
14389 
14394  bool ShowMaximumDeviation(float & out_deviation) const;
14395 
14400  bool ShowMaximumAngle(float & out_degrees) const;
14401 
14406  bool ShowMaximumLength(float & out_length) const;
14407 };
14408 
14409 
14413 class HPS_API CurveAttributeControl : public Control
14414 {
14415 public:
14416 
14418  explicit CurveAttributeControl(SegmentKey & in_seg);
14419 
14422 
14427 
14431  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
14432 
14435 
14436  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeControl;};
14437 
14441  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
14442 
14446  CurveAttributeControl & SetBudget(size_t in_budget);
14447 
14454  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14455 
14462  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
14463 
14470  CurveAttributeControl & SetViewDependent(bool in_state);
14471 
14475  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
14476 
14481  CurveAttributeControl & SetMaximumAngle(float in_degrees);
14482 
14487  CurveAttributeControl & SetMaximumLength(float in_length);
14488 
14489 
14492  CurveAttributeControl & UnsetBudget();
14493 
14496  CurveAttributeControl & UnsetContinuedBudget();
14497 
14500  CurveAttributeControl & UnsetViewDependent();
14501 
14504  CurveAttributeControl & UnsetMaximumDeviation();
14505 
14508  CurveAttributeControl & UnsetMaximumAngle();
14509 
14512  CurveAttributeControl & UnsetMaximumLength();
14513 
14516  CurveAttributeControl & UnsetEverything();
14517 
14518 
14522  bool ShowBudget(size_t & out_budget) const;
14523 
14528  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14529 
14533  bool ShowViewDependent(bool & out_state) const;
14534 
14539  bool ShowMaximumDeviation(float & out_deviation) const;
14540 
14545  bool ShowMaximumAngle(float & out_degrees) const;
14546 
14551  bool ShowMaximumLength(float & out_length) const;
14552 
14553 private:
14556 };
14557 
14558 
14559 
14560 
14562 class HPS_API MatrixKit : public Object
14563 {
14564 public:
14565 
14567  MatrixKit();
14568 
14571  MatrixKit(MatrixKit const & in_kit);
14572 
14576  MatrixKit(MatrixKit && in_that);
14577 
14581  MatrixKit & operator=(MatrixKit && in_that);
14582 
14586  MatrixKit(FloatArray const & in_matrix_source);
14587 
14591  MatrixKit(float const in_matrix_source []);
14592 
14595  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
14596 
14598  virtual ~MatrixKit();
14599 
14600  HPS::Type ObjectType() const {return HPS::Type::MatrixKit;};
14601 
14604  static MatrixKit GetDefault();
14605 
14608  void Set(MatrixKit const & in_kit);
14609 
14612  void Show(MatrixKit & out_kit) const;
14613 
14617  MatrixKit & operator=(MatrixKit const & in_kit);
14618 
14621  bool Empty() const;
14622 
14626  bool Equals(MatrixKit const & in_kit) const;
14627 
14631  bool operator==(MatrixKit const & in_kit) const;
14632 
14636  bool operator!=(MatrixKit const & in_kit) const;
14637 
14643  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
14644 
14649  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14650 
14654  MatrixKit & SetElements(FloatArray const & in_values);
14655 
14660  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
14661 
14662 
14665  MatrixKit & UnsetEverything();
14666 
14667 
14673  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14674 
14679  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14680 
14684  bool ShowElements(FloatArray & out_matrix) const;
14685 
14689  bool ShowDeterminant(float & out_determinant) const;
14690 
14694  bool ShowInverse(MatrixKit & out_matrix) const;
14695 
14700  bool ShowAdjoint(MatrixKit & out_matrix) const;
14701 
14702 
14708  MatrixKit & Rotate(float in_x, float in_y, float in_z);
14709 
14714  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
14715 
14721  MatrixKit & Translate(float in_x, float in_y, float in_z);
14722 
14728  MatrixKit & Scale(float in_x, float in_y, float in_z);
14729 
14733  MatrixKit & Concatenate(MatrixKit const & in_kit);
14734 
14737  MatrixKit & Normalize();
14738 
14741  MatrixKit & Invert();
14742 
14746  MatrixKit & Adjoint();
14747 
14748 
14752  MatrixKit Multiply(MatrixKit const & in_right) const;
14753 
14757  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14758 
14762  MatrixKit Multiply(float in_scalar) const;
14763 
14767  MatrixKit const & MultiplyAndAssign(float in_scalar);
14768 
14772  MatrixKit operator*(MatrixKit const & in_right) const;
14773 
14777  MatrixKit const & operator*=(MatrixKit const & in_right);
14778 
14782  MatrixKit operator*(float in_scalar) const;
14783 
14787  MatrixKit const & operator*=(float in_scalar);
14788 
14789 
14793  Point Transform(Point const & in_source) const;
14794 
14798  PointArray Transform(PointArray const & in_source) const;
14799 
14804  PointArray Transform(size_t in_count, Point const in_source []) const;
14805 
14809  Vector Transform(Vector const & in_source) const;
14810 
14814  VectorArray Transform(VectorArray const & in_source) const;
14815 
14820  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14821 
14825  Plane Transform(Plane const & in_source) const;
14826 
14830  PlaneArray Transform(PlaneArray const & in_source) const;
14831 
14836  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14837 
14841  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
14842 
14846  SimpleSphere Transform(SimpleSphere const & in_source) const;
14847 };
14848 
14852 class HPS_API ModellingMatrixControl : public Control
14853 {
14854 public:
14855 
14857  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14858 
14860  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14861 
14864 
14869 
14873  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14874 
14877 
14878  HPS::Type ObjectType() const {return HPS::Type::ModellingMatrixControl;};
14879 
14883  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14884 
14890  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14891 
14896  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14897 
14901  ModellingMatrixControl & SetElements(FloatArray const & in_values);
14902 
14907  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14908 
14909 
14912  ModellingMatrixControl & UnsetEverything();
14913 
14914 
14920  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14921 
14926  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14927 
14931  bool ShowElements(FloatArray & out_matrix) const;
14932 
14936  bool ShowDeterminant(float & out_determinant) const;
14937 
14941  bool ShowInverse(MatrixKit & out_matrix) const;
14942 
14947  bool ShowAdjoint(MatrixKit & out_matrix) const;
14948 
14954  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14955 
14960  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14961 
14967  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14968 
14974  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14975 
14979  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14980 
14983  ModellingMatrixControl & Normalize();
14984 
14987  ModellingMatrixControl & Invert();
14988 
14992  ModellingMatrixControl & Adjoint();
14993 
14994 private:
14997 };
14998 
15001 class HPS_API TextureMatrixControl : public Control
15002 {
15003 public:
15004 
15006  explicit TextureMatrixControl(SegmentKey & in_seg);
15007 
15009  TextureMatrixControl(const TextureMatrixControl & in_that);
15010 
15015 
15019  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
15020 
15023 
15024  HPS::Type ObjectType() const {return HPS::Type::TextureMatrixControl;};
15025 
15029  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
15030 
15036  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
15037 
15042  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
15043 
15047  TextureMatrixControl & SetElements(FloatArray const & in_values);
15048 
15053  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
15054 
15055 
15058  TextureMatrixControl & UnsetEverything();
15059 
15060 
15066  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
15067 
15072  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
15073 
15077  bool ShowElements(FloatArray & out_matrix) const;
15078 
15082  bool ShowDeterminant(float & out_determinant) const;
15083 
15087  bool ShowInverse(MatrixKit & out_matrix) const;
15088 
15093  bool ShowAdjoint(MatrixKit & out_matrix) const;
15094 
15100  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
15101 
15106  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
15107 
15113  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
15114 
15120  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
15121 
15125  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
15126 
15129  TextureMatrixControl & Normalize();
15130 
15133  TextureMatrixControl & Invert();
15134 
15138  TextureMatrixControl & Adjoint();
15139 
15140 private:
15143 };
15144 
15145 
15148 class HPS_API MaterialMappingKit : public Object
15149 {
15150 public:
15151 
15154 
15157  MaterialMappingKit(MaterialMappingKit const & in_kit);
15158 
15163 
15167  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
15168 
15170  ~MaterialMappingKit();
15171 
15172  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingKit;};
15173 
15177  static MaterialMappingKit GetDefault();
15178 
15181  void Set(MaterialMappingKit const & in_kit);
15182 
15185  void Show(MaterialMappingKit & out_kit) const;
15186 
15190  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
15191 
15194  bool Empty() const;
15195 
15199  bool Equals(MaterialMappingKit const & in_kit) const;
15200 
15204  bool operator==(MaterialMappingKit const & in_kit) const;
15205 
15209  bool operator!=(MaterialMappingKit const & in_kit) const;
15210 
15211  //Set
15212 
15216  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15217 
15223  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
15224 
15225 
15229  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15230 
15236  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
15237 
15243  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15244 
15249  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
15250 
15257  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15258 
15267  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);
15268 
15272  MaterialMappingKit & SetBackFaceGloss(float in_value);
15273 
15277  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
15278 
15283  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
15284 
15290  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15291 
15296  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
15297 
15304  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15305 
15314  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);
15315 
15319  MaterialMappingKit & SetFrontFaceGloss(float in_value);
15320 
15324  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
15325 
15330  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
15331 
15332 
15336  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15337 
15343  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
15344 
15350  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15351 
15356  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
15357 
15364  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15365 
15374  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);
15375 
15379  MaterialMappingKit & SetCutFaceGloss(float in_value);
15380 
15384  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
15385 
15390  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
15391 
15396  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
15397 
15403  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15404 
15411  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15412 
15421  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);
15422 
15426  MaterialMappingKit & SetEdgeGloss(float in_value);
15427 
15431  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
15432 
15437  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
15438 
15443  MaterialMappingKit & SetFaceAlpha(float in_alpha);
15444 
15450  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15451 
15458  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15459 
15468  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);
15469 
15473  MaterialMappingKit & SetFaceGloss(float in_value);
15474 
15478  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
15479 
15484  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
15485 
15489  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
15490 
15491 
15492 
15493 
15494 
15498  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
15499 
15505  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
15506 
15507 
15511  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
15512 
15518  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
15519 
15520 
15524  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
15525 
15531  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
15532 
15533 
15537  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
15538 
15544  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
15545 
15550  MaterialMappingKit & SetVertexAlpha(float in_alpha);
15551 
15557  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15558 
15565  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15566 
15575  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);
15576 
15580  MaterialMappingKit & SetVertexGloss(float in_value);
15581 
15585  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
15586 
15591  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
15592 
15596  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
15597 
15598 
15602  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
15603 
15609  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
15610 
15611 
15615  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15616 
15622  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
15623 
15624  //Aggregate Sets
15625 
15629  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15630 
15635  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
15636 
15637 
15641  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15642 
15648  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
15649 
15650 
15651  //Unset
15652 
15655  MaterialMappingKit & UnsetAmbientLightUpColor();
15656 
15657 
15660  MaterialMappingKit & UnsetAmbientLightDownColor();
15661 
15662 
15665  MaterialMappingKit & UnsetBackFaceMaterial();
15666 
15669  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
15670 
15673  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15674 
15677  MaterialMappingKit & UnsetFrontFaceMaterial();
15678 
15681  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
15682 
15685  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15686 
15687 
15688 
15691  MaterialMappingKit & UnsetCutEdgeColor();
15692 
15693 
15696  MaterialMappingKit & UnsetCutFaceMaterial();
15697 
15700  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
15701 
15704  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15705 
15706 
15709  MaterialMappingKit & UnsetEdgeMaterial();
15710 
15713  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
15714 
15717  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15718 
15719 
15722  MaterialMappingKit & UnsetFaceMaterial();
15723 
15726  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
15727 
15730  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15731 
15732 
15735  MaterialMappingKit & UnsetLightColor();
15736 
15737 
15740  MaterialMappingKit & UnsetLineColor();
15741 
15742 
15745  MaterialMappingKit & UnsetMarkerColor();
15746 
15747 
15750  MaterialMappingKit & UnsetTextColor();
15751 
15752 
15755  MaterialMappingKit & UnsetVertexMaterial();
15756 
15759  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15760 
15763  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15764 
15765 
15768  MaterialMappingKit & UnsetWindowColor();
15769 
15770 
15773  MaterialMappingKit & UnsetWindowContrastColor();
15774 
15775 
15776  //Aggregate Unsets
15777 
15780  MaterialMappingKit & UnsetCutGeometryColor();
15781 
15784  MaterialMappingKit & UnsetAmbientLightColor();
15785 
15788  MaterialMappingKit & UnsetEverything();
15789 
15790 
15791  //Show
15792 
15798  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15799 
15805  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15806 
15807 
15815  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15816 
15825  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;
15826 
15832  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15833 
15834 
15842  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15843 
15852  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;
15853 
15859  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15860 
15861 
15862 
15868  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15869 
15870 
15878  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15879 
15888  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;
15889 
15895  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15896 
15897 
15905  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15906 
15915  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;
15916 
15922  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15923 
15924 
15932  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15933 
15942  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;
15943 
15949  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15950 
15951 
15957  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15958 
15959 
15965  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15966 
15967 
15973  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15974 
15975 
15981  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15982 
15983 
15991  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15992 
16001  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;
16002 
16008  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16009 
16010 
16016  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16017 
16018 
16024  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16025 };
16026 
16027 
16033 class HPS_API MaterialMappingControl : public Control
16034 {
16035 public:
16036 
16038  explicit MaterialMappingControl(SegmentKey & in_seg);
16039 
16042 
16047 
16051  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
16052 
16055 
16056  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingControl;};
16057 
16061  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
16062 
16063  //Set
16064 
16068  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
16069 
16075  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
16076 
16077 
16081  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
16082 
16088  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
16089 
16094  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
16095 
16101  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16102 
16109  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16110 
16119  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);
16120 
16124  MaterialMappingControl & SetBackFaceGloss(float in_value);
16125 
16129  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
16130 
16135  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
16136 
16137 
16142  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
16143 
16149  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16150 
16157  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16158 
16167  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);
16168 
16172  MaterialMappingControl & SetFrontFaceGloss(float in_value);
16173 
16177  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
16178 
16183  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
16184 
16188  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
16189 
16195  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
16196 
16201  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
16202 
16208  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16209 
16216  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16217 
16226  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);
16227 
16231  MaterialMappingControl & SetCutFaceGloss(float in_value);
16232 
16236  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
16237 
16242  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
16243 
16248  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
16249 
16255  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16256 
16263  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16264 
16273  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);
16274 
16278  MaterialMappingControl & SetEdgeGloss(float in_value);
16279 
16283  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
16284 
16289  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
16290 
16296  MaterialMappingControl & SetFaceAlpha(float in_alpha);
16297 
16304  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16305 
16312  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16313 
16322  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);
16323 
16327  MaterialMappingControl & SetFaceGloss(float in_value);
16328 
16332  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
16333 
16338  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
16339 
16343  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
16344 
16345 
16349  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
16350 
16356  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
16357 
16358 
16362  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
16363 
16369  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
16370 
16371 
16375  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
16376 
16382  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
16383 
16384 
16388  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
16389 
16395  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
16396 
16397 
16402  MaterialMappingControl & SetVertexAlpha(float in_alpha);
16403 
16404 
16410  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16411 
16418  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16419 
16428  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);
16429 
16433  MaterialMappingControl & SetVertexGloss(float in_value);
16434 
16438  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
16439 
16444  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
16445 
16449  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
16450 
16451 
16455  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
16456 
16462  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
16463 
16464 
16468  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16469 
16475  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
16476 
16477  //Aggregate Sets
16478 
16482  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16483 
16488  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
16489 
16490 
16494  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16495 
16501  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
16502 
16503 
16504  //Unset
16505 
16508  MaterialMappingControl & UnsetAmbientLightUpColor();
16509 
16510 
16513  MaterialMappingControl & UnsetAmbientLightDownColor();
16514 
16515 
16518  MaterialMappingControl & UnsetFrontFaceMaterial();
16519 
16522  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
16523 
16526  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16527 
16528 
16531  MaterialMappingControl & UnsetBackFaceMaterial();
16532 
16535  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
16536 
16539  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16540 
16541 
16544  MaterialMappingControl & UnsetCutEdgeColor();
16545 
16546 
16549  MaterialMappingControl & UnsetCutFaceMaterial();
16550 
16553  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
16554 
16557  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16558 
16559 
16562  MaterialMappingControl & UnsetEdgeMaterial();
16563 
16566  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
16567 
16570  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
16571 
16572 
16575  MaterialMappingControl & UnsetFaceMaterial();
16576 
16579  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
16580 
16583  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
16584 
16585 
16588  MaterialMappingControl & UnsetLightColor();
16589 
16590 
16593  MaterialMappingControl & UnsetLineColor();
16594 
16595 
16598  MaterialMappingControl & UnsetMarkerColor();
16599 
16600 
16603  MaterialMappingControl & UnsetTextColor();
16604 
16605 
16608  MaterialMappingControl & UnsetVertexMaterial();
16609 
16612  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
16613 
16616  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
16617 
16618 
16621  MaterialMappingControl & UnsetWindowColor();
16622 
16623 
16626  MaterialMappingControl & UnsetWindowContrastColor();
16627 
16628 
16629  //Aggregate Unsets
16630 
16633  MaterialMappingControl & UnsetCutGeometryColor();
16634 
16637  MaterialMappingControl & UnsetAmbientLightColor();
16638 
16641  MaterialMappingControl & UnsetEverything();
16642 
16643 
16644  //Show
16645 
16651  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16652 
16653 
16659  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16660 
16661 
16669  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16670 
16679  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;
16680 
16686  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16687 
16688 
16696  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16697 
16706  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;
16707 
16713  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16714 
16715 
16721  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16722 
16723 
16731  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16732 
16741  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;
16742 
16748  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16749 
16750 
16758  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16759 
16768  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;
16769 
16775  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16776 
16777 
16785  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16786 
16795  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;
16796 
16802  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16803 
16804 
16810  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16811 
16812 
16818  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16819 
16820 
16826  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16827 
16828 
16834  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16835 
16836 
16844  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16845 
16854  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;
16855 
16861  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16862 
16863 
16869  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16870 
16871 
16877  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16878 
16879 private:
16881 };
16882 
16883 
16886 class HPS_API PortfolioControl : public Control
16887 {
16888 public:
16890  explicit PortfolioControl(SegmentKey & in_seg);
16891 
16893  PortfolioControl(PortfolioControl const & in_that);
16894 
16898  PortfolioControl(PortfolioControl && in_that);
16899 
16903  PortfolioControl & operator=(PortfolioControl && in_that);
16904 
16906  ~PortfolioControl();
16907 
16908  HPS::Type ObjectType() const { return HPS::Type::PortfolioControl; };
16909 
16913  PortfolioControl & operator=(PortfolioControl const & in_that);
16914 
16916  size_t GetCount() const;
16917 
16918 
16923  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16924 
16927  bool Pop();
16928 
16932  bool Pop(PortfolioKey & out_portfolio);
16933 
16934 
16938  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16939 
16943  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16944 
16949  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16950 
16951 
16954  PortfolioControl & UnsetTop();
16955 
16958  PortfolioControl & UnsetEverything();
16959 
16960 
16964  bool ShowTop(PortfolioKey & out_portfolio) const;
16965 
16969  bool Show(PortfolioKeyArray & out_portfolios) const;
16970 
16971 private:
16972  PortfolioControl();
16973 };
16974 
16975 
16976 
16979 class HPS_API StyleControl : public Control
16980 {
16981 public:
16983  explicit StyleControl(SegmentKey & in_seg);
16984 
16986  StyleControl(StyleControl const & in_that);
16987 
16991  StyleControl(StyleControl && in_that);
16992 
16996  StyleControl & operator=(StyleControl && in_that);
16997 
16999  ~StyleControl();
17000 
17001  HPS::Type ObjectType() const { return HPS::Type::StyleControl; };
17002 
17006  StyleControl & operator=(StyleControl const & in_that);
17007 
17009  size_t GetCount() const;
17010 
17012  StyleKey PushNamed(char const * in_style_name);
17013 
17019  StyleKey PushNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
17020 
17027  StyleKey AppendNamed(char const * in_style_name, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
17028 
17033  StyleKey PushSegment(SegmentKey const & in_style_source);
17034 
17040  StyleKey PushSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
17041 
17048  StyleKey AppendSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
17049 
17050 
17051 
17054  bool Pop();
17055 
17062  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional);
17063 
17067  void Flush(SegmentKey const & in_style_source);
17068 
17075  void Flush(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
17076 
17080  void Flush(char const * in_style_name);
17081 
17088  void Flush(char const * in_style_name, ConditionalExpression const & in_conditional);
17089 
17090 
17093  StyleKey SetNamed(char const * in_style_name);
17094 
17098  StyleKey SetNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
17099 
17100 
17103  StyleKey SetSegment(SegmentKey const & in_style_source);
17104 
17108  StyleKey SetSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
17109 
17110 
17116  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionalExpressionArray const & in_conditions);
17117 
17122  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
17123 
17130  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[]);
17131 
17132 
17133 
17135  void UnsetTop();
17136 
17138  void UnsetAllSegment();
17139 
17141  void UnsetAllNamed();
17142 
17144  void UnsetEverything();
17145 
17146 
17153  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional) const;
17154 
17158  bool ShowTop(StyleKey & out_style) const;
17159 
17166  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionalExpressionArray & out_conditions) const;
17167 
17171  bool Show(StyleKeyArray & out_styles) const;
17172 
17177  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionalExpressionArray & out_conditions) const;
17178 
17182  bool ShowAllSegment(StyleKeyArray & out_styles) const;
17183 
17188  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionalExpressionArray & out_conditions) const;
17189 
17193  bool ShowAllNamed(StyleKeyArray & out_styles) const;
17194 
17195 private:
17196  StyleControl();
17197 };
17198 
17199 
17202 class HPS_API ConditionControl : public Control
17203 {
17204 public:
17206  explicit ConditionControl(SegmentKey & in_seg);
17207 
17209  ConditionControl(ConditionControl const & in_that);
17210 
17214  ConditionControl(ConditionControl && in_that);
17215 
17219  ConditionControl & operator=(ConditionControl && in_that);
17220 
17222  ~ConditionControl();
17223 
17224 
17225  HPS::Type ObjectType() const { return HPS::Type::ConditionControl; };
17226 
17230  ConditionControl & operator=(ConditionControl const & in_that);
17231 
17234  size_t GetCount() const;
17235 
17239  ConditionControl & AddCondition(char const * in_condition);
17240 
17241 
17245  ConditionControl & SetCondition(char const * in_condition);
17246 
17250  ConditionControl & SetConditions(UTF8Array const & in_conditions);
17251 
17256  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
17257 
17258 
17262  ConditionControl & UnsetCondition(char const * in_condition);
17263 
17266  ConditionControl & UnsetEverything();
17267 
17268 
17272  bool ShowCondition(char const * in_condition) const;
17273 
17277  bool ShowConditions(UTF8Array & out_conditions) const;
17278 
17279 private:
17281  ConditionControl();
17282 };
17283 
17284 
17287 class HPS_API MaterialKit : public Object
17288 {
17289 public:
17290 
17292  MaterialKit();
17293 
17296  MaterialKit(MaterialKit const & in_kit);
17297 
17301  MaterialKit(MaterialKit && in_that);
17302 
17306  MaterialKit & operator=(MaterialKit && in_that);
17307 
17309  ~MaterialKit();
17310 
17311  HPS::Type ObjectType() const {return HPS::Type::MaterialKit;};
17312 
17315  void Set(MaterialKit const & in_kit);
17316 
17319  void Show(MaterialKit & out_kit) const;
17320 
17324  MaterialKit & operator=(MaterialKit const & in_kit);
17325 
17328  bool Empty() const;
17329 
17333  bool Equals(MaterialKit const & in_kit) const;
17334 
17338  bool operator==(MaterialKit const & in_kit) const;
17339 
17343  bool operator!=(MaterialKit const & in_kit) const;
17344 
17345 
17346  //Set
17347 
17351  MaterialKit & SetDiffuse(RGBColor const & in_color);
17352 
17356  MaterialKit & SetDiffuse(RGBAColor const & in_color);
17357 
17361  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
17362 
17366  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
17367 
17372  MaterialKit & SetDiffuseAlpha(float in_alpha);
17373 
17380  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
17381 
17389  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
17390 
17395  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
17396 
17402  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
17403 
17410  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
17411 
17419  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
17420 
17421 
17425  MaterialKit & SetShader(char const * in_shader_name);
17426 
17427 
17428 
17432  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
17433 
17437  MaterialKit & SetSpecular(char const * in_texture_name);
17438 
17443  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
17444 
17445 
17446 
17450  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
17451 
17455  MaterialKit & SetMirror(char const * in_texture_name);
17456 
17461  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
17462 
17463 
17464 
17468  MaterialKit & SetTransmission(char const * in_texture_name);
17469 
17474  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17475 
17476 
17477 
17481  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
17482 
17486  MaterialKit & SetEmission(char const * in_texture_name);
17487 
17492  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17493 
17494 
17495 
17499  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
17500 
17505  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
17506 
17510  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
17511 
17516  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
17517 
17520  MaterialKit & SetEnvironmentTexture();
17521 
17522 
17526  MaterialKit & SetBump(char const * in_texture_name);
17527 
17528 
17529 
17536  MaterialKit & SetGloss(float in_gloss);
17537 
17540  MaterialKit & UnsetDiffuseColorRGB();
17541 
17544  MaterialKit & UnsetDiffuseColor();
17545 
17548  MaterialKit & UnsetDiffuseAlpha();
17549 
17552  MaterialKit & UnsetDiffuseTexture();
17553 
17557  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
17558 
17561  MaterialKit & UnsetShader();
17562 
17565  MaterialKit & UnsetSpecular();
17566 
17569  MaterialKit & UnsetMirror();
17570 
17573  MaterialKit & UnsetTransmission();
17574 
17577  MaterialKit & UnsetEmission();
17578 
17581  MaterialKit & UnsetEnvironment();
17582 
17585  MaterialKit & UnsetBump();
17586 
17589  MaterialKit & UnsetGloss();
17590 
17593  MaterialKit & UnsetEverything();
17594 
17595 
17598  bool ShowDiffuse() const;
17599 
17603  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
17604 
17608  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
17609 
17613  bool ShowDiffuseAlpha(float & out_alpha) const;
17614 
17621  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17622 
17630  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17631 
17638  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
17639 
17643  bool ShowShader(UTF8 & out_shader_name) const;
17644 
17653  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17654 
17663  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17664 
17665 
17666 
17675  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17676 
17677 
17686  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17687 
17688 
17697  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17698 
17699 
17703  bool ShowBump(UTF8 & out_texture_name) const;
17704 
17709  bool ShowGloss(float & out_gloss) const;
17710 };
17711 
17712 
17714 class HPS_API NURBSSurfaceAttributeKit : public Object
17715 {
17716 public:
17717 
17720 
17724 
17729 
17733  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
17734 
17736  virtual ~NURBSSurfaceAttributeKit();
17737 
17738  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeKit;};
17739 
17743  static NURBSSurfaceAttributeKit GetDefault();
17744 
17747  void Set(NURBSSurfaceAttributeKit const & in_kit);
17748 
17751  void Show(NURBSSurfaceAttributeKit & out_kit) const;
17752 
17756  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17757 
17760  bool Empty() const;
17761 
17765  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17766 
17770  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17771 
17775  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17776 
17777 
17781  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17782 
17787  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17788 
17792  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17793 
17797  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17798 
17802  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17803 
17808  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17809 
17810 
17813  NURBSSurfaceAttributeKit & UnsetBudget();
17814 
17817  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17818 
17821  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17822 
17825  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17826 
17829  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17830 
17833  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17834 
17837  NURBSSurfaceAttributeKit & UnsetEverything();
17838 
17842  bool ShowBudget(size_t & out_budget) const;
17843 
17847  bool ShowMaximumDeviation(float & out_deviation) const;
17848 
17852  bool ShowMaximumAngle(float & out_degrees) const;
17853 
17857  bool ShowMaximumWidth(float & out_width) const;
17858 
17862  bool ShowTrimBudget(size_t & out_budget) const;
17863 
17867  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17868 };
17869 
17876 {
17877 public:
17878 
17880  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17881 
17884 
17889 
17894 
17897 
17898  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeControl;};
17899 
17903  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17904 
17908  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17909 
17914  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17915 
17919  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17920 
17924  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17925 
17929  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17930 
17935  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17936 
17937 
17940  NURBSSurfaceAttributeControl & UnsetBudget();
17941 
17944  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17945 
17948  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17949 
17952  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17953 
17956  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17957 
17960  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17961 
17964  NURBSSurfaceAttributeControl & UnsetEverything();
17965 
17966 
17970  bool ShowBudget(size_t & out_budget) const;
17971 
17975  bool ShowMaximumDeviation(float & out_deviation) const;
17976 
17980  bool ShowMaximumAngle(float & out_degrees) const;
17981 
17985  bool ShowMaximumWidth(float & out_width) const;
17986 
17990  bool ShowTrimBudget(size_t & out_budget) const;
17991 
17995  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17996 
17997 private:
18000 };
18001 
18002 
18003 
18005 class HPS_API PerformanceKit : public Object
18006 {
18007 public:
18008 
18010  PerformanceKit();
18011 
18014  PerformanceKit(PerformanceKit const & in_kit);
18015 
18019  PerformanceKit(PerformanceKit && in_that);
18020 
18024  PerformanceKit & operator=(PerformanceKit && in_that);
18025 
18027  virtual ~PerformanceKit();
18028 
18029  HPS::Type ObjectType() const {return HPS::Type::PerformanceKit;};
18030 
18034  static PerformanceKit GetDefault();
18035 
18038  void Set(PerformanceKit const & in_kit);
18039 
18042  void Show(PerformanceKit & out_kit) const;
18043 
18047  PerformanceKit & operator=(PerformanceKit const & in_kit);
18048 
18051  bool Empty() const;
18052 
18056  bool Equals(PerformanceKit const & in_kit) const;
18057 
18061  bool operator==(PerformanceKit const & in_kit) const;
18062 
18066  bool operator!=(PerformanceKit const & in_kit) const;
18067 
18068 
18073 
18078  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
18079 
18080 
18083  PerformanceKit & UnsetDisplayLists();
18084 
18087  PerformanceKit & UnsetStaticModel();
18088 
18091  PerformanceKit & UnsetEverything();
18092 
18096  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
18097 
18101  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
18102 };
18103 
18104 
18110 class HPS_API PerformanceControl : public Control
18111 {
18112 public:
18113 
18115  explicit PerformanceControl(SegmentKey & in_seg);
18116 
18118  PerformanceControl(PerformanceControl const & in_that);
18119 
18124 
18128  PerformanceControl & operator=(PerformanceControl && in_that);
18129 
18131  ~PerformanceControl();
18132 
18133  HPS::Type ObjectType() const {return HPS::Type::PerformanceControl;};
18134 
18138  PerformanceControl & operator=(PerformanceControl const & in_that);
18139 
18144 
18149  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
18150 
18151 
18154  PerformanceControl & UnsetDisplayLists();
18155 
18158  PerformanceControl & UnsetStaticModel();
18159 
18162  PerformanceControl & UnsetEverything();
18163 
18164 
18168  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
18169 
18173  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
18174 
18175 private:
18178 };
18179 
18180 
18181 
18183 class HPS_API HiddenLineAttributeKit : public Object
18184 {
18185 public:
18186 
18189 
18193 
18198 
18202  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
18203 
18205  virtual ~HiddenLineAttributeKit();
18206 
18207  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeKit;};
18208 
18212  static HiddenLineAttributeKit GetDefault();
18213 
18216  void Set(HiddenLineAttributeKit const & in_kit);
18217 
18220  void Show(HiddenLineAttributeKit & out_kit) const;
18221 
18225  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
18226 
18229  bool Empty() const;
18230 
18234  bool Equals(HiddenLineAttributeKit const & in_kit) const;
18235 
18239  bool operator==(HiddenLineAttributeKit const & in_kit) const;
18240 
18244  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
18245 
18246 
18250  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
18251 
18257  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
18258 
18268  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
18269 
18273  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
18274 
18278  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
18279 
18283  HiddenLineAttributeKit & SetRenderText(bool in_state);
18284 
18289  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18290 
18296  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
18297 
18301  HiddenLineAttributeKit & SetVisibility(bool in_state);
18302 
18307  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18308 
18314  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
18315 
18316 
18319  HiddenLineAttributeKit & UnsetColor();
18320 
18323  HiddenLineAttributeKit & UnsetDimFactor();
18324 
18327  HiddenLineAttributeKit & UnsetFaceDisplacement();
18328 
18331  HiddenLineAttributeKit & UnsetLinePattern();
18332 
18335  HiddenLineAttributeKit & UnsetRenderFaces();
18336 
18339  HiddenLineAttributeKit & UnsetRenderText();
18340 
18343  HiddenLineAttributeKit & UnsetAlgorithm();
18344 
18347  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
18348 
18351  HiddenLineAttributeKit & UnsetVisibility();
18352 
18355  HiddenLineAttributeKit & UnsetWeight();
18356 
18359  HiddenLineAttributeKit & UnsetTransparencyCutoff();
18360 
18363  HiddenLineAttributeKit & UnsetEverything();
18364 
18365 
18369  bool ShowColor(RGBAColor & out_color) const;
18370 
18374  bool ShowDimFactor(float & out_zero_to_one) const;
18375 
18379  bool ShowFaceDisplacement(float & out_buckets) const;
18380 
18384  bool ShowLinePattern(UTF8 & out_pattern) const;
18385 
18389  bool ShowRenderFaces(bool & out_state) const;
18390 
18394  bool ShowRenderText(bool & out_state) const;
18395 
18399  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18400 
18404  bool ShowSilhouetteCleanup(bool & out_state) const;
18405 
18409  bool ShowVisibility(bool & out_state) const;
18410 
18415  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18416 
18420  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18421 };
18422 
18423 
18429 class HPS_API HiddenLineAttributeControl : public Control
18430 {
18431 public:
18432 
18434  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
18435 
18438 
18443 
18448 
18451 
18452  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeControl;};
18453 
18457  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
18458 
18462  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
18463 
18469  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
18470 
18480  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
18481 
18485  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
18486 
18490  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
18491 
18495  HiddenLineAttributeControl & SetRenderText(bool in_state);
18496 
18501  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18502 
18508  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
18509 
18513  HiddenLineAttributeControl & SetVisibility(bool in_state);
18514 
18519  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18520 
18526  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
18527 
18528 
18531  HiddenLineAttributeControl & UnsetColor();
18532 
18535  HiddenLineAttributeControl & UnsetDimFactor();
18536 
18539  HiddenLineAttributeControl & UnsetFaceDisplacement();
18540 
18543  HiddenLineAttributeControl & UnsetLinePattern();
18544 
18547  HiddenLineAttributeControl & UnsetRenderFaces();
18548 
18551  HiddenLineAttributeControl & UnsetRenderText();
18552 
18555  HiddenLineAttributeControl & UnsetAlgorithm();
18556 
18559  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
18560 
18563  HiddenLineAttributeControl & UnsetVisibility();
18564 
18567  HiddenLineAttributeControl & UnsetWeight();
18568 
18571  HiddenLineAttributeControl & UnsetTransparencyCutoff();
18572 
18575  HiddenLineAttributeControl & UnsetEverything();
18576 
18577 
18581  bool ShowColor(RGBAColor & out_color) const;
18582 
18586  bool ShowDimFactor(float & out_zero_to_one) const;
18587 
18591  bool ShowFaceDisplacement(float & out_buckets) const;
18592 
18596  bool ShowLinePattern(UTF8 & out_pattern) const;
18597 
18601  bool ShowRenderFaces(bool & out_state) const;
18602 
18606  bool ShowRenderText(bool & out_state) const;
18607 
18611  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18612 
18616  bool ShowSilhouetteCleanup(bool & out_state) const;
18617 
18621  bool ShowVisibility(bool & out_state) const;
18622 
18627  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18628 
18632  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18633 
18634 private:
18637 };
18638 
18639 
18640 
18642 class HPS_API DrawingAttributeKit : public Object
18643 {
18644 public:
18645 
18648 
18651  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
18652 
18657 
18661  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
18662 
18664  virtual ~DrawingAttributeKit();
18665 
18666  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeKit;};
18667 
18671  static DrawingAttributeKit GetDefault();
18672 
18675  void Set(DrawingAttributeKit const & in_kit);
18676 
18679  void Show(DrawingAttributeKit & out_kit) const;
18680 
18684  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
18685 
18688  bool Empty() const;
18689 
18693  bool Equals(DrawingAttributeKit const & in_kit) const;
18694 
18698  bool operator==(DrawingAttributeKit const & in_kit) const;
18699 
18703  bool operator!=(DrawingAttributeKit const & in_kit) const;
18704 
18720  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
18721 
18727  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
18728 
18741  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
18742 
18749  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
18750 
18755  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
18756 
18763  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18764 
18769  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18770 
18777  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18778 
18783  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18784 
18788  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18789 
18794  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18795 
18801  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18802 
18809  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);
18810 
18816  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18817 
18820  DrawingAttributeKit & UnsetPolygonHandedness();
18821 
18824  DrawingAttributeKit & UnsetWorldHandedness();
18825 
18828  DrawingAttributeKit & UnsetDepthRange();
18829 
18832  DrawingAttributeKit & UnsetFaceDisplacement();
18833 
18836  DrawingAttributeKit & UnsetGeneralDisplacement();
18837 
18840  DrawingAttributeKit & UnsetVertexDisplacement();
18841 
18844  DrawingAttributeKit & UnsetOverlay();
18845 
18848  DrawingAttributeKit & UnsetDeferral();
18849 
18852  DrawingAttributeKit & UnsetClipRegion();
18853 
18856  DrawingAttributeKit & UnsetEverything();
18857 
18861  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18862 
18866  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18867 
18872  bool ShowDepthRange(float & out_near, float & out_far) const;
18873 
18878  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18879 
18884  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18885 
18890  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18891 
18895  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18896 
18900  bool ShowDeferral(int & out_defer_batch) const;
18901 
18907  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18908 
18909 };
18910 
18911 
18923 class HPS_API DrawingAttributeControl : public Control
18924 {
18925 public:
18926 
18928  explicit DrawingAttributeControl(SegmentKey & in_seg);
18929 
18932 
18937 
18941  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18942 
18945 
18946  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeControl;};
18947 
18951  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18952 
18962  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18963 
18969  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18970 
18983  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18984 
18991  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18992 
18997  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18998 
19005  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
19006 
19011  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
19012 
19019  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
19020 
19025  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
19026 
19030  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
19031 
19037  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
19038 
19045  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);
19046 
19052  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
19053 
19058  DrawingAttributeControl & SetDeferral(int in_deferral);
19061  DrawingAttributeControl & UnsetPolygonHandedness();
19062 
19065  DrawingAttributeControl & UnsetWorldHandedness();
19066 
19069  DrawingAttributeControl & UnsetDepthRange();
19070 
19073  DrawingAttributeControl & UnsetFaceDisplacement();
19074 
19077  DrawingAttributeControl & UnsetGeneralDisplacement();
19078 
19081  DrawingAttributeControl & UnsetVertexDisplacement();
19082 
19085  DrawingAttributeControl & UnsetOverlay();
19086 
19089  DrawingAttributeControl & UnsetDeferral();
19090 
19093  DrawingAttributeControl & UnsetClipRegion();
19094 
19097  DrawingAttributeControl & UnsetEverything();
19098 
19099 
19103  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
19104 
19108  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
19109 
19114  bool ShowDepthRange(float & out_x, float & out_y) const;
19115 
19120  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
19121 
19126  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
19127 
19132  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
19133 
19137  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
19138 
19142  bool ShowDeferral(int & out_defer_batch) const;
19143 
19149  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation);
19150 
19151 private:
19154 };
19155 
19156 
19158 class HPS_API PostProcessEffectsKit : public Object
19159 {
19160 public:
19161 
19164 
19168 
19173 
19177  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
19178 
19180  virtual ~PostProcessEffectsKit();
19181 
19182  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsKit;};
19183 
19187  static PostProcessEffectsKit GetDefault();
19188 
19191  void Set(PostProcessEffectsKit const & in_kit);
19192 
19195  void Show(PostProcessEffectsKit & out_kit) const;
19196 
19200  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
19201 
19204  bool Empty() const;
19205 
19209  bool Equals(PostProcessEffectsKit const & in_kit) const;
19210 
19214  bool operator==(PostProcessEffectsKit const & in_kit) const;
19215 
19219  bool operator!=(PostProcessEffectsKit const & in_kit) const;
19220 
19221 
19229  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19230 
19237  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19238 
19245  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19246 
19252  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19253 
19260  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19261 
19267  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19268 
19276  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19277 
19284  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19285 
19293  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19294 
19301  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
19302 
19305  PostProcessEffectsKit & UnsetAmbientOcclusion();
19306 
19309  PostProcessEffectsKit & UnsetBloom();
19310 
19313  PostProcessEffectsKit & UnsetDepthOfField();
19314 
19317  PostProcessEffectsKit & UnsetSilhouetteEdges();
19318 
19321  PostProcessEffectsKit & UnsetEyeDomeLighting();
19322 
19325  PostProcessEffectsKit & UnsetEverything();
19326 
19327 
19334  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19335 
19342  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19343 
19350  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19351 
19359  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19360 
19368  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19369 };
19370 
19371 
19375 class HPS_API PostProcessEffectsControl : public Control
19376 {
19377 public:
19378 
19380  explicit PostProcessEffectsControl(WindowKey & in_seg);
19381 
19384 
19389 
19393  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
19394 
19397 
19398  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsControl;};
19399 
19403  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
19404 
19412  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19413 
19420  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19421 
19428  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19429 
19435  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19436 
19443  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19444 
19450  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19451 
19459  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19460 
19467  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19468 
19476  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19477 
19484  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
19485 
19486 
19489  PostProcessEffectsControl & UnsetAmbientOcclusion();
19490 
19493  PostProcessEffectsControl & UnsetBloom();
19494 
19497  PostProcessEffectsControl & UnsetDepthOfField();
19498 
19501  PostProcessEffectsControl & UnsetSilhouetteEdges();
19502 
19505  PostProcessEffectsControl & UnsetEyeDomeLighting();
19506 
19509  PostProcessEffectsControl & UnsetEverything();
19510 
19511 
19518  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19519 
19526  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19527 
19534  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19535 
19543  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19544 
19552  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19553 
19554 private:
19557 };
19558 
19560 class HPS_API TransformMaskKit : public Object
19561 {
19562 public:
19563 
19565  TransformMaskKit();
19566 
19568  TransformMaskKit(TransformMaskKit const & in_kit);
19569 
19573  TransformMaskKit(TransformMaskKit && in_that);
19574 
19578  TransformMaskKit & operator=(TransformMaskKit && in_that);
19579 
19581  virtual ~TransformMaskKit();
19582 
19583  HPS::Type ObjectType() const {return HPS::Type::TransformMaskKit;};
19584 
19585  static TransformMaskKit GetDefault();
19586 
19588  void Set(TransformMaskKit const & in_kit);
19589 
19591  void Show(TransformMaskKit & out_kit) const;
19592 
19594  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
19595 
19597  bool Empty() const;
19598 
19600  bool Equals(TransformMaskKit const & in_kit) const;
19601 
19603  bool operator==(TransformMaskKit const & in_kit) const;
19604 
19606  bool operator!=(TransformMaskKit const & in_kit) const;
19607 
19608 
19612  TransformMaskKit & SetCameraRotation(bool in_state);
19613 
19617  TransformMaskKit & SetCameraScale(bool in_state);
19618 
19622  TransformMaskKit & SetCameraTranslation(bool in_state);
19623 
19627  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
19628 
19632  TransformMaskKit & SetCameraProjection(bool in_state);
19633 
19637  TransformMaskKit & SetCameraOffset(bool in_state);
19638 
19642  TransformMaskKit & SetCameraNearLimit(bool in_state);
19643 
19647  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
19648 
19652  TransformMaskKit & SetModellingMatrixScale(bool in_state);
19653 
19657  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
19658 
19662  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
19663 
19664 
19668  TransformMaskKit & SetCameraEverything(bool in_state);
19669 
19673  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
19674 
19678  TransformMaskKit & SetEverything(bool in_state);
19679 
19680 
19683  TransformMaskKit & UnsetCameraRotation();
19684 
19687  TransformMaskKit & UnsetCameraScale();
19688 
19691  TransformMaskKit & UnsetCameraTranslation();
19692 
19695  TransformMaskKit & UnsetCameraPerspectiveScale();
19696 
19699  TransformMaskKit & UnsetCameraProjection();
19700 
19703  TransformMaskKit & UnsetCameraOffset();
19704 
19707  TransformMaskKit & UnsetCameraNearLimit();
19708 
19711  TransformMaskKit & UnsetCameraEverything();
19712 
19715  TransformMaskKit & UnsetModellingMatrixRotation();
19716 
19719  TransformMaskKit & UnsetModellingMatrixScale();
19720 
19723  TransformMaskKit & UnsetModellingMatrixTranslation();
19724 
19727  TransformMaskKit & UnsetModellingMatrixOffset();
19728 
19731  TransformMaskKit & UnsetModellingMatrixEverything();
19732 
19735  TransformMaskKit & UnsetEverything();
19736 
19737 
19741  bool ShowCameraRotation(bool & out_state) const;
19742 
19746  bool ShowCameraScale(bool & out_state) const;
19747 
19751  bool ShowCameraTranslation(bool & out_state) const;
19752 
19756  bool ShowCameraPerspectiveScale(bool & out_state) const;
19757 
19761  bool ShowCameraProjection(bool & out_state) const;
19762 
19766  bool ShowCameraOffset(bool & out_state) const;
19767 
19771  bool ShowCameraNearLimit(bool & out_state) const;
19772 
19776  bool ShowModellingMatrixRotation(bool & out_state) const;
19777 
19781  bool ShowModellingMatrixScale(bool & out_state) const;
19782 
19786  bool ShowModellingMatrixTranslation(bool & out_state) const;
19787 
19791  bool ShowModellingMatrixOffset(bool & out_state) const;
19792 };
19793 
19794 
19799 class HPS_API TransformMaskControl : public Control
19800 {
19801 public:
19802 
19804  explicit TransformMaskControl(SegmentKey & in_seg);
19805 
19807  TransformMaskControl(TransformMaskControl const & in_that);
19808 
19813 
19817  TransformMaskControl & operator=(TransformMaskControl && in_that);
19818 
19821 
19822  HPS::Type ObjectType() const {return HPS::Type::TransformMaskControl;};
19823 
19827  TransformMaskControl & operator=(TransformMaskControl const & in_that);
19828 
19832  TransformMaskControl & SetCameraRotation(bool in_state);
19833 
19837  TransformMaskControl & SetCameraScale(bool in_state);
19838 
19842  TransformMaskControl & SetCameraTranslation(bool in_state);
19843 
19847  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19848 
19852  TransformMaskControl & SetCameraProjection(bool in_state);
19853 
19857  TransformMaskControl & SetCameraOffset(bool in_state);
19858 
19862  TransformMaskControl & SetCameraNearLimit(bool in_state);
19863 
19867  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19868 
19872  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19873 
19877  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19878 
19882  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19883 
19884 
19888  TransformMaskControl & SetCameraEverything(bool in_state);
19889 
19893  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19894 
19898  TransformMaskControl & SetEverything(bool in_state);
19899 
19900 
19903  TransformMaskControl & UnsetCameraRotation();
19904 
19907  TransformMaskControl & UnsetCameraScale();
19908 
19911  TransformMaskControl & UnsetCameraTranslation();
19912 
19915  TransformMaskControl & UnsetCameraPerspectiveScale();
19916 
19919  TransformMaskControl & UnsetCameraProjection();
19920 
19923  TransformMaskControl & UnsetCameraOffset();
19924 
19927  TransformMaskControl & UnsetCameraNearLimit();
19928 
19931  TransformMaskControl & UnsetCameraEverything();
19932 
19935  TransformMaskControl & UnsetModellingMatrixRotation();
19936 
19939  TransformMaskControl & UnsetModellingMatrixScale();
19940 
19943  TransformMaskControl & UnsetModellingMatrixTranslation();
19944 
19947  TransformMaskControl & UnsetModellingMatrixOffset();
19948 
19951  TransformMaskControl & UnsetModellingMatrixEverything();
19952 
19955  TransformMaskControl & UnsetEverything();
19956 
19957 
19961  bool ShowCameraRotation(bool & out_state) const;
19962 
19966  bool ShowCameraScale(bool & out_state) const;
19967 
19971  bool ShowCameraTranslation(bool & out_state) const;
19972 
19976  bool ShowCameraPerspectiveScale(bool & out_state) const;
19977 
19981  bool ShowCameraProjection(bool & out_state) const;
19982 
19986  bool ShowCameraOffset(bool & out_state) const;
19987 
19991  bool ShowCameraNearLimit(bool & out_state) const;
19992 
19996  bool ShowModellingMatrixRotation(bool & out_state) const;
19997 
20001  bool ShowModellingMatrixScale(bool & out_state) const;
20002 
20006  bool ShowModellingMatrixTranslation(bool & out_state) const;
20007 
20011  bool ShowModellingMatrixOffset(bool & out_state) const;
20012 
20013 private:
20016 };
20017 
20018 
20019 
20021 class HPS_API VisualEffectsKit : public Object
20022 {
20023 public:
20024 
20026  VisualEffectsKit();
20027 
20030  VisualEffectsKit(VisualEffectsKit const & in_kit);
20031 
20035  VisualEffectsKit(VisualEffectsKit && in_that);
20036 
20040  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
20041 
20043  virtual ~VisualEffectsKit();
20044 
20045  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsKit;};
20046 
20050  static VisualEffectsKit GetDefault();
20051 
20054  void Set(VisualEffectsKit const & in_kit);
20055 
20058  void Show(VisualEffectsKit & out_kit) const;
20059 
20063  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
20064 
20067  bool Empty() const;
20068 
20072  bool Equals(VisualEffectsKit const & in_kit) const;
20073 
20077  bool operator==(VisualEffectsKit const & in_kit) const;
20078 
20082  bool operator!=(VisualEffectsKit const & in_kit) const;
20083 
20087  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
20088 
20092  VisualEffectsKit & SetAntiAliasing(bool in_state);
20093 
20103  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
20104 
20113  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
20114 
20121  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
20122 
20128  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20129 
20133  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20134 
20138  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20139 
20143  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20144 
20155  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);
20156 
20166  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20167 
20171  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20172 
20176  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20177 
20178 
20181  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
20182 
20185  VisualEffectsKit & UnsetAntiAliasing();
20186 
20189  VisualEffectsKit & UnsetShadowMaps();
20190 
20193  VisualEffectsKit & UnsetSimpleShadow();
20194 
20197  VisualEffectsKit & UnsetSimpleShadowPlane();
20198 
20201  VisualEffectsKit & UnsetSimpleShadowLightDirection();
20202 
20205  VisualEffectsKit & UnsetSimpleShadowColor();
20206 
20209  VisualEffectsKit & UnsetSimpleReflection();
20210 
20213  VisualEffectsKit & UnsetSimpleReflectionPlane();
20214 
20217  VisualEffectsKit & UnsetSimpleReflectionVisibility();
20218 
20221  VisualEffectsKit & UnsetEverything();
20222 
20226  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20227 
20231  bool ShowAntiAliasing(bool & out_state) const;
20232 
20240  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20241 
20248  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20249 
20253  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20254 
20258  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20259 
20263  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20264 
20273  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;
20274 
20275 
20279  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20280 
20284  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20285 };
20286 
20287 
20293 class HPS_API VisualEffectsControl : public Control
20294 {
20295 public:
20296 
20298  explicit VisualEffectsControl(SegmentKey & in_seg);
20299 
20301  VisualEffectsControl(VisualEffectsControl const & in_that);
20302 
20307 
20311  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
20312 
20315 
20316  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsControl;};
20317 
20321  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
20322 
20326  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
20327 
20331  VisualEffectsControl & SetAntiAliasing(bool in_state);
20332 
20342  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
20343 
20352  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
20353 
20360  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
20361 
20367  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20368 
20372  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20373 
20377  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20378 
20382  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20383 
20394  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);
20395 
20405  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20406 
20410  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20411 
20415  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20416 
20417 
20420  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
20421 
20424  VisualEffectsControl & UnsetAntiAliasing();
20425 
20428  VisualEffectsControl & UnsetShadowMaps();
20429 
20432  VisualEffectsControl & UnsetSimpleShadow();
20433 
20436  VisualEffectsControl & UnsetSimpleShadowPlane();
20437 
20440  VisualEffectsControl & UnsetSimpleShadowLightDirection();
20441 
20444  VisualEffectsControl & UnsetSimpleShadowColor();
20445 
20448  VisualEffectsControl & UnsetSimpleReflection();
20449 
20452  VisualEffectsControl & UnsetSimpleReflectionPlane();
20453 
20456  VisualEffectsControl & UnsetSimpleReflectionVisibility();
20457 
20460  VisualEffectsControl & UnsetEverything();
20461 
20462 
20466  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20467 
20471  bool ShowAntiAliasing(bool & out_state) const;
20472 
20480  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20481 
20488  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20489 
20493  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20494 
20498  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20499 
20503  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20504 
20513  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;
20514 
20518  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20519 
20523  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20524 
20525 private:
20528 };
20529 
20530 
20531 
20533 class HPS_API ContourLineKit : public Object
20534 {
20535 public:
20536 
20538  ContourLineKit();
20539 
20542  ContourLineKit(ContourLineKit const & in_kit);
20543 
20547  ContourLineKit(ContourLineKit && in_that);
20548 
20552  ContourLineKit & operator=(ContourLineKit && in_that);
20553 
20555  virtual ~ContourLineKit();
20556 
20557  HPS::Type ObjectType() const { return HPS::Type::ContourLineKit; };
20558 
20562  static ContourLineKit GetDefault();
20563 
20566  void Set(ContourLineKit const & in_kit);
20567 
20570  void Show(ContourLineKit & out_kit) const;
20571 
20575  ContourLineKit & operator=(ContourLineKit const & in_kit);
20576 
20579  bool Empty() const;
20580 
20584  bool Equals(ContourLineKit const & in_kit) const;
20585 
20589  bool operator==(ContourLineKit const & in_kit) const;
20590 
20594  bool operator!=(ContourLineKit const & in_kit) const;
20595 
20596 
20600  ContourLineKit & SetVisibility(bool in_state);
20601 
20606  ContourLineKit & SetPositions(float in_interval, float in_offset);
20607 
20611  ContourLineKit & SetPositions(FloatArray const & in_positions);
20612 
20617  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
20618 
20622  ContourLineKit & SetColors(RGBColorArray const & in_colors);
20623 
20628  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
20629 
20633  ContourLineKit & SetColors(RGBColor const & in_color);
20634 
20638  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
20639 
20644  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20645 
20649  ContourLineKit & SetPatterns(char const * in_pattern);
20650 
20655  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20656 
20662  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20663 
20668  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20669 
20673  ContourLineKit & SetLighting(bool in_state);
20674 
20675 
20678  ContourLineKit & UnsetVisibility();
20679 
20682  ContourLineKit & UnsetPositions();
20683 
20686  ContourLineKit & UnsetColors();
20687 
20690  ContourLineKit & UnsetPatterns();
20691 
20694  ContourLineKit & UnsetWeights();
20695 
20698  ContourLineKit & UnsetLighting();
20699 
20702  ContourLineKit & UnsetEverything();
20703 
20704 
20708  bool ShowVisibility(bool & out_state) const;
20709 
20715  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20716 
20720  bool ShowColors(RGBColorArray & out_colors) const;
20721 
20725  bool ShowPatterns(UTF8Array & out_patterns) const;
20726 
20731  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20732 
20736  bool ShowLighting(bool & out_state) const;
20737 };
20738 
20742 class HPS_API ContourLineControl : public Control
20743 {
20744 public:
20745 
20747  explicit ContourLineControl(SegmentKey & in_seg);
20748 
20750  ContourLineControl(ContourLineControl const & in_that);
20751 
20756 
20760  ContourLineControl & operator=(ContourLineControl && in_that);
20761 
20763  ~ContourLineControl();
20764 
20765  HPS::Type ObjectType() const { return HPS::Type::ContourLineControl; };
20766 
20770  ContourLineControl & operator=(ContourLineControl const & in_that);
20771 
20775  ContourLineControl & SetVisibility(bool in_state);
20776 
20781  ContourLineControl & SetPositions(float in_interval, float in_offset);
20782 
20786  ContourLineControl & SetPositions(FloatArray const & in_positions);
20787 
20792  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20793 
20797  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20798 
20803  ContourLineControl & SetColors(size_t in_count, RGBColor const in_colors[]);
20804 
20808  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20809 
20813  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20814 
20819  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20820 
20824  ContourLineControl & SetPatterns(char const * in_pattern);
20825 
20830  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20831 
20837  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20838 
20843  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20844 
20848  ContourLineControl & SetLighting(bool in_state);
20849 
20850 
20853  ContourLineControl & UnsetVisibility();
20854 
20857  ContourLineControl & UnsetPositions();
20858 
20861  ContourLineControl & UnsetColors();
20862 
20865  ContourLineControl & UnsetPatterns();
20866 
20869  ContourLineControl & UnsetWeights();
20870 
20873  ContourLineControl & UnsetLighting();
20874 
20877  ContourLineControl & UnsetEverything();
20878 
20879 
20883  bool ShowVisibility(bool & out_state) const;
20884 
20890  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20891 
20895  bool ShowColors(RGBColorArray & out_colors) const;
20896 
20900  bool ShowPatterns(UTF8Array & out_patterns) const;
20901 
20906  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20907 
20911  bool ShowLighting(bool & out_state) const;
20912 
20913 private:
20916 };
20917 
20918 
20919 
20921 class HPS_API SubwindowKit : public Object
20922 {
20923 public:
20924 
20926  SubwindowKit();
20927 
20929  SubwindowKit(SubwindowKit const & in_kit);
20930 
20934  SubwindowKit(SubwindowKit && in_that);
20935 
20939  SubwindowKit & operator=(SubwindowKit && in_that);
20940 
20942  virtual ~SubwindowKit();
20943 
20944  HPS::Type ObjectType() const {return HPS::Type::SubwindowKit;}
20945 
20949  static SubwindowKit GetDefault();
20950 
20953  void Set(SubwindowKit const & in_kit);
20954 
20957  void Show(SubwindowKit & out_kit) const;
20958 
20962  SubwindowKit & operator=(SubwindowKit const & in_kit);
20963 
20966  bool Empty() const;
20967 
20971  bool Equals(SubwindowKit const & in_kit) const;
20972 
20976  bool operator==(SubwindowKit const & in_kit) const;
20977 
20981  bool operator!=(SubwindowKit const & in_kit) const;
20982 
20983 
20993  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20994 
21001  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
21002 
21007  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
21008 
21013  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
21014 
21020  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
21021 
21026  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
21027 
21030  SubwindowKit & UnsetSubwindow();
21031 
21034  SubwindowKit & UnsetBackground();
21035 
21038  SubwindowKit & UnsetBorder();
21039 
21042  SubwindowKit & UnsetRenderingAlgorithm();
21043 
21046  SubwindowKit & UnsetModelCompareMode();
21047 
21050  SubwindowKit & UnsetEverything();
21051 
21056  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
21057 
21062  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
21063 
21067  bool ShowBorder(Subwindow::Border & out_border_type) const;
21068 
21072  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
21073 
21079  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
21080 };
21081 
21082 
21083 
21089 class HPS_API SubwindowControl : public Control
21090 {
21091 public:
21092 
21094  explicit SubwindowControl(SegmentKey & in_seg);
21095 
21097  SubwindowControl(SubwindowControl const & in_that);
21098 
21102  SubwindowControl(SubwindowControl && in_that);
21103 
21107  SubwindowControl & operator=(SubwindowControl && in_that);
21108 
21110  ~SubwindowControl();
21111 
21112  HPS::Type ObjectType() const {return HPS::Type::SubwindowControl;}
21113 
21117  SubwindowControl & operator=(SubwindowControl const & in_that);
21118 
21129  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
21130 
21137  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
21138 
21143  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
21144 
21150  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
21151 
21157  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
21158 
21163  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
21164 
21167  SubwindowControl & UnsetSubwindow();
21168 
21171  SubwindowControl & UnsetBackground();
21172 
21175  SubwindowControl & UnsetBorder();
21176 
21179  SubwindowControl & UnsetRenderingAlgorithm();
21180 
21183  SubwindowControl & UnsetModelCompareMode();
21184 
21187  SubwindowControl & UnsetEverything();
21188 
21189 
21194  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
21195 
21200  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
21201 
21205  bool ShowBorder(Subwindow::Border & out_border_type) const;
21206 
21210  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
21211 
21217  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
21218 
21219 private:
21221  SubwindowControl();
21222 };
21223 
21224 
21225 
21227 class HPS_API DebuggingKit : public Object
21228 {
21229 public:
21230 
21232  DebuggingKit();
21233 
21235  DebuggingKit(DebuggingKit const & in_kit);
21236 
21240  DebuggingKit(DebuggingKit && in_that);
21241 
21245  DebuggingKit & operator=(DebuggingKit && in_that);
21246 
21248  virtual ~DebuggingKit();
21249 
21250  HPS::Type ObjectType() const {return HPS::Type::DebuggingKit;}
21251 
21255  static DebuggingKit GetDefault();
21256 
21259  void Set(DebuggingKit const & in_kit);
21260 
21263  void Show(DebuggingKit & out_kit) const;
21264 
21268  DebuggingKit & operator=(DebuggingKit const & in_kit);
21269 
21272  bool Empty() const;
21273 
21277  bool Equals(DebuggingKit const & in_kit) const;
21278 
21282  bool operator==(DebuggingKit const & in_kit) const;
21283 
21287  bool operator!=(DebuggingKit const & in_kit) const;
21288 
21289 
21293  DebuggingKit & SetResourceMonitor(bool in_display);
21294 
21295 
21298  DebuggingKit & UnsetResourceMonitor();
21299 
21302  DebuggingKit & UnsetEverything();
21303 
21304 
21308  bool ShowResourceMonitor(bool & out_display) const;
21309 };
21310 
21311 
21314 class HPS_API DebuggingControl : public Control
21315 {
21316 public:
21317 
21319  explicit DebuggingControl(WindowKey & in_window);
21320 
21322  DebuggingControl(DebuggingControl const & in_that);
21323 
21327  DebuggingControl(DebuggingControl && in_that);
21328 
21332  DebuggingControl & operator=(DebuggingControl && in_that);
21333 
21335  ~DebuggingControl();
21336 
21337  HPS::Type ObjectType() const {return HPS::Type::DebuggingControl;}
21338 
21342  DebuggingControl & operator=(DebuggingControl const & in_that);
21343 
21348  DebuggingControl & SetResourceMonitor(bool in_display);
21349 
21353  bool ShowResourceMonitor(bool & out_display) const;
21354 
21355 private:
21357  DebuggingControl();
21358 };
21359 
21360 
21362 class HPS_API WindowInfoKit : public Object
21363 {
21364 public:
21365 
21367  WindowInfoKit();
21368 
21370  WindowInfoKit(WindowInfoKit const & in_kit);
21371 
21375  WindowInfoKit(WindowInfoKit && in_that);
21376 
21380  WindowInfoKit & operator=(WindowInfoKit && in_that);
21381 
21383  virtual ~WindowInfoKit();
21384 
21385  HPS::Type ObjectType() const {return HPS::Type::WindowInfoKit;}
21386 
21389  void Set(WindowInfoKit const & in_kit);
21390 
21393  void Show(WindowInfoKit & out_kit) const;
21394 
21398  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
21399 
21402  bool Empty() const;
21403 
21407  bool Equals(WindowInfoKit const & in_kit) const;
21408 
21412  bool operator==(WindowInfoKit const & in_kit) const;
21413 
21417  bool operator!=(WindowInfoKit const & in_kit) const;
21418 
21419 
21424  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
21425 
21430  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
21431 
21436  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
21437 
21442  WindowInfoKit & SetWindowSize(float in_width, float in_height);
21443 
21444 
21447  WindowInfoKit & UnsetPhysicalPixels();
21448 
21451  WindowInfoKit & UnsetPhysicalSize();
21452 
21455  WindowInfoKit & UnsetWindowPixels();
21456 
21459  WindowInfoKit & UnsetWindowSize();
21460 
21463  WindowInfoKit & UnsetEverything();
21464 
21465 
21470  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21471 
21476  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21477 
21482  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21483 
21488  bool ShowWindowSize(float & out_width, float & out_height) const;
21489 
21495  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21496 
21500  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21501 
21505  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21506 };
21507 
21508 
21511 class HPS_API WindowInfoControl : public Control
21512 {
21513 public:
21514 
21516  explicit WindowInfoControl(WindowKey & in_window);
21517 
21519  WindowInfoControl(WindowInfoControl const & in_that);
21520 
21525 
21529  WindowInfoControl & operator=(WindowInfoControl && in_that);
21530 
21532  ~WindowInfoControl();
21533 
21534  HPS::Type ObjectType() const {return HPS::Type::WindowInfoControl;}
21535 
21539  WindowInfoControl & operator=(WindowInfoControl const & in_that);
21540 
21545  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21546 
21551  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21552 
21557  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21558 
21563  bool ShowWindowSize(float & out_width, float & out_height) const;
21564 
21570  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21571 
21575  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21576 
21580  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21581 
21586  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
21587 
21592  bool ShowLastUpdateTime(Time & out_time) const;
21593 
21597  bool ShowDepthPeelingLayers(size_t & out_layers) const;
21598 
21602  bool ShowVideoMemory(size_t & out_video_memory) const;
21603 
21607  bool ShowDepthBufferSize(size_t & out_bits) const;
21608 
21612  bool ShowMaxLights(size_t & out_lights) const;
21613 
21617  bool ShowColorBitPlanes(size_t & out_planes) const;
21618 
21622  bool ShowLastUpdateInfo(UpdateInfo & out_info) const;
21623 
21624 private:
21627 };
21628 
21630 class HPS_API FontInfoState : public Object
21631 {
21632 public:
21633 
21635  FontInfoState();
21636 
21638  FontInfoState(FontInfoState const & in_kit);
21639 
21643  FontInfoState(FontInfoState && in_that);
21644 
21648  FontInfoState & operator=(FontInfoState && in_that);
21649 
21651  virtual ~FontInfoState();
21652 
21653  HPS::Type ObjectType() const {return HPS::Type::FontInfoState;}
21654 
21657  void Assign(FontInfoState const & in_that);
21658 
21661  void Set(FontInfoState const & in_kit);
21662 
21665  void Show(FontInfoState & out_kit) const;
21666 
21670  FontInfoState & operator=(FontInfoState const & in_kit);
21671 
21674  bool Empty() const;
21675 
21679  bool Equals(FontInfoState const & in_kit) const;
21680 
21684  bool operator==(FontInfoState const & in_kit) const;
21685 
21689  bool operator!=(FontInfoState const & in_kit) const;
21690 
21693  UTF8 GetName() const;
21694 
21697  bool GetShellConvertibility() const;
21698 };
21699 
21700 
21705 class HPS_API AttributeLockKit : public Object
21706 {
21707 public:
21708 
21710  AttributeLockKit();
21711 
21713  AttributeLockKit(AttributeLockKit const & in_kit);
21714 
21718  AttributeLockKit(AttributeLockKit && in_that);
21719 
21723  AttributeLockKit & operator=(AttributeLockKit && in_that);
21724 
21726  virtual ~AttributeLockKit();
21727 
21728  HPS::Type ObjectType() const {return HPS::Type::AttributeLockKit;}
21729 
21733  static AttributeLockKit GetDefault();
21734 
21737  void Set(AttributeLockKit const & in_kit);
21738 
21741  void Show(AttributeLockKit & out_kit) const;
21742 
21746  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
21747 
21750  bool Empty() const;
21751 
21755  bool Equals(AttributeLockKit const & in_kit) const;
21756 
21760  bool operator==(AttributeLockKit const & in_kit) const;
21761 
21765  bool operator!=(AttributeLockKit const & in_kit) const;
21766 
21772  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
21773 
21778  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21779 
21785  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21786 
21792  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21793 
21794 
21797  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21798 
21801  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
21802 
21805  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21806 
21809  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21810 
21813  AttributeLockKit & UnsetEverything();
21814 
21815 
21820  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21821 
21826  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21827 
21832  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21833 
21838  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21839 };
21840 
21841 
21846 class HPS_API AttributeLockControl : public Control
21847 {
21848 public:
21849 
21851  explicit AttributeLockControl(SegmentKey & in_seg);
21852 
21857 
21861  AttributeLockControl & operator=(AttributeLockControl && in_that);
21862 
21864  AttributeLockControl(AttributeLockControl const & in_that);
21865 
21868 
21869  HPS::Type ObjectType() const {return HPS::Type::AttributeLockControl;}
21870 
21874  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21875 
21881  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21882 
21887  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21888 
21894  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21895 
21901  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21902 
21903 
21906  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21907 
21910  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21911 
21914  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21915 
21918  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21919 
21922  AttributeLockControl & UnsetEverything();
21923 
21924 
21929  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21930 
21935  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21936 
21941  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21942 
21947  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21948 
21949 private:
21952 };
21953 
21957 
21958 class HPS_API GeometryKey : public Key
21959 {
21960 public:
21962  GeometryKey();
21963 
21967  explicit GeometryKey(Key const & in_that);
21968 
21971  GeometryKey(GeometryKey const & in_that);
21972 
21976  GeometryKey & operator=(GeometryKey const & in_that);
21977 
21981  GeometryKey(GeometryKey && in_that);
21982 
21986  GeometryKey & operator=(GeometryKey && in_that);
21987 
21988  ~GeometryKey();
21989 
21990  HPS::Type ObjectType() const { return HPS::Type::GeometryKey; };
21991 
21992 
21996  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21997 
22001  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
22002 
22003 
22004 
22011  GeometryKey & SetPriority(int in_priority);
22012 
22015  GeometryKey & UnsetPriority();
22016 
22020  bool ShowPriority(int & out_priority) const;
22021 
22022 
22028  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22029 
22034  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
22035 
22040  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22041 
22045  GeometryKey & UnsetUserData(intptr_t in_index);
22046 
22051  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22052 
22056  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
22057 
22060  GeometryKey & UnsetAllUserData();
22061 
22063  size_t ShowUserDataCount() const;
22064 
22068  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22069 
22074  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22075 
22080  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22081 
22086  bool ShowBounding(BoundingKit & out_kit) const;
22087 };
22088 
22089 
22091 class HPS_API LineKit : public Object
22092 {
22093 public:
22095  LineKit();
22096 
22099  LineKit(LineKit const & in_kit);
22100 
22104  LineKit(LineKit && in_that);
22105 
22109  LineKit & operator=(LineKit && in_that);
22110 
22111  virtual ~LineKit();
22112 
22113  HPS::Type ObjectType() const { return HPS::Type::LineKit; };
22114 
22117  void Consume(LineKit & in_kit);
22118 
22121  void Set(LineKit const & in_kit);
22122 
22125  void Show(LineKit & out_kit) const;
22126 
22130  LineKit & operator=(LineKit const & in_kit);
22131 
22134  bool Empty() const;
22135 
22139  bool Equals(LineKit const & in_kit) const;
22140 
22144  bool operator==(LineKit const & in_kit) const;
22145 
22149  bool operator!=(LineKit const & in_kit) const;
22150 
22153  size_t GetPointCount() const;
22154 
22161  LineKit & SetPriority(int in_priority);
22162 
22165  LineKit & UnsetPriority();
22166 
22170  bool ShowPriority(int & out_priority) const;
22171 
22172 
22176  LineKit & SetPoints(PointArray const & in_points);
22177 
22182  LineKit & SetPoints(size_t in_count, Point const in_points []);
22183 
22184 
22187  LineKit & UnsetPoints();
22188 
22191  LineKit & UnsetEverything();
22192 
22193 
22197  bool ShowPoints(PointArray & out_points) const;
22198 
22204  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22205 
22210  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22211 
22217  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22218 
22219 
22225  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22226 
22231  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22232 
22237  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
22238 
22244  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22245 
22251  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22252 
22258  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22259 
22264  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22265 
22270  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22271 
22275  LineKit & UnsetUserData(intptr_t in_index);
22276 
22281  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22282 
22286  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
22287 
22290  LineKit & UnsetAllUserData();
22291 
22293  size_t ShowUserDataCount() const;
22294 
22298  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22299 
22304  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22305 
22310  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22311 };
22312 
22314 class HPS_API LineKey : public GeometryKey
22315 {
22316 public:
22318  LineKey();
22319 
22323  explicit LineKey(Key const & in_that);
22324 
22327  LineKey(LineKey const & in_that);
22328 
22332  LineKey & operator=(LineKey const & in_that);
22333 
22337  LineKey(LineKey && in_that);
22338 
22342  LineKey & operator=(LineKey && in_that);
22343 
22344  ~LineKey();
22345 
22346  HPS::Type ObjectType() const { return HPS::Type::LineKey; };
22347 
22348 
22351  void Consume(LineKit & in_kit);
22352 
22355  void Set(LineKit const & in_kit);
22356 
22359  void Show(LineKit & out_kit) const;
22360 
22363  size_t GetPointCount() const;
22364 
22368  LineKey & SetPoints(PointArray const & in_points);
22369 
22374  LineKey & SetPoints(size_t in_count, Point const in_points []);
22375 
22376 
22380  bool ShowPoints(PointArray & out_points) const;
22381 
22387  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22388 
22393  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22394 
22400  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22401 
22402 
22408  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22409 
22414  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22415 
22420  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22421 
22427  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22428 
22434  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22435 };
22436 
22437 
22438 
22440 class HPS_API MarkerKit : public Object
22441 {
22442 public:
22444  MarkerKit();
22445 
22448  MarkerKit(MarkerKit const & in_kit);
22449 
22453  MarkerKit(MarkerKit && in_that);
22454 
22458  MarkerKit & operator=(MarkerKit && in_that);
22459 
22460  virtual ~MarkerKit();
22461 
22462  HPS::Type ObjectType() const { return HPS::Type::MarkerKit; };
22463 
22466  void Consume(MarkerKit & in_kit);
22467 
22470  void Set(MarkerKit const & in_kit);
22471 
22474  void Show(MarkerKit & out_kit) const;
22475 
22479  MarkerKit & operator=(MarkerKit const & in_kit);
22480 
22483  bool Empty() const;
22484 
22488  bool Equals(MarkerKit const & in_kit) const;
22489 
22493  bool operator==(MarkerKit const & in_kit) const;
22494 
22498  bool operator!=(MarkerKit const & in_kit) const;
22499 
22500 
22507  MarkerKit & SetPriority(int in_priority);
22508 
22511  MarkerKit & UnsetPriority();
22512 
22516  bool ShowPriority(int & out_priority) const;
22517 
22521  MarkerKit & SetPoint(Point const & in_point);
22522 
22523 
22526  MarkerKit & UnsetPoint();
22527 
22530  MarkerKit & UnsetEverything();
22531 
22532 
22536  bool ShowPoint(HPS::Point & out_point) const;
22537 
22543  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22544 
22549  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22550 
22555  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22556 
22560  MarkerKit & UnsetUserData(intptr_t in_index);
22561 
22566  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22567 
22571  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
22572 
22575  MarkerKit & UnsetAllUserData();
22576 
22578  size_t ShowUserDataCount() const;
22579 
22583  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22584 
22589  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22590 
22595  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22596 };
22597 
22599 class HPS_API MarkerKey : public GeometryKey
22600 {
22601 public:
22603  MarkerKey();
22604 
22608  explicit MarkerKey(Key const & in_that);
22609 
22612  MarkerKey(MarkerKey const & in_that);
22613 
22617  MarkerKey & operator=(MarkerKey const & in_that);
22618 
22622  MarkerKey(MarkerKey && in_that);
22623 
22627  MarkerKey & operator=(MarkerKey && in_that);
22628 
22629  ~MarkerKey();
22630 
22631  HPS::Type ObjectType() const { return HPS::Type::MarkerKey; };
22632 
22633 
22636  void Consume(MarkerKit & in_kit);
22637 
22640  void Set(MarkerKit const & in_kit);
22641 
22644  void Show(MarkerKit & out_kit) const;
22645 
22646 
22650  MarkerKey & SetPoint(Point const & in_point);
22651 
22655  bool ShowPoint(Point & out_point) const;
22656 };
22657 
22658 
22659 
22661 class HPS_API DistantLightKit : public Object
22662 {
22663 public:
22665  DistantLightKit();
22666 
22669  DistantLightKit(DistantLightKit const & in_kit);
22670 
22674  DistantLightKit(DistantLightKit && in_that);
22675 
22679  DistantLightKit & operator=(DistantLightKit && in_that);
22680 
22681  virtual ~DistantLightKit();
22682 
22683  HPS::Type ObjectType() const { return HPS::Type::DistantLightKit; };
22684 
22687  void Consume(DistantLightKit & in_kit);
22688 
22691  void Set(DistantLightKit const & in_kit);
22692 
22695  void Show(DistantLightKit & out_kit) const;
22696 
22700  DistantLightKit & operator=(DistantLightKit const & in_kit);
22701 
22704  bool Empty() const;
22705 
22709  bool Equals(DistantLightKit const & in_kit) const;
22710 
22714  bool operator==(DistantLightKit const & in_kit) const;
22715 
22719  bool operator!=(DistantLightKit const & in_kit) const;
22720 
22721 
22728  DistantLightKit & SetPriority(int in_priority);
22729 
22735  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
22736 
22740  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
22741 
22745  DistantLightKit & SetColorByIndex(float in_index);
22746 
22752  DistantLightKit & SetCameraRelative(bool in_state);
22753 
22754 
22757  DistantLightKit & UnsetPriority();
22758 
22761  DistantLightKit & UnsetDirection();
22762 
22765  DistantLightKit & UnsetColor();
22766 
22769  DistantLightKit & UnsetCameraRelative();
22770 
22773  DistantLightKit & UnsetEverything();
22774 
22775 
22779  bool ShowPriority(int & out_priority) const;
22780 
22784  bool ShowDirection(HPS::Vector & out_vector) const;
22785 
22791  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22792 
22796  bool ShowCameraRelative(bool & out_state) const;
22797 
22803  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22804 
22809  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22810 
22815  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22816 
22820  DistantLightKit & UnsetUserData(intptr_t in_index);
22821 
22826  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22827 
22831  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
22832 
22835  DistantLightKit & UnsetAllUserData();
22836 
22838  size_t ShowUserDataCount() const;
22839 
22843  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22844 
22849  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22850 
22855  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22856 };
22857 
22858 
22859 
22861 class HPS_API DistantLightKey : public GeometryKey
22862 {
22863 public:
22865  DistantLightKey();
22866 
22870  explicit DistantLightKey(Key const & in_that);
22871 
22874  DistantLightKey(DistantLightKey const & in_that);
22875 
22879  DistantLightKey & operator=(DistantLightKey const & in_that);
22880 
22884  DistantLightKey(DistantLightKey && in_that);
22885 
22889  DistantLightKey & operator=(DistantLightKey && in_that);
22890 
22891  ~DistantLightKey();
22892 
22893  HPS::Type ObjectType() const { return HPS::Type::DistantLightKey; };
22894 
22897  void Consume(DistantLightKit & in_kit);
22898 
22901  void Set(DistantLightKit const & in_kit);
22902 
22905  void Show(DistantLightKit & out_kit) const;
22906 
22911  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
22912 
22916  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22917 
22921  DistantLightKey & SetColorByIndex(float in_index);
22922 
22927  DistantLightKey & SetCameraRelative(bool in_state);
22928 
22929 
22932  DistantLightKey & UnsetColor();
22933 
22934 
22938  bool ShowDirection(HPS::Vector & out_vector) const;
22939 
22945  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22946 
22950  bool ShowCameraRelative(bool & out_state) const;
22951 };
22952 
22953 
22954 
22955 
22957 class HPS_API CylinderKit : public Object
22958 {
22959 public:
22961  CylinderKit();
22962 
22965  CylinderKit(CylinderKit const & in_kit);
22966 
22970  CylinderKit(CylinderKit && in_that);
22971 
22975  CylinderKit & operator=(CylinderKit && in_that);
22976 
22977  virtual ~CylinderKit();
22978 
22979  HPS::Type ObjectType() const { return HPS::Type::CylinderKit; };
22980 
22983  void Consume(CylinderKit & in_kit);
22984 
22987  void Set(CylinderKit const & in_kit);
22988 
22991  void Show(CylinderKit & out_kit) const;
22992 
22996  CylinderKit & operator=(CylinderKit const & in_kit);
22997 
23000  bool Empty() const;
23001 
23005  bool Equals(CylinderKit const & in_kit) const;
23006 
23010  bool operator==(CylinderKit const & in_kit) const;
23011 
23015  bool operator!=(CylinderKit const & in_kit) const;
23016 
23019  size_t GetPointCount() const;
23020 
23027  CylinderKit & SetPriority(int in_priority);
23028 
23031  CylinderKit & UnsetPriority();
23032 
23036  bool ShowPriority(int & out_priority) const;
23037 
23038 
23042  CylinderKit & SetPoints(PointArray const & in_points);
23043 
23048  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
23049 
23053  CylinderKit & SetRadii(FloatArray const & in_radii);
23054 
23059  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
23060 
23064  CylinderKit & SetCaps(Cylinder::Capping in_capping);
23065 
23066 
23069  CylinderKit & UnsetPoints();
23070 
23073  CylinderKit & UnsetRadii();
23074 
23077  CylinderKit & UnsetCaps();
23078 
23081  CylinderKit & UnsetEverything();
23082 
23083 
23087  bool ShowPoints(PointArray & out_points) const;
23088 
23094  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23095 
23100  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23101 
23107  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23108 
23112  bool ShowRadii(FloatArray & out_radii) const;
23113 
23117  bool ShowCaps(Cylinder::Capping & out_caps) const;
23118 
23119 
23126  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23127 
23133  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23134 
23141  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23142 
23149  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23150 
23157  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23158 
23165  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23166 
23172  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23173 
23174 
23181  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23182 
23188  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23189 
23196  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23197 
23204  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23205 
23212  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23213 
23220  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23221 
23227  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23228 
23229 
23232  CylinderKit & UnsetVertexColors();
23233 
23238  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23239 
23243  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
23244 
23245 
23249  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
23250 
23256  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23257 
23262  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
23263 
23264 
23274  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23275 
23287  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;
23288 
23301  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23302 
23308  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23309 
23314  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23315 
23320  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23321 
23325  CylinderKit & UnsetUserData(intptr_t in_index);
23326 
23331  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23332 
23336  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
23337 
23340  CylinderKit & UnsetAllUserData();
23341 
23343  size_t ShowUserDataCount() const;
23344 
23348  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23349 
23354  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23355 
23360  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23361 };
23362 
23363 
23364 
23366 class HPS_API CylinderKey : public GeometryKey
23367 {
23368 public:
23370  CylinderKey();
23371 
23375  explicit CylinderKey(Key const & in_that);
23376 
23379  CylinderKey(CylinderKey const & in_that);
23380 
23384  CylinderKey & operator=(CylinderKey const & in_that);
23385 
23389  CylinderKey(CylinderKey && in_that);
23390 
23394  CylinderKey & operator=(CylinderKey && in_that);
23395 
23396  ~CylinderKey();
23397 
23398  HPS::Type ObjectType() const { return HPS::Type::CylinderKey; };
23399 
23402  void Consume(CylinderKit & in_kit);
23403 
23406  void Set(CylinderKit const & in_kit);
23407 
23408 
23414  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23415 
23420  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23421 
23426  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
23427 
23433  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23434 
23440  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23441 
23442 
23448  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
23449 
23454  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
23455 
23460  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
23461 
23467  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
23468 
23474  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
23475 
23476 
23479  void Show(CylinderKit & out_kit) const;
23480 
23483  size_t GetPointCount() const;
23484 
23488  bool ShowPoints(PointArray & out_points) const;
23489 
23495  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23496 
23501  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23502 
23508  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23509 
23513  bool ShowRadii(FloatArray & out_radii) const;
23514 
23518  bool ShowCaps(Cylinder::Capping & out_caps) const;
23519 
23520 
23527  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23528 
23535  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23536 
23543  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23544 
23545 
23552  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23553 
23560  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23561 
23568  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23569 
23570 
23573  CylinderKey & UnsetVertexColors();
23574 
23579  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23580 
23584  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
23585 
23591  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23592 
23602  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23603 
23615  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;
23616 
23629  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23630 };
23631 
23632 
23633 
23634 
23636 class HPS_API SphereKit : public Object
23637 {
23638 public:
23640  SphereKit();
23641 
23644  SphereKit(SphereKit const & in_kit);
23645 
23649  SphereKit(SphereKit && in_that);
23650 
23654  SphereKit & operator=(SphereKit && in_that);
23655 
23656  virtual ~SphereKit();
23657 
23658  HPS::Type ObjectType() const { return HPS::Type::SphereKit; };
23659 
23662  void Consume(SphereKit & in_kit);
23663 
23666  void Set(SphereKit const & in_kit);
23667 
23670  void Show(SphereKit & out_kit) const;
23671 
23675  SphereKit & operator=(SphereKit const & in_kit);
23676 
23679  bool Empty() const;
23680 
23684  bool Equals(SphereKit const & in_kit) const;
23685 
23689  bool operator==(SphereKit const & in_kit) const;
23690 
23694  bool operator!=(SphereKit const & in_kit) const;
23695 
23702  SphereKit & SetPriority(int in_priority);
23703 
23706  SphereKit & UnsetPriority();
23707 
23711  bool ShowPriority(int & out_priority) const;
23712 
23716  SphereKit & SetCenter(Point const & in_center);
23717 
23721  SphereKit & SetRadius(float in_radius);
23722 
23727  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23728 
23729 
23732  SphereKit & UnsetCenter();
23733 
23736  SphereKit & UnsetRadius();
23737 
23740  SphereKit & UnsetBasis();
23741 
23744  SphereKit & UnsetEverything();
23745 
23746 
23750  bool ShowCenter(Point & out_center) const;
23751 
23755  bool ShowRadius(float & out_radius) const;
23756 
23761  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23762 
23768  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23769 
23774  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23775 
23780  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23781 
23785  SphereKit & UnsetUserData(intptr_t in_index);
23786 
23791  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23792 
23796  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
23797 
23800  SphereKit & UnsetAllUserData();
23801 
23803  size_t ShowUserDataCount() const;
23804 
23808  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23809 
23814  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23815 
23820  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23821 };
23822 
23824 class HPS_API SphereKey : public GeometryKey
23825 {
23826 public:
23828  SphereKey();
23829 
23833  explicit SphereKey(Key const & in_that);
23834 
23837  SphereKey(SphereKey const & in_that);
23838 
23842  SphereKey & operator=(SphereKey const & in_that);
23843 
23847  SphereKey(SphereKey && in_that);
23848 
23852  SphereKey & operator=(SphereKey && in_that);
23853 
23854  ~SphereKey();
23855 
23856  HPS::Type ObjectType() const {return HPS::Type::SphereKey;};
23857 
23860  void Consume(SphereKit & in_kit);
23861 
23864  void Set(SphereKit const & in_kit);
23865 
23868  void Show(SphereKit & out_kit) const;
23869 
23870 
23874  SphereKey & SetCenter(Point const & in_center);
23875 
23879  SphereKey & SetRadius(float in_radius);
23880 
23885  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23886 
23887 
23891  bool ShowCenter(Point & out_center) const;
23892 
23896  bool ShowRadius(float & out_radius) const;
23897 
23902  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23903 };
23904 
23905 
23906 
23907 
23909 class HPS_API CircleKit : public Object
23910 {
23911 public:
23913  CircleKit();
23914 
23917  CircleKit(CircleKit const & in_kit);
23918 
23922  CircleKit(CircleKit && in_that);
23923 
23927  CircleKit & operator=(CircleKit && in_that);
23928 
23929  virtual ~CircleKit();
23930 
23931  HPS::Type ObjectType() const { return HPS::Type::CircleKit; };
23932 
23935  void Consume(CircleKit & in_kit);
23936 
23939  void Set(CircleKit const & in_kit);
23940 
23943  void Show(CircleKit & out_kit) const;
23944 
23948  CircleKit & operator=(CircleKit const & in_kit);
23949 
23952  bool Empty() const;
23953 
23957  bool Equals(CircleKit const & in_kit) const;
23958 
23962  bool operator==(CircleKit const & in_kit) const;
23963 
23967  bool operator!=(CircleKit const & in_kit) const;
23968 
23975  CircleKit & SetPriority(int const in_priority);
23976 
23979  CircleKit & UnsetPriority();
23980 
23984  bool ShowPriority(int & out_priority) const;
23985 
23986 
23987 
23991  CircleKit & SetCenter(Point const & in_center);
23992 
23996  CircleKit & SetRadius(float in_radius);
23997 
24001  CircleKit & SetNormal(Vector const & in_normal);
24002 
24003 
24006  CircleKit & UnsetCenter();
24007 
24010  CircleKit & UnsetRadius();
24011 
24014  CircleKit & UnsetNormal();
24015 
24018  CircleKit & UnsetEverything();
24019 
24020 
24024  bool ShowCenter(Point & out_center) const;
24025 
24029  bool ShowRadius(float & out_radius) const;
24030 
24034  bool ShowNormal(Vector & out_normal) const;
24035 
24041  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24042 
24047  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24048 
24053  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24054 
24058  CircleKit & UnsetUserData(intptr_t in_index);
24059 
24064  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24065 
24069  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
24070 
24073  CircleKit & UnsetAllUserData();
24074 
24076  size_t ShowUserDataCount() const;
24077 
24081  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24082 
24087  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24088 
24093  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24094 };
24095 
24096 
24099 class HPS_API CircleKey : public GeometryKey
24100 {
24101 public:
24103  CircleKey();
24104 
24108  explicit CircleKey(Key const & in_that);
24109 
24112  CircleKey(CircleKey const & in_that);
24113 
24117  CircleKey & operator=(CircleKey const & in_that);
24118 
24122  CircleKey(CircleKey && in_that);
24123 
24127  CircleKey & operator=(CircleKey && in_that);
24128 
24129  ~CircleKey();
24130 
24131  HPS::Type ObjectType() const { return HPS::Type::CircleKey; };
24132 
24133 
24136  void Consume(CircleKit & in_kit);
24137 
24140  void Set(CircleKit const & in_kit);
24141 
24144  void Show(CircleKit & out_kit) const;
24145 
24146 
24150  CircleKey & SetCenter(Point const & in_center);
24151 
24155  CircleKey & SetRadius(float in_radius);
24156 
24160  CircleKey & SetNormal(Vector const & in_normal);
24161 
24162 
24166  bool ShowCenter(Point & out_center) const;
24167 
24171  bool ShowRadius(float & out_radius) const;
24172 
24176  bool ShowNormal(Vector & out_normal) const;
24177 };
24178 
24179 
24180 
24181 
24183 class HPS_API CircularArcKit : public Object
24184 {
24185 public:
24187  CircularArcKit();
24188 
24191  CircularArcKit(CircularArcKit const & in_kit);
24192 
24196  CircularArcKit(CircularArcKit && in_that);
24197 
24201  CircularArcKit & operator=(CircularArcKit && in_that);
24202 
24203  virtual ~CircularArcKit();
24204 
24205  HPS::Type ObjectType() const { return HPS::Type::CircularArcKit; };
24206 
24209  void Consume(CircularArcKit & in_kit);
24210 
24213  void Set(CircularArcKit const & in_kit);
24214 
24217  void Show(CircularArcKit & out_kit) const;
24218 
24222  CircularArcKit & operator=(CircularArcKit const & in_kit);
24223 
24226  bool Empty() const;
24227 
24231  bool Equals(CircularArcKit const & in_kit) const;
24232 
24236  bool operator==(CircularArcKit const & in_kit) const;
24237 
24241  bool operator!=(CircularArcKit const & in_kit) const;
24242 
24249  CircularArcKit & SetPriority(int in_priority);
24250 
24253  CircularArcKit & UnsetPriority();
24254 
24258  bool ShowPriority(int & out_priority) const;
24259 
24260 
24264  CircularArcKit & SetStart(Point const & in_start);
24265 
24269  CircularArcKit & SetMiddle(Point const & in_middle);
24270 
24274  CircularArcKit & SetEnd(Point const & in_end);
24275 
24276 
24279  CircularArcKit & UnsetStart();
24280 
24283  CircularArcKit & UnsetMiddle();
24284 
24287  CircularArcKit & UnsetEnd();
24288 
24291  CircularArcKit & UnsetEverything();
24292 
24293 
24297  bool ShowStart(Point & out_start) const;
24298 
24302  bool ShowMiddle(Point & out_middle) const;
24303 
24307  bool ShowEnd(Point & out_end) const;
24308 
24314  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24315 
24320  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24321 
24326  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24327 
24331  CircularArcKit & UnsetUserData(intptr_t in_index);
24332 
24337  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24338 
24342  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
24343 
24346  CircularArcKit & UnsetAllUserData();
24347 
24349  size_t ShowUserDataCount() const;
24350 
24354  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24355 
24360  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24361 
24366  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24367 };
24368 
24371 class HPS_API CircularArcKey : public GeometryKey
24372 {
24373 public:
24375  CircularArcKey();
24376 
24380  explicit CircularArcKey(Key const & in_that);
24381 
24384  CircularArcKey(CircularArcKey const & in_that);
24385 
24389  CircularArcKey & operator=(CircularArcKey const & in_that);
24390 
24394  CircularArcKey(CircularArcKey && in_that);
24395 
24399  CircularArcKey & operator=(CircularArcKey && in_that);
24400 
24401  ~CircularArcKey();
24402 
24403  HPS::Type ObjectType() const { return HPS::Type::CircularArcKey; };
24404 
24405 
24408  void Consume(CircularArcKit & in_kit);
24409 
24412  void Set(CircularArcKit const & in_kit);
24413 
24416  void Show(CircularArcKit & out_kit) const;
24417 
24418 
24422  CircularArcKey & SetStart(Point const & in_start);
24423 
24427  CircularArcKey & SetMiddle(Point const & in_middle);
24428 
24432  CircularArcKey & SetEnd(Point const & in_end);
24433 
24434 
24438  bool ShowStart(Point & out_start) const;
24439 
24443  bool ShowMiddle(Point & out_middle) const;
24444 
24448  bool ShowEnd(Point & out_end) const;
24449 };
24450 
24451 
24452 
24454 class HPS_API CircularWedgeKit : public Object
24455 {
24456 public:
24458  CircularWedgeKit();
24459 
24462  CircularWedgeKit(CircularWedgeKit const & in_kit);
24463 
24467  CircularWedgeKit(CircularWedgeKit && in_that);
24468 
24472  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
24473 
24474  virtual ~CircularWedgeKit();
24475 
24476  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKit; };
24477 
24480  void Consume(CircularWedgeKit & in_kit);
24481 
24484  void Set(CircularWedgeKit const & in_kit);
24485 
24488  void Show(CircularWedgeKit & out_kit) const;
24489 
24493  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
24494 
24497  bool Empty() const;
24498 
24502  bool Equals(CircularWedgeKit const & in_kit) const;
24503 
24507  bool operator==(CircularWedgeKit const & in_kit) const;
24508 
24512  bool operator!=(CircularWedgeKit const & in_kit) const;
24513 
24514 
24521  CircularWedgeKit & SetPriority(int in_priority);
24522 
24525  CircularWedgeKit & UnsetPriority();
24526 
24530  bool ShowPriority(int & out_priority) const;
24531 
24532 
24536  CircularWedgeKit & SetStart(Point const & in_start);
24537 
24541  CircularWedgeKit & SetMiddle(Point const & in_middle);
24542 
24546  CircularWedgeKit & SetEnd(Point const & in_end);
24547 
24548 
24551  CircularWedgeKit & UnsetStart();
24552 
24555  CircularWedgeKit & UnsetMiddle();
24556 
24559  CircularWedgeKit & UnsetEnd();
24560 
24563  CircularWedgeKit & UnsetEverything();
24564 
24565 
24569  bool ShowStart(Point & out_start) const;
24570 
24574  bool ShowMiddle(Point & out_middle) const;
24575 
24579  bool ShowEnd(Point & out_end) const;
24580 
24586  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24587 
24592  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24593 
24598  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24599 
24603  CircularWedgeKit & UnsetUserData(intptr_t in_index);
24604 
24609  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24610 
24614  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
24615 
24618  CircularWedgeKit & UnsetAllUserData();
24619 
24621  size_t ShowUserDataCount() const;
24622 
24626  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24627 
24632  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24633 
24638  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24639 };
24640 
24641 
24645 class HPS_API CircularWedgeKey : public GeometryKey
24646 {
24647 public:
24649  CircularWedgeKey();
24650 
24654  explicit CircularWedgeKey(Key const & in_that);
24655 
24658  CircularWedgeKey(CircularWedgeKey const & in_that);
24659 
24663  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
24664 
24668  CircularWedgeKey(CircularWedgeKey && in_that);
24669 
24673  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
24674 
24675  ~CircularWedgeKey();
24676 
24677  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKey; };
24678 
24679 
24682  void Consume(CircularWedgeKit & in_kit);
24683 
24686  void Set(CircularWedgeKit const & in_kit);
24687 
24690  void Show(CircularWedgeKit & out_kit) const;
24691 
24692 
24696  CircularWedgeKey & SetStart(Point const & in_start);
24697 
24701  CircularWedgeKey & SetMiddle(Point const & in_middle);
24702 
24706  CircularWedgeKey & SetEnd(Point const & in_end);
24707 
24708 
24712  bool ShowStart(Point & out_start) const;
24713 
24717  bool ShowMiddle(Point & out_middle) const;
24718 
24722  bool ShowEnd(Point & out_end) const;
24723 };
24724 
24725 
24726 
24728 class HPS_API CuttingSectionKit : public Object
24729 {
24730 public:
24733 
24736  CuttingSectionKit(CuttingSectionKit const & in_kit);
24737 
24742 
24746  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
24747 
24748  virtual ~CuttingSectionKit();
24749 
24750  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKit; };
24751 
24754  void Consume(CuttingSectionKit & in_kit);
24755 
24758  void Set(CuttingSectionKit const & in_kit);
24759 
24762  void Show(CuttingSectionKit & out_kit) const;
24763 
24767  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
24768 
24771  bool Empty() const;
24772 
24776  bool Equals(CuttingSectionKit const & in_kit) const;
24777 
24781  bool operator==(CuttingSectionKit const & in_kit) const;
24782 
24786  bool operator!=(CuttingSectionKit const & in_kit) const;
24787 
24794  CuttingSectionKit & SetPriority(int in_priority);
24795 
24798  CuttingSectionKit & UnsetPriority();
24799 
24803  bool ShowPriority(int & out_priority) const;
24804 
24805 
24809  CuttingSectionKit & SetPlanes(Plane const & in_plane);
24810 
24814  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
24815 
24820  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
24821 
24827  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24828 
24829 
24832  CuttingSectionKit & UnsetPlanes();
24833 
24836  CuttingSectionKit & UnsetVisualization();
24837 
24840  CuttingSectionKit & UnsetEverything();
24841 
24842 
24845  size_t GetPlaneCount() const;
24846 
24850  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24851 
24857  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24858 
24859 
24866  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24867 
24873  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24874 
24881  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24882 
24889  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24890 
24898  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24899 
24905  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24906 
24911  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24912 
24917  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24918 
24922  CuttingSectionKit & UnsetUserData(intptr_t in_index);
24923 
24928  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24929 
24933  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
24934 
24937  CuttingSectionKit & UnsetAllUserData();
24938 
24940  size_t ShowUserDataCount() const;
24941 
24945  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24946 
24951  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24952 
24957  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24958 };
24959 
24960 
24962 class HPS_API CuttingSectionKey : public GeometryKey
24963 {
24964 public:
24967 
24971  explicit CuttingSectionKey(Key const & in_that);
24972 
24975  CuttingSectionKey(CuttingSectionKey const & in_that);
24976 
24980  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24981 
24986 
24990  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24991 
24992  ~CuttingSectionKey();
24993 
24994  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKey; };
24995 
24996 
24999  void Consume(CuttingSectionKit & in_kit);
25000 
25003  void Set(CuttingSectionKit const & in_kit);
25004 
25007  void Show(CuttingSectionKit & out_kit) const;
25008 
25009 
25013  CuttingSectionKey & SetPlanes(Plane const & in_plane);
25014 
25018  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
25019 
25024  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
25025 
25031  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
25032 
25033 
25036  size_t GetPlaneCount() const;
25037 
25041  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
25042 
25048  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
25049 
25050 
25057  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
25058 
25064  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
25065 
25072  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
25073 
25080  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
25081 
25087  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
25088 };
25089 
25090 
25091 
25093 class HPS_API InfiniteLineKit : public Object
25094 {
25095 public:
25097  InfiniteLineKit();
25098 
25101  InfiniteLineKit(InfiniteLineKit const & in_kit);
25102 
25106  InfiniteLineKit(InfiniteLineKit && in_that);
25107 
25111  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
25112 
25113  virtual ~InfiniteLineKit();
25114 
25115  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKit; };
25116 
25119  void Consume(InfiniteLineKit & in_kit);
25120 
25123  void Set(InfiniteLineKit const & in_kit);
25124 
25127  void Show(InfiniteLineKit & out_kit) const;
25128 
25132  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
25133 
25136  bool Empty() const;
25137 
25141  bool Equals(InfiniteLineKit const & in_kit) const;
25142 
25146  bool operator==(InfiniteLineKit const & in_kit) const;
25147 
25151  bool operator!=(InfiniteLineKit const & in_kit) const;
25152 
25159  InfiniteLineKit & SetPriority(int in_priority);
25160 
25163  InfiniteLineKit & UnsetPriority();
25164 
25168  bool ShowPriority(int & out_priority) const;
25169 
25170 
25174  InfiniteLineKit & SetFirst(Point const & in_first);
25175 
25179  InfiniteLineKit & SetSecond(Point const & in_second);
25180 
25184  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
25185 
25186 
25189  InfiniteLineKit & UnsetFirst();
25190 
25193  InfiniteLineKit & UnsetSecond();
25194 
25197  InfiniteLineKit & UnsetType();
25198 
25201  InfiniteLineKit & UnsetEverything();
25202 
25203 
25207  bool ShowFirst(Point & out_first) const;
25208 
25212  bool ShowSecond(Point & out_second) const;
25213 
25217  bool ShowType(InfiniteLine::Type & out_type) const;
25218 
25224  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25225 
25230  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25231 
25236  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25237 
25241  InfiniteLineKit & UnsetUserData(intptr_t in_index);
25242 
25247  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25248 
25252  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
25253 
25256  InfiniteLineKit & UnsetAllUserData();
25257 
25259  size_t ShowUserDataCount() const;
25260 
25264  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25265 
25270  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25271 
25276  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25277 };
25278 
25279 
25281 class HPS_API InfiniteLineKey : public GeometryKey
25282 {
25283 public:
25285  InfiniteLineKey();
25286 
25290  explicit InfiniteLineKey(Key const & in_that);
25291 
25294  InfiniteLineKey(InfiniteLineKey const & in_that);
25295 
25299  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
25300 
25304  InfiniteLineKey(InfiniteLineKey && in_that);
25305 
25309  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
25310 
25311  ~InfiniteLineKey();
25312 
25313  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKey; };
25314 
25317  void Consume(InfiniteLineKit & in_kit);
25318 
25321  void Set(InfiniteLineKit const & in_kit);
25322 
25325  void Show(InfiniteLineKit & out_kit) const;
25326 
25327 
25331  InfiniteLineKey & SetFirst(Point const & in_first);
25332 
25336  InfiniteLineKey & SetSecond(Point const & in_second);
25337 
25341  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
25342 
25343 
25347  bool ShowFirst(Point & out_first) const;
25348 
25352  bool ShowSecond(Point & out_second) const;
25353 
25357  bool ShowType(InfiniteLine::Type & out_type) const;
25358 };
25359 
25360 
25361 
25365 class HPS_API SpotlightKit : public Object
25366 {
25367 public:
25369  SpotlightKit();
25370 
25373  SpotlightKit(SpotlightKit const & in_kit);
25374 
25378  SpotlightKit(SpotlightKit && in_that);
25379 
25383  SpotlightKit & operator=(SpotlightKit && in_that);
25384 
25385  virtual ~SpotlightKit();
25386 
25387  HPS::Type ObjectType() const { return HPS::Type::SpotlightKit; };
25388 
25392  static SpotlightKit GetDefault();
25393 
25396  void Consume(SpotlightKit & in_kit);
25397 
25400  void Set(SpotlightKit const & in_kit);
25401 
25404  void Show(SpotlightKit & out_kit) const;
25405 
25409  SpotlightKit & operator=(SpotlightKit const & in_kit);
25410 
25413  bool Empty() const;
25414 
25418  bool Equals(SpotlightKit const & in_kit) const;
25419 
25423  bool operator==(SpotlightKit const & in_kit) const;
25424 
25428  bool operator!=(SpotlightKit const & in_kit) const;
25429 
25430 
25437  SpotlightKit & SetPriority(int in_priority);
25438 
25444  SpotlightKit & SetPosition(HPS::Point const & in_position);
25445 
25451  SpotlightKit & SetTarget(HPS::Point const & in_target);
25452 
25456  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
25457 
25461  SpotlightKit & SetColorByIndex(float in_index);
25462 
25469 
25476 
25482  SpotlightKit & SetConcentration(float in_concentration);
25483 
25489  SpotlightKit & SetCameraRelative(bool in_state);
25490 
25491 
25494  SpotlightKit & UnsetPriority();
25495 
25498  SpotlightKit & UnsetPosition();
25499 
25502  SpotlightKit & UnsetTarget();
25503 
25506  SpotlightKit & UnsetColor();
25507 
25510  SpotlightKit & UnsetOuterCone();
25511 
25514  SpotlightKit & UnsetInnerCone();
25515 
25518  SpotlightKit & UnsetConcentration();
25519 
25522  SpotlightKit & UnsetCameraRelative();
25523 
25526  SpotlightKit & UnsetEverything();
25527 
25528 
25532  bool ShowPriority(int & out_priority) const;
25533 
25537  bool ShowPosition(HPS::Point & out_position) const;
25538 
25542  bool ShowTarget(HPS::Point & out_target) const;
25543 
25549  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25550 
25555  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25556 
25561  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25562 
25566  bool ShowConcentration(float & out_concentration) const;
25567 
25571  bool ShowCameraRelative(bool & out_state) const;
25572 
25578  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25579 
25584  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25585 
25590  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25591 
25595  SpotlightKit & UnsetUserData(intptr_t in_index);
25596 
25601  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25602 
25606  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
25607 
25610  SpotlightKit & UnsetAllUserData();
25611 
25613  size_t ShowUserDataCount() const;
25614 
25618  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25619 
25624  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25625 
25630  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25631 };
25632 
25633 
25635 class HPS_API SpotlightKey : public GeometryKey
25636 {
25637 public:
25639  SpotlightKey();
25640 
25644  explicit SpotlightKey(Key const & in_that);
25645 
25648  SpotlightKey(SpotlightKey const & in_that);
25649 
25653  SpotlightKey & operator=(SpotlightKey const & in_that);
25654 
25658  SpotlightKey(SpotlightKey && in_that);
25659 
25663  SpotlightKey & operator=(SpotlightKey && in_that);
25664 
25665  ~SpotlightKey();
25666 
25667  HPS::Type ObjectType() const { return HPS::Type::SpotlightKey; };
25668 
25671  void Consume(SpotlightKit & in_kit);
25672 
25675  void Set(SpotlightKit const & in_kit);
25676 
25679  void Show(SpotlightKit & out_kit) const;
25680 
25681 
25687  SpotlightKey & SetPosition(HPS::Point const & in_position);
25688 
25694  SpotlightKey & SetTarget(HPS::Point const & in_target);
25695 
25699  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
25700 
25704  SpotlightKey & SetColorByIndex(float in_index);
25705 
25712 
25719 
25725  SpotlightKey & SetConcentration(float in_concentration);
25726 
25732  SpotlightKey & SetCameraRelative(bool in_state);
25733 
25734 
25737  SpotlightKey & UnsetColor();
25738 
25739 
25743  bool ShowPosition(HPS::Point & out_position) const;
25744 
25748  bool ShowTarget(HPS::Point & out_target) const;
25749 
25755  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25756 
25761  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25762 
25767  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25768 
25772  bool ShowConcentration(float & out_concentration) const;
25773 
25777  bool ShowCameraRelative(bool & out_state) const;
25778 };
25779 
25780 
25781 
25783 class HPS_API NURBSCurveKit : public Object
25784 {
25785 public:
25787  NURBSCurveKit();
25788 
25791  NURBSCurveKit(NURBSCurveKit const & in_kit);
25792 
25796  NURBSCurveKit(NURBSCurveKit && in_that);
25797 
25801  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
25802 
25803  virtual ~NURBSCurveKit();
25804 
25805  HPS::Type ObjectType() const { return HPS::Type::NURBSCurveKit; };
25806 
25809  void Consume(NURBSCurveKit & in_kit);
25810 
25813  void Set(NURBSCurveKit const & in_kit);
25814 
25817  void Show(NURBSCurveKit & out_kit) const;
25818 
25822  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
25823 
25826  bool Empty() const;
25827 
25831  bool Equals(NURBSCurveKit const & in_kit) const;
25832 
25836  bool operator==(NURBSCurveKit const & in_kit) const;
25837 
25841  bool operator!=(NURBSCurveKit const & in_kit) const;
25842 
25845  size_t GetPointCount() const;
25846 
25853  NURBSCurveKit & SetPriority(int in_priority);
25854 
25857  NURBSCurveKit & UnsetPriority();
25858 
25862  bool ShowPriority(int & out_priority) const;
25863 
25867  NURBSCurveKit & SetDegree(size_t in_degree);
25868 
25872  NURBSCurveKit & SetPoints(PointArray const & in_points);
25873 
25878  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
25879 
25883  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
25884 
25889  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
25890 
25894  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
25895 
25900  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
25901 
25906  NURBSCurveKit & SetParameters(float in_start, float in_end);
25907 
25908 
25911  NURBSCurveKit & UnsetDegree();
25912 
25915  NURBSCurveKit & UnsetPoints();
25916 
25919  NURBSCurveKit & UnsetWeights();
25920 
25923  NURBSCurveKit & UnsetKnots();
25924 
25927  NURBSCurveKit & UnsetParameters();
25928 
25931  NURBSCurveKit & UnsetEverything();
25932 
25933 
25937  bool ShowDegree(size_t & out_degree) const;
25938 
25942  bool ShowPoints(PointArray & out_points) const;
25943 
25949  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25950 
25955  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25956 
25962  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25963 
25967  bool ShowWeights(FloatArray & out_weights) const;
25968 
25972  bool ShowKnots(FloatArray & out_knots) const;
25973 
25978  bool ShowParameters(float & out_start, float & out_end) const;
25979 
25980 
25987  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25988 
25994  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25995 
26002  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
26003 
26010  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26011 
26018  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26019 
26020 
26028  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
26029 
26036  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
26037 
26045  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
26046 
26053  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26054 
26061  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26062 
26063 
26069  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26070 
26075  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26076 
26082  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
26083 
26090  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26091 
26098  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26099 
26105  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26106 
26111  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26112 
26117  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26118 
26122  NURBSCurveKit & UnsetUserData(intptr_t in_index);
26123 
26128  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26129 
26133  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
26134 
26137  NURBSCurveKit & UnsetAllUserData();
26138 
26140  size_t ShowUserDataCount() const;
26141 
26145  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26146 
26151  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26152 
26157  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26158 };
26159 
26160 
26162 class HPS_API NURBSCurveKey : public GeometryKey
26163 {
26164 public:
26166  NURBSCurveKey();
26167 
26171  explicit NURBSCurveKey(Key const & in_that);
26172 
26175  NURBSCurveKey(NURBSCurveKey const & in_that);
26176 
26180  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
26181 
26185  NURBSCurveKey(NURBSCurveKey && in_that);
26186 
26190  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
26191 
26192  ~NURBSCurveKey();
26193 
26194  HPS::Type ObjectType() const {return HPS::Type::NURBSCurveKey;};
26195 
26198  void Consume(NURBSCurveKit & in_kit);
26199 
26202  void Set(NURBSCurveKit const & in_kit);
26203 
26206  void Show(NURBSCurveKit & out_kit) const;
26207 
26210  size_t GetPointCount() const;
26211 
26216  NURBSCurveKey & SetParameters(float in_start, float in_end);
26217 
26221  bool ShowDegree(size_t & out_degree) const;
26222 
26226  bool ShowPoints(PointArray & out_points) const;
26227 
26233  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26234 
26239  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26240 
26246  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26247 
26251  bool ShowWeights(FloatArray & out_weights) const;
26252 
26256  bool ShowKnots(FloatArray & out_knots) const;
26257 
26262  bool ShowParameters(float & out_start, float & out_end) const;
26263 
26264 
26272  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26273 
26280  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26281 
26282 
26291  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26292 
26300  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26301 
26302 
26310  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26311 
26318  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26319 };
26320 
26321 
26322 
26324 class HPS_API NURBSSurfaceKit : public Object
26325 {
26326 public:
26328  NURBSSurfaceKit();
26329 
26332  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
26333 
26337  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
26338 
26342  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
26343 
26344  virtual ~NURBSSurfaceKit();
26345 
26346  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKit; };
26347 
26350  void Consume(NURBSSurfaceKit & in_kit);
26351 
26354  void Set(NURBSSurfaceKit const & in_kit);
26355 
26358  void Show(NURBSSurfaceKit & out_kit) const;
26359 
26363  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
26364 
26367  bool Empty() const;
26368 
26372  bool Equals(NURBSSurfaceKit const & in_kit) const;
26373 
26377  bool operator==(NURBSSurfaceKit const & in_kit) const;
26378 
26382  bool operator!=(NURBSSurfaceKit const & in_kit) const;
26383 
26386  size_t GetPointCount() const;
26387 
26394  NURBSSurfaceKit & SetPriority(int in_priority);
26395 
26398  NURBSSurfaceKit & UnsetPriority();
26399 
26403  bool ShowPriority(int & out_priority) const;
26404 
26408  NURBSSurfaceKit & SetUDegree(size_t in_degree);
26409 
26413  NURBSSurfaceKit & SetVDegree(size_t in_degree);
26414 
26418  NURBSSurfaceKit & SetUCount(size_t in_count);
26419 
26423  NURBSSurfaceKit & SetVCount(size_t in_count);
26424 
26428  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
26429 
26434  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
26435 
26440  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
26441 
26447  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
26448 
26453  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
26454 
26460  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
26461 
26466  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
26467 
26473  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
26474 
26478  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
26479 
26484  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
26485 
26489  NURBSSurfaceKit & SetTrim(TrimKit const & in_trim);
26490 
26491 
26494  NURBSSurfaceKit & UnsetUDegree();
26495 
26498  NURBSSurfaceKit & UnsetVDegree();
26499 
26502  NURBSSurfaceKit & UnsetUCount();
26503 
26506  NURBSSurfaceKit & UnsetVCount();
26507 
26510  NURBSSurfaceKit & UnsetPoints();
26511 
26514  NURBSSurfaceKit & UnsetWeights();
26515 
26518  NURBSSurfaceKit & UnsetUKnots();
26519 
26522  NURBSSurfaceKit & UnsetVKnots();
26523 
26526  NURBSSurfaceKit & UnsetTrims();
26527 
26530  NURBSSurfaceKit & UnsetEverything();
26531 
26532 
26536  bool ShowUDegree(size_t & out_degree) const;
26537 
26541  bool ShowVDegree(size_t & out_degree) const;
26542 
26546  bool ShowUCount(size_t & out_count) const;
26547 
26551  bool ShowVCount(size_t & out_count) const;
26552 
26556  bool ShowPoints(PointArray & out_points) const;
26557 
26563  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26564 
26569  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26570 
26576  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26577 
26581  bool ShowWeights(FloatArray & out_weights) const;
26582 
26586  bool ShowUKnots(FloatArray & out_knots) const;
26587 
26591  bool ShowVKnots(FloatArray & out_knots) const;
26592 
26596  bool ShowTrims(TrimKitArray & out_trims) const;
26597 
26598 
26605  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
26606 
26612  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
26613 
26620  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
26621 
26628  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26629 
26636  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26637 
26638 
26646  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
26647 
26654  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
26655 
26663  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
26664 
26671  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26672 
26679  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26680 
26681 
26688  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26689 
26695  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26696 
26703  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
26704 
26711  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26712 
26719  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26720 
26721 
26728  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26729 
26735  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26736 
26743  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
26744 
26751  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26752 
26759  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26760 
26766  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26767 
26772  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26773 
26778  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26779 
26783  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
26784 
26789  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26790 
26794  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
26795 
26798  NURBSSurfaceKit & UnsetAllUserData();
26799 
26801  size_t ShowUserDataCount() const;
26802 
26806  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26807 
26812  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26813 
26818  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26819 };
26820 
26821 
26823 class HPS_API NURBSSurfaceKey : public GeometryKey
26824 {
26825 public:
26827  NURBSSurfaceKey();
26828 
26832  explicit NURBSSurfaceKey(Key const & in_that);
26833 
26836  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
26837 
26841  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
26842 
26846  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
26847 
26851  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
26852 
26853  ~NURBSSurfaceKey();
26854 
26855  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKey; };
26856 
26859  void Consume(NURBSSurfaceKit & in_kit);
26860 
26863  void Set(NURBSSurfaceKit const & in_kit);
26864 
26867  void Show(NURBSSurfaceKit & out_kit) const;
26868 
26871  size_t GetPointCount() const;
26872 
26877  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
26878 
26882  NURBSSurfaceKey & SetTrim(TrimKit const & in_trim);
26883 
26887  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
26888 
26889 
26892  NURBSSurfaceKey & UnsetTrims();
26893 
26894 
26898  bool ShowUDegree(size_t & out_degree) const;
26899 
26903  bool ShowVDegree(size_t & out_degree) const;
26904 
26908  bool ShowUCount(size_t & out_count) const;
26909 
26913  bool ShowVCount(size_t & out_count) const;
26914 
26918  bool ShowPoints(PointArray & out_points) const;
26919 
26925  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26926 
26931  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26932 
26938  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26939 
26943  bool ShowWeights(FloatArray & out_weights) const;
26944 
26948  bool ShowUKnots(FloatArray & out_knots) const;
26949 
26953  bool ShowVKnots(FloatArray & out_knots) const;
26954 
26958  bool ShowTrims(TrimKitArray & out_trims) const;
26959 
26960 
26968  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26969 
26976  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26977 
26978 
26987  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26988 
26996  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26997 
26998 
27006  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
27007 
27014  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
27015 
27016 
27024  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
27025 
27032  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
27033 };
27034 
27035 
27036 
27038 class HPS_API TrimElement : public Object
27039 {
27040 public:
27042  TrimElement();
27043 
27046  TrimElement(TrimElement const & in_that);
27047 
27051  TrimElement(LineKit const & in_line);
27052 
27056  TrimElement(NURBSCurveKit const & in_curve);
27057 
27061  TrimElement(TrimElement && in_that);
27062 
27066  TrimElement & operator=(TrimElement && in_that);
27067 
27068  ~TrimElement();
27069 
27070  HPS::Type ObjectType() const { return HPS::Type::TrimElement; };
27071 
27074  void Set(TrimElement const & in_that);
27075 
27079  TrimElement & operator=(TrimElement const & in_that);
27080 
27084  bool Equals(TrimElement const & in_that) const;
27085 
27089  bool operator==(TrimElement const & in_that) const;
27090 
27094  bool operator!=(TrimElement const & in_that) const;
27095 
27096 
27100  void SetCurve(LineKit const & in_line);
27101 
27105  void SetCurve(NURBSCurveKit const & in_curve);
27106 
27112  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
27113 };
27114 
27115 
27116 
27118 class HPS_API TrimKit : public Object
27119 {
27120 public:
27122  TrimKit();
27123 
27126  TrimKit(TrimKit const & in_kit);
27127 
27131  TrimKit(TrimKit && in_that);
27132 
27136  TrimKit & operator=(TrimKit && in_that);
27137 
27138  virtual ~TrimKit();
27139 
27140  HPS::Type ObjectType() const { return HPS::Type::TrimKit; };
27141 
27144  void Set(TrimKit const & in_kit);
27145 
27148  void Show(TrimKit & out_kit) const;
27149 
27153  TrimKit & operator=(TrimKit const & in_kit);
27154 
27157  bool Empty() const;
27158 
27162  bool Equals(TrimKit const & in_kit) const;
27163 
27167  bool operator==(TrimKit const & in_kit) const;
27168 
27172  bool operator!=(TrimKit const & in_kit) const;
27173 
27174 
27179  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
27180 
27184  TrimKit & SetShape(TrimElementArray const & in_shape);
27185 
27189  TrimKit & SetShape(TrimElement const & in_shape);
27190 
27191 
27195  TrimKit & SetOperation(Trim::Operation in_operation);
27196 
27197 
27200  TrimKit & UnsetShape();
27201 
27204  TrimKit & UnsetOperation();
27205 
27208  TrimKit & UnsetEverything();
27209 
27210 
27214  bool ShowShape(TrimElementArray & out_shape) const;
27215 
27219  bool ShowOperation(Trim::Operation & out_operation) const;
27220 };
27221 
27222 
27223 
27225 class HPS_API EllipseKit : public Object
27226 {
27227 public:
27229  EllipseKit();
27230 
27233  EllipseKit(EllipseKit const & in_kit);
27234 
27238  EllipseKit(EllipseKit && in_that);
27239 
27243  EllipseKit & operator=(EllipseKit && in_that);
27244 
27245  virtual ~EllipseKit();
27246 
27247  HPS::Type ObjectType() const { return HPS::Type::EllipseKit; };
27248 
27251  void Consume(EllipseKit & in_kit);
27252 
27255  void Set(EllipseKit const & in_kit);
27256 
27259  void Show(EllipseKit & out_kit) const;
27260 
27264  EllipseKit & operator=(EllipseKit const & in_kit);
27265 
27268  bool Empty() const;
27269 
27273  bool Equals(EllipseKit const & in_kit) const;
27274 
27278  bool operator==(EllipseKit const & in_kit) const;
27279 
27283  bool operator!=(EllipseKit const & in_kit) const;
27284 
27291  EllipseKit & SetPriority(int in_priority);
27292 
27295  EllipseKit & UnsetPriority();
27296 
27300  bool ShowPriority(int & out_priority) const;
27301 
27302 
27306  EllipseKit & SetCenter(Point const & in_center);
27307 
27311  EllipseKit & SetMajor(Point const & in_major);
27312 
27316  EllipseKit & SetMinor(Point const & in_minor);
27317 
27318 
27321  EllipseKit & UnsetCenter();
27322 
27325  EllipseKit & UnsetMajor();
27326 
27329  EllipseKit & UnsetMinor();
27330 
27333  EllipseKit & UnsetEverything();
27334 
27335 
27339  bool ShowCenter(Point & out_center) const;
27340 
27344  bool ShowMajor(Point & out_major) const;
27345 
27349  bool ShowMinor(Point & out_minor) const;
27350 
27356  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27357 
27362  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27363 
27368  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27369 
27373  EllipseKit & UnsetUserData(intptr_t in_index);
27374 
27379  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27380 
27384  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
27385 
27388  EllipseKit & UnsetAllUserData();
27389 
27391  size_t ShowUserDataCount() const;
27392 
27396  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27397 
27402  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27403 
27408  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27409 };
27410 
27411 
27412 
27414 class HPS_API EllipseKey : public GeometryKey
27415 {
27416 public:
27418  EllipseKey();
27419 
27423  explicit EllipseKey(Key const & in_that);
27424 
27427  EllipseKey(EllipseKey const & in_that);
27428 
27432  EllipseKey & operator=(EllipseKey const & other);
27433 
27437  EllipseKey(EllipseKey && in_that);
27438 
27442  EllipseKey & operator=(EllipseKey && in_that);
27443 
27444  ~EllipseKey();
27445 
27446  HPS::Type ObjectType() const { return HPS::Type::EllipseKey; };
27447 
27450  void Consume(EllipseKit & in_kit);
27451 
27454  void Set(EllipseKit const & in_kit);
27455 
27458  void Show(EllipseKit & out_kit) const;
27459 
27460 
27464  EllipseKey & SetCenter(Point const & in_center);
27465 
27469  EllipseKey & SetMajor(Point const & in_major);
27470 
27474  EllipseKey & SetMinor(Point const & in_minor);
27475 
27476 
27480  bool ShowCenter(Point & out_center) const;
27481 
27485  bool ShowMajor(Point & out_major) const;
27486 
27490  bool ShowMinor(Point & out_minor) const;
27491 };
27492 
27493 
27494 
27496 class HPS_API EllipticalArcKit : public Object
27497 {
27498 public:
27500  EllipticalArcKit();
27501 
27504  EllipticalArcKit(EllipticalArcKit const & in_kit);
27505 
27509  EllipticalArcKit(EllipticalArcKit && in_that);
27510 
27514  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
27515 
27516  virtual ~EllipticalArcKit();
27517 
27518  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKit; };
27519 
27522  void Consume(EllipticalArcKit & in_kit);
27523 
27526  void Set(EllipticalArcKit const & in_kit);
27527 
27530  void Show(EllipticalArcKit & out_kit) const;
27531 
27535  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
27536 
27539  bool Empty() const;
27540 
27544  bool Equals(EllipticalArcKit const & in_kit) const;
27545 
27549  bool operator==(EllipticalArcKit const & in_kit) const;
27550 
27554  bool operator!=(EllipticalArcKit const & in_kit) const;
27555 
27562  EllipticalArcKit & SetPriority(int in_priority);
27563 
27566  EllipticalArcKit & UnsetPriority();
27567 
27571  bool ShowPriority(int & out_priority) const;
27572 
27573 
27577  EllipticalArcKit & SetCenter(Point const & in_center);
27578 
27582  EllipticalArcKit & SetMajor(Point const & in_major);
27583 
27587  EllipticalArcKit & SetMinor(Point const & in_minor);
27588 
27596  EllipticalArcKit & SetStart(float in_start);
27597 
27605  EllipticalArcKit & SetEnd(float in_end);
27606 
27607 
27610  EllipticalArcKit & UnsetCenter();
27611 
27614  EllipticalArcKit & UnsetMajor();
27615 
27618  EllipticalArcKit & UnsetMinor();
27619 
27622  EllipticalArcKit & UnsetStart();
27623 
27626  EllipticalArcKit & UnsetEnd();
27627 
27630  EllipticalArcKit & UnsetEverything();
27631 
27632 
27636  bool ShowCenter(Point & out_center) const;
27637 
27641  bool ShowMajor(Point & out_major) const;
27642 
27646  bool ShowMinor(Point & out_minor) const;
27647 
27651  bool ShowStart(float & out_start) const;
27652 
27656  bool ShowEnd(float & out_end) const;
27657 
27663  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27664 
27669  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27670 
27675  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27676 
27680  EllipticalArcKit & UnsetUserData(intptr_t in_index);
27681 
27686  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27687 
27691  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
27692 
27695  EllipticalArcKit & UnsetAllUserData();
27696 
27698  size_t ShowUserDataCount() const;
27699 
27703  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27704 
27709  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27710 
27715  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27716 };
27717 
27718 
27720 class HPS_API EllipticalArcKey : public GeometryKey
27721 {
27722 public:
27724  EllipticalArcKey();
27725 
27729  explicit EllipticalArcKey(Key const & in_that);
27730 
27733  EllipticalArcKey(EllipticalArcKey const & in_that);
27734 
27738  EllipticalArcKey & operator=(EllipticalArcKey const & other);
27739 
27743  EllipticalArcKey(EllipticalArcKey && in_that);
27744 
27748  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
27749 
27750  ~EllipticalArcKey();
27751 
27752  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKey; };
27753 
27754 
27757  void Consume(EllipticalArcKit & in_kit);
27758 
27761  void Set(EllipticalArcKit const & in_kit);
27762 
27765  void Show(EllipticalArcKit & out_kit) const;
27766 
27767 
27771  EllipticalArcKey & SetCenter(Point const & in_center);
27772 
27776  EllipticalArcKey & SetMajor(Point const & in_major);
27777 
27781  EllipticalArcKey & SetMinor(Point const & in_minor);
27782 
27790  EllipticalArcKey & SetStart(float in_start);
27791 
27799  EllipticalArcKey & SetEnd(float in_end);
27800 
27801 
27805  bool ShowCenter(Point & out_center) const;
27806 
27810  bool ShowMajor(Point & out_major) const;
27811 
27815  bool ShowMinor(Point & out_minor) const;
27816 
27820  bool ShowStart(float & out_start) const;
27821 
27825  bool ShowEnd(float & out_end) const;
27826 };
27827 
27828 
27829 
27831 class HPS_API TextKit : public Object
27832 {
27833 public:
27835  TextKit();
27836 
27839  TextKit(TextKit const & in_kit);
27840 
27844  TextKit(TextKit && in_that);
27845 
27849  TextKit & operator=(TextKit && in_that);
27850 
27851  virtual ~TextKit();
27852 
27853  HPS::Type ObjectType() const { return HPS::Type::TextKit; };
27854 
27857  void Consume(TextKit & in_kit);
27858 
27861  void Set(TextKit const & in_kit);
27862 
27865  void Show(TextKit & out_kit) const;
27866 
27870  TextKit & operator=(TextKit const & in_kit);
27871 
27874  bool Empty() const;
27875 
27879  bool Equals(TextKit const & in_kit) const;
27880 
27884  bool operator==(TextKit const & in_kit) const;
27885 
27889  bool operator!=(TextKit const & in_kit) const;
27890 
27897  TextKit & SetPriority(int in_priority);
27898 
27901  TextKit & UnsetPriority();
27902 
27906  bool ShowPriority(int & out_priority) const;
27907 
27911  TextKit & SetPosition(Point const & in_position);
27912 
27916  TextKit & SetText(char const * in_string);
27917 
27921  TextKit & SetColor(RGBAColor const & in_rgba_color);
27922 
27926  TextKit & SetColorByIndex(float in_index);
27927 
27931  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
27932 
27938  TextKit & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
27939 
27943  TextKit & SetBold(bool in_state);
27944 
27948  TextKit & SetItalic(bool in_state);
27949 
27953  TextKit & SetOverline(bool in_state);
27954 
27958  TextKit & SetStrikethrough(bool in_state);
27959 
27963  TextKit & SetUnderline(bool in_state);
27964 
27969  TextKit & SetSlant(float in_angle);
27970 
27974  TextKit & SetLineSpacing(float in_multiplier);
27975 
27981  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27982 
27986  TextKit & SetRotation(float in_angle);
27987 
27993  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27994 
27999  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
28000 
28007  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28008 
28014  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28015 
28024  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
28025 
28033  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
28034 
28039  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
28040 
28046  TextKit & SetFont(char const * in_name);
28047 
28051  TextKit & SetTransform(Text::Transform in_trans);
28052 
28056  TextKit & SetRenderer(Text::Renderer in_rend);
28057 
28061  TextKit & SetPreference(Text::Preference in_pref);
28062 
28069  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
28070 
28074  TextKit & SetPath(Vector const & in_path);
28075 
28081  TextKit & SetSpacing(float in_multiplier);
28082 
28083 
28086  TextKit & UnsetPosition();
28087 
28090  TextKit & UnsetText();
28091 
28094  TextKit & UnsetColor();
28095 
28098  TextKit & UnsetModellingMatrix();
28099 
28102  TextKit & UnsetAlignment();
28103 
28106  TextKit & UnsetBold();
28107 
28110  TextKit & UnsetItalic();
28111 
28114  TextKit & UnsetOverline();
28115 
28118  TextKit & UnsetStrikethrough();
28119 
28122  TextKit & UnsetUnderline();
28123 
28126  TextKit & UnsetSlant();
28127 
28130  TextKit & UnsetLineSpacing();
28131 
28134  TextKit & UnsetRotation();
28135 
28138  TextKit & UnsetExtraSpace();
28139 
28142  TextKit & UnsetGreeking();
28143 
28146  TextKit & UnsetSizeTolerance();
28147 
28150  TextKit & UnsetSize();
28151 
28154  TextKit & UnsetFont();
28155 
28158  TextKit & UnsetTransform();
28159 
28162  TextKit & UnsetRenderer();
28163 
28166  TextKit & UnsetPreference();
28167 
28170  TextKit & UnsetPath();
28171 
28174  TextKit & UnsetSpacing();
28175 
28178  TextKit & UnsetEverything();
28179 
28180 
28184  bool ShowPosition(Point & out_position) const;
28185 
28189  bool ShowText(UTF8 & out_string) const;
28190 
28196  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28197 
28201  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28202 
28208  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28209 
28213  bool ShowBold(bool & out_state) const;
28214 
28218  bool ShowItalic(bool & out_state) const;
28219 
28223  bool ShowOverline(bool & out_state) const;
28224 
28228  bool ShowStrikethrough(bool & out_state) const;
28229 
28233  bool ShowUnderline(bool & out_state) const;
28234 
28238  bool ShowSlant(float & out_angle) const;
28239 
28243  bool ShowLineSpacing(float & out_multiplier) const;
28244 
28249  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28250 
28256  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28257 
28264  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28265 
28271  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28272 
28277  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28278 
28282  bool ShowFont(UTF8 & out_name) const;
28283 
28287  bool ShowTransform(Text::Transform & out_trans) const;
28288 
28292  bool ShowRenderer(Text::Renderer & out_renderer) const;
28293 
28300  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28301 
28305  bool ShowPath(Vector & out_path) const;
28306 
28310  bool ShowSpacing(float & out_multiplier) const;
28311 
28312 
28320  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28321 
28328  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28329 
28337  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28338 
28347  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;
28348 
28361  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);
28362 
28376  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);
28377 
28383  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28384 
28387  TextKit & UnsetRegion();
28388 
28393  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28394 
28399  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28400 
28404  TextKit & UnsetUserData(intptr_t in_index);
28405 
28410  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28411 
28415  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
28416 
28419  TextKit & UnsetAllUserData();
28420 
28422  size_t ShowUserDataCount() const;
28423 
28427  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28428 
28433  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28434 
28439  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28440 };
28441 
28442 
28444 class HPS_API TextKey : public GeometryKey
28445 {
28446 public:
28448  TextKey();
28449 
28453  explicit TextKey(Key const & in_that);
28454 
28457  TextKey(TextKey const & in_that);
28458 
28462  TextKey & operator=(TextKey const & other);
28463 
28467  TextKey(TextKey && in_that);
28468 
28472  TextKey & operator=(TextKey && in_that);
28473 
28474  ~TextKey();
28475 
28476  HPS::Type ObjectType() const {return HPS::Type::TextKey;};
28477 
28480  void Consume(TextKit & in_kit);
28481 
28484  void Set(TextKit const & in_kit);
28485 
28488  void Show(TextKit & out_kit) const;
28489 
28492  TextKey & SetTextAttribute(TextAttributeKit const & in_kit);
28493 
28497  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
28498 
28502  TextKey & SetPosition(Point const & in_position);
28503 
28507  TextKey & SetText(char const * in_string);
28508 
28512  TextKey & SetColor(RGBAColor const & in_rgba_color);
28513 
28517  TextKey & SetColorByIndex(float in_index);
28518 
28522  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
28523 
28529  TextKey & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
28530 
28534  TextKey & SetBold(bool in_state);
28535 
28539  TextKey & SetItalic(bool in_state);
28540 
28544  TextKey & SetOverline(bool in_state);
28545 
28549  TextKey & SetStrikethrough(bool in_state);
28550 
28554  TextKey & SetUnderline(bool in_state);
28555 
28560  TextKey & SetSlant(float in_angle);
28561 
28566  TextKey & SetLineSpacing(float in_multiplier);
28567 
28573  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
28574 
28578  TextKey & SetRotation(float in_angle);
28579 
28585  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
28586 
28591  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
28592 
28599  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28600 
28606  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28607 
28616  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
28617 
28625  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
28626 
28631  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
28632 
28638  TextKey & SetFont(char const * in_name);
28639 
28643  TextKey & SetTransform(Text::Transform in_transform);
28644 
28648  TextKey & SetRenderer(Text::Renderer in_renderer);
28649 
28653  TextKey & SetPreference(Text::Preference in_preference);
28654 
28662  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
28663 
28668  TextKey & SetPath(Vector const & in_path);
28669 
28675  TextKey & SetSpacing(float in_multiplier);
28676 
28689  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);
28690 
28704  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);
28705 
28706 
28709  TextKey & UnsetColor();
28710 
28713  TextKey & UnsetModellingMatrix();
28714 
28717  TextKey & UnsetAlignment();
28718 
28721  TextKey & UnsetBold();
28722 
28725  TextKey & UnsetItalic();
28726 
28729  TextKey & UnsetOverline();
28730 
28733  TextKey & UnsetStrikethrough();
28734 
28737  TextKey & UnsetUnderline();
28738 
28741  TextKey & UnsetSlant();
28742 
28745  TextKey & UnsetLineSpacing();
28746 
28749  TextKey & UnsetRotation();
28750 
28753  TextKey & UnsetExtraSpace();
28754 
28757  TextKey & UnsetGreeking();
28758 
28761  TextKey & UnsetSizeTolerance();
28762 
28765  TextKey & UnsetSize();
28766 
28769  TextKey & UnsetFont();
28770 
28773  TextKey & UnsetTransform();
28774 
28777  TextKey & UnsetRenderer();
28778 
28781  TextKey & UnsetPreference();
28782 
28785  TextKey & UnsetPath();
28786 
28789  TextKey & UnsetSpacing();
28790 
28793  TextKey & UnsetRegion();
28794 
28797  TextKey & UnsetEverything();
28798 
28799 
28803  bool ShowPosition(Point & out_position) const;
28804 
28808  bool ShowText(UTF8 & out_string) const;
28809 
28815  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28816 
28820  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28821 
28827  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28828 
28832  bool ShowBold(bool & out_state) const;
28833 
28837  bool ShowItalic(bool & out_state) const;
28838 
28842  bool ShowOverline(bool & out_state) const;
28843 
28847  bool ShowStrikethrough(bool & out_state) const;
28848 
28852  bool ShowUnderline(bool & out_state) const;
28853 
28857  bool ShowSlant(float & out_angle) const;
28858 
28862  bool ShowLineSpacing(float & out_multiplier) const;
28863 
28868  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28869 
28875  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28876 
28883  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28884 
28890  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28891 
28896  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28897 
28901  bool ShowFont(UTF8 & out_name) const;
28902 
28906  bool ShowTransform(Text::Transform & out_trans) const;
28907 
28911  bool ShowRenderer(Text::Renderer & out_renderer) const;
28912 
28919  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28920 
28924  bool ShowPath(Vector & out_path) const;
28925 
28929  bool ShowSpacing(float & out_multiplier) const;
28930 
28939  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;
28940 
28941 
28949  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28950 
28957  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28958 
28966  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28967 };
28968 
28969 
28971 class HPS_API ShellOptimizationOptionsKit : public Object
28972 {
28973 public:
28976 
28980 
28985 
28986  virtual ~ShellOptimizationOptionsKit();
28987 
28988  HPS::Type ObjectType() const { return HPS::Type::ShellOptimizationOptionsKit; };
28989 
28992  void Consume(ShellOptimizationOptionsKit & in_kit);
28993 
28996  void Set(ShellOptimizationOptionsKit const & in_kit);
28997 
29000  void Show(ShellOptimizationOptionsKit & out_kit) const;
29001 
29005  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
29006 
29011 
29014  bool Empty() const;
29015 
29019  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
29020 
29024  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
29025 
29029  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
29030 
29034  static ShellOptimizationOptionsKit GetDefault();
29035 
29036 
29040  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
29041 
29046  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
29047 
29052  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
29053 
29058  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
29059 
29060 
29063  ShellOptimizationOptionsKit & UnsetNormalTolerance();
29064 
29067  ShellOptimizationOptionsKit & UnsetTolerance();
29068 
29071  ShellOptimizationOptionsKit & UnsetOrphanElimination();
29072 
29075  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
29076 
29079  ShellOptimizationOptionsKit & UnsetEverything();
29080 
29081 
29085  bool ShowNormalTolerance(float & out_normal_tolerance) const;
29086 
29091  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
29092 
29096  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
29097 
29102  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
29103 };
29104 
29105 
29109 class HPS_API ShellRelationOptionsKit : public Object
29110 {
29111 public:
29114 
29118 
29123 
29127  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
29128 
29129  virtual ~ShellRelationOptionsKit();
29130 
29131  HPS::Type ObjectType() const { return HPS::Type::ShellRelationOptionsKit; };
29132 
29136  static ShellRelationOptionsKit GetDefault();
29137 
29140  void Consume(ShellRelationOptionsKit & in_kit);
29141 
29144  void Set(ShellRelationOptionsKit const & in_kit);
29145 
29148  void Show(ShellRelationOptionsKit & out_kit) const;
29149 
29153  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
29154 
29157  bool Empty() const;
29158 
29162  bool Equals(ShellRelationOptionsKit const & in_kit) const;
29163 
29167  bool operator==(ShellRelationOptionsKit const & in_kit) const;
29168 
29172  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
29173 
29174 
29178  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
29179 
29183  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
29184 
29189  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
29190 
29194  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
29195 
29196 
29199  ShellRelationOptionsKit & UnsetTolerance();
29200 
29203  ShellRelationOptionsKit & UnsetTest();
29204 
29207  ShellRelationOptionsKit & UnsetTreeContext();
29208 
29211  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
29212 
29215  ShellRelationOptionsKit & UnsetEverything();
29216 
29217 
29221  bool ShowTolerance(float & out_tolerance) const;
29222 
29226  bool ShowTest(Shell::RelationTest & out_test) const;
29227 
29231  bool ShowTreeContext(TreeContext & out_tree_context) const;
29232 
29236  bool ShowNearestFaceCalculation(bool & out_state) const;
29237 };
29238 
29240 class HPS_API ShellRelationResultsKit : public Object
29241 {
29242 public:
29245 
29249 
29254 
29258  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
29259 
29260  virtual ~ShellRelationResultsKit();
29261 
29262  HPS::Type ObjectType() const { return HPS::Type::ShellRelationResultsKit; };
29263 
29266  void Consume(ShellRelationResultsKit & in_kit);
29267 
29270  void Set(ShellRelationResultsKit const & in_kit);
29271 
29274  void Show(ShellRelationResultsKit & out_kit) const;
29275 
29279  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
29280 
29283  bool Empty() const;
29284 
29288  bool Equals(ShellRelationResultsKit const & in_kit) const;
29289 
29293  bool operator==(ShellRelationResultsKit const & in_kit) const;
29294 
29298  bool operator!=(ShellRelationResultsKit const & in_kit) const;
29299 
29300 
29304  bool ShowRelations(ShellRelationArray & out_results) const;
29305 
29309  bool ShowNearestFaces(SizeTArray & out_faces) const;
29310 
29314  bool ShowDistances(FloatArray & out_distances) const;
29315 };
29316 
29317 
29319 class HPS_API ShellKit : public Object
29320 {
29321 public:
29323  ShellKit();
29324 
29327  ShellKit(ShellKit const & in_kit);
29328 
29332  ShellKit(ShellKit && in_that);
29333 
29337  ShellKit & operator=(ShellKit && in_that);
29338 
29339  virtual ~ShellKit();
29340 
29341  HPS::Type ObjectType() const { return HPS::Type::ShellKit; };
29342 
29345  void Consume(ShellKit & in_kit);
29346 
29349  void Set(ShellKit const & in_kit);
29350 
29353  void Show(ShellKit & out_kit) const;
29354 
29357  size_t GetPointCount() const;
29358 
29361  size_t GetFaceCount() const;
29362 
29366  ShellKit & operator=(ShellKit const & in_kit);
29367 
29370  bool Empty() const;
29371 
29375  bool Equals(ShellKit const & in_kit) const;
29376 
29380  bool operator==(ShellKit const & in_kit) const;
29381 
29385  bool operator!=(ShellKit const & in_kit) const;
29386 
29393  ShellKit & SetPriority(int in_priority);
29394 
29397  ShellKit & UnsetPriority();
29398 
29402  bool ShowPriority(int & out_priority) const;
29403 
29404 
29405 
29409  ShellKit & SetPoints(PointArray const & in_points);
29410 
29415  ShellKit & SetPoints(size_t in_count, Point const in_points []);
29416 
29420  ShellKit & SetFacelist(IntArray const & in_facelist);
29421 
29426  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
29427 
29431  ShellKit & SetTristrips(IntArray const & in_tristrips);
29432 
29437  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
29438 
29441  ShellKit & UnsetPoints();
29442 
29445  ShellKit & UnsetFacelist();
29446 
29449  ShellKit & UnsetTristrips();
29450 
29453  ShellKit & UnsetEverything();
29454 
29458  bool ShowPoints(PointArray & out_points) const;
29459 
29465  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29466 
29471  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29472 
29478  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29479 
29483  bool ShowFacelist(IntArray & out_facelist) const;
29484 
29488  bool ShowTristrips(IntArray & out_tristrips) const;
29489 
29495  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
29496 
29497 
29504  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29505 
29511  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29512 
29519  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29520 
29527  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29528 
29535  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29536 
29543  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29544 
29550  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29551 
29552 
29559  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29560 
29566  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29567 
29574  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29575 
29582  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29583 
29590  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29591 
29598  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29599 
29605  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29606 
29607 
29614  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29615 
29621  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29622 
29629  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29630 
29637  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29638 
29645  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29646 
29653  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29654 
29660  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29661 
29662 
29668  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29669 
29674  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29675 
29681  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29682 
29688  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29689 
29694  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29695 
29701  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29702 
29707  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29708 
29709 
29716  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29717 
29724  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29725 
29734  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);
29735 
29743  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29744 
29745 
29751  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29752 
29757  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29758 
29764  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29765 
29771  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29772 
29777  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29778 
29784  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29785 
29790  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29791 
29792 
29795  ShellKit & UnsetMaterialMapping();
29796 
29797 
29800  ShellKit & UnsetVertexColors();
29801 
29806  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29807 
29811  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29812 
29813 
29817  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
29818 
29824  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29825 
29830  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29831 
29832 
29835  ShellKit & UnsetVertexNormals();
29836 
29841  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29842 
29846  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29847 
29848 
29851  ShellKit & UnsetVertexParameters();
29852 
29857  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29858 
29862  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29863 
29864 
29867  ShellKit & UnsetVertexVisibilities();
29868 
29873  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29874 
29878  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29879 
29880 
29883  ShellKit & UnsetVertexEverything();
29884 
29885 
29889  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29890 
29891 
29903  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
29904  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29905 
29919  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
29920  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29921 
29936  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
29937  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29938 
29945  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
29946 
29955  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29956 
29965  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29966 
29967 
29975  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
29976 
29984  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29985 
29995  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29996 
30006  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30007 
30017  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
30018 
30028  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30029 
30030 
30037  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
30038 
30047  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30048 
30057  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30058 
30059 
30060 
30066  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30067 
30072  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
30073 
30079  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
30080 
30086  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
30087 
30092  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
30093 
30099  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
30100 
30105  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
30106 
30107 
30113  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
30114 
30119  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
30120 
30126  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
30127 
30133  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
30134 
30139  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
30140 
30146  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
30147 
30152  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
30153 
30154 
30160  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30161 
30166  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
30167 
30173  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30174 
30180  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
30181 
30186  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
30187 
30193  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
30194 
30199  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
30200 
30201 
30207  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30208 
30213  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30214 
30220  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30221 
30227  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
30228 
30233  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
30234 
30240  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
30241 
30246  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
30247 
30248 
30251  ShellKit & UnsetFaceColors();
30252 
30257  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
30258 
30262  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
30263 
30264 
30267  ShellKit & UnsetFaceNormals();
30268 
30273  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
30274 
30278  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
30279 
30280 
30283  ShellKit & UnsetFaceVisibilities();
30284 
30289  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
30290 
30294  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
30295 
30296 
30299  ShellKit & UnsetFaceEverything();
30300 
30308  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30309 
30319  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30320 
30331  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30332 
30333 
30340  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
30341 
30350  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30351 
30360  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
30361 
30368  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
30369 
30378  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30379 
30388  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
30389 
30390 
30397  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
30398 
30404  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
30405 
30411  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
30412 
30418  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
30419 
30425  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
30426 
30427 
30434  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
30435 
30441  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
30442 
30448  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
30449 
30458  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
30459 
30467  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
30468 
30471  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
30472 
30477  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30478 
30483  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30484 
30489  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30490 
30496  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30497 
30502  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30503 
30508  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30509 
30513  ShellKit & UnsetUserData(intptr_t in_index);
30514 
30519  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30520 
30524  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
30525 
30528  ShellKit & UnsetAllUserData();
30529 
30531  size_t ShowUserDataCount() const;
30532 
30536  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30537 
30542  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30543 
30548  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30549 };
30550 
30551 
30552 
30554 class HPS_API ShellKey : public GeometryKey
30555 {
30556 public:
30558  ShellKey();
30559 
30564  explicit ShellKey(Key const & in_that);
30565 
30568  ShellKey(ShellKey const & in_that);
30569 
30573  ShellKey & operator=(ShellKey const & other);
30574 
30578  ShellKey(ShellKey && in_that);
30579 
30583  ShellKey & operator=(ShellKey && in_that);
30584 
30585  ~ShellKey();
30586 
30587  HPS::Type ObjectType() const { return HPS::Type::ShellKey; };
30588 
30591  void Consume(ShellKit & in_kit);
30592 
30595  void Set(ShellKit const & in_kit);
30596 
30599  void Show(ShellKit & out_kit) const;
30600 
30603  size_t GetPointCount() const;
30604 
30607  size_t GetFaceCount() const;
30608 
30609 
30613  ShellKey & SetPoints(PointArray const & in_points);
30614 
30619  ShellKey & SetPoints(size_t in_count, Point const in_points []);
30620 
30624  ShellKey & SetFacelist(IntArray const & in_facelist);
30625 
30630  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
30631 
30635  ShellKey & SetTristrips(IntArray const & in_tristrips);
30636 
30641  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
30642 
30647  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
30648 
30651  ShellKey & UnsetPoints();
30652 
30655  ShellKey & UnsetFacelist();
30656 
30659  ShellKey & UnsetTristrips();
30660 
30663  ShellKey & UnsetMaterialMapping();
30664 
30667  ShellKey & UnsetEverything();
30668 
30672  bool ShowPoints(PointArray & out_points) const;
30673 
30679  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
30680 
30685  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
30686 
30692  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
30693 
30697  bool ShowFacelist(IntArray & out_facelist) const;
30698 
30702  bool ShowTristrips(IntArray & out_tristrips) const;
30703 
30708  bool ShowTristrips(IntArray & out_tristrips, IntArray & out_face_indices) const;
30709 
30713  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30714 
30715 
30722  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30723 
30730  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30731 
30738  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30739 
30746  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30747 
30754  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30755 
30762  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30763 
30769  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30770 
30771 
30778  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30779 
30786  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30787 
30794  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30795 
30802  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30803 
30810  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30811 
30818  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30819 
30825  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30826 
30827 
30834  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30835 
30842  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30843 
30850  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30851 
30858  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30859 
30866  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30867 
30874  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30875 
30881  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30882 
30883 
30889  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30890 
30896  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30897 
30903  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30904 
30910  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30911 
30916  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30917 
30923  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30924 
30929  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30930 
30931 
30939  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30940 
30947  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30948 
30957  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);
30958 
30966  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30967 
30968 
30974  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30975 
30981  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30982 
30988  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30989 
30995  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30996 
31001  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31002 
31008  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31009 
31014  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31015 
31016 
31019  ShellKey & UnsetVertexColors();
31020 
31025  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31026 
31030  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31031 
31032 
31036  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
31037 
31043  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
31044 
31049  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
31050 
31051 
31054  ShellKey & UnsetVertexNormals();
31055 
31060  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31061 
31065  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31066 
31067 
31070  ShellKey & UnsetVertexParameters();
31071 
31076  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31077 
31081  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31082 
31083 
31086  ShellKey & UnsetVertexVisibilities();
31087 
31092  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31093 
31097  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31098 
31099 
31102  ShellKey & UnsetVertexEverything();
31103 
31104 
31116  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
31117  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31118 
31132  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
31133  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31134 
31149  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
31150  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31151 
31152 
31159  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
31160 
31169  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31170 
31179  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31180 
31184  bool ShowNetVertexNormals(VectorArray & out_normals) const;
31185 
31191  bool ShowNetVertexNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
31192 
31200  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
31201 
31209  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31210 
31220  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31221 
31231  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31232 
31242  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31243 
31253  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31254 
31255 
31262  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
31263 
31272  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31273 
31282  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31283 
31284 
31290  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31291 
31297  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31298 
31304  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31305 
31311  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
31312 
31317  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
31318 
31324  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
31325 
31330  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
31331 
31332 
31338  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
31339 
31345  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
31346 
31352  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
31353 
31359  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
31360 
31365  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
31366 
31372  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
31373 
31378  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
31379 
31380 
31386  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31387 
31393  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
31394 
31400  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31401 
31407  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
31408 
31413  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
31414 
31420  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
31421 
31426  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
31427 
31428 
31434  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31435 
31441  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31442 
31448  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31449 
31455  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
31456 
31461  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
31462 
31468  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
31469 
31474  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
31475 
31476 
31479  ShellKey & UnsetFaceColors();
31480 
31485  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
31486 
31490  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
31491 
31492 
31495  ShellKey & UnsetFaceNormals();
31496 
31501  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
31502 
31506  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
31507 
31508 
31511  ShellKey & UnsetFaceVisibilities();
31512 
31517  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
31518 
31522  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
31523 
31524 
31527  ShellKey & UnsetFaceEverything();
31528 
31536  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31537 
31547  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31548 
31559  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31560 
31567  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
31568 
31577  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31578 
31587  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31588 
31589 
31595  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
31596 
31603  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
31604 
31605 
31612  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
31613 
31622  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31623 
31632  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31633 
31634 
31641  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
31642 
31648  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
31649 
31655  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
31656 
31662  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
31663 
31669  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
31670 
31671 
31678  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
31679 
31685  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
31686 
31692  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
31693 
31702  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
31703 
31711  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
31712 
31715  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
31716 
31721  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31722 
31727  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31728 
31733  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31734 };
31735 
31736 
31737 
31739 class HPS_API MeshKit : public Object
31740 {
31741 public:
31743  MeshKit();
31744 
31747  MeshKit(MeshKit const & in_kit);
31748 
31752  MeshKit(MeshKit && in_that);
31753 
31757  MeshKit & operator=(MeshKit && in_that);
31758 
31759  virtual ~MeshKit();
31760 
31761  HPS::Type ObjectType() const { return HPS::Type::MeshKit; };
31762 
31765  void Consume(MeshKit & in_kit);
31766 
31769  void Set(MeshKit const & in_kit);
31770 
31773  void Show(MeshKit & out_kit) const;
31774 
31778  MeshKit & operator=(MeshKit const & in_kit);
31779 
31782  bool Empty() const;
31783 
31787  bool Equals(MeshKit const & in_kit) const;
31788 
31792  bool operator==(MeshKit const & in_kit) const;
31793 
31797  bool operator!=(MeshKit const & in_kit) const;
31798 
31801  size_t GetPointCount() const;
31802 
31809  MeshKit & SetPriority(int in_priority);
31810 
31813  MeshKit & UnsetPriority();
31814 
31818  bool ShowPriority(int & out_priority) const;
31819 
31823  MeshKit & SetPoints(PointArray const & in_points);
31824 
31829  MeshKit & SetPoints(size_t in_count, Point const in_points []);
31830 
31836  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
31837 
31844  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31845 
31849  MeshKit & SetRows(size_t in_rows);
31850 
31854  MeshKit & SetColumns(size_t in_columns);
31855 
31858  MeshKit & UnsetPoints();
31859 
31862  MeshKit & UnsetRows();
31863 
31866  MeshKit & UnsetColumns();
31867 
31870  MeshKit & UnsetEverything();
31871 
31875  bool ShowPoints(PointArray & out_points) const;
31876 
31882  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
31883 
31888  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
31889 
31895  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
31896 
31902  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31903 
31907  bool ShowRows(size_t & out_rows) const;
31908 
31912  bool ShowColumns(size_t & out_columns) const;
31913 
31914 
31920  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
31921 
31928  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31929 
31935  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31936 
31943  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31944 
31951  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31952 
31959  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31960 
31967  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31968 
31974  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31975 
31976 
31983  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31984 
31990  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31991 
31998  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31999 
32006  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32007 
32014  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32015 
32022  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32023 
32029  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32030 
32031 
32038  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32039 
32045  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32046 
32053  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32054 
32061  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32062 
32069  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32070 
32077  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32078 
32084  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32085 
32086 
32092  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32093 
32098  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32099 
32105  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32106 
32112  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32113 
32118  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32119 
32125  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32126 
32131  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32132 
32133 
32140  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32141 
32148  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32149 
32158  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);
32159 
32167  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32168 
32169 
32175  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32176 
32181  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32182 
32188  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32189 
32195  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32196 
32201  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32202 
32208  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32209 
32214  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32215 
32216 
32219  MeshKit & UnsetMaterialMapping();
32220 
32223  MeshKit & UnsetVertexColors();
32224 
32229  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32230 
32234  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32235 
32236 
32240  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
32241 
32247  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
32248 
32253  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
32254 
32255 
32258  MeshKit & UnsetVertexNormals();
32259 
32264  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
32265 
32269  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
32270 
32271 
32274  MeshKit & UnsetVertexParameters();
32275 
32280  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
32281 
32285  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
32286 
32287 
32290  MeshKit & UnsetVertexVisibilities();
32291 
32296  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
32297 
32301  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
32302 
32303 
32306  MeshKit & UnsetVertexEverything();
32307 
32308 
32312  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32313 
32325  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32326  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32327 
32341  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32342  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32343 
32358  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32359  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32360 
32361 
32368  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
32369 
32378  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32379 
32388  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32389 
32397  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
32398 
32406  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32407 
32417  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32418 
32428  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32429 
32439  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32440 
32450  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32451 
32458  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
32459 
32468  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32469 
32478  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32479 
32480 
32486  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32487 
32492  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32493 
32499  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
32500 
32506  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32507 
32512  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32513 
32519  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32520 
32525  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32526 
32527 
32533  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32534 
32539  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32540 
32546  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32547 
32553  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32554 
32559  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32560 
32566  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32567 
32572  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32573 
32574 
32580  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32581 
32586  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
32587 
32593  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32594 
32600  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
32601 
32606  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
32607 
32613  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32614 
32619  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32620 
32621 
32627  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32628 
32633  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32634 
32640  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32641 
32647  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32648 
32653  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32654 
32660  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32661 
32666  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32667 
32668 
32671  MeshKit & UnsetFaceColors();
32672 
32677  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32678 
32682  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
32683 
32684 
32687  MeshKit & UnsetFaceNormals();
32688 
32693  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32694 
32698  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
32699 
32700 
32703  MeshKit & UnsetFaceVisibilities();
32704 
32709  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32710 
32714  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
32715 
32716 
32719  MeshKit & UnsetFaceEverything();
32720 
32728  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32729 
32739  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32740 
32751  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32752 
32753 
32760  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
32761 
32770  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32771 
32780  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32781 
32788  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
32789 
32798  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32799 
32808  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32809 
32815  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32816 
32821  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32822 
32827  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32828 
32832  MeshKit & UnsetUserData(intptr_t in_index);
32833 
32838  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32839 
32843  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
32844 
32847  MeshKit & UnsetAllUserData();
32848 
32850  size_t ShowUserDataCount() const;
32851 
32855  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32856 
32861  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32862 
32867  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32868 
32869 };
32870 
32871 
32872 
32874 class HPS_API MeshKey : public GeometryKey
32875 {
32876 public:
32878  MeshKey();
32879 
32884  explicit MeshKey(Key const & in_that);
32885 
32888  MeshKey(MeshKey const & in_that);
32889 
32893  MeshKey & operator=(MeshKey const & in_that);
32894 
32898  MeshKey(MeshKey && in_that);
32899 
32903  MeshKey & operator=(MeshKey && in_that);
32904 
32905  ~MeshKey();
32906 
32907  HPS::Type ObjectType() const { return HPS::Type::MeshKey; };
32908 
32911  void Consume(MeshKit & in_kit);
32912 
32915  void Set(MeshKit const & in_kit);
32916 
32919  void Show(MeshKit & out_kit) const;
32920 
32923  size_t GetPointCount() const;
32924 
32930  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
32931 
32938  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
32939 
32943  bool ShowPoints(PointArray & out_points) const;
32944 
32950  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32951 
32956  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32957 
32963  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32964 
32970  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
32971 
32975  bool ShowRows(size_t & out_rows) const;
32976 
32980  bool ShowColumns(size_t & out_columns) const;
32981 
32982 
32987  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
32988 
32991  MeshKey & UnsetMaterialMapping();
32992 
32996  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32997 
32998 
33005  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
33006 
33013  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
33014 
33021  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
33022 
33029  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
33030 
33037  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
33038 
33045  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
33046 
33052  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
33053 
33054 
33061  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
33062 
33069  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
33070 
33077  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
33078 
33085  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
33086 
33093  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
33094 
33101  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
33102 
33108  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
33109 
33110 
33117  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
33118 
33125  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
33126 
33133  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
33134 
33141  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
33142 
33149  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
33150 
33157  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
33158 
33164  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
33165 
33166 
33172  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33173 
33179  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
33180 
33186  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33187 
33193  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
33194 
33199  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
33200 
33206  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
33207 
33212  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
33213 
33214 
33222  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
33223 
33230  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
33231 
33240  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);
33241 
33249  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
33250 
33251 
33257  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33258 
33264  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33265 
33271  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33272 
33278  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
33279 
33284  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
33285 
33291  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
33292 
33297  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
33298 
33299 
33302  MeshKey & UnsetVertexColors();
33303 
33308  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
33309 
33313  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
33314 
33315 
33319  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
33320 
33326  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
33327 
33332  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
33333 
33334 
33337  MeshKey & UnsetVertexNormals();
33338 
33343  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
33344 
33348  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
33349 
33350 
33353  MeshKey & UnsetVertexParameters();
33354 
33359  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
33360 
33364  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
33365 
33366 
33369  MeshKey & UnsetVertexVisibilities();
33370 
33375  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
33376 
33380  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
33381 
33382 
33385  MeshKey & UnsetVertexEverything();
33386 
33389  MeshKey & UnsetEverything();
33390 
33391 
33403  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33404  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33405 
33419  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33420  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33421 
33436  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33437  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33438 
33439 
33446  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
33447 
33456  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33457 
33466  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
33467 
33475  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
33476 
33484  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33485 
33495  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
33496 
33506  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33507 
33517  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
33518 
33528  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33529 
33530 
33537  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
33538 
33547  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33548 
33557  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
33558 
33559 
33565  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
33566 
33572  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
33573 
33579  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
33580 
33586  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
33587 
33592  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
33593 
33599  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
33600 
33605  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
33606 
33607 
33613  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
33614 
33620  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
33621 
33627  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
33628 
33634  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
33635 
33640  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
33641 
33647  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
33648 
33653  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
33654 
33655 
33661  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33662 
33668  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33669 
33675  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33676 
33682  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33683 
33688  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33689 
33695  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33696 
33701  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33702 
33703 
33709  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33710 
33716  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33717 
33723  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33724 
33730  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33731 
33736  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33737 
33743  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33744 
33749  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33750 
33751 
33754  MeshKey & UnsetFaceColors();
33755 
33760  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33761 
33765  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
33766 
33767 
33770  MeshKey & UnsetFaceNormals();
33771 
33776  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33777 
33781  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
33782 
33783 
33786  MeshKey & UnsetFaceVisibilities();
33787 
33792  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33793 
33797  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
33798 
33799 
33802  MeshKey & UnsetFaceEverything();
33803 
33811  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33812 
33822  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33823 
33834  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33835 
33842  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
33843 
33852  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33853 
33862  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33863 
33870  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
33871 
33880  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33881 
33890  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33891 
33900  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[]);
33901 
33909  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);
33910 };
33911 
33912 
33913 
33914 
33916 class HPS_API PolygonKit : public Object
33917 {
33918 public:
33920  PolygonKit();
33921 
33924  PolygonKit(PolygonKit const & in_kit);
33925 
33929  PolygonKit(PolygonKit && in_that);
33930 
33934  PolygonKit & operator=(PolygonKit && in_that);
33935 
33936  virtual ~PolygonKit();
33937 
33938  HPS::Type ObjectType() const { return HPS::Type::PolygonKit; };
33939 
33942  void Consume(PolygonKit & in_kit);
33943 
33946  void Set(PolygonKit const & in_kit);
33947 
33950  void Show(PolygonKit & out_kit) const;
33951 
33955  PolygonKit & operator=(PolygonKit const & in_kit);
33956 
33959  bool Empty() const;
33960 
33964  bool Equals(PolygonKit const & in_kit) const;
33965 
33969  bool operator==(PolygonKit const & in_kit) const;
33970 
33974  bool operator!=(PolygonKit const & in_kit) const;
33975 
33978  size_t GetPointCount() const;
33979 
33986  PolygonKit & SetPriority(int in_priority);
33987 
33990  PolygonKit & UnsetPriority();
33991 
33995  bool ShowPriority(int & out_priority) const;
33996 
33997 
34001  PolygonKit & SetPoints(PointArray const & in_points);
34002 
34007  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
34008 
34011  PolygonKit & UnsetPoints();
34012 
34015  PolygonKit & UnsetEverything();
34016 
34020  bool ShowPoints(PointArray & out_points) const;
34021 
34027  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
34028 
34033  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
34034 
34040  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
34041 
34047  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
34048 
34053  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
34054 
34059  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
34060 
34066  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
34067 
34072  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
34073 
34079  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
34080 
34085  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
34086 
34091  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
34092 
34096  PolygonKit & UnsetUserData(intptr_t in_index);
34097 
34102  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
34103 
34107  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
34108 
34111  PolygonKit & UnsetAllUserData();
34112 
34114  size_t ShowUserDataCount() const;
34115 
34119  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
34120 
34125  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
34126 
34131  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
34132 };
34133 
34134 
34136 class HPS_API PolygonKey : public GeometryKey
34137 {
34138 public:
34140  PolygonKey();
34141 
34146  explicit PolygonKey(Key const & in_that);
34147 
34150  PolygonKey(PolygonKey const & in_that);
34151 
34155  PolygonKey & operator=(PolygonKey const & in_that);
34156 
34160  PolygonKey(PolygonKey && in_that);
34161 
34165  PolygonKey & operator=(PolygonKey && in_that);
34166 
34167  ~PolygonKey();
34168 
34169  HPS::Type ObjectType() const { return HPS::Type::PolygonKey; };
34170 
34171 
34174  void Consume(PolygonKit & in_kit);
34175 
34178  void Set(PolygonKit const & in_kit);
34179 
34182  void Show(PolygonKit & out_kit) const;
34183 
34186  size_t GetPointCount() const;
34187 
34191  PolygonKey & SetPoints(PointArray const & in_points);
34192 
34197  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
34198 
34202  bool ShowPoints(PointArray & out_points) const;
34203 
34209  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
34210 
34215  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
34216 
34222  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
34223 
34229  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
34230 
34235  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
34236 
34241  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
34242 
34248  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
34249 
34254  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
34255 };
34256 
34257 
34258 
34259 
34261 class HPS_API GridKit : public Object
34262 {
34263 public:
34265  GridKit();
34266 
34269  GridKit(GridKit const & in_kit);
34270 
34273  GridKit(GridKit && in_that);
34274 
34275  virtual ~GridKit();
34276 
34277  HPS::Type ObjectType() const { return HPS::Type::GridKit; };
34278 
34281  void Consume(GridKit & in_kit);
34282 
34285  void Set(GridKit const & in_kit);
34286 
34289  void Show(GridKit & out_kit) const;
34290 
34294  GridKit & operator=(GridKit const & in_kit);
34295 
34299  GridKit & operator=(GridKit && in_that);
34300 
34303  bool Empty() const;
34304 
34308  bool Equals(GridKit const & in_kit) const;
34309 
34313  bool operator==(GridKit const & in_kit) const;
34314 
34318  bool operator!=(GridKit const & in_kit) const;
34319 
34320 
34327  GridKit & SetPriority(int in_priority);
34328 
34332  GridKit & SetType(Grid::Type in_type);
34333 
34337  GridKit & SetOrigin(Point const & in_origin);
34338 
34345  GridKit & SetFirstPoint(Point const & in_first_point);
34346 
34354  GridKit & SetSecondPoint(Point const & in_second_point);
34355 
34369  GridKit & SetFirstCount(int in_first_count);
34370 
34381  GridKit & SetSecondCount(int in_second_count);
34382 
34383 
34386  GridKit & UnsetPriority();
34387 
34390  GridKit & UnsetType();
34391 
34394  GridKit & UnsetOrigin();
34395 
34398  GridKit & UnsetFirstPoint();
34399 
34402  GridKit & UnsetSecondPoint();
34403 
34406  GridKit & UnsetFirstCount();
34407 
34410  GridKit & UnsetSecondCount();
34411 
34414  GridKit & UnsetEverything();
34415 
34416 
34420  bool ShowPriority(int & out_priority) const;
34421 
34425  bool ShowType(Grid::Type & out_type) const;
34426 
34430  bool ShowOrigin(Point & out_origin) const;
34431 
34435  bool ShowFirstPoint(Point & out_first_point) const;
34436 
34440  bool ShowSecondPoint(Point & out_second_point) const;
34441 
34445  bool ShowFirstCount(int & out_first_count) const;
34446 
34450  bool ShowSecondCount(int & out_second_count) const;
34451 
34457  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
34458 
34463  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
34464 
34469  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
34470 
34474  GridKit & UnsetUserData(intptr_t in_index);
34475 
34480  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
34481 
34485  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
34486 
34489  GridKit & UnsetAllUserData();
34490 
34492  size_t ShowUserDataCount() const;
34493 
34497  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
34498 
34503  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
34504 
34509  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
34510 };
34511 
34512 
34514 class HPS_API GridKey : public GeometryKey
34515 {
34516 public:
34518  GridKey();
34519 
34524  explicit GridKey(Key const & in_that);
34525 
34528  GridKey(GridKey const & in_that);
34529 
34532  GridKey(GridKey && in_that);
34533 
34537  GridKey & operator=(GridKey const & in_that);
34538 
34542  GridKey & operator=(GridKey && in_that);
34543 
34544  ~GridKey();
34545 
34546  HPS::Type ObjectType() const { return HPS::Type::GridKey; };
34547 
34550  void Consume(GridKit & in_kit);
34551 
34554  void Set(GridKit const & in_kit);
34555 
34558  void Show(GridKit & out_kit) const;
34559 
34560 
34564  GridKey & SetType(Grid::Type in_type);
34565 
34569  GridKey & SetOrigin(Point const & in_origin);
34570 
34577  GridKey & SetFirstPoint(Point const & in_first_point);
34578 
34586  GridKey & SetSecondPoint(Point const & in_second_point);
34587 
34601  GridKey & SetFirstCount(int in_first_count);
34602 
34613  GridKey & SetSecondCount(int in_second_count);
34614 
34615 
34616 
34620  bool ShowType(Grid::Type & out_type) const;
34621 
34625  bool ShowOrigin(Point & out_origin) const;
34626 
34630  bool ShowFirstPoint(Point & out_first_point) const;
34631 
34635  bool ShowSecondPoint(Point & out_second_point) const;
34636 
34640  bool ShowFirstCount(int & out_first_count) const;
34641 
34645  bool ShowSecondCount(int & out_second_count) const;
34646 };
34647 
34648 
34649 
34650 
34652 class HPS_API IncludeKey : public Key
34653 {
34654 public:
34656  IncludeKey();
34657 
34662  explicit IncludeKey(Key const & in_that);
34663 
34666  IncludeKey(IncludeKey const & in_that);
34667 
34671  IncludeKey & operator=(IncludeKey const & in_that);
34672 
34676  IncludeKey(IncludeKey && in_that);
34677 
34681  IncludeKey & operator=(IncludeKey && in_that);
34682 
34683  ~IncludeKey();
34684 
34685 
34686  HPS::Type ObjectType() const { return HPS::Type::IncludeKey; };
34687 
34690  SegmentKey GetTarget() const;
34691 
34692 
34697  IncludeKey & SetPriority(int in_priority);
34698 
34706  IncludeKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
34707 
34708 
34711  IncludeKey & UnsetPriority();
34712 
34715  IncludeKey & UnsetConditionalExpression();
34716 
34717 
34721  bool ShowPriority(int & out_priority) const;
34722 
34726  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
34727 
34733  IncludeKey & SetFilter(AttributeLock::Type in_type);
34734 
34741  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34742 
34748  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
34749 
34755  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
34756 
34763  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34764 
34770  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34771 
34777  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34778 
34784  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34785 };
34786 
34787 
34788 
34790 class HPS_API StyleKey : public Key
34791 {
34792 public:
34794  StyleKey();
34795 
34800  explicit StyleKey(Key const & in_that);
34801 
34804  StyleKey(StyleKey const & in_that);
34805 
34809  StyleKey & operator=(StyleKey const & other);
34810 
34814  StyleKey(StyleKey && in_that);
34815 
34819  StyleKey & operator=(StyleKey && in_that);
34820 
34821  ~StyleKey();
34822 
34823  HPS::Type ObjectType() const { return HPS::Type::StyleKey; };
34824 
34825 
34831  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
34832 
34833 
34841  StyleKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
34842 
34843 
34846  StyleKey & UnsetConditionalExpression();
34847 
34848 
34852  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
34853 
34854 
34860  StyleKey & SetFilter(AttributeLock::Type in_type);
34861 
34868  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34869 
34875  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
34876 
34882  StyleKey & UnsetFilter(AttributeLock::Type in_type);
34883 
34890  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34891 
34897  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34898 
34904  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34905 
34911  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34912 };
34913 
34914 
34915 
34917 class HPS_API ReferenceKey : public GeometryKey
34918 {
34919 public:
34921  ReferenceKey();
34922 
34927  explicit ReferenceKey(Key const & in_that);
34928 
34931  ReferenceKey(ReferenceKey const & in_that);
34932 
34936  ReferenceKey & operator=(ReferenceKey const & in_that);
34937 
34941  ReferenceKey(ReferenceKey && in_that);
34942 
34946  ReferenceKey & operator=(ReferenceKey && in_that);
34947 
34948  ~ReferenceKey();
34949 
34950  HPS::Type ObjectType() const { return HPS::Type::ReferenceKey; };
34951 
34955  Key GetTarget() const;
34956 
34960  size_t ShowTargets(bool masked=true) const;
34961 
34966  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
34967 
34971  size_t ShowGeometryMask() const;
34972 
34977  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
34978 
34982  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
34983 
34986  ReferenceKey & UnsetGeometryMask();
34987 
34990  void SetModellingMatrix(MatrixKit const & in_kit);
34991 
35000  ReferenceKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
35001 
35002 
35004  void UnsetModellingMatrix();
35005 
35008  ReferenceKey & UnsetConditionalExpression();
35009 
35010 
35014  bool ShowModellingMatrix(MatrixKit & out_kit) const;
35015 
35019  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
35020 
35021 
35024  ModellingMatrixControl GetModellingMatrixControl();
35025 
35028  ModellingMatrixControl const GetModellingMatrixControl() const;
35029 };
35030 
35031 
35032 
35036 class HPS_API StandAloneWindowOptionsKit : public Object
35037 {
35038 public:
35041 
35045 
35050 
35055 
35056  virtual ~StandAloneWindowOptionsKit();
35057 
35058  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsKit; };
35059 
35063  static StandAloneWindowOptionsKit GetDefault();
35064 
35067  void Set(StandAloneWindowOptionsKit const & in_kit);
35068 
35071  void Show(StandAloneWindowOptionsKit & out_kit) const;
35072 
35076  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
35077 
35080  bool Empty() const;
35081 
35085  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
35086 
35090  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
35091 
35095  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
35096 
35100  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
35101 
35106  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
35107 
35111  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
35112 
35117  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
35118 
35122  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
35123 
35127  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
35128 
35131  StandAloneWindowOptionsKit & UnsetDriver();
35132 
35135  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
35136 
35139  StandAloneWindowOptionsKit & UnsetTitle();
35140 
35143  StandAloneWindowOptionsKit & UnsetSubscreen();
35144 
35147  StandAloneWindowOptionsKit & UnsetMobility();
35148 
35151  StandAloneWindowOptionsKit & UnsetFullScreen();
35152 
35155  StandAloneWindowOptionsKit & UnsetEverything();
35156 
35160  bool ShowDriver(Window::Driver & out_driver) const;
35161 
35166  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35167 
35171  bool ShowTitle(UTF8 & out_window_name) const;
35172 
35176  bool ShowSubscreen(Rectangle & out_subscreen) const;
35177 
35181  bool ShowMobility(Window::Mobility & out_mobility) const;
35182 
35186  bool ShowFullScreen(bool & out_state) const;
35187 };
35188 
35189 
35190 
35197 {
35198 public:
35202 
35206 
35211 
35216 
35219 
35220  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsControl; };
35221 
35226 
35231  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
35232 
35236  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
35237 
35241  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
35242 
35246  bool ShowDriver(Window::Driver & out_driver) const;
35247 
35252  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35253 
35257  bool ShowTitle(UTF8 & out_window_name) const;
35258 
35262  bool ShowSubscreen(Rectangle & out_subscreen) const;
35263 
35267  bool ShowMobility(Window::Mobility & out_mobility) const;
35268 
35272  bool ShowFullScreen(bool & out_state) const;
35273 
35277  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
35278 private:
35281 };
35282 
35283 
35284 
35288 class HPS_API OffScreenWindowOptionsKit : public Object
35289 {
35290 public:
35293 
35297 
35302 
35306  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
35307 
35308  virtual ~OffScreenWindowOptionsKit();
35309 
35310  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsKit; };
35311 
35315  static OffScreenWindowOptionsKit GetDefault();
35316 
35319  void Set(OffScreenWindowOptionsKit const & in_kit);
35320 
35323  void Show(OffScreenWindowOptionsKit & out_kit) const;
35324 
35328  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
35329 
35332  bool Empty() const;
35333 
35337  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
35338 
35342  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
35343 
35347  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
35348 
35352  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
35353 
35358  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
35359 
35364  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
35365 
35370  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
35371 
35376  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
35377 
35381  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
35382 
35385  OffScreenWindowOptionsKit & UnsetDriver();
35386 
35389  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
35390 
35393  OffScreenWindowOptionsKit & UnsetHardwareResident();
35394 
35397  OffScreenWindowOptionsKit & UnsetNativeFormat();
35398 
35401  OffScreenWindowOptionsKit & UnsetOpacity();
35402 
35405  OffScreenWindowOptionsKit & UnsetEverything();
35406 
35410  bool ShowDriver(Window::Driver & out_driver) const;
35411 
35416  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35417 
35421  bool ShowHardwareResident(bool & out_state) const;
35422 
35427  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
35428 
35433  bool ShowOpacity(bool & out_state, float & out_opacity) const;
35434 };
35435 
35439 class HPS_API ApplicationWindowOptionsKit : public Object
35440 {
35441 public:
35444 
35448 
35453 
35458 
35459  virtual ~ApplicationWindowOptionsKit();
35460 
35461  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsKit; };
35462 
35466  static ApplicationWindowOptionsKit GetDefault();
35467 
35470  void Set(ApplicationWindowOptionsKit const & in_kit);
35471 
35474  void Show(ApplicationWindowOptionsKit & out_kit) const;
35475 
35479  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
35480 
35483  bool Empty() const;
35484 
35488  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
35489 
35493  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
35494 
35498  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
35499 
35503  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
35504 
35509  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
35510 
35514  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
35515 
35519  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
35520 
35523  ApplicationWindowOptionsKit & UnsetDriver();
35524 
35527  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
35528 
35531  ApplicationWindowOptionsKit & UnsetPlatformData();
35532 
35535  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
35536 
35539  ApplicationWindowOptionsKit & UnsetEverything();
35540 
35544  bool ShowDriver(Window::Driver & out_driver) const;
35545 
35550  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35551 
35555  bool ShowPlatformData(PlatformData & out_platform_data) const;
35556 
35560  bool ShowFramebufferRetention(bool & out_retain) const;
35561 
35562 };
35563 
35564 
35565 
35568 {
35569 public:
35573 
35577 
35582 
35587 
35590 
35591  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsControl; };
35592 
35597 
35602  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35603 
35607  bool ShowDriver(Window::Driver & out_driver) const;
35608 
35612  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
35613 
35617  bool ShowPlatformData(PlatformData & out_platform_data) const;
35618 
35622  bool ShowFramebufferRetention(bool & out_retain) const;
35623 
35627  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
35628 
35632  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
35633 
35634 private:
35637 };
35638 
35639 
35640 
35645 class HPS_API StandAloneWindowKey : public WindowKey
35646 {
35647 public:
35650 
35655  StandAloneWindowKey(Key const & in_key);
35656 
35659  StandAloneWindowKey(StandAloneWindowKey const & in_that);
35660 
35665 
35669  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
35670 
35672 
35673  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowKey; };
35674 
35677  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
35678 
35681  StandAloneWindowOptionsControl GetWindowOptionsControl();
35682 
35686  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
35687 
35690  Window::UpdateStatus Pause();
35691 };
35692 
35693 
35694 
35696 class HPS_API ApplicationWindowKey : public WindowKey
35697 {
35698 public:
35701 
35706  ApplicationWindowKey(Key const & in_key);
35707 
35710  ApplicationWindowKey(ApplicationWindowKey const & in_that);
35711 
35716 
35720  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
35721 
35723 
35724  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowKey; };
35725 
35728  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
35729 
35732  ApplicationWindowOptionsControl GetWindowOptionsControl();
35733 
35737  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
35738 };
35739 
35743 
35744 
35745 
35747 class HPS_API GlyphElement : public Object
35748 {
35749 public:
35751  GlyphElement();
35752 
35755  GlyphElement(GlyphElement const & in_that);
35756 
35760  GlyphElement(GlyphElement && in_that);
35761 
35765  GlyphElement & operator=(GlyphElement && in_that);
35766 
35767  virtual ~GlyphElement();
35768 
35769  HPS::Type ObjectType() const { return HPS::Type::GlyphElement; };
35770 
35773  void Set(GlyphElement const & in_that);
35774 
35778  GlyphElement & operator=(GlyphElement const & in_that);
35779 
35783  bool Equals(GlyphElement const & in_that) const;
35784 
35788  bool operator==(GlyphElement const & in_that) const;
35789 
35793  bool operator!=(GlyphElement const & in_that) const;
35794 
35797  void SetFill(Glyph::Fill in_fill);
35798 
35801  void SetIndexedColor(byte in_index);
35802 
35804  void SetNormalColor();
35805 
35808  void SetExplicitColor(RGBAColor const & in_color);
35809 
35813  bool ShowFill(Glyph::Fill & out_fill) const;
35814 
35820  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
35821 };
35822 
35823 
35825 class HPS_API LineGlyphElement : public GlyphElement
35826 {
35827 public:
35829  LineGlyphElement();
35830 
35835  LineGlyphElement(GlyphElement const & in_that);
35836 
35839  LineGlyphElement(LineGlyphElement const & in_that);
35840 
35843  explicit LineGlyphElement(GlyphPointArray const & in_points);
35844 
35848  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
35849 
35853  LineGlyphElement(LineGlyphElement && in_that);
35854 
35858  LineGlyphElement & operator=(LineGlyphElement && in_that);
35859 
35860  ~LineGlyphElement();
35861 
35862  HPS::Type ObjectType() const { return HPS::Type::LineGlyphElement; };
35863 
35866  void SetPoints(GlyphPointArray const & in_points);
35867 
35871  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
35872 
35876  bool ShowPoints(GlyphPointArray & out_points) const;
35877 };
35878 
35880 class HPS_API DotGlyphElement : public GlyphElement
35881 {
35882 public:
35884  DotGlyphElement();
35885 
35890  DotGlyphElement(GlyphElement const & in_that);
35891 
35894  DotGlyphElement(DotGlyphElement const & in_that);
35895 
35898  explicit DotGlyphElement(GlyphPoint const & in_point);
35899 
35903  DotGlyphElement(DotGlyphElement && in_that);
35904 
35908  DotGlyphElement & operator=(DotGlyphElement && in_that);
35909 
35910  ~DotGlyphElement();
35911 
35912  HPS::Type ObjectType() const { return HPS::Type::DotGlyphElement; };
35913 
35916  void SetPoint(GlyphPoint const & in_point);
35917 
35921  bool ShowPoint(GlyphPoint & out_point) const;
35922 };
35923 
35924 
35926 class HPS_API EllipseGlyphElement : public GlyphElement
35927 {
35928 public:
35931 
35936  EllipseGlyphElement(GlyphElement const & in_that);
35937 
35940  EllipseGlyphElement(EllipseGlyphElement const & in_that);
35941 
35945  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35946 
35951 
35955  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
35956 
35958 
35959  HPS::Type ObjectType() const { return HPS::Type::EllipseGlyphElement; };
35960 
35963  void SetLowerLeft(GlyphPoint const & in_point);
35964 
35967  void SetUpperRight(GlyphPoint const & in_point);
35968 
35972  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35973 
35977  bool ShowLowerLeft(GlyphPoint & out_point) const;
35978 
35982  bool ShowUpperRight(GlyphPoint & out_point) const;
35983 };
35984 
35986 class HPS_API SphereGlyphElement : public GlyphElement
35987 {
35988 public:
35991 
35996  SphereGlyphElement(GlyphElement const & in_that);
35997 
36000  SphereGlyphElement(SphereGlyphElement const & in_that);
36001 
36006 
36010  SphereGlyphElement & operator=(SphereGlyphElement && in_that);
36011 
36012  ~SphereGlyphElement();
36013 
36014  HPS::Type ObjectType() const { return HPS::Type::SphereGlyphElement; };
36015 };
36016 
36017 
36020 {
36021 public:
36024 
36029  CircularArcGlyphElement(GlyphElement const & in_that);
36030 
36034 
36039  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
36040 
36045 
36049  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
36050 
36052 
36053  HPS::Type ObjectType() const { return HPS::Type::CircularArcGlyphElement; };
36054 
36057  void SetStartPoint(GlyphPoint const & in_point);
36058 
36061  void SetIntermediatePoint(GlyphPoint const & in_point);
36062 
36065  void SetEndPoint(GlyphPoint const & in_point);
36066 
36071  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
36072 
36076  bool ShowStartPoint(GlyphPoint & out_point) const;
36077 
36081  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
36082 
36086  bool ShowEndPoint(GlyphPoint & out_point) const;
36087 };
36088 
36089 
36090 
36093 {
36094 public:
36097 
36102  InfiniteLineGlyphElement(GlyphElement const & in_that);
36103 
36107 
36112  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
36113 
36118 
36122  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
36123 
36125 
36126  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineGlyphElement; };
36127 
36130  void SetFirstPoint(GlyphPoint const & in_point);
36131 
36134  void SetSecondPoint(GlyphPoint const & in_point);
36135 
36139  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
36140 
36143  void SetInfiniteType(InfiniteLine::Type in_type);
36144 
36148  bool ShowFirstPoint(GlyphPoint & out_point) const;
36149 
36153  bool ShowSecondPoint(GlyphPoint & out_point) const;
36154 
36158  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
36159 };
36160 
36161 
36162 
36164 class HPS_API GlyphKit : public Object
36165 {
36166 public:
36168  GlyphKit();
36169 
36172  GlyphKit(GlyphKit const & in_kit);
36173 
36177  GlyphKit(GlyphKit && in_that);
36178 
36182  GlyphKit & operator=(GlyphKit && in_that);
36183 
36184  virtual ~GlyphKit();
36185 
36186  HPS::Type ObjectType() const { return HPS::Type::GlyphKit; };
36187 
36191  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
36192 
36195  void Set(GlyphKit const & in_kit);
36196 
36199  void Show(GlyphKit & out_kit) const;
36200 
36204  GlyphKit & operator=(GlyphKit const & in_kit);
36205 
36208  bool Empty() const;
36209 
36213  bool Equals(GlyphKit const & in_kit) const;
36214 
36218  bool operator==(GlyphKit const & in_kit) const;
36219 
36223  bool operator!=(GlyphKit const & in_kit) const;
36224 
36228  GlyphKit & SetRadius(sbyte in_radius);
36229 
36234  GlyphKit & SetOffset(GlyphPoint const & in_point);
36235 
36239  GlyphKit & SetElements(GlyphElementArray const & in_def);
36240 
36245  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
36246 
36250  GlyphKit & SetElement(GlyphElement const & in_element);
36251 
36254  GlyphKit & UnsetRadius();
36255 
36258  GlyphKit & UnsetOffset();
36259 
36262  GlyphKit & UnsetElements();
36263 
36266  GlyphKit & UnsetEverything();
36267 
36271  bool ShowRadius(sbyte & out_radius) const;
36272 
36276  bool ShowOffset(GlyphPoint & out_point) const;
36277 
36281  bool ShowElements(GlyphElementArray & out_def) const;
36282 };
36283 
36287 
36288 
36291 class HPS_API LinePatternOptionsKit : public Object
36292 {
36293 public:
36296 
36300 
36305 
36309  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
36310 
36311  virtual ~LinePatternOptionsKit();
36312 
36313  HPS::Type ObjectType() const { return HPS::Type::LinePatternOptionsKit; };
36314 
36317  void Set(LinePatternOptionsKit const & in_kit);
36318 
36321  void Show(LinePatternOptionsKit & out_kit) const;
36322 
36326  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
36327 
36330  bool Empty() const;
36331 
36335  bool Equals(LinePatternOptionsKit const & in_kit) const;
36336 
36340  bool operator==(LinePatternOptionsKit const & in_kit) const;
36341 
36345  bool operator!=(LinePatternOptionsKit const & in_kit) const;
36346 
36350  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
36351 
36355  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
36356 
36360  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
36361 
36365  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
36366 
36370  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
36371 
36375  LinePatternOptionsKit & SetJoin(char const * in_glyph);
36376 
36380  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
36381 
36385  LinePatternOptionsKit & UnsetStartCap();
36386 
36390  LinePatternOptionsKit & UnsetEndCap();
36391 
36394  LinePatternOptionsKit & UnsetInnerCap();
36395 
36399  LinePatternOptionsKit & UnsetJoin();
36400 
36403  LinePatternOptionsKit & UnsetEverything();
36404 
36410  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
36411 
36417  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
36418 
36422  bool ShowInnerCap(LinePattern::Cap & out_type) const;
36423 
36429  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
36430 };
36431 
36434 class HPS_API LinePatternElement : public Object
36435 {
36436 public:
36439 
36442  LinePatternElement(LinePatternElement const & in_that);
36443 
36448 
36452  LinePatternElement & operator=(LinePatternElement && in_that);
36453 
36454  ~LinePatternElement();
36455 
36456  HPS::Type ObjectType() const { return HPS::Type::LinePatternElement; };
36457 
36460  void Set(LinePatternElement const & in_that);
36461 
36465  LinePatternElement & operator=(LinePatternElement const & in_that);
36466 
36470  bool Equals(LinePatternElement const & in_that) const;
36471 
36475  bool operator==(LinePatternElement const & in_that) const;
36476 
36480  bool operator!=(LinePatternElement const & in_that) const;
36481 
36485  void SetSize(float in_size, LinePattern::SizeUnits in_units);
36486 
36491  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
36492 };
36493 
36496 {
36497 public:
36500 
36506 
36510 
36514  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
36515 
36520 
36524  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
36525 
36527 
36528  HPS::Type ObjectType() const { return HPS::Type::SolidLinePatternElement; };
36529 
36533  void SetColor(RGBAColor const & in_color);
36534 
36538  void SetMaterialByIndex(float in_material_index);
36539 
36545  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
36546 };
36547 
36548 
36551 {
36552 public:
36555 
36561 
36565 
36569  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
36570 
36575 
36579  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
36580 
36582 
36583  HPS::Type ObjectType() const { return HPS::Type::BlankLinePatternElement; };
36584 };
36585 
36586 
36589 {
36590 public:
36593 
36599 
36603 
36607  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
36608 
36613 
36617  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
36618 
36620 
36621  HPS::Type ObjectType() const { return HPS::Type::GlyphLinePatternElement; };
36622 
36625  void SetSource(char const * in_source);
36626 
36630  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
36631 
36634  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
36635 
36638  void SetMirror(bool in_state);
36639 
36642  void SetFixed(bool in_state);
36643 
36646  void SetRotation(float in_degrees);
36647 
36651  bool ShowSource(UTF8 & out_source) const;
36652 
36657  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
36658 
36662  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
36663 
36667  bool ShowMirror(bool & out_state) const;
36668 
36672  bool ShowFixed(bool & out_state) const;
36673 
36677  bool ShowRotation(float & out_degrees) const;
36678 };
36679 
36681 class HPS_API LinePatternParallelKit : public Object
36682 {
36683 public:
36686 
36690 
36695 
36699  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
36700 
36701  virtual ~LinePatternParallelKit();
36702 
36703  HPS::Type ObjectType() const { return HPS::Type::LinePatternParallelKit; };
36704 
36707  void Set(LinePatternParallelKit const & in_kit);
36708 
36711  void Show(LinePatternParallelKit & out_kit) const;
36712 
36716  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
36717 
36720  bool Empty() const;
36721 
36725  bool Equals(LinePatternParallelKit const & in_kit) const;
36726 
36730  bool operator==(LinePatternParallelKit const & in_kit) const;
36731 
36735  bool operator!=(LinePatternParallelKit const & in_kit) const;
36736 
36740  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
36741 
36745  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
36746 
36750  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
36751 
36755  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
36756 
36761  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
36762 
36766  LinePatternParallelKit & SetBody(LinePatternElement const & in_element);
36767 
36771  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
36772 
36776  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
36777 
36781  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
36782 
36789  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
36790 
36796  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
36797 
36801  LinePatternParallelKit & SetContinuous(bool in_state);
36802 
36805  LinePatternParallelKit & UnsetStartCap();
36806 
36809  LinePatternParallelKit & UnsetEndCap();
36810 
36813  LinePatternParallelKit & UnsetJoin();
36814 
36817  LinePatternParallelKit & UnsetBody();
36818 
36821  LinePatternParallelKit & UnsetAbsoluteLength();
36822 
36825  LinePatternParallelKit & UnsetAbsoluteWeight();
36826 
36829  LinePatternParallelKit & UnsetJustification();
36830 
36833  LinePatternParallelKit & UnsetOffset();
36834 
36837  LinePatternParallelKit & UnsetWeight();
36838 
36841  LinePatternParallelKit & UnsetContinuous();
36842 
36845  LinePatternParallelKit & UnsetEverything();
36846 
36850  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
36851 
36855  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
36856 
36860  bool ShowJoin(GlyphLinePatternElement & out_join) const;
36861 
36865  bool ShowBody(LinePatternElementArray & out_elements) const;
36866 
36870  bool ShowAbsoluteLength(bool & out_state) const;
36871 
36875  bool ShowAbsoluteWeight(bool & out_state) const;
36876 
36880  bool ShowJustification(LinePattern::Justification & out_type) const;
36881 
36887  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36888 
36894  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36895 
36899  bool ShowContinuous(bool & out_state) const;
36900 };
36901 
36902 
36904 class HPS_API LinePatternKit : public Object
36905 {
36906 public:
36908  LinePatternKit();
36909 
36912  LinePatternKit(LinePatternKit const & in_kit);
36913 
36917  LinePatternKit(LinePatternKit && in_that);
36918 
36922  LinePatternKit & operator=(LinePatternKit && in_that);
36923 
36924  virtual ~LinePatternKit();
36925 
36926  HPS::Type ObjectType() const { return HPS::Type::LinePatternKit; };
36927 
36931  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
36932 
36935  void Set(LinePatternKit const & in_kit);
36936 
36939  void Show(LinePatternKit & out_kit) const;
36940 
36944  LinePatternKit & operator=(LinePatternKit const & in_kit);
36945 
36948  bool Empty() const;
36949 
36953  bool Equals(LinePatternKit const & in_kit) const;
36954 
36958  bool operator==(LinePatternKit const & in_kit) const;
36959 
36963  bool operator!=(LinePatternKit const & in_kit) const;
36964 
36968  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
36969 
36974  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
36975 
36979  LinePatternKit & SetParallel(LinePatternParallelKit const & in_parallel);
36980 
36984  LinePatternKit & SetJoin(LinePattern::Join in_type);
36985 
36988  LinePatternKit & UnsetParallels();
36989 
36992  LinePatternKit & UnsetJoin();
36993 
36996  LinePatternKit & UnsetEverything();
36997 
37001  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
37002 
37006  bool ShowJoin(LinePattern::Join & out_type) const;
37007 };
37008 
37009 
37010 
37014 
37015 
37017 class HPS_API Definition : public Object
37018 {
37019 public:
37021  Definition();
37022 
37025  Definition(Definition const & in_that);
37026 
37030  Definition & operator=(Definition const & in_that);
37031 
37035  Definition(Definition && in_that);
37036 
37040  Definition & operator=(Definition && in_that);
37041 
37042  virtual ~Definition();
37043 
37044  HPS::Type ObjectType() const { return HPS::Type::Definition; };
37045 
37047  void Undefine();
37048 
37051  PortfolioKey Owner() const;
37052 
37055  UTF8 Name() const;
37056 
37059  virtual void Assign(Definition const & in_that);
37060 
37064  bool Equals(Definition const & in_that) const;
37065 
37069  bool operator==(Definition const & in_that) const;
37070 
37074  bool operator!=(Definition const & in_that) const;
37075 };
37076 
37077 
37080 class HPS_API PortfolioKey : public Key
37081 {
37082 public:
37084  PortfolioKey();
37085 
37090  explicit PortfolioKey(Key const & in_that);
37091 
37094  PortfolioKey(PortfolioKey const & in_that);
37095 
37099  PortfolioKey & operator=(PortfolioKey const & in_that);
37100 
37104  PortfolioKey(PortfolioKey && in_that);
37105 
37109  PortfolioKey & operator=(PortfolioKey && in_that);
37110 
37111  ~PortfolioKey();
37112 
37113  HPS::Type ObjectType() const { return HPS::Type::PortfolioKey; };
37114 
37115  // Define
37116 
37123  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
37124 
37132  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
37133 
37134 
37146  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
37147  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
37148  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
37149 
37162  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
37163  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
37164  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
37165 
37166 
37172  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
37173 
37174 
37180  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
37181 
37182 
37188  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
37189 
37196  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
37197 
37198 
37204  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
37205 
37206 
37212  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
37213 
37214 
37220  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
37221 
37222 
37223  // UnDefine
37224 
37228  PortfolioKey & UndefineTexture(char const * in_name);
37229 
37233  PortfolioKey & UndefineCubeMap(char const * in_name);
37234 
37238  PortfolioKey & UndefineImage(char const * in_name);
37239 
37243  PortfolioKey & UndefineNamedStyle(char const * in_name);
37244 
37248  PortfolioKey & UndefineMaterialPalette(char const * in_name);
37249 
37253  PortfolioKey & UndefineGlyph(char const * in_name);
37254 
37258  PortfolioKey & UndefineLinePattern(char const * in_name);
37259 
37263  PortfolioKey & UndefineShader(char const * in_name);
37264 
37265 
37266  // Import collections
37272  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37273 
37274 
37280  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37281 
37287  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37288 
37294  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37295 
37301  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37302 
37308  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37309 
37315  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37316 
37322  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37323 
37329  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
37330 
37331 
37332  // Import individual definitions
37336  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
37337 
37341  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
37342 
37346  ImageDefinition ImportImage(ImageDefinition const & in_definition);
37347 
37351  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
37352 
37356  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
37357 
37361  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
37362 
37366  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
37367 
37371  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
37372 
37373 
37374  // Show
37376  size_t GetDefinitionCount() const;
37377 
37379  size_t GetTextureDefinitionCount() const;
37380 
37382  size_t GetCubeMapDefinitionCount() const;
37383 
37385  size_t GetImageDefinitionCount() const;
37386 
37388  size_t GetNamedStyleDefinitionCount() const;
37389 
37391  size_t GetMaterialPaletteDefinitionCount() const;
37392 
37394  size_t GetGlyphDefinitionCount() const;
37395 
37397  size_t GetLinePatternDefinitionCount() const;
37398 
37401  size_t GetShaderDefinitionCount() const;
37402 
37406  bool ShowTextureDefinition(char const * in_name) const;
37407 
37412  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
37413 
37417  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
37418 
37422  bool ShowCubeMapDefinition(char const * in_name) const;
37423 
37428  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
37429 
37433  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
37434 
37438  bool ShowImageDefinition(char const * in_name) const;
37439 
37444  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
37445 
37449  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
37450 
37454  bool ShowNamedStyleDefinition(char const * in_name) const;
37455 
37460  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
37461 
37465  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
37466 
37470  bool ShowMaterialPaletteDefinition(char const * in_name) const;
37471 
37476  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
37477 
37481  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
37482 
37486  bool ShowGlyphDefinition(char const * in_name) const;
37487 
37492  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
37493 
37497  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
37498 
37502  bool ShowLinePatternDefinition(char const * in_name) const;
37503 
37508  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
37509 
37513  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
37514 
37518  bool ShowShaderDefinition(char const * in_name) const;
37519 
37524  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
37525 
37529  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
37530 
37531 private:
37533  void MoveTo(SegmentKey const & in_new_owner);
37534 
37536  Key CopyTo(SegmentKey const & in_destination) const;
37537 };
37538 
37539 
37540 
37542 class HPS_API GlyphDefinition : public Definition
37543 {
37544 public:
37546  GlyphDefinition();
37547 
37552  GlyphDefinition(Definition const & in_that);
37553 
37556  GlyphDefinition(GlyphDefinition const & in_that);
37557 
37561  GlyphDefinition & operator=(GlyphDefinition const & in_that);
37562 
37566  GlyphDefinition(GlyphDefinition && in_that);
37567 
37571  GlyphDefinition & operator=(GlyphDefinition && in_that);
37572 
37573  ~GlyphDefinition();
37574 
37575  HPS::Type ObjectType() const { return HPS::Type::GlyphDefinition; };
37576 
37579  void Set(GlyphKit const & in_kit);
37580 
37583  void Show(GlyphKit & out_kit) const;
37584 };
37585 
37586 
37588 class HPS_API TextureDefinition : public Definition
37589 {
37590 public:
37593 
37598  TextureDefinition(Definition const & in_that);
37599 
37602  TextureDefinition(TextureDefinition const & in_that);
37603 
37607  TextureDefinition & operator=(TextureDefinition const & in_that);
37608 
37613 
37617  TextureDefinition & operator=(TextureDefinition && in_that);
37618 
37619  ~TextureDefinition();
37620 
37621  HPS::Type ObjectType() const { return HPS::Type::TextureDefinition; };
37622 
37625  void SetSource(ImageDefinition const & in_source);
37626 
37629  void ShowSource(ImageDefinition & out_source) const;
37630 
37633  void SetOptions(TextureOptionsKit const & in_options);
37634 
37637  void ShowOptions(TextureOptionsKit & out_options) const;
37638 
37639 };
37640 
37644 class HPS_API TextureOptionsKit : public Object
37645 {
37646 public:
37649 
37652  TextureOptionsKit(TextureOptionsKit const & in_kit);
37653 
37658 
37662  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
37663 
37664  virtual ~TextureOptionsKit();
37665 
37666  HPS::Type ObjectType() const { return HPS::Type::TextureOptionsKit; };
37667 
37671  static TextureOptionsKit GetDefault();
37672 
37675  void Set(TextureOptionsKit const & in_kit);
37676 
37679  void Show(TextureOptionsKit & out_kit) const;
37680 
37684  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
37685 
37688  bool Empty() const;
37689 
37693  bool Equals(TextureOptionsKit const & in_kit) const;
37694 
37698  bool operator==(TextureOptionsKit const & in_kit) const;
37699 
37703  bool operator!=(TextureOptionsKit const & in_kit) const;
37704 
37709  TextureOptionsKit & SetDecal(bool in_state);
37710 
37714  TextureOptionsKit & SetDownSampling(bool in_state);
37715 
37719  TextureOptionsKit & SetModulation(bool in_state);
37720 
37724  TextureOptionsKit & SetParameterOffset(size_t in_offset);
37725 
37729  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
37730 
37734  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
37735 
37739  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
37740 
37744  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
37745 
37749  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
37750 
37753  TextureOptionsKit & UnsetDecal();
37754 
37757  TextureOptionsKit & UnsetDownSampling();
37758 
37761  TextureOptionsKit & UnsetModulation();
37762 
37765  TextureOptionsKit & UnsetParameterOffset();
37766 
37769  TextureOptionsKit & UnsetParameterizationSource();
37770 
37773  TextureOptionsKit & UnsetTiling();
37774 
37777  TextureOptionsKit & UnsetInterpolationFilter();
37778 
37781  TextureOptionsKit & UnsetDecimationFilter();
37782 
37785  TextureOptionsKit & UnsetTransformMatrix();
37786 
37789  TextureOptionsKit & UnsetEverything();
37790 
37794  bool ShowDecal(bool & out_state) const;
37795 
37799  bool ShowDownSampling(bool & out_state) const;
37800 
37804  bool ShowModulation(bool & out_state) const;
37805 
37809  bool ShowParameterOffset(size_t & out_offset) const;
37810 
37814  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
37815 
37819  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
37820 
37824  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
37825 
37829  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
37830 
37834  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37835 };
37836 
37837 
37839 class HPS_API Image
37840 {
37841 public:
37844  enum class Format
37845  {
37846  RGB,
37847  RGBA,
37848  ARGB,
37849  Mapped8,
37850  Grayscale,
37851  Bmp,
37852  Jpeg,
37853  Png,
37854  Targa,
37855  DXT1,
37856  DXT3,
37857  DXT5
37858  };
37859 
37861  class HPS_API ExportOptionsKit : public Object
37862  {
37863  public:
37865  ExportOptionsKit();
37866 
37869  ExportOptionsKit(ExportOptionsKit const & in_kit);
37870 
37874  ExportOptionsKit(ExportOptionsKit && in_that);
37875 
37879  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
37880 
37881  virtual ~ExportOptionsKit();
37882 
37883  HPS::Type ObjectType() const { return HPS::Type::ImageExportOptionsKit; };
37884 
37888  static ExportOptionsKit GetDefault();
37889 
37892  void Set(ExportOptionsKit const & in_kit);
37893 
37896  void Show(ExportOptionsKit & out_kit) const;
37897 
37901  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
37902 
37905  bool Empty() const;
37906 
37910  bool Equals(ExportOptionsKit const & in_kit) const;
37911 
37915  bool operator==(ExportOptionsKit const & in_kit) const;
37916 
37920  bool operator!=(ExportOptionsKit const & in_kit) const;
37921 
37926  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37927 
37932  ExportOptionsKit & SetFormat(Image::Format in_format);
37933 
37936  ExportOptionsKit & UnsetSize();
37937 
37940  ExportOptionsKit & UnsetFormat();
37941 
37944  ExportOptionsKit & UnsetEverything();
37945 
37950  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37951 
37955  bool ShowFormat(Image::Format & out_format) const;
37956  };
37957 
37959  class HPS_API ImportOptionsKit : public Object
37960  {
37961  public:
37963  ImportOptionsKit();
37964 
37967  ImportOptionsKit(ImportOptionsKit const & in_kit);
37968 
37972  ImportOptionsKit(ImportOptionsKit && in_that);
37973 
37977  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37978 
37979  virtual ~ImportOptionsKit();
37980 
37981  HPS::Type ObjectType() const { return HPS::Type::ImageImportOptionsKit; };
37982 
37985  void Set(ImportOptionsKit const & in_kit);
37986 
37989  void Show(ImportOptionsKit & out_kit) const;
37990 
37994  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37995 
37998  bool Empty() const;
37999 
38003  bool Equals(ImportOptionsKit const & in_kit) const;
38004 
38008  bool operator==(ImportOptionsKit const & in_kit) const;
38009 
38013  bool operator!=(ImportOptionsKit const & in_kit) const;
38014 
38021  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
38022 
38026  ImportOptionsKit & SetFormat(Image::Format in_format);
38027 
38032  ImportOptionsKit & SetDownSampling(bool in_state);
38033 
38038  ImportOptionsKit & SetCompressionQuality(float in_quality);
38039 
38042  ImportOptionsKit & UnsetSize();
38043 
38046  ImportOptionsKit & UnsetFormat();
38047 
38050  ImportOptionsKit & UnsetDownSampling();
38051 
38054  ImportOptionsKit & UnsetCompressionQuality();
38055 
38058  ImportOptionsKit & UnsetEverything();
38059 
38064  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
38065 
38069  bool ShowFormat(Image::Format & out_format) const;
38070 
38074  bool ShowDownSampling(bool & out_state) const;
38075 
38079  bool ShowCompressionQuality(float & out_quality) const;
38080  };
38081 
38083  class HPS_API File
38084  {
38085  public:
38091  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
38092 
38099  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
38100 
38108  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);
38109 
38114  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
38115 
38116  private:
38118  File();
38119  };
38120 
38121 private:
38123  Image();
38124 };
38125 
38126 
38128 class HPS_API ImageKit : public Object
38129 {
38130 public:
38132  ImageKit();
38133 
38136  ImageKit(ImageKit const & in_kit);
38137 
38142  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
38143 
38147  ImageKit(ImageKit && in_that);
38148 
38152  ImageKit & operator=(ImageKit && in_that);
38153 
38154  virtual ~ImageKit();
38155 
38156  HPS::Type ObjectType() const { return HPS::Type::ImageKit; };
38157 
38160  void Set(ImageKit const & in_kit);
38161 
38164  void Show(ImageKit & out_kit) const;
38165 
38169  ImageKit & operator=(ImageKit const & in_kit);
38170 
38173  bool Empty() const;
38174 
38178  bool Equals(ImageKit const & in_kit) const;
38179 
38183  bool operator==(ImageKit const & in_kit) const;
38184 
38188  bool operator!=(ImageKit const & in_kit) const;
38189 
38193  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
38194 
38197  void Convert(HPS::Image::Format in_format);
38198 
38203  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
38204 
38208  ImageKit & SetData(ByteArray const & in_image_data);
38209 
38214  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
38215 
38219  ImageKit & SetFormat(Image::Format in_format);
38220 
38224  ImageKit & SetDownSampling(bool in_state);
38225 
38229  ImageKit & SetCompressionQuality(float in_quality);
38230 
38233  ImageKit & UnsetSize();
38234 
38237  ImageKit & UnsetData();
38238 
38241  ImageKit & UnsetFormat();
38242 
38245  ImageKit & UnsetDownSampling();
38246 
38249  ImageKit & UnsetCompressionQuality();
38250 
38253  ImageKit & UnsetEverything();
38254 
38259  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
38260 
38264  bool ShowData(ByteArray & out_image_data) const;
38265 
38269  bool ShowFormat(Image::Format & out_format) const;
38270 
38274  bool ShowDownSampling(bool & out_state) const;
38275 
38279  bool ShowCompressionQuality(float & out_quality) const;
38280 };
38281 
38282 
38288 {
38289 public:
38293 
38298 
38303 
38308 
38310 
38311  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsControl; };
38312 
38316  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
38317 
38322  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
38323 
38328  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
38329 
38333  bool ShowDriver(Window::Driver & out_driver) const;
38334 
38339  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
38340 
38345  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
38346 
38351  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
38352 
38357  bool ShowImage(ByteArray & out_bytes) const;
38358 
38362  bool ShowHardwareResident(bool & out_state) const;
38363 
38368  bool ShowOpacity(bool & out_state, float & out_opacity) const;
38369 
38374  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
38375 
38376 
38377 private:
38380 };
38381 
38382 
38385 class HPS_API OffScreenWindowKey : public WindowKey
38386 {
38387 public:
38390 
38395  OffScreenWindowKey(Key const & in_key);
38396 
38399  OffScreenWindowKey(OffScreenWindowKey const & in_that);
38400 
38405 
38409  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
38410 
38411  ~OffScreenWindowKey();
38412 
38413  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowKey; };
38414 
38417  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
38418 
38421  OffScreenWindowOptionsControl GetWindowOptionsControl();
38422 
38426  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
38427 };
38428 
38429 
38430 
38431 
38433 class HPS_API ImageDefinition : public Definition
38434 {
38435 public:
38437  ImageDefinition();
38438 
38443  ImageDefinition(Definition const & in_that);
38444 
38447  ImageDefinition(ImageDefinition const & in_that);
38448 
38452  ImageDefinition & operator=(ImageDefinition const & in_that);
38453 
38457  ImageDefinition(ImageDefinition && in_that);
38458 
38462  ImageDefinition & operator=(ImageDefinition && in_that);
38463 
38464  ~ImageDefinition();
38465 
38466  HPS::Type ObjectType() const { return HPS::Type::ImageDefinition; };
38467 
38470  void Set(ImageKit const & in_kit);
38471 
38474  void Show(ImageKit & out_kit) const;
38475 };
38476 
38478 class HPS_API CubeMapDefinition : public Definition
38479 {
38480 public:
38483 
38488  CubeMapDefinition(Definition const & in_that);
38489 
38492  CubeMapDefinition(CubeMapDefinition const & in_that);
38493 
38497  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
38498 
38503 
38507  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
38508 
38509  ~CubeMapDefinition();
38510 
38511  HPS::Type ObjectType() const { return HPS::Type::CubeMapDefinition; };
38512 
38520  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
38521  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
38522  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
38523 
38531  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
38532  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
38533  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
38534 
38538  void ShowSource(ImageDefinitionArray & out_image_sources) const;
38539 
38542  void SetOptions(TextureOptionsKit const & in_options);
38543 
38546  void ShowOptions(TextureOptionsKit & out_options) const;
38547 };
38548 
38549 
38551 class HPS_API NamedStyleDefinition : public Definition
38552 {
38553 public:
38556 
38561  NamedStyleDefinition(Definition const & in_that);
38562 
38565  NamedStyleDefinition(NamedStyleDefinition const & in_that);
38566 
38570  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
38571 
38576 
38580  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
38581 
38583 
38584  HPS::Type ObjectType() const { return HPS::Type::NamedStyleDefinition; };
38585 
38589  SegmentKey GetSource() const;
38590 };
38591 
38592 
38595 {
38596 public:
38599 
38604  MaterialPaletteDefinition(Definition const & in_that);
38605 
38609 
38613  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
38614 
38619 
38623  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
38624 
38626 
38627  HPS::Type ObjectType() const { return HPS::Type::MaterialPaletteDefinition; };
38628 
38631  void Set(MaterialKitArray const & in_source);
38632 
38636  void Set(size_t in_count, MaterialKit const in_source []);
38637 
38640  void Show(MaterialKitArray & out_source) const;
38641 };
38642 
38643 
38644 
38646 class HPS_API LinePatternDefinition : public Definition
38647 {
38648 public:
38651 
38656  LinePatternDefinition(Definition const & in_that);
38657 
38661 
38665  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
38666 
38671 
38675  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
38676 
38678 
38679  HPS::Type ObjectType() const { return HPS::Type::LinePatternDefinition; };
38680 
38683  void Set(LinePatternKit const & in_kit);
38684 
38687  void Show(LinePatternKit & out_kit) const;
38688 };
38689 
38690 
38691 
38693 class HPS_API Shader
38694 {
38695 public:
38698  enum class Parameterization
38699  {
38701  Cylinder,
38703  PhysicalReflection,
38705  Object,
38711  NaturalUV,
38713  ReflectionVector,
38715  SurfaceNormal,
38717  Sphere,
38719  UV,
38721  World
38722  };
38723 
38725  class HPS_API ImportOptionsKit : public Object
38726  {
38727  public:
38729  ImportOptionsKit();
38730 
38733  ImportOptionsKit(ImportOptionsKit const & in_kit);
38734 
38738  ImportOptionsKit(ImportOptionsKit && in_that);
38739 
38743  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38744 
38745  virtual ~ImportOptionsKit();
38746 
38747  HPS::Type ObjectType() const { return HPS::Type::ShaderImportOptionsKit; };
38748 
38751  void Set(ImportOptionsKit const & in_kit);
38752 
38755  void Show(ImportOptionsKit & out_kit) const;
38756 
38760  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
38761 
38764  bool Empty() const;
38765 
38769  bool Equals(ImportOptionsKit const & in_kit) const;
38770 
38774  bool operator==(ImportOptionsKit const & in_kit) const;
38775 
38779  bool operator!=(ImportOptionsKit const & in_kit) const;
38780 
38787  ImportOptionsKit & SetMultitexture(bool in_state);
38788 
38792  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38793 
38797  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
38798 
38802  ImportOptionsKit & UnsetMultitexture();
38803 
38806  ImportOptionsKit & UnsetParameterizationSource();
38807 
38810  ImportOptionsKit & UnsetTransformMatrix();
38811 
38814  ImportOptionsKit & UnsetEverything();
38815 
38821  bool ShowMultitexture(bool & out_state) const;
38822 
38826  bool ShowParameterizationSource(Parameterization & out_source) const;
38827 
38831  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38832  };
38833 
38835  class HPS_API File
38836  {
38837  public:
38843  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
38844 
38845  private:
38847  File();
38848  };
38849 
38850 private:
38852  Shader();
38853 };
38854 
38855 
38857 class HPS_API ShaderKit : public Object
38858 {
38859 public:
38861  ShaderKit();
38862 
38865  ShaderKit(ShaderKit const & in_kit);
38866 
38870  ShaderKit(ShaderKit && in_that);
38871 
38875  ShaderKit & operator=(ShaderKit && in_that);
38876 
38877  virtual ~ShaderKit();
38878 
38879  HPS::Type ObjectType() const { return HPS::Type::ShaderKit; };
38880 
38883  void Set(ShaderKit const & in_kit);
38884 
38887  void Show(ShaderKit & out_kit) const;
38888 
38892  ShaderKit & operator=(ShaderKit const & in_kit);
38893 
38896  bool Empty() const;
38897 
38901  bool Equals(ShaderKit const & in_kit) const;
38902 
38906  bool operator==(ShaderKit const & in_kit) const;
38907 
38911  bool operator!=(ShaderKit const & in_kit) const;
38912 
38916  ShaderKit & SetSource(char const * in_source);
38917 
38924  ShaderKit & SetMultitexture(bool in_state);
38925 
38929  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38930 
38934  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
38935 
38938  ShaderKit & UnsetSource();
38939 
38943  ShaderKit & UnsetMultitexture();
38944 
38947  ShaderKit & UnsetParameterizationSource();
38948 
38951  ShaderKit & UnsetTransformMatrix();
38952 
38955  ShaderKit & UnsetEverything();
38956 
38960  bool ShowSource(UTF8 & out_source) const;
38961 
38967  bool ShowMultitexture(bool & out_state) const;
38968 
38972  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
38973 
38977  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38978 };
38979 
38980 
38982 class HPS_API ShaderDefinition : public Definition
38983 {
38984 public:
38986  ShaderDefinition();
38987 
38992  ShaderDefinition(Definition const & in_that);
38993 
38996  ShaderDefinition(ShaderDefinition const & in_that);
38997 
39001  ShaderDefinition & operator=(ShaderDefinition const & in_that);
39002 
39006  ShaderDefinition(ShaderDefinition && in_that);
39007 
39011  ShaderDefinition & operator=(ShaderDefinition && in_that);
39012 
39013  ~ShaderDefinition();
39014 
39015  HPS::Type ObjectType() const { return HPS::Type::ShaderDefinition; };
39016 
39019  void Set(ShaderKit const & in_kit);
39020 
39023  void Show(ShaderKit & out_kit) const;
39024 };
39025 
39026 
39027 
39028 
39032 
39034 {
39035 public:
39038 
39042 
39047 
39052 
39053  virtual ~CutGeometryGatheringOptionsKit();
39054 
39055  HPS::Type ObjectType() const {return HPS::Type::CutGeometryGatheringOptionsKit;};
39056 
39060  static CutGeometryGatheringOptionsKit GetDefault();
39061 
39064  void Set(CutGeometryGatheringOptionsKit const & in_kit);
39065 
39068  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
39069 
39074 
39077  bool Empty() const;
39078 
39082  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
39083 
39087  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
39088 
39092  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
39093 
39094 
39098  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
39099 
39103  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
39104 
39109 
39110 
39113  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
39114 
39117  CutGeometryGatheringOptionsKit & UnsetOffset();
39118 
39121  CutGeometryGatheringOptionsKit & UnsetLevel();
39122 
39125  CutGeometryGatheringOptionsKit & UnsetEverything();
39126 
39127 
39131  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
39132 
39136  bool ShowOffset(size_t & out_offset) const;
39137 
39141  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
39142 };
39143 
39145 class HPS_API SearchOptionsKit : public Object
39146 {
39147 public:
39149  SearchOptionsKit();
39150 
39153  SearchOptionsKit(SearchOptionsKit const & in_kit);
39154 
39158  SearchOptionsKit(SearchOptionsKit && in_that);
39159 
39163  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
39164 
39165  virtual ~SearchOptionsKit();
39166 
39167  HPS::Type ObjectType() const {return HPS::Type::SearchOptionsKit;};
39168 
39172  static SearchOptionsKit GetDefault();
39173 
39176  void Set(SearchOptionsKit const & in_kit);
39177 
39180  void Show(SearchOptionsKit & out_kit) const;
39181 
39185  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
39186 
39189  bool Empty() const;
39190 
39194  bool Equals(SearchOptionsKit const & in_kit) const;
39195 
39199  bool operator==(SearchOptionsKit const & in_kit) const;
39200 
39204  bool operator!=(SearchOptionsKit const & in_kit) const;
39205 
39209  SearchOptionsKit & SetCriteria(Search::Type in_request);
39210 
39214  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
39215 
39219  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
39220 
39225  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
39226 
39230  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
39231 
39234  SearchOptionsKit & UnsetBehavior();
39235 
39238  SearchOptionsKit & UnsetCriteria();
39239 
39242  SearchOptionsKit & UnsetSearchSpace();
39243 
39246  SearchOptionsKit & UnsetEverything();
39247 
39251  bool ShowBehavior(Search::Behavior & out_behavior) const;
39252 
39256  bool ShowCriteria(SearchTypeArray & out_types) const;
39257 
39261  bool ShowSearchSpace(Search::Space & out_search_space) const;
39262 };
39263 
39267 class HPS_API TreeContext : public Object
39268 {
39269 public:
39272  TreeContext(bool in_create = true);
39273 
39276  TreeContext(TreeContext const & in_that);
39277 
39281  TreeContext(TreeContext && in_that);
39282 
39286  TreeContext & operator=(TreeContext && in_that);
39287 
39289  virtual ~TreeContext();
39290 
39291  HPS::Type ObjectType() const {return HPS::Type::TreeContext;};
39292 
39296  TreeContext & operator=(TreeContext const & in_that);
39297 
39301  bool Equals(TreeContext const & in_that) const;
39302 
39306  bool operator==(TreeContext const & in_that) const;
39307 
39311  bool operator!=(TreeContext const & in_that) const;
39312 
39313 };
39314 
39316 class HPS_API SelectionOptionsKit : public Object
39317 {
39318 public:
39321 
39324  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
39325 
39330 
39334  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
39335 
39336  virtual ~SelectionOptionsKit();
39337 
39338  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsKit;};
39339 
39343  static SelectionOptionsKit GetDefault();
39344 
39347  void Set(SelectionOptionsKit const & in_kit);
39348 
39351  void Show(SelectionOptionsKit & out_kit) const;
39352 
39356  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
39357 
39360  bool Empty() const;
39361 
39365  bool Equals(SelectionOptionsKit const & in_kit) const;
39366 
39370  bool operator==(SelectionOptionsKit const & in_kit) const;
39371 
39375  bool operator!=(SelectionOptionsKit const & in_kit) const;
39376 
39404  SelectionOptionsKit & SetProximity(float in_proximity);
39405 
39411  SelectionOptionsKit & SetLevel(Selection::Level in_level);
39412 
39418  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
39419 
39429  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
39430 
39438  SelectionOptionsKit & SetSorting(bool in_sorted);
39439 
39445  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
39446 
39452  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
39453 
39458  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
39459 
39464  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
39465 
39470  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
39471 
39478  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
39479 
39486  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
39487 
39494  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
39495 
39502  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
39503 
39504  SelectionOptionsKit & SetSelectability(HPS::SelectabilityKit const & in_selectability);
39505 
39506  SelectionOptionsKit & UnsetSelectability();
39507 
39510  SelectionOptionsKit & UnsetProximity();
39511 
39514  SelectionOptionsKit & UnsetLevel();
39515 
39518  SelectionOptionsKit & UnsetInternalLimit();
39519 
39522  SelectionOptionsKit & UnsetRelatedLimit();
39523 
39526  SelectionOptionsKit & UnsetSorting();
39527 
39530  SelectionOptionsKit & UnsetAlgorithm();
39531 
39534  SelectionOptionsKit & UnsetGranularity();
39535 
39538  SelectionOptionsKit & UnsetScope();
39539 
39542  SelectionOptionsKit & UnsetTreeContext();
39543 
39546  SelectionOptionsKit & UnsetExtentCullingRespected();
39547 
39550  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
39551 
39554  SelectionOptionsKit & UnsetFrustumCullingRespected();
39555 
39558  SelectionOptionsKit & UnsetVectorCullingRespected();
39559 
39560 
39563  SelectionOptionsKit & UnsetEverything();
39564 
39568  bool ShowProximity(float & out_proximity) const;
39569 
39573  bool ShowLevel(Selection::Level & out_level) const;
39574 
39578  bool ShowInternalLimit(size_t & out_limit) const;
39579 
39583  bool ShowRelatedLimit(size_t & out_limit) const;
39584 
39588  bool ShowSorting(bool & out_sorted) const;
39589 
39593  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
39594 
39598  bool ShowGranularity(Selection::Granularity & out_granularity) const;
39599 
39603  bool ShowScope(KeyPath & out_start_path) const;
39604 
39608  bool ShowTreeContext(TreeContext & out_tree_context) const;
39609 
39613  bool ShowExtentCullingRespected(bool & out_state) const;
39614 
39618  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
39619 
39623  bool ShowFrustumCullingRespected(bool & out_state) const;
39624 
39628  bool ShowVectorCullingRespected(bool & out_state) const;
39629 
39630  bool ShowSelectability(HPS::SelectabilityKit & out_selectability) const;
39631 };
39632 
39633 
39634 
39638 class HPS_API SelectionOptionsControl : public Control
39639 {
39640 public:
39643  explicit SelectionOptionsControl(WindowKey const & in_window);
39644 
39648 
39653 
39657  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
39658 
39660 
39661  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsControl;};
39662 
39666  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
39667 
39695  SelectionOptionsControl & SetProximity(float in_proximity);
39696 
39702  SelectionOptionsControl & SetLevel(Selection::Level in_level);
39703 
39710  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
39711 
39720  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
39721 
39729  SelectionOptionsControl & SetSorting(bool in_sorted);
39730 
39736  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
39737 
39743  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
39744 
39751  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
39752 
39759  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
39760 
39767  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
39768 
39775  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
39776 
39777  // there is no way to unset default values, intentionally
39778 
39782  bool ShowProximity(float & out_proximity) const;
39783 
39787  bool ShowLevel(Selection::Level & out_level) const;
39788 
39792  bool ShowInternalLimit(size_t & out_limit) const;
39793 
39797  bool ShowRelatedLimit(size_t & out_limit) const;
39798 
39802  bool ShowSorting(bool & out_sorted) const;
39803 
39807  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
39808 
39812  bool ShowGranularity(Selection::Granularity & out_granularity) const;
39813 
39817  bool ShowExtentCullingRespected(bool & out_state) const;
39818 
39822  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
39823 
39827  bool ShowFrustumCullingRespected(bool & out_state) const;
39828 
39832  bool ShowVectorCullingRespected(bool & out_state) const;
39833 
39834 private:
39837 };
39838 
39839 
39840 
39842 class HPS_API SelectionItem : public Object
39843 {
39844 public:
39846  SelectionItem();
39847 
39850  SelectionItem(SelectionItem const & in_that);
39851 
39855  SelectionItem(SelectionItem && in_that);
39856 
39860  SelectionItem & operator=(SelectionItem && in_that);
39861 
39862  virtual ~SelectionItem();
39863 
39864  HPS::Type ObjectType() const {return HPS::Type::SelectionItem;};
39865 
39868  void Set(SelectionItem const & in_that);
39869 
39873  SelectionItem & operator=(SelectionItem const & in_that);
39874 
39878  bool Equals(SelectionItem const & in_that) const;
39879 
39883  bool operator==(SelectionItem const & in_that) const;
39884 
39888  bool operator!=(SelectionItem const & in_that) const;
39889 
39893  bool ShowSelectionLevel(Selection::Level & out_level) const;
39894 
39898  bool ShowSelectedItem(Key & out_selection) const;
39899 
39903  bool ShowPath(KeyPath & out_path) const;
39904 
39908  bool ShowFaces(SizeTArray & out_faces) const;
39909 
39913  bool ShowVertices(SizeTArray & out_vertices) const;
39914 
39919  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
39920 
39924  bool ShowCharacters(SizeTArray & out_characters) const;
39925 
39929  bool ShowSelectionPosition(WindowPoint & out_location) const;
39930 
39934  bool ShowSelectionPosition(WorldPoint & out_location) const;
39935 
39939  bool ShowNormalizedSelectionPosition(WindowPoint & out_location) const;
39940 
39941 };
39942 
39944 class HPS_API SelectionResultsIterator : public Object
39945 {
39946 public:
39949 
39954 
39959 
39963  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
39964 
39966 
39967  HPS::Type ObjectType() const {return HPS::Type::SelectionResultsIterator;}
39968 
39972  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
39973 
39976  void Set(SelectionResultsIterator const & in_that);
39977 
39979  void Next();
39980 
39983  SelectionResultsIterator & operator++();
39984 
39987  SelectionResultsIterator operator++(int in_val);
39988 
39991  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
39992 
39995  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
39996 
39997 
40000  bool IsValid() const;
40001 
40003  void Reset();
40004 
40007  SelectionItem GetItem() const;
40008 
40011  SelectionItem operator*() const;
40012 
40013 
40014 };
40015 
40019 class HPS_API SelectionResults : public Object
40020 {
40021 public:
40023  SelectionResults();
40024 
40027  SelectionResults(SelectionResults const & in_that);
40028 
40032  SelectionResults(SelectionResults && in_that);
40033 
40037  SelectionResults & operator=(SelectionResults && in_that);
40038 
40039  ~SelectionResults();
40040 
40041  HPS::Type ObjectType() const {return HPS::Type::SelectionResults;}
40042 
40045  void Assign(SelectionResults const & in_that);
40046 
40050  SelectionResults & operator=(SelectionResults const & in_that);
40051 
40055  bool Equals(SelectionResults const & in_that) const;
40056 
40060  bool operator==(SelectionResults const & in_that) const;
40061 
40065  bool operator!=(SelectionResults const & in_that) const;
40066 
40068  virtual void Reset();
40069 
40072  Selection::Level GetSelectionLevel() const;
40073 
40076  size_t GetCount() const;
40077 
40080  SelectionResultsIterator GetIterator() const;
40081 
40087  bool Union(SelectionResults const & in_that);
40088 
40093  bool Intersect(SelectionResults const & in_that);
40094 
40100  bool SymmetricDifference(SelectionResults const & in_that);
40101 
40106  bool Difference(SelectionResults const & in_that);
40107 
40110  void Copy(SelectionResults const & in_that);
40111 };
40112 
40115 class HPS_API SelectionControl : public Object
40116 {
40117 public:
40120  explicit SelectionControl(WindowKey const & in_window);
40121 
40124  SelectionControl(SelectionControl const & in_that);
40125 
40129  SelectionControl(SelectionControl && in_that);
40130 
40134  SelectionControl & operator=(SelectionControl && in_that);
40135 
40136  ~SelectionControl();
40137 
40138  HPS::Type ObjectType() const {return HPS::Type::SelectionControl;};
40139 
40143  SelectionControl & operator=(SelectionControl const & in_that);
40144 
40150  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
40151 
40156  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
40157 
40163  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
40164 
40169  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
40170 
40176  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
40177 
40182  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
40183 
40190  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
40191 
40197  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
40198 
40204  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
40205 
40210  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
40211 
40218  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
40219 
40225  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
40226 
40227 
40228  //Object space selections
40229 
40235  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
40236 
40241  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
40242 
40248  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
40249 
40254  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
40255 
40256 
40263  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
40264 
40270  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
40271 
40272 
40279  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
40280 
40286  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
40287 
40288 private:
40290  SelectionControl();
40291 };
40292 
40293 
40294 
40296 class HPS_API HighlightOptionsKit : public Object
40297 {
40298 public:
40301 
40304  HighlightOptionsKit(char const * in_style_name);
40305 
40309  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
40310 
40313  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
40314 
40319 
40323  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
40324 
40325  virtual ~HighlightOptionsKit();
40326 
40327  HPS::Type ObjectType() const {return HPS::Type::HighlightOptionsKit;};
40328 
40332  static HighlightOptionsKit GetDefault();
40333 
40336  void Set(HighlightOptionsKit const & in_kit);
40337 
40340  void Show(HighlightOptionsKit & out_kit) const;
40341 
40345  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
40346 
40349  bool Empty() const;
40350 
40354  bool Equals(HighlightOptionsKit const & in_kit) const;
40355 
40359  bool operator==(HighlightOptionsKit const & in_kit) const;
40360 
40364  bool operator!=(HighlightOptionsKit const & in_kit) const;
40365 
40366 
40370  HighlightOptionsKit & SetStyleName(char const * in_style_name);
40371 
40375  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
40376 
40383  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
40384 
40390  HighlightOptionsKit & SetNotification(bool in_state);
40391 
40392 
40395  HighlightOptionsKit & UnsetStyleName();
40396 
40399  HighlightOptionsKit & UnsetSecondaryStyleName();
40400 
40403  HighlightOptionsKit & UnsetOverlay();
40404 
40407  HighlightOptionsKit & UnsetNotification();
40408 
40411  HighlightOptionsKit & UnsetEverything();
40412 
40413 
40417  bool ShowStyleName(UTF8 & out_style_name) const;
40418 
40422  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
40423 
40427  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
40428 
40432  bool ShowNotification(bool & out_state) const;
40433 };
40434 
40437 class HPS_API HighlightControl : public Control
40438 {
40439 public:
40442  explicit HighlightControl(WindowKey const & in_window);
40443 
40446  HighlightControl(HighlightControl const & in_that);
40447 
40451  HighlightControl(HighlightControl && in_that);
40452 
40456  HighlightControl & operator=(HighlightControl && in_that);
40457 
40458  ~HighlightControl();
40459 
40460  HPS::Type ObjectType() const {return HPS::Type::HighlightControl;};
40461 
40465  HighlightControl & operator=(HighlightControl const & in_that);
40466 
40471  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
40472 
40477  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
40478 
40483  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
40484 
40489  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
40490 
40495  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
40496 
40501  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
40502 
40507  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
40508 
40513  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
40514 
40519  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
40520 
40525  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
40526 
40530  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
40531 
40534  HighlightControl & UnhighlightEverything();
40535 
40536 private:
40538  HighlightControl();
40539 };
40540 
40542 class HPS_API UpdateOptionsKit : public Object
40543 {
40544 public:
40546  UpdateOptionsKit();
40547 
40550  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
40551 
40555  UpdateOptionsKit(UpdateOptionsKit && in_that);
40556 
40560  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
40561 
40562  virtual ~UpdateOptionsKit();
40563 
40564  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsKit;};
40565 
40569  static UpdateOptionsKit GetDefault();
40570 
40573  void Set(UpdateOptionsKit const & in_kit);
40574 
40577  void Show(UpdateOptionsKit & out_kit) const;
40578 
40582  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
40583 
40586  bool Empty() const;
40587 
40591  bool Equals(UpdateOptionsKit const & in_kit) const;
40592 
40596  bool operator==(UpdateOptionsKit const & in_kit) const;
40597 
40601  bool operator!=(UpdateOptionsKit const & in_kit) const;
40602 
40606  UpdateOptionsKit & SetUpdateType(HPS::Window::UpdateType in_type);
40607 
40611  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
40612 
40615  UpdateOptionsKit & UnsetUpdateType();
40616 
40619  UpdateOptionsKit & UnsetTimeLimit();
40620 
40623  UpdateOptionsKit & UnsetEverything();
40624 
40625 
40629  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
40630 
40634  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
40635 
40636 };
40637 
40638 
40639 
40645 class HPS_API UpdateOptionsControl : public Control
40646 {
40647 public:
40650  explicit UpdateOptionsControl(WindowKey const & in_window);
40651 
40654  UpdateOptionsControl(UpdateOptionsControl const & in_that);
40655 
40660 
40664  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
40665 
40667 
40668  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsControl;};
40669 
40673  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
40674 
40678  UpdateOptionsControl & SetUpdateType(HPS::Window::UpdateType in_type);
40679 
40683  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
40684 
40687  UpdateOptionsControl & UnsetUpdateType();
40688 
40691  UpdateOptionsControl & UnsetTimeLimit();
40692 
40695  UpdateOptionsControl & UnsetEverything();
40696 
40700  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
40701 
40705  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
40706 
40707 private:
40710 };
40711 
40714 class HPS_API World : public Object
40715 {
40716 public:
40720  World(char const * in_license);
40721 
40723  ~World();
40724 
40725  HPS::Type ObjectType() const {return HPS::Type::World;};
40726 
40731  World & SetMaterialLibraryDirectory(char const * in_directory);
40732 
40737  World & SetFontDirectory(char const * in_directory);
40738 
40744  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
40745 
40750  World & SetFontDirectories(UTF8Array const & in_directories);
40751 
40757  World & SetDriverConfigFile(char const * in_filename);
40758 
40764  World & SetExchangeLibraryDirectory(char const * in_directory);
40765 
40771  World & SetPublishResourceDirectory(char const * in_directory);
40772 
40777  World & SetParasolidSchemaDirectory(char const * in_directory);
40778 
40783  World & SetRealDWGDirectory(char const * in_directory);
40784 
40790  World & SetRealDWGDirectory(char const * in_directory, UTF8Array const & in_object_enabler_directories);
40791 
40797  World & SetParasolidBodyshopDirectory(char const * in_directory);
40798 
40801  World & UnsetMaterialLibraryDirectory();
40802 
40805  World & UnsetFontDirectories();
40806 
40809  World & UnsetDriverConfigFile();
40810 
40813  World & UnsetExchangeLibraryDirectory();
40814 
40817  World & UnsetPublishResourceDirectory();
40818 
40821  World & UnsetParasolidSchemaDirectory();
40822 
40825  World & UnsetRealDWGDirectory();
40826 
40829  World & UnsetParasolidBodyshopDirectory();
40830 
40834  bool ShowLicense(UTF8 & out_license) const;
40835 
40839  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
40840 
40844  bool ShowFontDirectories(UTF8Array & out_directories) const;
40845 
40849  bool ShowDriverConfigFile(UTF8 & out_filename) const;
40850 
40854  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
40855 
40859  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
40860 
40864  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
40865 
40870  bool ShowRealDWGDirectory(UTF8 & out_directory, UTF8Array & out_object_enabler_directories) const;
40871 
40875  bool ShowParasolidBodyshopDirectory(UTF8 & out_directory) const;
40876 
40877 
40878 private:
40880  World();
40881 
40883  virtual void Reset() {}
40884 };
40885 
40886 
40902 class HPS_API EmergencyHandler
40903 {
40904 public:
40905 
40908 
40909  virtual ~EmergencyHandler();
40910 
40912  intptr_t GetClassID() const;
40913 
40917  virtual void Handle(char const * message, HPS::Emergency::Code code) = 0;
40918 
40919  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
40920  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
40921 };
40922 
40923 
40926 class HPS_API Database
40927 {
40928 public:
40933  static void Execute(bool in_once=true);
40934 
40937  static Time GetTime();
40938 
40940  static void Sleep(Time milliseconds);
40941 
40966  static void RelinquishMemory();
40967 
40968 
40994  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
40995 
41003  static void Reset();
41004 
41006  static void Synchronize();
41007 
41010  static WindowKeyArray GetWindowKeys();
41011 
41014  static SegmentKeyArray GetRootSegments();
41015 
41018  static PortfolioKeyArray GetPortfolios();
41019 
41024  static PortfolioKey const GetMaterialLibraryPortfolio();
41025 
41031  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
41032 
41037  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
41038 
41042  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
41043 
41047  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
41048 
41055  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
41056 
41062  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
41063 
41069  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
41070 
41075  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
41076 
41079  static SegmentKey CreateRootSegment();
41080 
41083  static PortfolioKey CreatePortfolio();
41084 
41087  static EventDispatcher CreateEventDispatcher();
41088 
41092  static EventDispatcher CreateEventDispatcher(char const * in_name);
41093 
41099  static size_t SelectByShell(ShellKit const & in_shell,
41100  SelectionOptionsKit const & in_options,
41101  SelectionResults & out_results);
41102 
41108  static size_t SelectByShell(ShellKey const & in_shell,
41109  SelectionOptionsKit const & in_options,
41110  SelectionResults & out_results);
41111 
41118  static size_t SelectByVolume(SimpleCuboid const & in_volume,
41119  SelectionOptionsKit const & in_options,
41120  SelectionResults & out_results);
41121 
41128  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
41129  SelectionOptionsKit const & in_options,
41130  SelectionResults & out_results);
41131 
41134  static EventDispatcher const & GetEventDispatcher();
41135 
41136 
41140  static bool GetInformationEventFilter(HPS::Info::Code in_code);
41141 
41145  static bool GetWarningEventFilter(HPS::Info::Code in_code);
41146 
41150  static bool GetErrorEventFilter(HPS::Info::Code in_code);
41151 
41156  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
41157 
41162  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
41163 
41168  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
41169 
41170 
41173  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
41174 
41176  static void UnsetEmergencyHandler();
41177 
41180  static size_t GetSoftMemoryLimit();
41181 
41185  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
41186 
41190  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
41191 
41192 private:
41194  Database();
41195 };
41196 
41197 
41201 
41202 
41203 
41205 class HPS_API EventDispatcher : public Object
41206 {
41207 public:
41210  EventDispatcher();
41211 
41214  EventDispatcher(EventDispatcher const & in_that);
41215 
41219  EventDispatcher(EventDispatcher && in_that);
41220 
41224  EventDispatcher & operator=(EventDispatcher && in_that);
41225 
41226  virtual ~EventDispatcher();
41227 
41228  HPS::Type ObjectType() const {return HPS::Type::EventDispatcher;};
41229 
41233  EventDispatcher & operator=(EventDispatcher const & in_that);
41234 
41238  bool Equals(EventDispatcher const & in_that) const;
41239 
41243  bool operator==(EventDispatcher const & in_that) const;
41244 
41248  bool operator!=(EventDispatcher const & in_that) const;
41249 
41254  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
41255 
41260  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
41261 
41266  bool UnSubscribe(EventHandler const & in_handler) const;
41267 
41271  bool UnSubscribe(intptr_t in_type) const;
41272 
41276  bool InjectEvent(Event const & in_event) const;
41277 
41282  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
41283 
41286  void Shutdown() const;
41287 
41290  bool IsShutdown() const;
41291 
41292 
41295  void SetName(char const * in_name) const;
41296 
41299  void ShowName(UTF8 & out_name) const;
41300 
41301 private:
41303  virtual void Reset() {}
41304 };
41305 
41306 
41309 class HPS_API EventHandler : public Object
41310 {
41311 public:
41313  EventHandler();
41314 
41317  EventHandler(EventHandler const & in_that);
41318 
41322  EventHandler(EventHandler && in_that);
41323 
41327  EventHandler & operator=(EventHandler && in_that);
41328 
41332  EventHandler & operator=(EventHandler const & in_that);
41333 
41334  virtual ~EventHandler();
41335 
41336  HPS::Type ObjectType() const {return HPS::Type::EventHandler;};
41337 
41342  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
41343 
41348  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
41349 
41353  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
41354 
41356  void UnSubscribeEverything() const;
41357 
41359  virtual void Reset() { UnSubscribeEverything(); }
41360 
41363  void Shutdown();
41364 
41367  enum class HandleResult
41368  {
41369  Handled,
41370  NotHandled
41371  };
41372 
41377  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
41378 };
41379 
41380 
41381 
41383 class HPS_API TimerTickEvent : public Event
41384 {
41385 public:
41388  {
41389  channel = GetClassID();
41390  consumable = false;
41391  }
41392 
41393 
41396  TimerTickEvent(Event const & in_event) : Event(in_event)
41397  {
41398  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
41399  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41400  }
41401 
41402  ~TimerTickEvent();
41403 
41406  Event * Clone() const
41407  {
41408  TimerTickEvent * new_event = new TimerTickEvent(*this);
41409  return new_event;
41410  }
41411 
41415  virtual bool Drop(Event const * in_that_event) const
41416  {
41417  HPS_UNREFERENCED(in_that_event);
41418  return true;
41419  }
41420 
41421  virtual intptr_t Freshen() const {
41422  return GetClassID();
41423  }
41424 };
41425 
41427 class HPS_API HighlightEvent : public Event
41428 {
41429 public:
41430  enum class Action
41431  {
41432  None = 0,
41433  Highlight,
41434  Unhighlight,
41435  };
41436 
41439  {
41440  channel = GetClassID();
41441  consumable = false;
41442  action = Action::None;
41443  }
41444 
41445  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
41446  : Event(), action(in_action), results(in_results), options(in_options)
41447  {
41448  channel = GetClassID();
41449  consumable = false;
41450  }
41451 
41454  HighlightEvent(Event const & in_event) : Event(in_event)
41455  {
41456  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
41457  {
41458  auto that = static_cast<HighlightEvent const &>(in_event);
41459  action = that.action;
41460  results = that.results;
41461  options = that.options;
41462  }
41463  else
41464  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41465  }
41466 
41467  ~HighlightEvent();
41468 
41471  Event * Clone() const
41472  {
41473  HighlightEvent * new_event = new HighlightEvent(*this);
41474  return new_event;
41475  }
41476 
41477  Action action;
41478  SelectionResults results;
41479  HighlightOptionsKit options;
41480 };
41481 
41483 class HPS_API InformationEvent : public Event
41484 {
41485 public:
41487  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41488 
41491  InformationEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41492 
41496  InformationEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
41497 
41500  InformationEvent(Event const & in_event) : Event(in_event)
41501  {
41502  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
41503  {
41504  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
41505  message = event->message;
41506  code = event->code;
41507  }
41508  else
41509  {
41510  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41511  }
41512  }
41513 
41514  ~InformationEvent();
41515 
41518  Event * Clone() const
41519  {
41520  InformationEvent * new_event = new InformationEvent(*this);
41521  return new_event;
41522  }
41523 
41527  virtual bool Equals(InformationEvent const & in_that) const
41528  {
41529  return message == in_that.message && code == in_that.code;
41530  }
41531 
41535  virtual bool operator== (InformationEvent const & in_that) const
41536  {
41537  return Equals(in_that);
41538  }
41539 
41543  virtual bool operator!= (InformationEvent const & in_that) const
41544  {
41545  return !Equals(in_that);
41546  }
41547 
41550 };
41551 
41552 
41554 class HPS_API WarningEvent : public Event
41555 {
41556 public:
41558  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41559 
41562  WarningEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41563 
41567  WarningEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
41568 
41571  WarningEvent(Event const & in_event) : Event(in_event)
41572  {
41573  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
41574  {
41575  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
41576  message = event->message;
41577  code = event->code;
41578  }
41579  else
41580  {
41581  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41582  }
41583  }
41584 
41585  ~WarningEvent();
41586 
41589  Event * Clone() const
41590  {
41591  WarningEvent * new_event = new WarningEvent(*this);
41592  return new_event;
41593  }
41594 
41598  virtual bool Equals(WarningEvent const & in_that) const
41599  {
41600  return message == in_that.message && code == in_that.code;
41601  }
41602 
41606  virtual bool operator== (WarningEvent const & in_that) const
41607  {
41608  return Equals(in_that);
41609  }
41610 
41614  virtual bool operator!= (WarningEvent const & in_that) const
41615  {
41616  return !Equals(in_that);
41617  }
41618 
41621 };
41622 
41623 
41625 class HPS_API ErrorEvent : public Event
41626 {
41627 public:
41629  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41630 
41633  ErrorEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
41634 
41638  ErrorEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
41639 
41642  ErrorEvent(Event const & in_event) : Event(in_event)
41643  {
41644  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
41645  {
41646  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
41647  message = event->message;
41648  code = event->code;
41649  }
41650  else
41651  {
41652  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41653  }
41654  }
41655 
41656  ~ErrorEvent();
41657 
41660  Event * Clone() const
41661  {
41662  ErrorEvent * new_event = new ErrorEvent(*this);
41663  return new_event;
41664  }
41665 
41669  virtual bool Equals(ErrorEvent const & in_that) const
41670  {
41671  return message == in_that.message && code == in_that.code;
41672  }
41673 
41677  virtual bool operator== (ErrorEvent const & in_that) const
41678  {
41679  return Equals(in_that);
41680  }
41681 
41685  virtual bool operator!= (ErrorEvent const & in_that) const
41686  {
41687  return !Equals(in_that);
41688  }
41689 
41692 };
41693 
41694 
41696 class HPS_API StandAloneWindowEvent : public Event
41697 {
41698 public:
41699 
41702  enum class Action
41703  {
41704  Unknown,
41705  Close,
41706  FocusIn,
41707  FocusOut,
41708  };
41709 
41711  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
41712 
41713 
41716  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
41717 
41720  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
41721  {
41722  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
41723  {
41724  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
41725  action = event->action;
41726  }
41727  else
41728  {
41729  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41730  }
41731  }
41732 
41734 
41737  Event * Clone() const
41738  {
41739  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
41740  return new_event;
41741  }
41742 
41746  virtual bool Equals(StandAloneWindowEvent const & in_that) const
41747  {
41748  return action == in_that.action;
41749  }
41750 
41754  virtual bool operator== (StandAloneWindowEvent const & in_that) const
41755  {
41756  return Equals(in_that);
41757  }
41758 
41762  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
41763  {
41764  return !Equals(in_that);
41765  }
41766 
41768 };
41769 
41771 class HPS_API FocusLostEvent : public Event
41772 {
41773 public:
41776  Event()
41777  { channel = GetClassID(); }
41778 
41779  ~FocusLostEvent();
41780 
41783  Event * Clone() const
41784  {
41785  FocusLostEvent * new_event = new FocusLostEvent(*this);
41786  return new_event;
41787  }
41788 };
41789 
41791 class HPS_API TextInputEvent : public Event
41792 {
41793  public:
41796  Event()
41797  { channel = GetClassID(); }
41798 
41801  TextInputEvent(char const * in_text) : Event(), text(in_text) { channel = GetClassID(); }
41802 
41805  TextInputEvent(Event const & in_event) : Event(in_event)
41806  {
41807  if(in_event.GetChannel() == Object::ClassID<TextInputEvent>())
41808  {
41809  TextInputEvent const * event = static_cast<TextInputEvent const *>(&in_event);
41810  text = event->text;
41811  }
41812  else
41813  {
41814  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41815  }
41816  }
41817 
41821  virtual bool Equals(TextInputEvent const & in_that) const
41822  {
41823  return text == in_that.text;
41824  }
41825 
41829  virtual bool operator== (TextInputEvent const & in_that) const
41830  {
41831  return Equals(in_that);
41832  }
41833 
41837  virtual bool operator!= (ErrorEvent const & in_that) const
41838  {
41839  return !Equals(in_that);
41840  }
41841 
41842  ~TextInputEvent();
41843 
41846  Event * Clone() const
41847  {
41848  TextInputEvent * new_event = new TextInputEvent(*this);
41849  return new_event;
41850  }
41851 
41853 };
41854 
41855 
41857 class HPS_API UpdateCompletedEvent : public Event
41858 {
41859 public:
41861  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
41862 
41864  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
41865 
41868  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
41869  {
41870  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41871  {
41872  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
41873  update_time = event->update_time;
41874  }
41875  else
41876  {
41877  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41878  }
41879  }
41880 
41881  virtual ~UpdateCompletedEvent();
41882 
41885  Event * Clone() const
41886  {
41887  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
41888  return new_event;
41889  }
41890 
41891  Time update_time;
41892 };
41893 
41895 class HPS_API ImportStatusEvent : public Event
41896 {
41897 public:
41900  : Event()
41901  , import_status_message(HPS::UTF8())
41902  { channel = GetClassID(); }
41903 
41904  ImportStatusEvent(char const * in_message)
41905  : Event()
41906  , import_status_message(in_message)
41907  { channel = GetClassID(); }
41908 
41911  ImportStatusEvent(Event const & in_event) : Event(in_event)
41912  {
41913  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
41914  {
41915  auto event = static_cast<ImportStatusEvent const &>(in_event);
41916  import_status_message = event.import_status_message;
41917  }
41918  else
41919  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41920  }
41921 
41922  ~ImportStatusEvent();
41923 
41926  Event * Clone() const
41927  {
41928  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
41929  return new_event;
41930  }
41931 
41932  HPS::UTF8 import_status_message;
41933 };
41934 
41936 class HPS_API ShowKeyboardEvent : public Event
41937 {
41938 public:
41941  : Event()
41942  { channel = GetClassID(); }
41943 
41946  ShowKeyboardEvent(Event const & in_event) : Event(in_event)
41947  {
41948  if (in_event.GetChannel() != Object::ClassID<ShowKeyboardEvent>())
41949  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41950  }
41951 
41952  ~ShowKeyboardEvent();
41953 
41956  Event * Clone() const
41957  {
41958  ShowKeyboardEvent * new_event = new ShowKeyboardEvent(*this);
41959  return new_event;
41960  }
41961 
41962 };
41963 
41965 class HPS_API HideKeyboardEvent : public Event
41966 {
41967 public:
41970  : Event()
41971  { channel = GetClassID(); }
41972 
41975  HideKeyboardEvent(Event const & in_event) : Event(in_event)
41976  {
41977  if (in_event.GetChannel() != Object::ClassID<HideKeyboardEvent>())
41978  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41979  }
41980 
41981  ~HideKeyboardEvent();
41982 
41985  Event * Clone() const
41986  {
41987  HideKeyboardEvent * new_event = new HideKeyboardEvent(*this);
41988  return new_event;
41989  }
41990 
41991 };
41992 
41994 class HPS_API ModifierKeys
41995 {
41996 public:
41998  ModifierKeys() : modifiers(_key_none) {}
41999 
42003  bool Equals(ModifierKeys const & in_that) const
42004  {
42005  return modifiers == in_that.modifiers;
42006  }
42007 
42011  bool operator== (ModifierKeys const & in_that) const
42012  {
42013  return Equals(in_that);
42014  }
42015 
42019  bool operator!= (ModifierKeys const & in_that) const
42020  {
42021  return !Equals(in_that);
42022  }
42023 
42026  bool None() const { return modifiers == _key_none; }
42027 
42030  bool Shift() const { return (modifiers & _key_shift) != 0; }
42031 
42034  bool Control() const { return (modifiers & _key_control) != 0; }
42035 
42038  bool Alt() const { return (modifiers & _key_alt) != 0; }
42039 
42042  bool Meta() const { return (modifiers & _key_meta) != 0; }
42043 
42044 
42048  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
42049 
42053  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
42054 
42055 
42058  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
42059 
42062  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
42063 
42066  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
42067 
42070  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
42071 
42075  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
42076  {
42077  ModifierKeys ret;
42078  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
42079  return ret;
42080  }
42081 
42085  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
42086  {
42087  ModifierKeys ret;
42088  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
42089  return ret;
42090  }
42091 
42095  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
42096 
42100  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
42101 
42102 
42105  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
42106 
42109  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
42110 
42113  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
42114 
42117  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
42118 
42119 protected:
42120 
42124  {
42125  _key_none = 0x0000,
42126  _key_shift = 0x0001,
42127  _key_control = 0x0002,
42128  _key_alt = 0x0004,
42129  _key_meta = 0x0008,
42130  };
42131 
42132  int modifiers;
42133 };
42134 
42135 
42138 class HPS_API InputEvent : public Event
42139 {
42140 public:
42141 
42143  InputEvent() : Event() { channel = GetClassID(); }
42144 
42147  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
42148 
42149  ~InputEvent();
42150 
42153  Event * Clone() const
42154  {
42155  InputEvent * new_event = new InputEvent(*this);
42156  return new_event;
42157  }
42158 
42162  virtual bool Equals(InputEvent const & in_that) const
42163  {
42164  return ModifierKeyState == in_that.ModifierKeyState;
42165  }
42166 
42170  virtual bool operator== (InputEvent const & in_that) const
42171  {
42172  return Equals(in_that);
42173  }
42174 
42178  virtual bool operator!= (InputEvent const & in_that) const
42179  {
42180  return !Equals(in_that);
42181  }
42182 
42186  {
42187  return ModifierKeyState;
42188  }
42189 
42191 };
42192 
42194 class HPS_API TouchEvent : public InputEvent
42195 {
42196 public:
42199  enum class Action
42200  {
42201  TouchDown,
42202  TouchUp,
42203  Move,
42204  };
42205 
42207  TouchEvent() : InputEvent() { channel = GetClassID(); }
42208 
42213  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
42214  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
42215 
42221  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
42222  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
42223 
42230  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
42231  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
42232 
42233 
42236  TouchEvent(Event const & in_event) : InputEvent()
42237  {
42238  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
42239  {
42240  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
42241  channel = GetClassID();
42242  CurrentAction = event->CurrentAction;
42243  Touches = event->Touches;
42244  ModifierKeyState = event->ModifierKeyState;
42245  }
42246  else
42247  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
42248  }
42249 
42250  ~TouchEvent();
42251 
42252 
42255  Event * Clone() const
42256  {
42257  TouchEvent * new_event = new TouchEvent(*this);
42258  return new_event;
42259  }
42260 
42264  virtual bool Equals(TouchEvent const & in_that) const
42265  {
42266  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
42267  }
42268 
42272  virtual bool operator== (TouchEvent const & in_that) const
42273  {
42274  return Equals(in_that);
42275  }
42276 
42280  virtual bool operator!= (TouchEvent const & in_that) const
42281  {
42282  return !Equals(in_that);
42283  }
42284 
42288  virtual bool Drop(Event const * in_that_event) const
42289  {
42290  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
42291 
42292  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
42293  && Touches.size() == that_touch_event->Touches.size() )
42294  {
42295  TouchArray these_touches = Touches;
42296  TouchArray those_touches = that_touch_event->Touches;
42297 
42298  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
42299  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
42300 
42301  for (size_t i = 0 ; i < these_touches.size() ; i++)
42302  {
42303  if (these_touches[i].ID != those_touches[i].ID)
42304  return false;
42305  }
42306  return true;
42307  }
42308 
42309  return false;
42310  }
42311 
42313  HPS::TouchArray Touches;
42314 
42315 private:
42321  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
42322  {
42323  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
42324  }
42325 };
42326 
42327 
42329 class HPS_API MouseButtons
42330 {
42331 public:
42333  MouseButtons() : buttons(_button_none) {}
42334 
42338  bool Equals(MouseButtons const & in_that) const
42339  {
42340  return buttons == in_that.buttons;
42341  }
42342 
42346  bool operator== (MouseButtons const & in_that) const
42347  {
42348  return Equals(in_that);
42349  }
42350 
42354  bool operator!= (MouseButtons const & in_that) const
42355  {
42356  return !Equals(in_that);
42357  }
42358 
42361  bool None() const { return buttons == _button_none; }
42362 
42365  bool Left() const { return (buttons & _button_left) != 0; }
42366 
42369  bool Right() const { return (buttons & _button_right) != 0; }
42370 
42373  bool Middle() const { return (buttons & _button_middle) != 0; }
42374 
42377  bool X1() const { return (buttons & _button_x1) != 0; }
42378 
42381  bool X2() const { return (buttons & _button_x2) != 0; }
42382 
42383 
42387  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
42388 
42392  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
42393 
42396  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
42397 
42400  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
42401 
42404  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
42405 
42408  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
42409 
42412  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
42413 
42417  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
42418  {
42419  MouseButtons ret;
42420  ret.buttons = buttons | in_buttons_to_merge.buttons;
42421  return ret;
42422  }
42423 
42427  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
42428  {
42429  MouseButtons ret;
42430  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
42431  return ret;
42432  }
42433 
42437  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
42438 
42442  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
42443 
42444 
42447  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
42448 
42451  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
42452 
42455  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
42456 
42459  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
42460 
42463  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
42464 
42465 protected:
42466 
42469  enum Buttons
42470  {
42471  _button_none = 0x0000,
42472  _button_left = 0x0001,
42473  _button_right = 0x0002,
42474  _button_middle = 0x0004,
42475  _button_x1 = 0x0008,
42476  _button_x2 = 0x0010
42477  };
42478 
42479  int buttons;
42480 };
42481 
42483 class HPS_API MouseEvent : public InputEvent
42484 {
42485 public:
42486 
42489  enum class Action
42490  {
42491  ButtonUp,
42492  ButtonDown,
42493  Move,
42494  Scroll,
42495  Enter,
42496  Leave
42497  };
42498 
42500  MouseEvent() : InputEvent() { channel = GetClassID(); }
42501 
42508  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
42509  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
42510 
42518  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)
42519  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
42520 
42523  MouseEvent(Event const & in_event) : InputEvent()
42524  {
42525  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
42526  {
42527  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
42528  channel = GetClassID();
42529  CurrentAction = event->CurrentAction;
42530  Location = event->Location;
42531  CurrentButton = event->CurrentButton;
42532  WheelDelta = event->WheelDelta;
42533  ClickCount = event->ClickCount;
42534  }
42535  else
42536  {
42537  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
42538  }
42539  }
42540 
42541  ~MouseEvent();
42542 
42545  Event * Clone() const
42546  {
42547  MouseEvent * new_event = new MouseEvent(*this);
42548  return new_event;
42549  }
42550 
42554  virtual bool Equals(MouseEvent const & in_that) const
42555  {
42556  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
42557  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
42558  && Location == in_that.Location && ClickCount == in_that.ClickCount;
42559  }
42560 
42564  virtual bool operator== (MouseEvent const & in_that) const
42565  {
42566  return Equals(in_that);
42567  }
42568 
42572  virtual bool operator!= (MouseEvent const & in_that) const
42573  {
42574  return !Equals(in_that);
42575  }
42576 
42580  virtual bool Drop(Event const * in_that_event) const
42581  {
42582  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
42583 
42584  if (CurrentAction == that_mouse_event->CurrentAction &&
42585  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
42586  CurrentButton == that_mouse_event->CurrentButton)
42587  return true;
42588 
42589  return false;
42590  }
42591 
42592  virtual intptr_t Freshen() const {
42593 
42594  if (CurrentAction == Action::Move)
42595  return GetClassID();
42596 
42597  return 0;
42598  }
42599 
42603  float WheelDelta;
42604  size_t ClickCount;
42605 };
42606 
42607 
42609 class HPS_API KeyboardEvent : public InputEvent
42610 {
42611 public:
42614  enum class Action
42615  {
42616  None,
42617  KeyDown,
42618  KeyUp
42619  };
42620 
42622  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
42623 
42628  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
42629 
42635  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
42636  : InputEvent(in_modifiers), CurrentAction(in_action)
42637  {
42638  channel = GetClassID();
42639  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
42640  }
42641 
42646  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
42647  : InputEvent(in_modifiers), CurrentAction(in_action)
42648  {
42649  channel = GetClassID();
42650  KeyboardCodes = in_keyboardcodes;
42651  }
42652 
42655  KeyboardEvent(Event const & in_event) : InputEvent()
42656  {
42657  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
42658  {
42659  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
42660  channel = GetClassID();
42661  KeyboardCodes = event->KeyboardCodes;
42662  CurrentAction = event->CurrentAction;
42663  }
42664  else
42665  {
42666  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
42667  }
42668  }
42669 
42670  ~KeyboardEvent();
42671 
42674  Event * Clone() const
42675  {
42676  KeyboardEvent * new_event = new KeyboardEvent(*this);
42677  return new_event;
42678  }
42679 
42683  virtual bool Equals(KeyboardEvent const & in_that) const
42684  {
42685  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
42686  }
42687 
42691  virtual bool operator== (KeyboardEvent const & in_that) const
42692  {
42693  return Equals(in_that);
42694  }
42695 
42699  virtual bool operator!= (KeyboardEvent const & in_that) const
42700  {
42701  return !Equals(in_that);
42702  }
42703 
42707  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
42708  {
42709  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
42710  }
42711 
42714  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
42715  {
42716  KeyboardCodes = in_keyboardcodes;
42717  }
42718 
42719  HPS::KeyboardCodeArray KeyboardCodes;
42721 };
42722 
42723 
42725 class HPS_API MouseState : public Object
42726 {
42727 public:
42729  MouseState();
42730 
42733  MouseState(MouseState const & in_that);
42734 
42738  MouseState(MouseState && in_that);
42739 
42743  MouseState & operator=(MouseState && in_that);
42744 
42745  ~MouseState();
42746 
42747  HPS::Type ObjectType() const {return HPS::Type::MouseState;};
42748 
42751  void Assign(MouseState const & in_that);
42752 
42756  MouseState & operator=(MouseState const & in_that);
42757 
42761  bool Equals(MouseState const & in_that) const;
42762 
42766  bool operator== (MouseState const & in_that) const;
42767 
42771  bool operator!= (MouseState const & in_that) const;
42772 
42777  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
42778 
42785  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
42786 
42789  HPS::MouseEvent GetActiveEvent() const;
42790 
42794  HPS::WindowKey GetEventSource() const;
42795 
42799  HPS::KeyArray GetEventPath() const;
42800 
42803  MouseButtons GetButtons() const;
42804 
42807  WindowPoint GetLocation() const;
42808 
42811  ModifierKeys GetModifierKeys() const;
42812 
42815  void SetActiveEvent(MouseEvent const & in_event);
42816 
42819  void SetEventPath(KeyArray const & in_path);
42820 
42823  void SetButtons(MouseButtons in_buttons);
42824 
42827  void SetLocation(WindowPoint const & in_point);
42828 
42831  void SetModifierKeys(ModifierKeys in_modifiers);
42832 };
42833 
42834 
42835 
42837 class HPS_API TouchState : public Object
42838 {
42839 public:
42841  TouchState();
42842 
42845  TouchState(TouchState const & in_that);
42846 
42850  TouchState(TouchState && in_that);
42851 
42855  TouchState & operator=(TouchState && in_that);
42856 
42857  ~TouchState();
42858 
42859  HPS::Type ObjectType() const {return HPS::Type::TouchState;};
42860 
42863  void Assign(TouchState const & in_that);
42864 
42868  TouchState & operator=(TouchState const & in_that);
42869 
42873  bool Equals(TouchState const & in_that) const;
42874 
42878  bool operator== (TouchState const & in_that) const;
42879 
42883  bool operator!= (TouchState const & in_that) const;
42884 
42890  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
42891 
42894  HPS::TouchEvent GetActiveEvent() const;
42895 
42899  HPS::WindowKey GetEventSource() const;
42900 
42904  HPS::KeyArray GetEventPath() const;
42905 
42908  size_t GetTouchCount() const;
42909 
42912  HPS::TouchArray GetTouches() const;
42913 
42916  ModifierKeys GetModifierKeys() const;
42917 
42920  void SetActiveEvent(TouchEvent const & in_event);
42921 
42924  void SetEventPath(KeyArray const & in_path);
42925 
42928  void SetTouches(TouchArray const & in_touches);
42929 
42932  void SetModifierKeys(ModifierKeys in_modifiers);
42933 };
42934 
42935 
42936 
42938 class HPS_API KeyboardState : public Object
42939 {
42940 public:
42942  KeyboardState();
42943 
42946  KeyboardState(KeyboardState const & in_that);
42947 
42951  KeyboardState(KeyboardState && in_that);
42952 
42956  KeyboardState & operator=(KeyboardState && in_that);
42957 
42958  ~KeyboardState();
42959 
42960  HPS::Type ObjectType() const {return HPS::Type::KeyboardState;};
42961 
42964  void Assign(KeyboardState const & in_that);
42965 
42969  KeyboardState & operator=(KeyboardState const & in_that);
42970 
42974  bool Equals(KeyboardState const & in_that) const;
42975 
42979  bool operator== (KeyboardState const & in_that) const;
42980 
42984  bool operator!= (KeyboardState const & in_that) const;
42985 
42991  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
42992 
42995  HPS::KeyboardEvent GetActiveEvent() const;
42996 
43000  HPS::WindowKey GetEventSource() const;
43001 
43005  HPS::KeyArray GetEventPath() const;
43006 
43009  size_t GetKeyboardCodeCount() const;
43010 
43013  HPS::KeyboardCodeArray GetKeyboardCodes() const;
43014 
43018  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
43019 
43022  ModifierKeys GetModifierKeys() const;
43023 
43026  void SetActiveEvent(KeyboardEvent const & in_event);
43027 
43030  void SetEventPath(KeyArray const & in_path);
43031 
43034  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
43035 
43038  void SetModifierKeys(ModifierKeys in_modifiers);
43039 };
43040 
43041 
43045 
43048 class HPS_API IONotifier : public Object
43049 {
43050 public:
43052  IONotifier();
43053 
43056  IONotifier(IONotifier const & in_that);
43057 
43061  IONotifier(IONotifier && in_that);
43062 
43066  IONotifier & operator=(IONotifier && in_that);
43067 
43068  virtual ~IONotifier();
43069 
43070  HPS::Type ObjectType() const {return HPS::Type::IONotifier;};
43071 
43075  IONotifier & operator=(IONotifier const & in_that);
43076 
43079  void Assign(IONotifier const & in_that);
43080 
43082  void Wait();
43083 
43086  IOResult Status() const;
43087 
43091  IOResult Status(float & out_percent_complete) const;
43092 
43096  void Cancel();
43097 };
43098 
43100 class HPS_API Stream
43101 {
43102 public:
43103  class ImportNotifier;
43104  class ImportOptionsKit;
43105 
43107  class HPS_API Toolkit : public Object
43108  {
43109  public:
43111  Toolkit();
43112 
43115  Toolkit(Toolkit const & in_toolkit);
43116 
43120  Toolkit(Toolkit && in_toolkit);
43121 
43125  Toolkit & operator=(Toolkit const & in_toolkit);
43126 
43130  Toolkit & operator=(Toolkit && in_toolkit);
43131 
43132  HPS::Type ObjectType() const { return HPS::Type::StreamToolkit; }
43133 
43135  virtual void Restart();
43136 
43137  ImportNotifier ParseBuffers(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
43138  };
43139 
43142  static Toolkit CreateToolkit();
43143 
43144 
43145 
43147 
43149  class HPS_API ExportEvent
43150  {
43151  protected:
43152  ExportEvent() {}
43153  public:
43154  virtual ~ExportEvent();
43156  intptr_t GetClassID() const;
43159  HPS::ByteArray non_db_user_data;
43160  };
43161 
43163  class HPS_API ExportEventHandler
43164  {
43165  public:
43166  ExportEventHandler() {}
43167  virtual ~ExportEventHandler();
43171  virtual void Handle(ExportEvent * in_event);
43172  };
43173 
43175 
43177  class HPS_API GeometryExportEvent : public ExportEvent
43178  {
43180  GeometryExportEvent & operator=(GeometryExportEvent const &);
43181  public:
43182  GeometryExportEvent();
43183  virtual ~GeometryExportEvent();
43184  GeometryExportEvent(HPS::Key & in_key);
43185 
43188  };
43189 
43191  class HPS_API SegmentExportEvent : public ExportEvent
43192  {
43194  SegmentExportEvent & operator=(SegmentExportEvent const &);
43195  public:
43196  SegmentExportEvent();
43197  virtual ~SegmentExportEvent();
43198  SegmentExportEvent(HPS::SegmentKey & in_segment_key);
43199 
43202  };
43203 
43205 
43207  class HPS_API ImportEvent
43208  {
43209  protected:
43210  ImportEvent() {}
43211  public:
43212  virtual ~ImportEvent();
43214  intptr_t GetClassID() const;
43215  };
43216 
43221  class HPS_API ImportEventHandler
43222  {
43223  public:
43224  ImportEventHandler() {}
43225  virtual ~ImportEventHandler();
43226 
43232  virtual bool Handle(ImportEvent * in_event);
43233  };
43234 
43236 
43237  class HPS_API AttributeLockImportEvent : public ImportEvent
43238  {
43240  AttributeLockImportEvent & operator=(AttributeLockImportEvent const &);
43241  public:
43242  AttributeLockImportEvent();
43243  virtual ~AttributeLockImportEvent();
43244  AttributeLockImportEvent(HPS::SegmentKey & in_segment_key, HPS::AttributeLockKit & in_attribute_lock_kit);
43245 
43246  HPS::SegmentKey & segment_key;
43247  HPS::AttributeLockKit & attribute_lock_kit;
43248  };
43249 
43250  class HPS_API BoundingImportEvent : public ImportEvent
43251  {
43253  BoundingImportEvent & operator=(BoundingImportEvent const &);
43254  public:
43255  BoundingImportEvent();
43256  virtual ~BoundingImportEvent();
43257  BoundingImportEvent(HPS::SegmentKey & in_segment_key, HPS::BoundingKit & in_bounding_kit);
43258 
43259  HPS::SegmentKey & segment_key;
43260  HPS::BoundingKit & bounding_kit;
43261  };
43262 
43263  class HPS_API CameraImportEvent : public ImportEvent
43264  {
43266  CameraImportEvent & operator=(CameraImportEvent const &);
43267  public:
43268  CameraImportEvent();
43269  virtual ~CameraImportEvent();
43270  CameraImportEvent(HPS::SegmentKey & in_segment_key, HPS::CameraKit & in_camera_kit);
43271 
43272  HPS::SegmentKey & segment_key;
43273  HPS::CameraKit & camera_kit;
43274  };
43275 
43276  class HPS_API CircleImportEvent : public ImportEvent
43277  {
43279  CircleImportEvent & operator=(CircleImportEvent const &);
43280  public:
43281  CircleImportEvent();
43282  virtual ~CircleImportEvent();
43283  CircleImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircleKit & in_circle_kit);
43284 
43285  HPS::SegmentKey & segment_key;
43286  HPS::CircleKit & circle_kit;
43287  };
43288 
43289  class HPS_API CircularArcImportEvent : public ImportEvent
43290  {
43292  CircularArcImportEvent & operator=(CircularArcImportEvent const &);
43293  public:
43294  CircularArcImportEvent();
43295  virtual ~CircularArcImportEvent();
43296  CircularArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularArcKit & in_circular_arc_kit);
43297 
43298  HPS::SegmentKey & segment_key;
43299  HPS::CircularArcKit & circular_arc_kit;
43300  };
43301 
43302  class HPS_API CircularWedgeImportEvent : public ImportEvent
43303  {
43305  CircularWedgeImportEvent & operator=(CircularWedgeImportEvent const &);
43306  public:
43307  CircularWedgeImportEvent();
43308  virtual ~CircularWedgeImportEvent();
43309  CircularWedgeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularWedgeKit & in_circular_wedge_kit);
43310 
43311  HPS::SegmentKey & segment_key;
43312  HPS::CircularWedgeKit & circular_wedge_kit;
43313  };
43314 
43316  {
43318  ColorInterpolationImportEvent & operator=(ColorInterpolationImportEvent const &);
43319  public:
43320  ColorInterpolationImportEvent();
43321  virtual ~ColorInterpolationImportEvent();
43322  ColorInterpolationImportEvent(HPS::SegmentKey & in_segment_key, HPS::ColorInterpolationKit & in_color_interpolation_kit);
43323 
43324  HPS::SegmentKey & segment_key;
43325  HPS::ColorInterpolationKit & color_interpolation_kit;
43326  };
43327 
43328  class HPS_API CommentImportEvent : public ImportEvent
43329  {
43331  CommentImportEvent & operator=(CommentImportEvent const &);
43332  public:
43333  CommentImportEvent();
43334  virtual ~CommentImportEvent();
43335  CommentImportEvent(HPS::SegmentKey & in_segment_key, const char* in_comment);
43336 
43337  HPS::SegmentKey & segment_key;
43338  HPS::UTF8 const comment;
43339  };
43340 
43341  class HPS_API ConditionImportEvent : public ImportEvent
43342  {
43344  ConditionImportEvent & operator=(ConditionImportEvent const &);
43345  public:
43346  ConditionImportEvent();
43347  virtual ~ConditionImportEvent();
43348  ConditionImportEvent(HPS::SegmentKey & in_segment_key);
43349 
43350  HPS::SegmentKey & segment_key;
43351  HPS::UTF8Array conditions;
43352  };
43353 
43354  class HPS_API ContourLineImportEvent : public ImportEvent
43355  {
43357  ContourLineImportEvent & operator=(ContourLineImportEvent const &);
43358  public:
43359  ContourLineImportEvent();
43360  virtual ~ContourLineImportEvent();
43361  ContourLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::ContourLineKit & in_contour_line_kit);
43362 
43363  HPS::SegmentKey & segment_key;
43364  HPS::ContourLineKit & contour_line_kit;
43365  };
43366 
43368  {
43370  CuttingSectionImportEvent & operator=(CuttingSectionImportEvent const &);
43371  public:
43372  CuttingSectionImportEvent();
43373  virtual ~CuttingSectionImportEvent();
43374  CuttingSectionImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionKit & in_cutting_section_kit);
43375 
43376  HPS::SegmentKey & segment_key;
43377  HPS::CuttingSectionKit & cutting_section_kit;
43378  };
43379 
43381  {
43383  CuttingSectionAttributeImportEvent & operator=(CuttingSectionAttributeImportEvent const &);
43384  public:
43385  CuttingSectionAttributeImportEvent();
43386  virtual ~CuttingSectionAttributeImportEvent();
43387  CuttingSectionAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionAttributeKit & in_cutting_section_attribute_kit);
43388 
43389  HPS::SegmentKey & segment_key;
43390  HPS::CuttingSectionAttributeKit & cutting_section_attribute_kit;
43391  };
43392 
43394  {
43396  CubeMapDefinitionImportEvent & operator=(CubeMapDefinitionImportEvent const &);
43397  public:
43398  CubeMapDefinitionImportEvent();
43399  virtual ~CubeMapDefinitionImportEvent();
43400  CubeMapDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name,
43401  HPS::ImageDefinition & in_negative_z, HPS::ImageDefinition & in_positive_z,
43402  HPS::ImageDefinition & in_negative_x, HPS::ImageDefinition & in_positive_x,
43403  HPS::ImageDefinition & in_negative_y, HPS::ImageDefinition & in_positive_y,
43404  HPS::TextureOptionsKit & in_texture_kit);
43405 
43406  HPS::PortfolioKey & portfolio_key;
43407  UTF8 name;
43408  HPS::ImageDefinition & negative_z;
43409  HPS::ImageDefinition & positive_z;
43410  HPS::ImageDefinition & negative_x;
43411  HPS::ImageDefinition & positive_x;
43412  HPS::ImageDefinition & negative_y;
43413  HPS::ImageDefinition & positive_y;
43414  HPS::TextureOptionsKit & texture_kit;
43415  };
43416 
43417  class HPS_API CullingImportEvent : public ImportEvent
43418  {
43420  CullingImportEvent & operator=(CullingImportEvent const &);
43421  public:
43422  CullingImportEvent();
43423  virtual ~CullingImportEvent();
43424  CullingImportEvent(HPS::SegmentKey & in_segment_key, HPS::CullingKit & in_culling_kit);
43425 
43426  HPS::SegmentKey & segment_key;
43427  HPS::CullingKit & culling_kit;
43428  };
43429 
43431  {
43433  CurveAttributeImportEvent & operator=(CurveAttributeImportEvent const &);
43434  public:
43435  CurveAttributeImportEvent();
43436  virtual ~CurveAttributeImportEvent();
43437  CurveAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CurveAttributeKit & in_curve_attribute_kit);
43438 
43439  HPS::SegmentKey & segment_key;
43440  HPS::CurveAttributeKit & curve_attribute_kit;
43441  };
43442 
43444  {
43446  CylinderAttributeImportEvent & operator=(CylinderAttributeImportEvent const &);
43447  public:
43448  CylinderAttributeImportEvent();
43449  virtual ~CylinderAttributeImportEvent();
43450  CylinderAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderAttributeKit & in_cylinder_attribute_kit);
43451 
43452  HPS::SegmentKey & segment_key;
43453  HPS::CylinderAttributeKit & cylinder_attribute_kit;
43454  };
43455 
43456  class HPS_API CylinderImportEvent : public ImportEvent
43457  {
43459  CylinderImportEvent & operator=(CylinderImportEvent const &);
43460  public:
43461  CylinderImportEvent();
43462  virtual ~CylinderImportEvent();
43463  CylinderImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderKit & in_cylinder_kit);
43464 
43465  HPS::SegmentKey & segment_key;
43466  HPS::CylinderKit & cylinder_kit;
43467  };
43468 
43470  {
43472  DistantLightPropertyImportEvent & operator=(DistantLightPropertyImportEvent const &);
43473  public:
43474  DistantLightPropertyImportEvent();
43475  virtual ~DistantLightPropertyImportEvent();
43476  DistantLightPropertyImportEvent(HPS::DistantLightKey & in_distant_light_key, HPS::DistantLightKit & in_distant_light_kit);
43477 
43478  HPS::DistantLightKey & distant_light_key;
43479  HPS::DistantLightKit & distant_light_kit;
43480  };
43481 
43482  class HPS_API DistantLightImportEvent : public ImportEvent
43483  {
43485  DistantLightImportEvent & operator=(DistantLightImportEvent const &);
43486  public:
43487  DistantLightImportEvent();
43488  virtual ~DistantLightImportEvent();
43489  DistantLightImportEvent(HPS::SegmentKey & in_segment_key, HPS::DistantLightKit & in_distantlight_kit);
43490 
43491  HPS::SegmentKey & segment_key;
43492  HPS::DistantLightKit & distant_light_kit;
43493  };
43494 
43496  {
43498  DrawingAttributeImportEvent & operator=(DrawingAttributeImportEvent const &);
43499  public:
43500  DrawingAttributeImportEvent();
43501  virtual ~DrawingAttributeImportEvent();
43502  DrawingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::DrawingAttributeKit & in_drawing_attribute_kit);
43503 
43504  HPS::SegmentKey & segment_key;
43505  HPS::DrawingAttributeKit & drawing_attribute_kit;
43506  };
43507 
43508  class HPS_API EdgeAttributeImportEvent : public ImportEvent
43509  {
43511  EdgeAttributeImportEvent & operator=(EdgeAttributeImportEvent const &);
43512  public:
43513  EdgeAttributeImportEvent();
43514  virtual ~EdgeAttributeImportEvent();
43515  EdgeAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::EdgeAttributeKit & in_edge_attribute_kit);
43516 
43517  HPS::SegmentKey & segment_key;
43518  HPS::EdgeAttributeKit & edge_attribute_kit;
43519  };
43520 
43521  class HPS_API EllipseImportEvent : public ImportEvent
43522  {
43524  EllipseImportEvent & operator=(EllipseImportEvent const &);
43525  public:
43526  EllipseImportEvent();
43527  virtual ~EllipseImportEvent();
43528  EllipseImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipseKit & in_ellipse_kit);
43529 
43530  HPS::SegmentKey & segment_key;
43531  HPS::EllipseKit & ellipse_kit;
43532  };
43533 
43534  class HPS_API EllipticalArcImportEvent : public ImportEvent
43535  {
43537  EllipticalArcImportEvent & operator=(EllipticalArcImportEvent const &);
43538  public:
43539  EllipticalArcImportEvent();
43540  virtual ~EllipticalArcImportEvent();
43541  EllipticalArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipticalArcKit & in_elliptical_arc_kit);
43542 
43543  HPS::SegmentKey & segment_key;
43544  HPS::EllipticalArcKit & elliptical_arc_kit;
43545  };
43546 
43548  {
43550  GlyphDefinitionImportEvent & operator=(GlyphDefinitionImportEvent const &);
43551  public:
43552  GlyphDefinitionImportEvent();
43553  virtual ~GlyphDefinitionImportEvent();
43554  GlyphDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::GlyphKit & in_glyph_kit);
43555 
43556  HPS::PortfolioKey & portfolio_key;
43557  UTF8 name;
43558  HPS::GlyphKit & glyph_kit;
43559  };
43560 
43561  class HPS_API GridImportEvent : public ImportEvent
43562  {
43564  GridImportEvent & operator=(GridImportEvent const &);
43565  public:
43566  GridImportEvent();
43567  virtual ~GridImportEvent();
43568  GridImportEvent(HPS::SegmentKey & in_segment_key, HPS::GridKit & in_grid_kit);
43569 
43570  HPS::SegmentKey & segment_key;
43571  HPS::GridKit & grid_kit;
43572  };
43573 
43575  {
43577  HiddenLineAttributeImportEvent & operator=(HiddenLineAttributeImportEvent const &);
43578  public:
43579  HiddenLineAttributeImportEvent();
43580  virtual ~HiddenLineAttributeImportEvent();
43581  HiddenLineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::HiddenLineAttributeKit & in_hidden_attribute_kit);
43582 
43583  HPS::SegmentKey & segment_key;
43584  HPS::HiddenLineAttributeKit & hidden_line_attribute_kit;
43585  };
43586 
43588  {
43590  ImageDefinitionImportEvent & operator=(ImageDefinitionImportEvent const &);
43591  public:
43592  ImageDefinitionImportEvent();
43593  virtual ~ImageDefinitionImportEvent();
43594  ImageDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::ImageKit & in_image_kit);
43595 
43596  HPS::PortfolioKey & portfolio_key;
43597  UTF8 name;
43598  HPS::ImageKit & image_kit;
43599  };
43600 
43602  {
43604  IncludeSegmentImportEvent & operator=(IncludeSegmentImportEvent const &);
43605  public:
43606  IncludeSegmentImportEvent();
43607  virtual ~IncludeSegmentImportEvent();
43608  IncludeSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_reference_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
43609 
43610  HPS::SegmentKey & segment_key;
43611  HPS::SegmentKey & reference_segment_key;
43612  HPS::ConditionalExpression & condition;
43613  HPS::AttributeLockTypeArray filter_types;
43614  };
43615 
43616  class HPS_API InfiniteLineImportEvent : public ImportEvent
43617  {
43619  InfiniteLineImportEvent & operator=(InfiniteLineImportEvent const &);
43620  public:
43621  InfiniteLineImportEvent();
43622  virtual ~InfiniteLineImportEvent();
43623  InfiniteLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::InfiniteLineKit & in_infinite_line_kit);
43624 
43625  HPS::SegmentKey & segment_key;
43626  HPS::InfiniteLineKit & infinite_line_kit;
43627  };
43628 
43630  {
43632  LightingAttributeImportEvent & operator=(LightingAttributeImportEvent const &);
43633  public:
43634  LightingAttributeImportEvent();
43635  virtual ~LightingAttributeImportEvent();
43636  LightingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LightingAttributeKit & in_lighting_attribute_kit);
43637 
43638  HPS::SegmentKey & segment_key;
43639  HPS::LightingAttributeKit & lighting_attribute_kit;
43640  };
43641 
43642  class HPS_API LineAttributeImportEvent : public ImportEvent
43643  {
43645  LineAttributeImportEvent & operator=(LineAttributeImportEvent const &);
43646  public:
43647  LineAttributeImportEvent();
43648  virtual ~LineAttributeImportEvent();
43649  LineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineAttributeKit & in_line_attribute_kit);
43650 
43651  HPS::SegmentKey & segment_key;
43652  HPS::LineAttributeKit & line_attribute_kit;
43653  };
43654 
43655  class HPS_API LineImportEvent : public ImportEvent
43656  {
43658  LineImportEvent & operator=(LineImportEvent const &);
43659  public:
43660  LineImportEvent();
43661  virtual ~LineImportEvent();
43662  LineImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineKit & in_line_kit);
43663 
43664  HPS::SegmentKey & segment_key;
43665  HPS::LineKit & line_kit;
43666  };
43667 
43669  {
43671  LinePatternDefinitionImportEvent & operator=(LinePatternDefinitionImportEvent const &);
43672  public:
43673  LinePatternDefinitionImportEvent();
43674  virtual ~LinePatternDefinitionImportEvent();
43675  LinePatternDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::LinePatternKit & in_line_pattern_kit);
43676 
43677  HPS::PortfolioKey & portfolio_key;
43678  UTF8 name;
43679  HPS::LinePatternKit & line_pattern_kit;
43680  };
43681 
43682  class HPS_API MarkerImportEvent : public ImportEvent
43683  {
43685  MarkerImportEvent & operator=(MarkerImportEvent const &);
43686  public:
43687  MarkerImportEvent();
43688  virtual ~MarkerImportEvent();
43689  MarkerImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerKit & in_marker_kit);
43690 
43691  HPS::SegmentKey & segment_key;
43692  HPS::MarkerKit & marker_kit;
43693  };
43694 
43696  {
43698  MarkerAttributeImportEvent & operator=(MarkerAttributeImportEvent const &);
43699  public:
43700  MarkerAttributeImportEvent();
43701  virtual ~MarkerAttributeImportEvent();
43702  MarkerAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerAttributeKit & in_marker_attribute_kit);
43703 
43704  HPS::SegmentKey & segment_key;
43705  HPS::MarkerAttributeKit & marker_attribute_kit;
43706  };
43707 
43708  class HPS_API MaterialImportEvent : public ImportEvent
43709  {
43711  MaterialImportEvent & operator=(MaterialImportEvent const &);
43712  public:
43713  MaterialImportEvent();
43714  virtual ~MaterialImportEvent();
43715  MaterialImportEvent(HPS::Key & in_key, HPS::MaterialMappingKit & in_material_mapping_kit);
43716 
43717  HPS::Key & key;
43718  HPS::MaterialMappingKit & material_mapping_kit;
43719  };
43720 
43722  {
43724  MaterialPaletteDefinitionImportEvent & operator=(MaterialPaletteDefinitionImportEvent const &);
43725  public:
43726  MaterialPaletteDefinitionImportEvent();
43727  virtual ~MaterialPaletteDefinitionImportEvent();
43728  MaterialPaletteDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::MaterialKitArray & in_material_mapping_kit_array);
43729 
43730  HPS::PortfolioKey & portfolio_key;
43731  HPS::UTF8 name;
43732  HPS::MaterialKitArray & material_mapping_kit_array;
43733  };
43734 
43736  {
43738  MaterialPaletteImportEvent & operator=(MaterialPaletteImportEvent const &);
43739  public:
43740  MaterialPaletteImportEvent();
43741  virtual ~MaterialPaletteImportEvent();
43742  MaterialPaletteImportEvent(HPS::SegmentKey & in_segment_key, HPS::UTF8 && in_name);
43743 
43744  HPS::SegmentKey & segment_key;
43745  HPS::UTF8 name;
43746  };
43747 
43748  class HPS_API MatrixImportEvent : public ImportEvent
43749  {
43751  MatrixImportEvent & operator=(MatrixImportEvent const &);
43752  public:
43753  MatrixImportEvent();
43754  virtual ~MatrixImportEvent();
43755  MatrixImportEvent(HPS::Key & in_key, HPS::MatrixKit & in_matrix_kit);
43756 
43757  HPS::Key & key;
43758  HPS::MatrixKit & matrix_kit;
43759  };
43760 
43761  class HPS_API MeshImportEvent : public ImportEvent
43762  {
43764  MeshImportEvent & operator=(MeshImportEvent const &);
43765  public:
43766  MeshImportEvent();
43767  virtual ~MeshImportEvent();
43768  MeshImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit);
43769 
43770  HPS::SegmentKey & segment_key;
43771  HPS::MeshKit & mesh_kit;
43772  };
43773 
43774  class HPS_API MeshInstanceImportEvent : public ImportEvent
43775  {
43777  MeshInstanceImportEvent & operator=(MeshInstanceImportEvent const &);
43778  public:
43779  MeshInstanceImportEvent();
43780  virtual ~MeshInstanceImportEvent();
43781  MeshInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit, HPS::MatrixKit & in_modelling_matrix);
43782 
43783  HPS::SegmentKey & segment_key;
43784  HPS::MeshKit & mesh_kit;
43785  HPS::MatrixKit & modelling_matrix;
43786  };
43787 
43789  {
43791  NamedStyleDefinitionImportEvent & operator=(NamedStyleDefinitionImportEvent const &);
43792  public:
43793  NamedStyleDefinitionImportEvent();
43794  virtual ~NamedStyleDefinitionImportEvent();
43795  NamedStyleDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::SegmentKey & in_style_key);
43796 
43797  HPS::PortfolioKey & portfolio_key;
43798  HPS::UTF8 name;
43799  HPS::SegmentKey & style_key;
43800  };
43801 
43802  class HPS_API NamedStyleImportEvent : public ImportEvent
43803  {
43805  NamedStyleImportEvent & operator=(NamedStyleImportEvent const &);
43806  public:
43807  NamedStyleImportEvent();
43808  virtual ~NamedStyleImportEvent();
43809  NamedStyleImportEvent(HPS::SegmentKey & in_segment_key, HPS::UTF8 && in_name, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
43810 
43811  HPS::SegmentKey & segment_key;
43812  HPS::UTF8 name;
43813  HPS::ConditionalExpression & condition;
43814  HPS::AttributeLockTypeArray filter_types;
43815  };
43816 
43817  class HPS_API NURBSCurveImportEvent : public ImportEvent
43818  {
43820  NURBSCurveImportEvent & operator=(NURBSCurveImportEvent const &);
43821  public:
43822  NURBSCurveImportEvent();
43823  virtual ~NURBSCurveImportEvent();
43824  NURBSCurveImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSCurveKit & in_nurbs_curve_kit);
43825 
43826  HPS::SegmentKey & segment_key;
43827  HPS::NURBSCurveKit & nurbs_curve_kit;
43828  };
43829 
43830  class HPS_API NURBSSurfaceImportEvent : public ImportEvent
43831  {
43833  NURBSSurfaceImportEvent & operator=(NURBSSurfaceImportEvent const &);
43834  public:
43835  NURBSSurfaceImportEvent();
43836  virtual ~NURBSSurfaceImportEvent();
43837  NURBSSurfaceImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceKit & in_nurbs_surface_kit);
43838 
43839  HPS::SegmentKey & segment_key;
43840  HPS::NURBSSurfaceKit & nurbs_surface_kit;
43841  };
43842 
43844  {
43846  NURBSSurfaceAttributeImportEvent & operator=(NURBSSurfaceAttributeImportEvent const &);
43847  public:
43848  NURBSSurfaceAttributeImportEvent();
43849  virtual ~NURBSSurfaceAttributeImportEvent();
43850  NURBSSurfaceAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceAttributeKit & in_nurbs_surface_attribute_kit);
43851 
43852  HPS::SegmentKey & segment_key;
43853  HPS::NURBSSurfaceAttributeKit & nurbs_surface_attribute_kit;
43854  };
43855 
43856  class HPS_API PerformanceImportEvent : public ImportEvent
43857  {
43859  PerformanceImportEvent & operator=(PerformanceImportEvent const &);
43860  public:
43861  PerformanceImportEvent();
43862  virtual ~PerformanceImportEvent();
43863  PerformanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::PerformanceKit & in_performance_kit);
43864 
43865  HPS::SegmentKey & segment_key;
43866  HPS::PerformanceKit & performance_kit;
43867  };
43868 
43869  class HPS_API PolygonImportEvent : public ImportEvent
43870  {
43872  PolygonImportEvent & operator=(PolygonImportEvent const &);
43873  public:
43874  PolygonImportEvent();
43875  virtual ~PolygonImportEvent();
43876  PolygonImportEvent(HPS::SegmentKey & in_segment_key, HPS::PolygonKit & in_polygon_kit);
43877 
43878  HPS::SegmentKey & segment_key;
43879  HPS::PolygonKit & polygon_kit;
43880  };
43881 
43882  class HPS_API PriorityImportEvent : public ImportEvent
43883  {
43885  PriorityImportEvent & operator=(PriorityImportEvent const &);
43886  public:
43887  PriorityImportEvent();
43888  virtual ~PriorityImportEvent();
43889  PriorityImportEvent(HPS::Key & in_key, int in_priority);
43890 
43891  HPS::Key & key;
43892  int priority;
43893  };
43894 
43896  {
43898  ReferenceGeometryImportEvent & operator=(ReferenceGeometryImportEvent const &);
43899  public:
43900  ReferenceGeometryImportEvent();
43901  virtual ~ReferenceGeometryImportEvent();
43902  ReferenceGeometryImportEvent(HPS::SegmentKey & in_segment_key, HPS::Key & in_reference_geometry_key, HPS::ConditionalExpression & in_conditional);
43903 
43904  HPS::SegmentKey & segment_key;
43905  HPS::Key & reference_geometry_key;
43906  HPS::ConditionalExpression & condition;
43907  };
43908 
43909  class HPS_API SegmentImportEvent : public ImportEvent
43910  {
43912  SegmentImportEvent & operator=(SegmentImportEvent const &);
43913  public:
43914  SegmentImportEvent();
43915  virtual ~SegmentImportEvent();
43916  SegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::UTF8 && in_name);
43917 
43918  HPS::SegmentKey & segment_key;
43919  HPS::UTF8 name;
43920  };
43921 
43922  class HPS_API SelectabilityImportEvent : public ImportEvent
43923  {
43925  SelectabilityImportEvent & operator=(SelectabilityImportEvent const &);
43926  public:
43927  SelectabilityImportEvent();
43928  virtual ~SelectabilityImportEvent();
43929  SelectabilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::SelectabilityKit & in_selectability_kit);
43930 
43931  HPS::SegmentKey & segment_key;
43932  HPS::SelectabilityKit & selectability_kit;
43933  };
43934 
43936  {
43938  ShaderDefinitionImportEvent & operator=(ShaderDefinitionImportEvent const &);
43939  public:
43940  ShaderDefinitionImportEvent();
43941  virtual ~ShaderDefinitionImportEvent();
43942  ShaderDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name, HPS::ShaderKit & in_shader_kit);
43943 
43944  HPS::PortfolioKey & portfolio_key;
43945  UTF8 name;
43946  HPS::ShaderKit & shader_kit;
43947  };
43948 
43949  class HPS_API ShellImportEvent : public ImportEvent
43950  {
43952  ShellImportEvent & operator=(ShellImportEvent const &);
43953  public:
43954  ShellImportEvent();
43955  virtual ~ShellImportEvent();
43956  ShellImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit);
43957 
43958  HPS::SegmentKey & segment_key;
43959  HPS::ShellKit & shell_kit;
43960  };
43961 
43962  class HPS_API ShellInstanceImportEvent : public ImportEvent
43963  {
43965  ShellInstanceImportEvent & operator=(ShellInstanceImportEvent const &);
43966  public:
43967  ShellInstanceImportEvent();
43968  virtual ~ShellInstanceImportEvent();
43969  ShellInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit, HPS::MatrixKit & in_modelling_matrix);
43970 
43971  HPS::SegmentKey & segment_key;
43972  HPS::ShellKit & shell_kit;
43973  HPS::MatrixKit & modelling_matrix;
43974  };
43975 
43976  class HPS_API SphereImportEvent : public ImportEvent
43977  {
43979  SphereImportEvent & operator=(SphereImportEvent const &);
43980  public:
43981  SphereImportEvent();
43982  virtual ~SphereImportEvent();
43983  SphereImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereKit & in_sphere_kit);
43984 
43985  HPS::SegmentKey & segment_key;
43986  HPS::SphereKit & sphere_kit;
43987  };
43988 
43990  {
43992  SphereAttributeImportEvent & operator=(SphereAttributeImportEvent const &);
43993  public:
43994  SphereAttributeImportEvent();
43995  virtual ~SphereAttributeImportEvent();
43996  SphereAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereAttributeKit & in_sphere_attribute_kit);
43997 
43998  HPS::SegmentKey & segment_key;
43999  HPS::SphereAttributeKit & sphere_attribute_kit;
44000  };
44001 
44002  class HPS_API SpotlightImportEvent : public ImportEvent
44003  {
44005  SpotlightImportEvent & operator=(SpotlightImportEvent const &);
44006  public:
44007  SpotlightImportEvent();
44008  virtual ~SpotlightImportEvent();
44009  SpotlightImportEvent(HPS::SegmentKey & in_segment_key, HPS::SpotlightKit & in_spotlight_kit);
44010 
44011  HPS::SegmentKey & segment_key;
44012  HPS::SpotlightKit & spotlight_kit;
44013  };
44014 
44015  class HPS_API StyleSegmentImportEvent : public ImportEvent
44016  {
44018  StyleSegmentImportEvent & operator=(StyleSegmentImportEvent const &);
44019  public:
44020  StyleSegmentImportEvent();
44021  virtual ~StyleSegmentImportEvent();
44022  StyleSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_style_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
44023 
44024  HPS::SegmentKey & segment_key;
44025  HPS::SegmentKey & style_segment_key;
44026  HPS::ConditionalExpression & condition;
44027  HPS::AttributeLockTypeArray filter_types;
44028  };
44029 
44030  class HPS_API TextImportEvent : public ImportEvent
44031  {
44033  TextImportEvent & operator=(TextImportEvent const &);
44034  public:
44035  TextImportEvent();
44036  virtual ~TextImportEvent();
44037  TextImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextKit & in_text_kit);
44038 
44039  HPS::SegmentKey & segment_key;
44040  HPS::TextKit & text_kit;
44041  };
44042 
44043  class HPS_API TextAttributeImportEvent : public ImportEvent
44044  {
44046  TextAttributeImportEvent & operator=(TextAttributeImportEvent const &);
44047  public:
44048  TextAttributeImportEvent();
44049  virtual ~TextAttributeImportEvent();
44050  TextAttributeImportEvent(HPS::TextKey & in_text_key, HPS::TextAttributeKit & in_text_attribute_kit);
44051  TextAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextAttributeKit & in_text_attribute_kit);
44052 
44053  HPS::Key & key;
44054  HPS::TextAttributeKit & text_attribute_kit;
44055  };
44056 
44058  {
44060  TextureDefinitionImportEvent & operator=(TextureDefinitionImportEvent const &);
44061  public:
44062  TextureDefinitionImportEvent();
44063  virtual ~TextureDefinitionImportEvent();
44064  TextureDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, HPS::UTF8 && in_name,
44065  HPS::ImageDefinition & in_source_definition, HPS::TextureOptionsKit & in_texture_kit);
44066 
44067  HPS::PortfolioKey & portfolio_key;
44068  UTF8 name;
44069  HPS::ImageDefinition & source_definition;
44070  HPS::TextureOptionsKit & texture_kit;
44071  };
44072 
44073  class HPS_API TransformMaskImportEvent : public ImportEvent
44074  {
44076  TransformMaskImportEvent & operator=(TransformMaskImportEvent const &);
44077  public:
44078  TransformMaskImportEvent();
44079  virtual ~TransformMaskImportEvent();
44080  TransformMaskImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransformMaskKit & in_transform_mask_kit);
44081 
44082  HPS::SegmentKey & segment_key;
44083  HPS::TransformMaskKit & transform_mask_kit;
44084  };
44085 
44086  class HPS_API TransparencyImportEvent : public ImportEvent
44087  {
44089  TransparencyImportEvent & operator=(TransparencyImportEvent const &);
44090  public:
44091  TransparencyImportEvent();
44092  virtual ~TransparencyImportEvent();
44093  TransparencyImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransparencyKit & in_transparency_kit);
44094 
44095  HPS::SegmentKey & segment_key;
44096  HPS::TransparencyKit & transparency_kit;
44097  };
44098 
44099  class HPS_API SubwindowImportEvent : public ImportEvent
44100  {
44102  SubwindowImportEvent & operator=(SubwindowImportEvent const &);
44103  public:
44104  SubwindowImportEvent();
44105  virtual ~SubwindowImportEvent();
44106  SubwindowImportEvent(HPS::SegmentKey & in_segment_key, HPS::SubwindowKit & in_subwindow_kit);
44107 
44108  HPS::SegmentKey & segment_key;
44109  HPS::SubwindowKit & subwindow_kit;
44110  };
44111 
44113  class HPS_API NonDBUserDataImportEvent : public ImportEvent
44114  {
44116  NonDBUserDataImportEvent & operator=(NonDBUserDataImportEvent const &);
44117  public:
44118  NonDBUserDataImportEvent() {}
44119  virtual ~NonDBUserDataImportEvent();
44120  NonDBUserDataImportEvent(size_t in_count, HPS::byte const in_data[]);
44121 
44123  HPS::ByteArray user_data;
44124  };
44125 
44127  class HPS_API UserDataImportEvent : public ImportEvent
44128  {
44130  UserDataImportEvent & operator=(UserDataImportEvent const &);
44131  public:
44132  virtual ~UserDataImportEvent();
44133  UserDataImportEvent();
44134  UserDataImportEvent(HPS::Key & in_key, intptr_t in_index, size_t in_count, HPS::byte const in_data[]);
44135 
44136  HPS::Key key;
44137  intptr_t index;
44138 
44140  HPS::ByteArray user_data;
44141  };
44142 
44143  class HPS_API VisibilityImportEvent : public ImportEvent
44144  {
44146  VisibilityImportEvent & operator=(VisibilityImportEvent const &);
44147  public:
44148  VisibilityImportEvent();
44149  virtual ~VisibilityImportEvent();
44150  VisibilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisibilityKit & in_visibility_kit);
44151 
44152  HPS::SegmentKey & segment_key;
44153  HPS::VisibilityKit & visibility_kit;
44154  };
44155 
44156  class HPS_API VisualEffectsImportEvent : public ImportEvent
44157  {
44159  VisualEffectsImportEvent & operator=(VisualEffectsImportEvent const &);
44160  public:
44161  VisualEffectsImportEvent();
44162  virtual ~VisualEffectsImportEvent();
44163  VisualEffectsImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisualEffectsKit & in_visual_effects_kit);
44164 
44165  HPS::SegmentKey & segment_key;
44166  HPS::VisualEffectsKit & visual_effects_kit;
44167  };
44168 
44170 
44171 
44173  class HPS_API ImportOptionsKit : public Object
44174  {
44175  public:
44177  ImportOptionsKit();
44178 
44181  ImportOptionsKit(ImportOptionsKit const & in_kit);
44182 
44186  ImportOptionsKit(ImportOptionsKit && in_that);
44187 
44191  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
44192 
44193  virtual ~ImportOptionsKit();
44194 
44195  HPS::Type ObjectType() const { return HPS::Type::StreamImportOptionsKit; };
44196 
44199  void Set(ImportOptionsKit const & in_kit);
44200 
44203  void Show(ImportOptionsKit & out_kit) const;
44204 
44208  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
44209 
44212  bool Empty() const;
44213 
44217  bool Equals(ImportOptionsKit const & in_kit) const;
44218 
44222  bool operator==(ImportOptionsKit const & in_kit) const;
44223 
44227  bool operator!=(ImportOptionsKit const & in_kit) const;
44228 
44231  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
44232 
44235  ImportOptionsKit & UnsetToolkit();
44236 
44240  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
44241 
44246  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
44247 
44250  ImportOptionsKit & UnsetSegment();
44251 
44255  bool ShowSegment(SegmentKey & out_segment) const;
44256 
44261  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
44262 
44265  ImportOptionsKit & UnsetAlternateRoot();
44266 
44270  bool ShowAlternateRoot(SegmentKey & out_segment) const;
44271 
44276  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
44277 
44280  ImportOptionsKit & UnsetPortfolio();
44281 
44285  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
44286 
44289  ImportOptionsKit & UnsetEverything();
44290 
44295  ImportOptionsKit & SetEventHandler(HPS::Stream::ImportEventHandler & in_handler, intptr_t in_type);
44296 
44300  ImportOptionsKit & UnsetEventHandler(intptr_t in_type);
44301 
44304  ImportOptionsKit & UnsetEventHandlers();
44305  };
44306 
44308  class HPS_API ImportResultsKit : public Object
44309  {
44310  public:
44312  ImportResultsKit();
44313 
44316  ImportResultsKit(ImportResultsKit const & in_kit);
44317 
44321  ImportResultsKit(ImportResultsKit && in_that);
44322 
44326  ImportResultsKit & operator=(ImportResultsKit && in_that);
44327 
44328  virtual ~ImportResultsKit();
44329 
44330  HPS::Type ObjectType() const { return HPS::Type::StreamImportResultsKit; };
44331 
44334  void Set(ImportResultsKit const & in_kit);
44335 
44338  void Show(ImportResultsKit & out_kit) const;
44339 
44343  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
44344 
44347  bool Empty() const;
44348 
44352  bool Equals(ImportResultsKit const & in_kit) const;
44353 
44357  bool operator==(ImportResultsKit const & in_kit) const;
44358 
44362  bool operator!=(ImportResultsKit const & in_kit) const;
44363 
44368  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
44369 
44373  ImportResultsKit & UnsetSegment();
44374 
44379  bool ShowSegment(SegmentKey & out_segment) const;
44380 
44385  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
44386 
44390  ImportResultsKit & UnsetAlternateRoot();
44391 
44397  bool ShowAlternateRoot(SegmentKey & out_segment) const;
44398 
44403  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
44404 
44408  ImportResultsKit & UnsetPortfolio();
44409 
44415  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
44416 
44421  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
44422 
44426  ImportResultsKit & UnsetDefaultCamera();
44427 
44431  bool ShowDefaultCamera(CameraKit & out_camera) const;
44432 
44433 
44439  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
44440 
44444  ImportResultsKit & UnsetAlternateCameras();
44445 
44450  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
44451 
44452 
44455  ImportResultsKit & UnsetEverything();
44456  };
44457 
44459  class HPS_API ExportOptionsKit : public Object
44460  {
44461  public:
44463  ExportOptionsKit();
44464 
44467  ExportOptionsKit(ExportOptionsKit const & in_kit);
44468 
44472  ExportOptionsKit(ExportOptionsKit && in_that);
44473 
44477  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
44478 
44482  static ExportOptionsKit GetDefault();
44483 
44484  virtual ~ExportOptionsKit();
44485 
44486  HPS::Type ObjectType() const { return HPS::Type::StreamExportOptionsKit; };
44487 
44490  void Set(ExportOptionsKit const & in_kit);
44491 
44494  void Show(ExportOptionsKit & out_kit) const;
44495 
44499  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
44500 
44503  bool Empty() const;
44504 
44508  bool Equals(ExportOptionsKit const & in_kit) const;
44509 
44513  bool operator==(ExportOptionsKit const & in_kit) const;
44514 
44518  bool operator!=(ExportOptionsKit const & in_kit) const;
44519 
44522  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
44523 
44531  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
44532 
44540  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
44541 
44547  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
44548 
44556  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
44557 
44565  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
44566 
44572  ExportOptionsKit & SetConnectivityCompression(bool in_state);
44573 
44579  ExportOptionsKit & SetSerializeTristrips(bool in_state);
44580 
44589  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
44590 
44593  ExportOptionsKit & UnsetToolkit();
44594 
44597  ExportOptionsKit & UnsetVertexCompression();
44598 
44601  ExportOptionsKit & UnsetNormalCompression();
44602 
44605  ExportOptionsKit & UnsetParameterCompression();
44606 
44609  ExportOptionsKit & UnsetColorCompression();
44610 
44613  ExportOptionsKit & UnsetIndexCompression();
44614 
44617  ExportOptionsKit & UnsetConnectivityCompression();
44618 
44621  ExportOptionsKit & UnsetImageCompression();
44622 
44625  ExportOptionsKit & UnsetSerializeTristrips();
44626 
44629  ExportOptionsKit & UnsetEverything();
44630 
44634  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
44635 
44640  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
44641 
44646  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
44647 
44652  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
44653 
44658  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
44659 
44664  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
44665 
44669  bool ShowConnectivityCompression(bool & out_state) const;
44670 
44675  bool ShowImageCompression(bool & out_state, float & out_quality) const;
44676 
44680  bool ShowSerializeTristrips(bool & out_state) const;
44681 
44686  ExportOptionsKit & SetEventHandler(HPS::Stream::ExportEventHandler & in_handler, intptr_t in_type);
44687 
44691  ExportOptionsKit & UnsetEventHandler(intptr_t in_type);
44692 
44695  ExportOptionsKit & UnsetEventHandlers();
44696  };
44697 
44700  class HPS_API ImportNotifier : public IONotifier
44701  {
44702  public:
44704  ImportNotifier();
44705 
44708  ImportNotifier(ImportNotifier const & in_that);
44709 
44714  ImportNotifier(IONotifier const & in_that);
44715 
44719  ImportNotifier(ImportNotifier && in_that);
44720 
44724  ImportNotifier & operator=(ImportNotifier && in_that);
44725 
44726  virtual ~ImportNotifier();
44727 
44728  HPS::Type ObjectType() const {return HPS::Type::StreamImportNotifier;};
44729 
44733  ImportNotifier & operator=(ImportNotifier const & in_that);
44734 
44737  void Assign(ImportNotifier const & in_that);
44738 
44742  ImportResultsKit GetResults() const;
44743  };
44744 
44747  class HPS_API ExportNotifier : public IONotifier
44748  {
44749  public:
44751  ExportNotifier();
44752 
44755  ExportNotifier(ExportNotifier const & in_that);
44756 
44761  ExportNotifier(IONotifier const & in_that);
44762 
44766  ExportNotifier(ExportNotifier && in_that);
44767 
44771  ExportNotifier & operator=(ExportNotifier && in_that);
44772 
44773  virtual ~ExportNotifier();
44774 
44775  HPS::Type ObjectType() const {return HPS::Type::StreamExportNotifier;};
44776 
44780  ExportNotifier & operator=(ExportNotifier const & in_that);
44781 
44784  void Assign(ExportNotifier const & in_that);
44785  };
44786 
44787 
44789  class HPS_API File
44790  {
44791  public:
44797  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
44798 
44804  static ImportNotifier Import(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
44805 
44812  static ExportNotifier Export(char const * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
44813 
44820  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
44821 
44822  private:
44824  File();
44825  };
44826 private:
44828  Stream();
44829 };
44830 
44834 
44839 class HPS_API Hardcopy
44840 {
44841 public:
44842 
44844  enum class SizeUnits
44845  {
44846  Centimeters,
44847  Inches,
44848  };
44849 
44851  enum class ResolutionUnits
44852  {
44853  DPCM,
44854  DPI,
44855  DotsPerCentimeter = DPCM,
44856  DotsPerInch = DPI,
44857  };
44858 
44860  class HPS_API File
44861  {
44862  public:
44863 
44865  class HPS_API ExportOptionsKit : public Object
44866  {
44867  public:
44869  ExportOptionsKit();
44870 
44873  ExportOptionsKit(ExportOptionsKit const & in_kit);
44874 
44878  ExportOptionsKit(ExportOptionsKit && in_that);
44879 
44883  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
44884 
44885  virtual ~ExportOptionsKit();
44886 
44887  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
44888 
44891  void Set(ExportOptionsKit const & in_kit);
44892 
44895  void Show(ExportOptionsKit & out_kit) const;
44896 
44900  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
44901 
44904  bool Empty() const;
44905 
44909  bool Equals(ExportOptionsKit const & in_kit) const;
44910 
44914  bool operator==(ExportOptionsKit const & in_kit) const;
44915 
44919  bool operator!=(ExportOptionsKit const & in_kit) const;
44920 
44921 
44922 
44923 
44929  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
44930 
44938  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
44939 
44942  ExportOptionsKit & UnsetSize();
44943 
44944 
44945 
44951  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
44952 
44959  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
44960 
44963  ExportOptionsKit & UnsetResolution();
44964 
44965 
44966 
44969  bool ShowWYSIWYG(bool & out_onoff) const;
44970 
44982  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
44983 
44986  ExportOptionsKit & UnsetWYSIWYG();
44987 
44988 
44991  ExportOptionsKit & UnsetEverything();
44992 
44993 
44997  static ExportOptionsKit GetDefault();
44998  };
44999 
45001  enum class Driver
45002  {
45003  PDF,
45004  Postscript
45005  };
45006 
45012  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
45013  private:
45014  File();
45015  };
45016 
45017 #ifdef _MSC_VER
45018  class HPS_API GDI
45019  {
45020  public:
45021 
45023  class HPS_API ExportOptionsKit : public Object
45024  {
45025  public:
45027  ExportOptionsKit();
45028 
45031  ExportOptionsKit(ExportOptionsKit const & in_kit);
45032 
45036  ExportOptionsKit(ExportOptionsKit && in_that);
45037 
45041  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
45042 
45043  virtual ~ExportOptionsKit();
45044 
45045  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
45046 
45049  void Set(ExportOptionsKit const & in_kit);
45050 
45053  void Show(ExportOptionsKit & out_kit) const;
45054 
45058  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
45059 
45062  bool Empty() const;
45063 
45067  bool Equals(ExportOptionsKit const & in_kit) const;
45068 
45072  bool operator==(ExportOptionsKit const & in_kit) const;
45073 
45077  bool operator!=(ExportOptionsKit const & in_kit) const;
45078 
45079 
45080 
45081 
45085  bool ShowResolution(float & out_resolution) const;
45086 
45090  ExportOptionsKit & SetResolution(float in_resolution);
45091 
45094  ExportOptionsKit & UnsetResolution();
45095 
45096 
45097 
45098 
45101  bool ShowWYSIWYG(bool & out_onoff) const;
45102 
45106  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
45107 
45110  ExportOptionsKit & UnsetWYSIWYG();
45111 
45112 
45115  ExportOptionsKit & UnsetEverything();
45116  };
45117 
45124  static IOResult Export(intptr_t hdc, intptr_t attribdc, HPS::WindowKey const & window, ExportOptionsKit const & options);
45125 
45126  private:
45127  GDI();
45128  };
45129 #endif
45130 
45131 private:
45132  Hardcopy();
45133 };
45134 
45138 
45140 class HPS_API OBJ
45141 {
45142 public:
45143 
45145  class HPS_API ImportOptionsKit : public Object
45146  {
45147  public:
45149  ImportOptionsKit();
45150 
45153  ImportOptionsKit(ImportOptionsKit const & in_kit);
45154 
45158  ImportOptionsKit(ImportOptionsKit && in_that);
45159 
45163  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
45164 
45165  virtual ~ImportOptionsKit();
45166 
45167  HPS::Type ObjectType() const { return HPS::Type::OBJImportOptionsKit; };
45168 
45171  void Set(ImportOptionsKit const & in_kit);
45172 
45175  void Show(ImportOptionsKit & out_kit) const;
45176 
45180  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
45181 
45184  bool Empty() const;
45185 
45189  bool Equals(ImportOptionsKit const & in_kit) const;
45190 
45194  bool operator==(ImportOptionsKit const & in_kit) const;
45195 
45199  bool operator!=(ImportOptionsKit const & in_kit) const;
45200 
45205  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
45206 
45209  ImportOptionsKit & UnsetSegment();
45210 
45214  bool ShowSegment(SegmentKey & out_segment) const;
45215 
45220  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
45221 
45224  ImportOptionsKit & UnsetPortfolio();
45225 
45229  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
45230 
45236  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
45237 
45240  ImportOptionsKit & UnsetHandedness();
45241 
45245  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
45246 
45249  ImportOptionsKit & UnsetEverything();
45250  };
45251 
45253  class HPS_API ImportResultsKit : public Object
45254  {
45255  public:
45257  ImportResultsKit();
45258 
45261  ImportResultsKit(ImportResultsKit const & in_kit);
45262 
45266  ImportResultsKit(ImportResultsKit && in_that);
45267 
45271  ImportResultsKit & operator=(ImportResultsKit && in_that);
45272 
45273  virtual ~ImportResultsKit();
45274 
45275  HPS::Type ObjectType() const { return HPS::Type::OBJImportResultsKit; };
45276 
45279  void Set(ImportResultsKit const & in_kit);
45280 
45283  void Show(ImportResultsKit & out_kit) const;
45284 
45288  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
45289 
45292  bool Empty() const;
45293 
45297  bool Equals(ImportResultsKit const & in_kit) const;
45298 
45302  bool operator==(ImportResultsKit const & in_kit) const;
45303 
45307  bool operator!=(ImportResultsKit const & in_kit) const;
45308 
45313  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
45314 
45318  ImportResultsKit & UnsetSegment();
45319 
45324  bool ShowSegment(SegmentKey & out_segment) const;
45325 
45330  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
45331 
45335  ImportResultsKit & UnsetPortfolio();
45336 
45342  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
45343 
45348  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
45349 
45353  ImportResultsKit & UnsetHandedness();
45354 
45359  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
45360 
45363  ImportResultsKit & UnsetEverything();
45364  };
45365 
45368  class HPS_API ImportNotifier : public IONotifier
45369  {
45370  public:
45372  ImportNotifier();
45373 
45376  ImportNotifier(ImportNotifier const & in_that);
45377 
45382  ImportNotifier(IONotifier const & in_that);
45383 
45387  ImportNotifier(ImportNotifier && in_that);
45388 
45392  ImportNotifier & operator=(ImportNotifier && in_that);
45393 
45394  virtual ~ImportNotifier();
45395 
45396  HPS::Type ObjectType() const {return HPS::Type::OBJImportNotifier;};
45397 
45401  ImportNotifier & operator=(ImportNotifier const & in_that);
45402 
45405  void Assign(ImportNotifier const & in_that);
45406 
45410  ImportResultsKit GetResults() const;
45411  };
45412 
45413 
45415  class HPS_API File
45416  {
45417  public:
45423  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
45424 
45425  private:
45427  File();
45428  };
45429 private:
45431  OBJ();
45432 };
45433 
45437 
45439 class HPS_API STL
45440 {
45441 public:
45442 
45444  class HPS_API ImportOptionsKit : public Object
45445  {
45446  public:
45448  ImportOptionsKit();
45449 
45452  ImportOptionsKit(ImportOptionsKit const & in_kit);
45453 
45457  ImportOptionsKit(ImportOptionsKit && in_that);
45458 
45462  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
45463 
45464  virtual ~ImportOptionsKit();
45465 
45466  HPS::Type ObjectType() const { return HPS::Type::STLImportOptionsKit; };
45467 
45470  void Set(ImportOptionsKit const & in_kit);
45471 
45474  void Show(ImportOptionsKit & out_kit) const;
45475 
45479  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
45480 
45483  bool Empty() const;
45484 
45488  bool Equals(ImportOptionsKit const & in_kit) const;
45489 
45493  bool operator==(ImportOptionsKit const & in_kit) const;
45494 
45498  bool operator!=(ImportOptionsKit const & in_kit) const;
45499 
45503  static ImportOptionsKit GetDefault();
45504 
45509  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
45510 
45518  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
45519 
45526  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
45527 
45528 
45531  ImportOptionsKit & UnsetSegment();
45532 
45535  ImportOptionsKit & UnsetOptimization();
45536 
45539  ImportOptionsKit & UnsetEverything();
45540 
45541 
45545  bool ShowSegment(SegmentKey & out_segment) const;
45546 
45551  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
45552  };
45553 
45555  class HPS_API ImportResultsKit : public Object
45556  {
45557  public:
45559  ImportResultsKit();
45560 
45563  ImportResultsKit(ImportResultsKit const & in_kit);
45564 
45568  ImportResultsKit(ImportResultsKit && in_that);
45569 
45573  ImportResultsKit & operator=(ImportResultsKit && in_that);
45574 
45575  virtual ~ImportResultsKit();
45576 
45577  HPS::Type ObjectType() const { return HPS::Type::STLImportResultsKit; };
45578 
45581  void Set(ImportResultsKit const & in_kit);
45582 
45585  void Show(ImportResultsKit & out_kit) const;
45586 
45590  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
45591 
45594  bool Empty() const;
45595 
45599  bool Equals(ImportResultsKit const & in_kit) const;
45600 
45604  bool operator==(ImportResultsKit const & in_kit) const;
45605 
45609  bool operator!=(ImportResultsKit const & in_kit) const;
45610 
45615  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
45616 
45620  ImportResultsKit & UnsetSegment();
45621 
45626  bool ShowSegment(SegmentKey & out_segment) const;
45627 
45630  ImportResultsKit & UnsetEverything();
45631  };
45632 
45635  class HPS_API ImportNotifier : public IONotifier
45636  {
45637  public:
45639  ImportNotifier();
45640 
45643  ImportNotifier(ImportNotifier const & in_that);
45644 
45649  ImportNotifier(IONotifier const & in_that);
45650 
45654  ImportNotifier(ImportNotifier && in_that);
45655 
45659  ImportNotifier & operator=(ImportNotifier && in_that);
45660 
45661  virtual ~ImportNotifier();
45662 
45663  HPS::Type ObjectType() const {return HPS::Type::STLImportNotifier;};
45664 
45668  ImportNotifier & operator=(ImportNotifier const & in_that);
45669 
45672  void Assign(ImportNotifier const & in_that);
45673 
45677  ImportResultsKit GetResults() const;
45678  };
45679 
45680 
45682  class HPS_API File
45683  {
45684  public:
45690  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
45691 
45692  private:
45694  File();
45695  };
45696 private:
45698  STL();
45699 };
45700 
45701 }
45702 
45703 #ifdef _MSC_VER
45704 # pragma warning(pop)
45705 #endif
45706 
45707 #endif
45708 
45709 
HPS::Type ObjectType() const
Definition: hps.h:40725
Rotation
Definition: hps.h:1569
HPS::Type ObjectType() const
Definition: hps.h:27247
bool Empty() const
Definition: hps.h:6879
CameraPoint(Point const &in_point)
Definition: hps.h:5830
Alignment
Definition: hps.h:1502
HPS::Type ObjectType() const
Definition: hps.h:19583
Space
Definition: hps.h:562
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:42601
Definition: hps.h:3286
Definition: hps.h:6069
Channel
Definition: hps.h:910
HPS::Type ObjectType() const
Definition: hps.h:24403
Handedness
Definition: hps.h:1257
Definition: hps.h:14413
Definition: hps.h:1030
Definition: hps.h:12157
ColorSource
Definition: hps.h:1895
HPS::Type ObjectType() const
Definition: hps.h:17311
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:42387
HPS::Type ObjectType() const
Definition: hps.h:36926
Event(intptr_t in_channel=0)
Definition: hps.h:6183
Definition: hps.h:18429
HPS::Type ObjectType() const
Definition: hps.h:45396
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3778
HPS::ByteArray user_data
Definition: hps.h:44123
float alpha
Definition: hps.h:4317
Definition: hps.h:35288
HPS::Type ObjectType() const
Definition: hps.h:36528
bool operator==(Touch const &in_that) const
Definition: hps.h:6473
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:42408
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:42058
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:41691
InformationEvent(char const *in_message)
Definition: hps.h:41491
size_t display_list_tristrip_count
Number of tristrips drawn from display lists during the last update.
Definition: hps.h:4835
HPS::Type ObjectType() const
Definition: hps.h:34950
Definition: hps.h:8697
HPS::Type ObjectType() const
Definition: hps.h:22113
HPS::Type ObjectType() const
Definition: hps.h:23931
size_t extent_culled_segment_count
Number of segments culled because of extent culling during the last update.
Definition: hps.h:4841
HPS::Type ObjectType() const
Definition: hps.h:24677
Action
Definition: hps.h:42199
Definition: hps.h:43263
Orientation
Definition: hps.h:538
Definition: hps.h:20921
Code
Definition: hps.h:136
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1315
Definition: hps.h:40542
HPS::Type ObjectType() const
Definition: hps.h:15172
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:41746
HPS::Type ObjectType() const
Definition: hps.h:8628
HPS::Type ObjectType() const
Definition: hps.h:28476
Definition: hps.h:43521
Event * Clone() const
Definition: hps.h:41589
Definition: hps.h:13439
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:42518
Definition: hps.h:45140
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:41377
ImportStatusEvent()
Definition: hps.h:41899
HPS::Type ObjectType() const
Definition: hps.h:21728
HPS::Type ObjectType() const
Definition: hps.h:36703
Definition: hps.h:13947
HPS::Type ObjectType() const
Definition: hps.h:26194
Definition: hps.h:43191
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:42264
size_t frustum_culled_segment_count
Number of segments culled because of frustum culling during the last update.
Definition: hps.h:4840
HPS::Type ObjectType() const
Definition: hps.h:30587
HPS::Type ObjectType() const
Definition: hps.h:25805
HPS::Type ObjectType() const
Definition: hps.h:11806
static MouseButtons ButtonX2()
Definition: hps.h:42463
Definition: hps.h:20021
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41638
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:42707
Definition: hps.h:45555
Definition: hps.h:38646
Definition: hps.h:19375
HPS::Type ObjectType() const
Definition: hps.h:38466
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5727
Definition: hps.h:43817
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5975
bool Middle() const
Definition: hps.h:42373
Definition: hps.h:473
Driver
Definition: hps.h:159
HPS::Type ObjectType() const
Definition: hps.h:42747
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2219
Definition: hps.h:36019
HPS::Type ObjectType() const
Definition: hps.h:39864
CappingLevel
Definition: hps.h:1701
Definition: hps.h:42609
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8712
HPS::Type ObjectType() const
Definition: hps.h:23658
HPS::Type ObjectType() const
Definition: hps.h:36456
Definition: hps.h:9447
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12951
size_t dot_3d_count
Number of 3D dots drawn during the last update.
Definition: hps.h:4823
HPS::Type ObjectType() const
Definition: hps.h:42859
HPS::Type ObjectType() const
Definition: hps.h:20765
Definition: hps.h:43761
Definition: hps.h:26823
HPS::Type ObjectType() const
Definition: hps.h:13970
InputEvent()
Definition: hps.h:42143
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5578
HPS::UTF8 text
The text for this TextInputEvent.
Definition: hps.h:41852
Multiline strings will be left justified.
Definition: hps.h:35986
static MouseButtons ButtonRight()
Definition: hps.h:42451
HPS::Type ObjectType() const
Definition: hps.h:29262
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3885
Definition: hps.h:5618
Definition: hps.h:36291
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:42646
static ModifierKeys KeyMeta()
Definition: hps.h:42117
HPS::Type ObjectType() const
Definition: hps.h:36186
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1478
Definition: hps.h:23824
HPS::Type ObjectType() const
Definition: hps.h:37621
Definition: hps.h:16886
HPS::Type ObjectType() const
Definition: hps.h:44775
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:42338
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3764
Definition: hps.h:35645
HPS::Type ObjectType() const
Definition: hps.h:19822
HPS::Type ObjectType() const
Definition: hps.h:40041
HPS::Type ObjectType() const
Definition: hps.h:23856
HPS::Type ObjectType() const
Definition: hps.h:35724
Definition: hps.h:22661
HPS::Type ObjectType() const
Definition: hps.h:17001
MouseButtons()
Definition: hps.h:42333
HPS::Type ObjectType() const
Definition: hps.h:39055
Definition: hps.h:20533
Time GetTimeStamp() const
Definition: hps.h:6205
Definition: hps.h:45682
void Left(bool in_state)
Definition: hps.h:42396
HPS::Type ObjectType() const
Definition: hps.h:22631
NormalizedPoint(Point const &in_point)
Definition: hps.h:5880
HPS::Type ObjectType() const
Definition: hps.h:24205
Event * Clone() const
Definition: hps.h:41406
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3813
Definition: hps.h:43328
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:42392
Renderer
Definition: hps.h:1550
HPS::Type ObjectType() const
Definition: hps.h:34686
Definition: hps.h:40902
KeyboardEvent()
Definition: hps.h:42622
HPS::Type ObjectType() const
Definition: hps.h:7386
Definition: hps.h:38433
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:4006
ObjectPoint(Point const &in_point)
Definition: hps.h:5730
HPS::Type ObjectType() const
Definition: hps.h:17898
Definition: hps.h:34136
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:41965
Definition: hps.h:40645
Definition: hps.h:4394
Definition: hps.h:6688
Definition: hps.h:1308
Definition: hps.h:41427
Definition: hps.h:24645
Point_3D< F > min
Definition: hps.h:3748
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:41720
static ModifierKeys KeyAlt()
Definition: hps.h:42113
bool IsConsumable() const
Definition: hps.h:6208
HPS::ByteArray user_data
Definition: hps.h:44140
Definition: hps.h:1026
size_t GetHash() const
Definition: hps.h:1638
MaterialPreference
Definition: hps.h:1718
size_t line_dc_count
Number of DC lines drawn during the last update.
Definition: hps.h:4824
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:42635
Mobility
Definition: hps.h:206
HPS::Type ObjectType() const
Definition: hps.h:13462
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5928
Definition: hps.h:14852
InterpolationAlgorithm
Definition: hps.h:1484
Fill
Definition: hps.h:1886
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3801
Definition: hps.h:24099
Definition: hps.h:19560
HPS::Type ObjectType() const
Definition: hps.h:27752
HPS::Type ObjectType() const
Definition: hps.h:19398
char At(size_t in_index) const
Definition: hps.h:6922
Definition: hps.h:40714
Definition: hps.h:4420
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:42053
HPS::Type ObjectType() const
Definition: hps.h:36583
HPS::Type ObjectType() const
Definition: hps.h:7105
Definition: hps.h:130
ReferenceFrame
Definition: hps.h:1517
size_t polygon_dc_count
Number of DC polygons drawn during the last update.
Definition: hps.h:4828
Definition: hps.h:26162
Radial bloom.
Definition: hps.h:42938
HideKeyboardEvent()
Definition: hps.h:41969
Definition: hps.h:3746
Definition: hps.h:3743
HPS::Type ObjectType() const
Definition: hps.h:17225
GreekingUnits
Definition: hps.h:1604
Definition: hps.h:18923
Definition: hps.h:7441
HPS::Type ObjectType() const
Definition: hps.h:12360
InnerConeUnits
Definition: hps.h:493
Definition: hps.h:27038
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6024
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3918
static MouseButtons ButtonX1()
Definition: hps.h:42459
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41861
Definition: hps.h:18642
Definition: hps.h:3433
OuterConeUnits
Definition: hps.h:479
Definition: hps.h:6455
void X2(bool in_state)
Definition: hps.h:42412
HPS::Type ObjectType() const
Definition: hps.h:19182
HPS::Type ObjectType() const
Definition: hps.h:41228
size_t culled_display_list_tristrip_count
Number of tristrips from display lists culled during the last update.
Definition: hps.h:4837
HPS::Type ObjectType() const
Definition: hps.h:40138
HPS::Type ObjectType() const
Definition: hps.h:14600
Definition: hps.h:15148
Definition: hps.h:1967
HPS::Type ObjectType() const
Definition: hps.h:34169
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:42714
HPS::Type ObjectType() const
Definition: hps.h:27140
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:42288
Definition: hps.h:44030
Definition: hps.h:43417
HPS::Type ObjectType() const
Definition: hps.h:12834
HPS::Type ObjectType() const
Definition: hps.h:25387
Definition: hps.h:446
HPS::Type ObjectType() const
Definition: hps.h:37044
Definition: hps.h:22091
Channel
Definition: hps.h:870
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:41620
AreaUnits
Definition: hps.h:1443
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3855
HPS::Type ObjectType() const
Definition: hps.h:12181
Definition: hps.h:2067
Definition: hps.h:27118
Definition: hps.h:19799
HPS::Type ObjectType() const
Definition: hps.h:35310
Action
Definition: hps.h:41702
Event * Clone() const
Definition: hps.h:41518
HPS::Type ObjectType() const
Definition: hps.h:14436
Definition: hps.h:4669
HPS::Type ObjectType() const
Definition: hps.h:44486
HPS::Type ObjectType() const
Definition: hps.h:27853
Definition: hps.h:44002
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6488
Definition: hps.h:21511
Definition: hps.h:4551
HPS::Type ObjectType() const
Definition: hps.h:38584
HPS::Type ObjectType() const
Definition: hps.h:34823
Definition: hps.h:1376
Definition: hps.h:18110
Definition: hps.h:847
Definition: hps.h:5604
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:42221
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3964
Border
Definition: hps.h:275
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:42048
Time update_time
Time taken by the last update.
Definition: hps.h:4845
Definition: hps.h:38551
Definition: hps.h:36681
size_t vector_culled_segment_count
Number of segments culled because of vector culling during the last update.
Definition: hps.h:4842
Definition: hps.h:7431
HPS::Type ObjectType() const
Definition: hps.h:23398
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:42683
HPS::Type ObjectType() const
Definition: hps.h:21653
WarningEvent(Event const &in_event)
Definition: hps.h:41571
Definition: hps.h:37644
HPS::Type ObjectType() const
Definition: hps.h:11678
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1905
Definition: hps.h:1685
static ModifierKeys KeyShift()
Definition: hps.h:42105
Definition: hps.h:151
HPS::Type ObjectType() const
Definition: hps.h:28988
Shape
Definition: hps.h:1052
bool IsValid() const
Definition: hps.h:6872
Definition: hps.h:20742
Definition: hps.h:1496
Cuboid_3D()
Definition: hps.h:3756
ErrorEvent(Event const &in_event)
Definition: hps.h:41642
size_t GetWStrLength() const
Definition: hps.h:6901
Event * Clone() const
Definition: hps.h:41471
HPS::Type ObjectType() const
Definition: hps.h:11267
AppendMode
Definition: hps.h:341
Definition: hps.h:8608
Definition: hps.h:25635
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:42377
Definition: hps.h:247
Definition: hps.h:41895
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3949
void Meta(bool in_state)
Definition: hps.h:42070
Definition: hps.h:6640
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6123
Definition: hps.h:27225
Definition: hps.h:43748
HPS::Type ObjectType() const
Definition: hps.h:14878
UpdateStatus
Definition: hps.h:170
HPS_INLINE bool IsValid() const
Definition: hps.h:3806
HPS::Type ObjectType() const
Definition: hps.h:39167
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:41767
Definition: hps.h:21314
Quality
Definition: hps.h:1036
ResolutionUnits
Definition: hps.h:44851
Event * Clone() const
Definition: hps.h:42153
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:42190
Definition: hps.h:4493
TimerTickEvent(Event const &in_event)
Definition: hps.h:41396
Component
Definition: hps.h:360
Definition: hps.h:45253
Definition: hps.h:5722
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6074
HPS::Type ObjectType() const
Definition: hps.h:12447
Definition: hps.h:12574
Default
Definition: hps.h:1859
HPS::Type ObjectType() const
Definition: hps.h:10796
Definition: hps.h:17202
Definition: hps.h:2159
Definition: hps.h:25093
InformationEvent()
Definition: hps.h:41487
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5094
Definition: hps.h:38385
Definition: hps.h:11782
Definition: hps.h:41936
Definition: hps.h:14028
size_t triangle_3d_count
Number of 3D triangles drawn during the last update.
Definition: hps.h:4827
Definition: hps.h:11243
Definition: hps.h:45635
bool Shift() const
Definition: hps.h:42030
SizeToleranceUnits
Definition: hps.h:1591
HPS::Type ObjectType() const
Definition: hps.h:39291
Definition: hps.h:1737
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4035
Definition: hps.h:43708
Cap
Definition: hps.h:1811
Point_3D< F > max
Definition: hps.h:3750
HPS::Type ObjectType() const
Definition: hps.h:7469
Definition: hps.h:11511
Definition: hps.h:21089
Definition: hps.h:14149
HPS::Type ObjectType() const
Definition: hps.h:45167
HPS::Type ObjectType() const
Definition: hps.h:45275
MouseEvent()
Definition: hps.h:42500
Definition: hps.h:14236
HPS::Type ObjectType() const
Definition: hps.h:12286
Definition: hps.h:20293
Definition: hps.h:27496
Definition: hps.h:1046
HPS::Type ObjectType() const
Definition: hps.h:16908
Definition: hps.h:12482
Definition: hps.h:32874
HPS::Type ObjectType() const
Definition: hps.h:35769
Definition: hps.h:12810
static const float Infinity
Definition: hps.h:2214
InsetBehavior
Definition: hps.h:1792
HPS::Type ObjectType() const
Definition: hps.h:25313
Definition: hps.h:5691
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2227
HPS::Type ObjectType() const
Definition: hps.h:13858
HPS::Type ObjectType() const
Definition: hps.h:27446
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6487
HPS::Type ObjectType() const
Definition: hps.h:35959
HPS::Type ObjectType() const
Definition: hps.h:38311
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3928
Algorithm
Definition: hps.h:1430
Definition: hps.h:42837
Definition: hps.h:8647
Decimation
Definition: hps.h:990
StaticModel
Definition: hps.h:1095
Definition: hps.h:39267
Granularity
Definition: hps.h:1360
Definition: hps.h:37542
DisplayLists
Definition: hps.h:1073
Definition: hps.h:11024
Search the current segment only.
size_t display_list_line_3d_count
Number of lines drawn from display lists during the last update.
Definition: hps.h:4832
Definition: hps.h:44747
Definition: hps.h:2673
Definition: hps.h:44459
Definition: hps.h:556
KeyboardEvent(Event const &in_event)
Definition: hps.h:42655
Definition: hps.h:21362
Definition: hps.h:35696
ClipOperation
Definition: hps.h:1288
HPS::Type ObjectType() const
Definition: hps.h:8970
Definition: hps.h:2586
Definition: hps.h:30554
Method
Definition: hps.h:1421
Definition: hps.h:37588
HPS::Type ObjectType() const
Definition: hps.h:26855
Definition: hps.h:44789
Parameterization
Definition: hps.h:924
Definition: hps.h:4311
Definition: hps.h:37839
Definition: hps.h:37017
FocusLostEvent()
Definition: hps.h:41775
CuttingLevel
Definition: hps.h:1710
Channel
Definition: hps.h:891
Definition: hps.h:9530
Definition: hps.h:45444
HandleResult
Definition: hps.h:41367
Definition: hps.h:39842
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5106
Definition: hps.h:5970
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:41690
Value
Definition: hps.h:1402
Definition: hps.h:1066
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2235
Code
Definition: hps.h:105
HPS::Type ObjectType() const
Definition: hps.h:26346
Event * Clone() const
Definition: hps.h:41783
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:42554
Definition: hps.h:43107
Definition: hps.h:42483
ShowKeyboardEvent(Event const &in_event)
Definition: hps.h:41946
ErrorEvent()
Definition: hps.h:41629
Definition: hps.h:41696
Justification
Definition: hps.h:1525
The vertex colors applied to faces.
Definition: hps.h:6560
HPS::Type ObjectType() const
Definition: hps.h:14260
Definition: hps.h:35825
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5596
Definition: hps.h:43207
ErrorEvent(char const *in_message)
Definition: hps.h:41633
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41868
Definition: hps.h:42194
FrameSize
Definition: hps.h:216
Definition: hps.h:2174
Definition: hps.h:9338
Definition: hps.h:23909
Definition: hps.h:12263
Justification
Definition: hps.h:1828
Definition: hps.h:21846
HPS::Type ObjectType() const
Definition: hps.h:12004
Definition: hps.h:41205
Definition: hps.h:38594
Definition: hps.h:44127
HPS::Type ObjectType() const
Definition: hps.h:20045
Definition: hps.h:1662
TextInputEvent(Event const &in_event)
Definition: hps.h:41805
Definition: hps.h:1455
HPS::Type ObjectType() const
Definition: hps.h:22462
bool None() const
Definition: hps.h:42361
Definition: hps.h:327
Definition: hps.h:1396
HPS::Type ObjectType() const
Definition: hps.h:8753
HPS::Type ObjectType() const
Definition: hps.h:37575
Definition: hps.h:43909
Definition: hps.h:41791
HPS::Type ObjectType() const
Definition: hps.h:35673
Definition: hps.h:17875
GreekingMode
Definition: hps.h:1616
HPS::Type ObjectType() const
Definition: hps.h:20557
Definition: hps.h:36904
Definition: hps.h:43221
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:42719
Operation
Definition: hps.h:461
Definition: hps.h:1415
HPS::Type ObjectType() const
Definition: hps.h:38156
Type
Definition: hps.h:1973
WorldPoint(Point const &in_point)
Definition: hps.h:5780
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:42313
Definition: hps.h:45415
Definition: hps.h:43149
HPS::Type ObjectType() const
Definition: hps.h:9993
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2506
Definition: hps.h:22861
HPS::Type ObjectType() const
Definition: hps.h:6719
Definition: hps.h:35439
Definition: hps.h:18183
TouchEvent(Event const &in_event)
Definition: hps.h:42236
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7004
Definition: hps.h:5077
Definition: hps.h:40115
Definition: hps.h:45439
size_t save_region_count
Number of framebuffer regions saved during the last update.
Definition: hps.h:4843
Definition: hps.h:35926
Definition: hps.h:4250
Relation
Definition: hps.h:386
Action
Definition: hps.h:42614
ChannelMapping
Definition: hps.h:1006
HPS::Type ObjectType() const
Definition: hps.h:22979
Definition: hps.h:6817
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5613
HPS::Type ObjectType() const
Definition: hps.h:39661
HPS::Type ObjectType() const
Definition: hps.h:40327
Definition: hps.h:24183
Definition: hps.h:5823
HPS::Type ObjectType() const
Definition: hps.h:43132
bool Alt() const
Definition: hps.h:42038
Definition: hps.h:42329
ToleranceUnits
Definition: hps.h:369
Definition: hps.h:24962
Definition: hps.h:27720
HPS::Type ObjectType() const
Definition: hps.h:12760
SizeUnits
Definition: hps.h:1779
Type
Definition: hps.h:2008
HPS::Type ObjectType() const
Definition: hps.h:18029
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:36014
RelationTest
Definition: hps.h:396
Definition: hps.h:40019
Definition: hps.h:8676
Definition: hps.h:43655
Type
Definition: hps.h:333
Event * Clone() const
Definition: hps.h:41985
HPS::Type ObjectType() const
Definition: hps.h:15024
Behavior
Definition: hps.h:571
Definition: hps.h:5773
Fastest ambient occlusion but lower quality.
HPS::Type ObjectType() const
Definition: hps.h:6794
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:42720
Definition: hps.h:41383
HPS::Type ObjectType() const
Definition: hps.h:18946
Style Append Mode.
ImageFormat
Definition: hps.h:232
Definition: hps.h:39316
Definition: hps.h:25783
Definition: hps.h:42725
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5587
float blue
Definition: hps.h:4316
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:41771
Type
Definition: hps.h:434
HPS::Type ObjectType() const
Definition: hps.h:21385
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7022
PixelPoint(Point const &in_point)
Definition: hps.h:6126
HPS::Type ObjectType() const
Definition: hps.h:6248
Definition: hps.h:18005
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:42580
Definition: hps.h:21227
Definition: hps.h:44700
size_t non_display_list_tristrip_count
Number of tristrips drawn during the last update.
Definition: hps.h:4836
HPS::Type ObjectType() const
Definition: hps.h:21990
size_t display_list_vertex_3d_count
Number of vertices drawn from display lists during the last update.
Definition: hps.h:4834
HPS::Type ObjectType() const
Definition: hps.h:21869
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
HPS::Type ObjectType() const
Definition: hps.h:35912
UpdateType
Definition: hps.h:181
HPS::Type ObjectType() const
Definition: hps.h:29131
HPS::Type ObjectType() const
Definition: hps.h:24476
HPS::Type ObjectType() const
Definition: hps.h:39967
HPS::Type ObjectType() const
Definition: hps.h:21250
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:42600
Event * Clone() const
Definition: hps.h:41926
Definition: hps.h:14562
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5100
Definition: hps.h:36550
Definition: hps.h:41857
HPS::Type ObjectType() const
Definition: hps.h:35220
HPS::Type ObjectType() const
Definition: hps.h:41336
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:44308
HPS::Type ObjectType() const
Definition: hps.h:16056
Definition: hps.h:1880
Definition: hps.h:31739
Infinite line which extends infinitely in both directions along a vector.
size_t line_3d_count
Number of 3D lines drawn during the last update.
Definition: hps.h:4825
InformationEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41496
intptr_t GetChannel() const
Definition: hps.h:6202
HPS::Type ObjectType() const
Definition: hps.h:9362
Definition: hps.h:1328
Definition: hps.h:13834
Algorithm
Definition: hps.h:1343
Definition: hps.h:43682
HPS::Type ObjectType() const
Definition: hps.h:31761
Definition: hps.h:43882
HPS::Type ObjectType() const
Definition: hps.h:38627
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3873
Definition: hps.h:12737
Definition: hps.h:43456
Definition: hps.h:10772
Driver
Definition: hps.h:45001
Definition: hps.h:7063
Definition: hps.h:43048
SizeUnits
Definition: hps.h:1645
StandAloneWindowEvent()
Definition: hps.h:41711
HPS::Type ObjectType() const
Definition: hps.h:37113
HPS::Type ObjectType() const
Definition: hps.h:35058
ModifierKeys GetModifierKeys() const
Definition: hps.h:42185
Definition: hps.h:41994
Definition: hps.h:40296
TextInputEvent(char const *in_text)
Definition: hps.h:41801
Definition: hps.h:41554
HPS::Type ObjectType() const
Definition: hps.h:12597
HPS::Type ObjectType() const
Definition: hps.h:11417
Definition: hps.h:43869
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:41598
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:42508
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5559
HPS::Type ObjectType() const
Definition: hps.h:17738
Level
Definition: hps.h:1334
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:41527
bool X2() const
Definition: hps.h:42381
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:42003
Definition: hps.h:35036
Definition: hps.h:45368
bool Left() const
Definition: hps.h:42365
void Control(bool in_state)
Definition: hps.h:42062
Definition: hps.h:21958
Definition: hps.h:2923
Definition: hps.h:17287
Definition: hps.h:42138
HPS::Type ObjectType() const
Definition: hps.h:44728
HPS::Type ObjectType() const
Definition: hps.h:18452
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:4020
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:41619
The base class of all HPS exceptions.
Definition: hps.h:5551
RegionAlignment
Definition: hps.h:1625
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:42230
Event * Clone() const
Definition: hps.h:42545
Definition: hps.h:6169
HPS::Type ObjectType() const
Definition: hps.h:21534
Definition: hps.h:38083
InformationEvent(Event const &in_event)
Definition: hps.h:41500
Definition: hps.h:13014
void Invalidate()
Definition: hps.h:3818
Definition: hps.h:23366
Definition: hps.h:39638
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4812
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5610
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41864
HPS::Type ObjectType() const
Definition: hps.h:34546
size_t restore_region_count
Number of framebuffer regions restored during the last update.
Definition: hps.h:4844
Definition: hps.h:43949
Definition: hps.h:6119
HPS::Type ObjectType() const
Definition: hps.h:40564
HPS::ByteArray non_db_user_data
Definition: hps.h:43159
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6195
Definition: hps.h:409
char const * GetBytes() const
Definition: hps.h:6908
virtual intptr_t Freshen() const
Definition: hps.h:42592
Definition: hps.h:34917
virtual bool Equals(TextInputEvent const &in_that) const
Definition: hps.h:41821
Event * Clone() const
Definition: hps.h:41846
HPS::Type ObjectType() const
Definition: hps.h:36053
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:42147
float green
Definition: hps.h:4315
Action
Definition: hps.h:42489
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1668
HPS::Type ObjectType() const
Definition: hps.h:10399
HPS::Type ObjectType() const
Definition: hps.h:27518
HPS::Type ObjectType() const
Definition: hps.h:24994
size_t triangle_dc_count
Number of DC triangles drawn during the last update.
Definition: hps.h:4826
HPS::Type ObjectType() const
Definition: hps.h:24750
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10598
HPS::Type ObjectType() const
Definition: hps.h:38679
HPS::Type ObjectType() const
Definition: hps.h:25115
InnerPixelPoint(Point const &in_point)
Definition: hps.h:6027
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41911
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5877
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6467
Definition: hps.h:43250
static const float NegativeInfinity
Definition: hps.h:2216
Definition: hps.h:43341
HighlightEvent(Event const &in_event)
Definition: hps.h:41454
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7013
SizeUnits
Definition: hps.h:1461
HPS::Type ObjectType() const
Definition: hps.h:13038
HPS::Type ObjectType() const
Definition: hps.h:20944
Definition: hps.h:21630
TextInputEvent()
Definition: hps.h:41795
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:42602
HPS::Type ObjectType() const
Definition: hps.h:10620
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5978
GatheringLevel
Definition: hps.h:1726
HPS::Type ObjectType() const
Definition: hps.h:29341
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:41549
Definition: hps.h:41309
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3785
Definition: hps.h:12632
FrameOptions
Definition: hps.h:224
HPS::Type ObjectType() const
Definition: hps.h:35862
Space
Definition: hps.h:2074
void Alt(bool in_state)
Definition: hps.h:42066
Definition: hps.h:1986
Buttons
Definition: hps.h:42469
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:42627
HPS::Type ObjectType() const
Definition: hps.h:37883
Type
Definition: hps.h:269
HideKeyboardEvent(Event const &in_event)
Definition: hps.h:41975
bool operator!=(Touch const &in_that) const
Definition: hps.h:6481
Definition: hps.h:40926
Definition: hps.h:24371
Definition: hps.h:99
Type
Definition: hps.h:452
HPS::Type ObjectType() const
Definition: hps.h:44195
HPS::Type ObjectType() const
Definition: hps.h:45577
HPS::Type ObjectType() const
Definition: hps.h:45466
HPS::Type ObjectType() const
Definition: hps.h:34277
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5777
HPS::Type ObjectType() const
Definition: hps.h:9554
HPS::Type ObjectType() const
Definition: hps.h:45663
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6995
ShowKeyboardEvent()
Definition: hps.h:41940
Definition: hps.h:23636
HPS::SegmentKey & segment_key
Definition: hps.h:43201
Definition: hps.h:43163
Definition: hps.h:35747
Definition: hps.h:1251
Event * Clone() const
Definition: hps.h:42255
void Middle(bool in_state)
Definition: hps.h:42404
Definition: hps.h:29319
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:41669
Definition: hps.h:4820
Event * Clone() const
Definition: hps.h:41737
Definition: hps.h:43976
size_t GetLength() const
Definition: hps.h:6893
HPS::Type ObjectType() const
Definition: hps.h:21337
HPS::Type ObjectType() const
Definition: hps.h:27070
Type
Definition: hps.h:1114
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:9470
bool None() const
Definition: hps.h:42026
size_t ClickCount
The number of clicks received.
Definition: hps.h:42604
virtual intptr_t Freshen() const
Definition: hps.h:6199
void Reset()
Definition: hps.h:6888
HPS::Type ObjectType() const
Definition: hps.h:38413
HPS::Type ObjectType() const
Definition: hps.h:24131
Definition: hps.h:34790
HPS::Type ObjectType() const
Definition: hps.h:40668
Definition: hps.h:39944
Definition: hps.h:44143
SizeUnits
Definition: hps.h:1579
Event * Clone() const
Definition: hps.h:41660
MouseEvent(Event const &in_event)
Definition: hps.h:42523
bool Right() const
Definition: hps.h:42369
Definition: hps.h:2002
virtual bool Empty() const
Definition: hps.h:5653
Join
Definition: hps.h:1802
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3942
Modifier
Definition: hps.h:1839
static MouseButtons ButtonLeft()
Definition: hps.h:42447
size_t dot_dc_count
Number of DC dots drawn during the last update.
Definition: hps.h:4822
static MouseButtons ButtonMiddle()
Definition: hps.h:42455
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:42213
static intptr_t ClassID()
Definition: hps.h:5675
HighlightEvent()
Definition: hps.h:41438
virtual HPS::Type ObjectType() const
Definition: hps.h:5649
Definition: hps.h:43276
Definition: hps.h:19158
HPS::Type ObjectType() const
Definition: hps.h:14052
Definition: hps.h:28971
Definition: hps.h:16979
Definition: hps.h:5872
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:42312
Definition: hps.h:8724
Type
Definition: hps.h:579
virtual intptr_t Freshen() const
Definition: hps.h:41421
Background
Definition: hps.h:250
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3862
Definition: hps.h:44860
static ModifierKeys KeyControl()
Definition: hps.h:42109
HPS::Type ObjectType() const
Definition: hps.h:18666
Definition: hps.h:5569
HPS::Type ObjectType() const
Definition: hps.h:36313
Definition: hps.h:7360
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5925
Definition: hps.h:43802
HPS::Type ObjectType() const
Definition: hps.h:40460
StandAloneWindowEvent(Action in_action)
Definition: hps.h:41716
Mode
Definition: hps.h:1691
Definition: hps.h:33916
size_t segment_count
Number of segments traversed during the last update.
Definition: hps.h:4839
Definition: hps.h:11394
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:41548
Event * Clone() const
Definition: hps.h:41885
Definition: hps.h:34652
size_t polygon_3d_count
Number of 3D polygons drawn during the last update.
Definition: hps.h:4829
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4079
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3897
Definition: hps.h:34514
size_t display_list_triangle_3d_count
Number of triangles drawn from display lists during the last update.
Definition: hps.h:4833
Type
Definition: hps.h:853
Definition: hps.h:354
Definition: hps.h:15001
Definition: hps.h:21705
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3850
Definition: hps.h:885
Event * Clone() const
Definition: hps.h:41956
HPS::Type ObjectType() const
Definition: hps.h:12506
Definition: hps.h:36495
HPS::Type ObjectType() const
Definition: hps.h:32907
HPS::Type ObjectType() const
Definition: hps.h:18133
Definition: hps.h:43100
HPS::Type ObjectType() const
Definition: hps.h:38511
Definition: hps.h:36164
HPS::Type ObjectType() const
Definition: hps.h:44330
Definition: hps.h:5921
HPS::Type ObjectType() const
Definition: hps.h:42960
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3836
HPS::Type ObjectType() const
Definition: hps.h:37666
Definition: hps.h:36434
HPS::Type ObjectType() const
Definition: hps.h:12656
HPS::Type ObjectType() const
Definition: hps.h:18207
Definition: hps.h:24454
Mode
Definition: hps.h:1744
Definition: hps.h:8938
Event * Clone() const
Definition: hps.h:42674
Definition: hps.h:10375
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3908
Tiling
Definition: hps.h:960
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4064
WindowPoint(Point const &in_point)
Definition: hps.h:6077
Transform
Definition: hps.h:1534
HPS::Type ObjectType() const
Definition: hps.h:37981
Definition: hps.h:11655
Definition: hps.h:8668
HPS::Key & key
Definition: hps.h:43187
Definition: hps.h:41483
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:22314
Definition: hps.h:35880
Definition: hps.h:27831
Definition: hps.h:22599
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:39338
Definition: hps.h:26324
Definition: hps.h:904
ModifierKeys()
Definition: hps.h:41998
Definition: hps.h:25365
Definition: hps.h:1773
Definition: hps.h:22957
Definition: hps.h:28444
Definition: hps.h:43177
Preference
Definition: hps.h:1559
HPS::Type ObjectType() const
Definition: hps.h:25667
Capping
Definition: hps.h:528
Definition: hps.h:41625
HPS::Type ObjectType() const
Definition: hps.h:36126
TouchEvent()
Definition: hps.h:42207
Interpolation
Definition: hps.h:979
HPS::Type ObjectType() const
Definition: hps.h:20316
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:42162
WarningEvent(char const *in_message)
Definition: hps.h:41562
HPS::Type ObjectType() const
Definition: hps.h:21112
Modifiers
Definition: hps.h:42123
Component
Definition: hps.h:520
Definition: hps.h:514
Definition: hps.h:9970
Definition: hps.h:38287
HPS::Type ObjectType() const
Definition: hps.h:36621
HPS::Type ObjectType() const
Definition: hps.h:6584
HPS::Type ObjectType() const
Definition: hps.h:22893
Definition: hps.h:17714
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4049
HPS::Type ObjectType() const
Definition: hps.h:44887
HPS::Type ObjectType() const
Definition: hps.h:22683
Definition: hps.h:3209
Format
Definition: hps.h:37844
WarningEvent()
Definition: hps.h:41558
Definition: hps.h:25281
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41415
Touch()
Definition: hps.h:6461
Definition: hps.h:12424
Definition: hps.h:36588
size_t polyhedron_count
Number of polyhedra drawn during the last update.
Definition: hps.h:4830
Component
Definition: hps.h:415
Definition: hps.h:34261
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:40437
Definition: hps.h:1109
float red
Definition: hps.h:4314
ClipSpace
Definition: hps.h:1296
Definition: hps.h:12336
Definition: hps.h:38478
Definition: hps.h:16033
Control & operator=(Control &&in_that)
Definition: hps.h:5712
Definition: hps.h:43561
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41567
HPS::Type ObjectType() const
Definition: hps.h:14172
Definition: hps.h:29240
SizeUnits
Definition: hps.h:44844
void Right(bool in_state)
Definition: hps.h:42400
virtual void Reset()
Definition: hps.h:41359
Definition: hps.h:11981
Definition: hps.h:44099
HPS::Type ObjectType() const
Definition: hps.h:11534
bool Meta() const
Definition: hps.h:42042
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4091
Definition: hps.h:36092
TimerTickEvent()
Definition: hps.h:41387
Definition: hps.h:39145
Definition: hps.h:37861
HPS::Type ObjectType() const
Definition: hps.h:22346
RenderingAlgorithm
Definition: hps.h:286
EmergencyHandler()
Definition: hps.h:40907
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5827
TouchID ID
TouchID for this Touch.
Definition: hps.h:6486
Definition: hps.h:37080
HPS::Type ObjectType() const
Definition: hps.h:11047
HPS::Type ObjectType() const
Definition: hps.h:33938
HPS::Type ObjectType() const
Definition: hps.h:8477
Definition: hps.h:44839
Definition: hps.h:6225
Definition: hps.h:24728
HandednessOptimization
Definition: hps.h:377
Definition: hps.h:6767
size_t raster_count
Number of rasters drawn during the last update.
Definition: hps.h:4838
size_t deleted_display_list_count
Number of deleted display lists during the last update.
Definition: hps.h:4831
Control(Control &&in_that)
Definition: hps.h:5707
bool Control() const
Definition: hps.h:42034
Definition: hps.h:5476
HPS::Type ObjectType() const
Definition: hps.h:35461
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8701
Overlay
Definition: hps.h:1266
Definition: hps.h:29109
Definition: hps.h:6019
Definition: hps.h:37959
Definition: hps.h:45145
size_t GetHash() const
Status
Definition: hps.h:6175
Definition: hps.h:22440
HPS::Type ObjectType() const
Definition: hps.h:35591
HPS::Type ObjectType() const
Definition: hps.h:6666
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:42603
Definition: hps.h:38128
Definition: hps.h:44173
Definition: hps.h:27414
Definition: hps.h:2019
Projection
Definition: hps.h:1382
Definition: hps.h:7072
HPS::Type ObjectType() const
Definition: hps.h:43070