hps.h
1 
2 // Copyright (c) 1998-2014 by Tech Soft 3D, Inc.
3 //
4 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
5 // and considered a trade secret as defined under civil and criminal statutes.
6 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
7 // unauthorized use or misappropriation of its trade secrets. Use of this information
8 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
9 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
10 
11 #ifndef HPS_H
12 #define HPS_H
13 
14 #ifdef _MSC_VER
15 # ifndef STATIC_APP
16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
19 # else
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
22 # endif
23 # define HPS_TEMPLATE_API __declspec (dllexport)
24 # endif
25 # ifdef _WINDOWS_
26 # undef Ellipse
27 # undef Polyline
28 # undef Polygon
29 # undef Rectangle
30 # undef min
31 # undef max
32 # endif
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
35 #else
36 # include <limits.h>
37 # include <stddef.h>
38 # ifdef LINUX_SYSTEM
39 # ifndef STATIC_APP
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
43 # else
44 # define EXPIMP_TEMPLATE extern
45 # endif
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
47 # endif
48 # endif
49 #endif
50 #ifndef HPS_API
51 # define HPS_API
52 #endif
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
55 #endif
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
58 #endif
59 #ifndef ENUM_CLASS
60 # define ENUM_CLASS enum class
61 #endif
62 
63 #define NO_HPS_API
64 
65 #include <stdint.h>
66 #include <memory>
67 #include <vector>
68 #include <math.h>
69 #include <float.h>
70 #include <limits>
71 #include <stdexcept>
72 #include <algorithm>
73 #include <cstring>
74 
75 
76 
77 namespace HPSI
78 {
79  class Impl;
80  class KeyImpl;
81  class TicketImpl;
82  class EventDispatcherImpl;
83  class AbstractImage;
84 };
85 
86 namespace HPS
87 {
88 
89  // unimplemented
90 
91 
92 //Begin Info
94 class HPS_API Info
95 {
96 public:
99  enum class Code {
100  Unknown,
101  Exchange,
102  Publish,
103  Data,
104  Key,
105  Geometry,
106  Database,
107  Driver,
108  Internal,
109  Memory,
110  System,
111  Unsupported,
112  };
113 
114 private:
116  Info();
117 };
118 
119 
120 //Begin Info
122 class HPS_API Emergency
123 {
124 public:
127  enum class Code {
128  Unknown,
129  Fatal,
130  SoftMemoryLimit,
131  HardMemoryLimit,
132  };
133 
134 private:
136  Emergency();
137 };
138 
139 
140 //Begin Window
142 class HPS_API Window
143 {
144 public:
147  enum class Driver {
148  Default3D,
149  OpenGL,
150  OpenGL2,
151  DirectX9,
152  DirectX11,
153  };
154 
157  enum class UpdateStatus {
158  InProgress,
159  Completed,
160  TimedOut,
161  Interrupted,
162  Failed
163  };
164 
168  enum class UpdateControl {
169  DefaultUpdate,
170 
173  CompleteUpdate,
174 
175  RefreshUpdate,
176 
177  CompileOnlyUpdate,
178 
182  ExhaustiveUpdate,
183  };
184 
187  enum class Mobility
188  {
189  Locked,
190  Floating,
191  FixedRatio,
192  Free
193  };
194 
198  enum class FrameSize
199  {
200  Single,
201  Double
202  };
203 
207  enum class FrameOptions
208  {
209  Inset,
210  Overlay
211  };
212 
213  enum class ImageFormat
214  {
215  Default,
216  RGBA,
217  RGB,
218  Jpeg,
219  Png
220  };
221 
222 private:
224  Window();
225 };
226 
227 //Begin Subwindow
229 class HPS_API Subwindow
230 {
231 public:
232  enum class Background
233  {
234  SolidColor,
235  Image,
236  Cubemap,
237  Blend,
238  Transparent,
239  Interactive,
240 
241  GradientTopToBottom,
242  GradientBottomToTop,
243  GradientLeftToRight,
244  GradientRightToLeft,
245  GradientTopLeftToBottomRight,
246  GradientTopRightToBottomLeft,
247  GradientBottomLeftToTopRight,
248  GradientBottomRightToTopLeft,
249  };
250 
251  enum class Type
252  {
253  Standard,
254  Lightweight
255  };
256 
257  enum class Border
258  {
259  None,
260  Inset,
261  InsetBold,
262  Overlay,
263  OverlayBold
264  };
265 
266 
269  {
272  ZBuffer,
273 
279  HiddenLine,
280 
286  FastHiddenLine,
287 
300  Priority
301  };
302 
303 private:
304  Subwindow();
305 };
306 //End Subwindow
307 
309 class HPS_API Style
310 {
311 public:
312 
316  enum class Type
317  {
318  Segment,
319  Named
320  };
321 
325  enum class AppendMode
326  {
327  None,
328  And,
329  Or
330  };
331 
332 private:
333  Style();
334 };
335 
336 
337 //Begin Shell Attributes
339 class HPS_API Shell
340 {
341 public:
342 
345  enum class Component
346  {
347  Faces,
348  Edges,
349  Vertices
350  };
351 
352  /* \enum ToleranceUnits
353  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
354  enum class ToleranceUnits
355  {
356  ObjectSpace,
357  FeatureSizePercentage
358  };
359 
360  /* \enum HandednessOptimization
361  * Enumerates the shell optimization options with regards to handedness. */
363  {
364  None,
365  FixHandedness,
366  ReverseHandedness
367  };
368 
369  /* \enum RelationResults
370  * Enumerates the results of a shell relation computation. */
371  enum class Relation
372  {
373  On,
374  Off,
375  In,
376  Out
377  };
378 
379  /* \enum RelationTest
380  * Enumerates the test options for a shell relation computation. */
381  enum class RelationTest
382  {
383  Simple,
384  Enclosure,
385  Distance
386  };
387 
388 private:
390  Shell();
391 };
392 //End Shell Attributes
393 
394 //Begin Mesh Attributes
396 class HPS_API Mesh
397 {
398 public:
401  enum class Component
402  {
403  Faces,
404  Edges,
405  Vertices
406  };
407 
408 private:
410  Mesh();
411 };
412 //End Mesh Attributes
413 
414 //Begin InfiniteLine Attributes
416 class HPS_API InfiniteLine
417 {
418 public:
421  enum class Type
422  {
423  Line,
424  Ray
425  };
426 
427 private:
429  InfiniteLine();
430 };
431 //End InfiniteLine Attributes
432 
434 class HPS_API Trim
435 {
436 public:
439  enum class Type
440  {
441  Line,
442  Curve
443  };
444 
448  enum class Operation
449  {
450  Keep,
451  Remove
452  };
453 private:
455  Trim();
456 };
457 
458 //Begin Spotlight Attributes
460 class HPS_API Spotlight
461 {
462 public:
465  enum class OuterConeUnits
466  {
470  Degrees,
474  FieldRadius
475  };
476 
479  enum class InnerConeUnits
480  {
484  Degrees,
488  FieldRadius,
491  Percent
492  };
493 
494 
495 private:
497  Spotlight();
498 };
499 //End Spotlight Attributes
500 
501 
502 
503 
504 //Begin Cylinder Attributes
506 class HPS_API Cylinder
507 {
508 public:
511  enum class Component
512  {
513  Faces,
514  Edges,
515  };
516 
519  enum class Capping
520  {
521  None,
522  First,
523  Last,
524  Both
525  };
526 
530  enum class Orientation
531  {
532  Default,
533  DefaultRadii,
534  InvertRadii,
535  InvertRadiiOnly,
536  DefaultColors,
537  InvertColors,
538  InvertColorsOnly,
539  InvertAll
540  };
541 
542 private:
544  Cylinder();
545 };
546 
547 
549 class HPS_API Search
550 {
551 public:
554  enum class Space
555  {
556  SegmentOnly,
557  Subsegments,
558  SubsegmentsAndIncludes
559  };
560 
563  enum class Behavior
564  {
565  Exhaustive,
566  FirstMatch
567  };
568 
569 
570  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to 3DF HK types (if they map to HK types)
574  enum class Type : uint32_t {
575 
576  /* This enum classeration is divided into three parts.
577 
578  0xAABBBCCC
579 
580  The bits in A encode the most general category of the type (Geometry, Attribute).
581  The bits in B encode the subtype (Culling, TextAttribute). Attributes alone have these so far.
582  The bits in C encode the specific type (Shell, CullingVectorTolerance, TextAttributeSpacing).
583 
584  General category designators should have no bits in B or C.
585  Subtype category designators should have bits in A and B but not C.
586  Specific category designators should have bits in A and C and optionally B.
587 
588  Some types map to an HK type. To get the HK type you should mask out its subtype if it has one, else mask out its general type.
589  These types are kept in sync with the 3DF HK types by using Compile-time assets in hpsi.cpp.
590 
591  Geometry have no subtype. Most, 'Ordinary Geometry' map to a 3DF HK type.
592  The mutants or 'Special Geometry' (some lights and infinite ray) have no HK type to map to.
593 
594  Attributes come in a few forms.
595  The 'Simple Attributes' map to an HK type and have no subtypes -- they are what they are. ModellingMatrix, Camera, etc.
596  The 'Complex Attributes' have subtypes. A handful map to an HK type, but the majority are not.
597  */
598  None = 0x00000000,
599  Everything = 0x00ffffff,
600 
601  // Segment Stuff (Include & Segment map to HK types)
602  Include = 0x00000042,
603  Segment = 0x00000043,
604 
605  Includer = 0x00000100,
606 
607  // Geometry
608  Geometry = 0x10000000,
609 
610  // Ordinary Geometry (map to HK types) - (HK_* | Geometry)
611  CuttingSection = 0x10000026,
612  Shell = 0x10000028,
613  Mesh = 0x10000029,
614  Grid = 0x1000002a,
615  NURBSSurface = 0x1000002b,
616  Cylinder = 0x1000002d,
617  Sphere = 0x1000002e,
618  Polygon = 0x1000002f,
619  Circle = 0x10000030,
620  //unused = 0x10000031,
621  CircularWedge = 0x10000032,
622  Ellipse = 0x10000033,
623  Line = 0x10000034,
624  NURBSCurve = 0x10000037,
625  CircularArc = 0x10000038,
626  EllipticalArc = 0x10000039,
627  InfiniteLine = 0x1000003a,
628 // Image = 0x1000003b, N/A since images live in portfolios
629  Marker = 0x1000003c,
630  Text = 0x1000003e,
631  Reference = 0x10000040,
632 
633  // Special Geometry
634  DistantLight = 0x10000100,
635  Spotlight = 0x10000101,
636  InfiniteRay = 0x10000102,
637 
638  // Attributes
639  Attribute = 0x20000000,
640 
641  Priority = 0x20000001,
642 
643  // Simple Attributes (map to HK types)
644  Material = 0x2000000a,
645  Camera = 0x2000000e,
646  ModellingMatrix = 0x20000010,
647  UserData = 0x20000021,
648  TextureMatrix = 0x20000023,
649 
650  // Complex Attributes
651  Culling = 0x20001000,
652  CullingBackFace = 0x20001001,
653  CullingExtent = 0x20001002,
654  CullingVector = 0x20001003,
655  CullingVectorTolerance = 0x20001004,
656  CullingFrustum = 0x20001005,
657  CullingDeferralExtent = 0x20001006,
658 
659  CurveAttribute = 0x20002000,
660  CurveAttributeBudget = 0x20002001,
661  CurveAttributeContinuedBudget = 0x20002002,
662  CurveAttributeViewDependent = 0x20002003,
663  CurveAttributeMaximumDeviation = 0x20002004,
664  CurveAttributeMaximumAngle = 0x20002005,
665  CurveAttributeMaximumLength = 0x20002006,
666 
667  CylinderAttribute = 0x20003000,
668  CylinderAttributeTessellation = 0x20003001,
669  CylinderAttributeOrientation = 0x20003002,
670 
671  // EdgeAttributes map to HK types
672  EdgeAttribute = 0x20004000,
673  EdgeAttributePattern = 0x20004015,
674  EdgeAttributeWeight = 0x20004016,
675 
676  LightingAttribute = 0x20005000,
677  LightingAttributeInterpolation = 0x20005001,
678 
679  // LineAttributes map to HK types
680  LineAttribute = 0x20006000,
681  LineAttributePattern = 0x20006019,
682  LineAttributeWeight = 0x2000601a,
683 
684  // MarkerAttributes map to HK types
685  MarkerAttribute = 0x20007000,
686  MarkerAttributeSize = 0x2000701b,
687  MarkerAttributeSymbol = 0x2000701c,
688 
689  SurfaceAttribute = 0x20008000,
690  SurfaceAttributeBudget = 0x20008001,
691  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
692  SurfaceAttributeMaximumFacetAngle = 0x20008003,
693  SurfaceAttributeMaximumFacetWidth = 0x20008004,
694  SurfaceAttributeTrimCurveBudget = 0x20008005,
695  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
696 
697  Selectability = 0x20009000,
698  SelectabilityWindows = 0x20009001,
699  SelectabilityEdges = 0x20009002,
700  SelectabilityFaces = 0x20009003,
701  SelectabilityLights = 0x20009004,
702  SelectabilityLines = 0x20009005,
703  SelectabilityMarkers = 0x20009006,
704  SelectabilityVertices = 0x20009007,
705  SelectabilityText = 0x20009008,
706 
707  SphereAttribute = 0x2000a000,
708  SphereAttributeTessellation = 0x2000a001,
709 
710  Subwindow = 0x2000b000,
711  SubwindowEitherType = 0x2000b001,
712  SubwindowStandard = 0x2000b00d,
713  SubwindowLightweight = 0x2000b002,
714  SubwindowBackground = 0x2000b003,
715  SubwindowBorder = 0x2000b004,
716  SubwindowRenderingAlgorithm = 0x2000b005,
717 
718  // TextAttributeAlignment, Path, & Spacing map to HK types
719  TextAttribute = 0x2000c000,
720  TextAttributeAlignment = 0x2000c01d,
721  TextAttributeBold = 0x2000c002,
722  TextAttributeItalic = 0x2000c003,
723  TextAttributeOverline = 0x2000c004,
724  TextAttributeStrikethrough = 0x2000c005,
725  TextAttributeUnderline = 0x2000c006,
726  TextAttributeSlant = 0x2000c007,
727  TextAttributeLineSpacing = 0x2000c008,
728  TextAttributeRotation = 0x2000c00a,
729  TextAttributeExtraSpace = 0x2000c00b,
730  TextAttributeGreeking = 0x2000c00c,
731  TextAttributeSizeTolerance = 0x2000c00d,
732  TextAttributeSize = 0x2000c00e,
733  TextAttributeFont = 0x2000c00f,
734  TextAttributeTransform = 0x2000c010,
735  TextAttributeRenderer = 0x2000c011,
736  TextAttributePreference = 0x2000c012,
737  TextAttributePath = 0x2000c01f,
738  TextAttributeSpacing = 0x2000c020,
739 
740  Transparency = 0x2000d000,
741  TransparencyMethod = 0x2000d001,
742  TransparencyAlgorithm = 0x2000d002,
743  TransparencyDepthPeelingLayers = 0x2000d004,
744  TransparencyDepthPeelingMinimumArea = 0x2000d005,
745  TransparencyDepthWriting = 0x2000d006,
746 
747  Visibility = 0x2000e000,
748  VisibilityCuttingSections = 0x2000e001,
749  VisibilityCutEdges = 0x2000e002,
750  VisibilityCutFaces = 0x2000e003,
751  VisibilityWindows = 0x2000e004,
752  VisibilityText = 0x2000e005,
753  VisibilityLines = 0x2000e006,
754  VisibilityEdgeLights = 0x2000e007,
755  VisibilityMarkerLights = 0x2000e008,
756  VisibilityFaceLights = 0x2000e009,
757  VisibilityGenericEdges = 0x2000e00a,
758  VisibilityHardEdges = 0x2000e00b,
759  VisibilityAdjacentEdges = 0x2000e00c,
760  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
761  VisibilityShadowEmitting = 0x2000e00e,
762  VisibilityShadowReceiving = 0x2000e00f,
763  VisibilityShadowCasting = 0x2000e010,
764  VisibilityMarkers = 0x2000e011,
765  VisibilityVertices = 0x2000e012,
766  VisibilityFaces = 0x2000e013,
767  VisibilityPerimeterEdges = 0x2000e014,
768  VisibilityNonCulledEdges = 0x2000e015,
769  VisibilityMeshQuadEdges = 0x2000e016,
770 
771  VisualEffects = 0x2000f000,
772  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
773  VisualEffectsAntiAliasing = 0x2000f002,
774  VisualEffectsShadowMaps = 0x2000f003,
775  VisualEffectsSimpleShadow = 0x2000f004,
776  VisualEffectsSimpleShadowPlane = 0x2000f005,
777  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
778  VisualEffectsSimpleShadowColor = 0x2000f007,
779  VisualEffectsSimpleReflection = 0x2000f008,
780  VisualEffectsSimpleReflectionPlane = 0x2000f009,
781  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
782 
783  Performance = 0x20010000,
784  PerformanceDisplayLists = 0x20010001,
785  PerformanceStaticModel = 0x20010002,
786  StaticModelSegment = 0x40000043,
787 
788  // DrawingAttributeWorldHandedness map to HK types
789  DrawingAttribute = 0x20011000,
790  DrawingAttributePolygonHandedness = 0x20011001,
791  DrawingAttributeDepthRange = 0x20011002,
792  DrawingAttributeFaceDisplacement = 0x20011003,
793  DrawingAttributeGeneralDisplacement = 0x20011004,
794  DrawingAttributeVertexDisplacement = 0x20011005,
795  DrawingAttributeOverlay = 0x20011006,
796  DrawingAttributeDeferral = 0x20011007,
797  DrawingAttributeClipRegion = 0x20011012,
798  DrawingAttributeWorldHandedness = 0x20011018,
799 
800  HiddenLineAttribute = 0x20012000,
801  HiddenLineAttributeColor = 0x20012001,
802  HiddenLineAttributeDimFactor = 0x20012002,
803  HiddenLineAttributeFaceDisplacement = 0x20012003,
804  HiddenLineAttributeLinePattern = 0x20012005,
805  HiddenLineAttributeRenderFaces = 0x20012006,
806  HiddenLineAttributeRenderText = 0x20012007,
807  HiddenLineAttributeAlgorithm = 0x20012008,
808  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
809  HiddenLineAttributeVisibility = 0x2001200a,
810  HiddenLineAttributeWeight = 0x2001200b,
811  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
812 
813  SegmentStyle = 0x20013001,
814  NamedStyle = 0x20013002,
815  MaterialPalette = 0x20013003,
816  Portfolio = 0x20013004,
817 
818  ContourLine = 0x20014000,
819  ContourLineVisibility = 0x20014001,
820  ContourLinePosition = 0x20014002,
821  ContourLineColor = 0x20014003,
822  ContourLinePattern = 0x20014004,
823  ContourLineWeight = 0x20014005,
824  ContourLineLighting = 0x20014006,
825 
826  Condition = 0x20015000,
827 
828  Bounding = 0x20016000,
829  BoundingVolume = 0x20016001,
830  BoundingExclusion = 0x20016002,
831 
832  AttributeLock = 0x20017000,
833  AttributeLockSetting = 0x20017001,
834  AttributeLockSubsegmentOverride = 0x20017002,
835 
836  TransformMask = 0x20018000,
837  TransformMaskCamera = 0x20018001,
838  TransformMaskCameraTranslation = 0x20018002,
839  TransformMaskCameraScale = 0x20018003,
840  TransformMaskCameraOffset = 0x20018004,
841  TransformMaskCameraRotation = 0x20018005,
842  TransformMaskCameraPerspectiveScale = 0x20018006,
843  TransformMaskCameraProjection = 0x20018007,
844  TransformMaskModellingMatrix = 0x20018008,
845  TransformMaskModellingMatrixTranslation = 0x20018009,
846  TransformMaskModellingMatrixScale = 0x20018010,
847  TransformMaskModellingMatrixOffset = 0x20018011,
848  TransformMaskModellingMatrixRotation = 0x20018012,
849 
850  ColorInterpolation = 0x20019000,
851  ColorInterpolationFaceColor = 0x20019001,
852  ColorInterpolationEdgeColor = 0x20019002,
853  ColorInterpolationMarkerColor = 0x20019003,
854  ColorInterpolationFaceIndex = 0x20019004,
855  ColorInterpolationEdgeIndex = 0x20019005,
856  ColorInterpolationMarkerIndex = 0x20019006,
857 
858  CuttingSectionAttribute = 0x2001a000,
859  CuttingSectionAttributeCuttingLevel = 0x2001a001,
860  CuttingSectionAttributeCappingLevel = 0x2001a002,
861  CuttingSectionAttributeMaterialPreference = 0x2001a003,
862 
863  };
864  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to HK types (if they are map to HK types)
865 
866 private:
868  Search();
869 };
870 
872 class HPS_API Material
873 {
874 public:
877  enum class Type
878  {
879  InvalidMaterialIndex = -1,
880  Nothing = 0,
881  FullMaterial,
882  ExplicitRGBColor,
883  ExplicitRGBAColor,
884  MaterialIndex,
885  TextureName,
886  ModulatedTexture,
887  CubeMapName,
888  ModulatedCubeMap,
889  GlossValue,
890  DiffuseChannelAlpha
891 
892  };
893 
897  enum class Channel
898  {
899  DiffuseColor = 1,
900  DiffuseTexture = 2,
901  Specular = 3,
902  Emission = 4,
903  Transmission = 5,
904  Mirror = 6,
905  Bump = 7,
906  EnvironmentTexture = 8,
907  EnvironmentCubeMap = 9,
908  Gloss = 10
909  };
910 
912  class HPS_API Color
913  {
914  public:
918  enum class Channel
919  {
920  DiffuseColor = 1,
921  Specular = 3,
922  Emission = 4,
923  Mirror = 6
924  };
925 
926  private:
928  Color();
929  };
930 
932  class HPS_API Texture
933  {
934  public:
938  enum class Channel
939  {
940  DiffuseTexture = 2,
941  Specular = 3,
942  Emission = 4,
943  Transmission = 5,
944  Mirror = 6,
945  Bump = 7,
946  EnvironmentTexture = 8,
947  EnvironmentCubeMap = 9
948  };
949 
952  enum class Parameterization
953  {
955  Cylinder,
957  PhysicalReflection,
959  Object,
965  NaturalUV,
967  ReflectionVector,
969  SurfaceNormal,
971  Sphere,
973  UV,
975  World
976  };
977 
980  enum class Tiling
981  {
984  Clamp,
986  Repeat,
988  Reflect,
991  Trim
992  };
993 
996  enum class Interpolation
997  {
999  Bilinear,
1000 
1002  InterpolationOff
1003  };
1004 
1007  enum class Decimation
1008  {
1011  Anisotropic,
1013  Mipmap,
1015  DecimationOff
1016  };
1017 
1021  enum class ChannelMapping
1022  {
1023  Red,
1024  Green,
1025  Blue,
1026  Alpha,
1027  Zero,
1028  One,
1029  Luminance
1030  };
1031 
1032  private:
1034  Texture();
1035  };
1036 private:
1038  Material();
1039 };
1040 
1041 class HPS_API PostProcessEffects
1042 {
1043 public:
1044  class HPS_API AmbientOcclusion
1045  {
1046  public:
1050  enum class Quality
1051  {
1052  Fastest,
1053  Nicest
1054  };
1055 
1056  private:
1057  AmbientOcclusion();
1058  };
1059 
1060  class HPS_API Bloom
1061  {
1062  public:
1066  enum class Shape
1067  {
1068  Star,
1069  Radial
1070  };
1071 
1072  private:
1073  Bloom();
1074  };
1075 
1076 private:
1077  PostProcessEffects() {}
1078 };
1079 
1080 class HPS_API Performance
1081 {
1082 public:
1086  enum class DisplayLists
1087  {
1089  NoDisplayLists,
1090 
1093  GeometryDisplayLists,
1094 
1097  SegmentDisplayLists
1098  };
1099 
1108  enum class StaticModel
1109  {
1110 
1111  NoStaticModel,
1112  AttributeStaticModel,
1113  AttributeSpatialStaticModel
1114  };
1115 
1116 
1117 private:
1118  Performance() {}
1119 };
1120 
1121 
1122 class HPS_API AttributeLock
1123 {
1124 public:
1125 
1127  enum class Type : uint32_t
1128  {
1129  Everything = 0x01000000,
1130 
1131  Visibility = 0x02000000,
1132 
1133  VisibilityCuttingSections,
1134  VisibilityCutEdges,
1135  VisibilityCutFaces,
1136  VisibilityWindows,
1137  VisibilityText,
1138  VisibilityLines,
1139  VisibilityEdgeLights,
1140  VisibilityMarkerLights,
1141  VisibilityFaceLights,
1142  VisibilityGenericEdges,
1143  VisibilityHardEdges,
1144  VisibilityAdjacentEdges,
1145  VisibilityInteriorSilhouetteEdges,
1146  VisibilityShadowEmitting,
1147  VisibilityShadowReceiving,
1148  VisibilityShadowCasting,
1149  VisibilityMarkers,
1150  VisibilityVertices,
1151  VisibilityFaces,
1152  VisibilityPerimeterEdges,
1153  VisibilityNonCulledEdges,
1154  VisibilityMeshQuadEdges,
1155  VisibilityCutGeometry,
1156  VisibilityEdges,
1157  VisibilityGeometry,
1158  VisibilityLights,
1159  VisibilityShadows,
1160 
1161  Material = 0x03000000,
1162 
1163  MaterialGeometry,
1164  MaterialCutGeometry,
1165 
1166  MaterialAmbientLightUpColor,
1167  MaterialAmbientLightDownColor,
1168  MaterialAmbientLightColor,
1169 
1170  MaterialWindowColor,
1171  MaterialWindowContrastColor,
1172 
1173  MaterialLightColor,
1174  MaterialLineColor,
1175  MaterialMarkerColor,
1176  MaterialTextColor,
1177  MaterialCutEdgeColor,
1178 
1179  MaterialVertex,
1180  MaterialVertexDiffuse,
1181  MaterialVertexDiffuseColor,
1182  MaterialVertexDiffuseAlpha,
1183  MaterialVertexDiffuseTexture,
1184  MaterialVertexSpecular,
1185  MaterialVertexMirror,
1186  MaterialVertexTransmission,
1187  MaterialVertexEmission,
1188  MaterialVertexEnvironment,
1189  MaterialVertexBump,
1190  MaterialVertexGloss,
1191 
1192  MaterialEdge,
1193  MaterialEdgeDiffuse,
1194  MaterialEdgeDiffuseColor,
1195  MaterialEdgeDiffuseAlpha,
1196  MaterialEdgeDiffuseTexture,
1197  MaterialEdgeSpecular,
1198  MaterialEdgeMirror,
1199  MaterialEdgeTransmission,
1200  MaterialEdgeEmission,
1201  MaterialEdgeEnvironment,
1202  MaterialEdgeBump,
1203  MaterialEdgeGloss,
1204 
1205  MaterialFace,
1206  MaterialFaceDiffuse,
1207  MaterialFaceDiffuseColor,
1208  MaterialFaceDiffuseAlpha,
1209  MaterialFaceDiffuseTexture,
1210  MaterialFaceSpecular,
1211  MaterialFaceMirror,
1212  MaterialFaceTransmission,
1213  MaterialFaceEmission,
1214  MaterialFaceEnvironment,
1215  MaterialFaceBump,
1216  MaterialFaceGloss,
1217 
1218  MaterialBackFace,
1219  MaterialBackFaceDiffuse,
1220  MaterialBackFaceDiffuseColor,
1221  MaterialBackFaceDiffuseAlpha,
1222  MaterialBackFaceDiffuseTexture,
1223  MaterialBackFaceSpecular,
1224  MaterialBackFaceMirror,
1225  MaterialBackFaceTransmission,
1226  MaterialBackFaceEmission,
1227  MaterialBackFaceEnvironment,
1228  MaterialBackFaceBump,
1229  MaterialBackFaceGloss,
1230 
1231  MaterialFrontFace,
1232  MaterialFrontFaceDiffuse,
1233  MaterialFrontFaceDiffuseColor,
1234  MaterialFrontFaceDiffuseAlpha,
1235  MaterialFrontFaceDiffuseTexture,
1236  MaterialFrontFaceSpecular,
1237  MaterialFrontFaceMirror,
1238  MaterialFrontFaceTransmission,
1239  MaterialFrontFaceEmission,
1240  MaterialFrontFaceEnvironment,
1241  MaterialFrontFaceBump,
1242  MaterialFrontFaceGloss,
1243 
1244  MaterialCutFace,
1245  MaterialCutFaceDiffuse,
1246  MaterialCutFaceDiffuseColor,
1247  MaterialCutFaceDiffuseAlpha,
1248  MaterialCutFaceDiffuseTexture,
1249  MaterialCutFaceSpecular,
1250  MaterialCutFaceMirror,
1251  MaterialCutFaceTransmission,
1252  MaterialCutFaceEmission,
1253  MaterialCutFaceEnvironment,
1254  MaterialCutFaceBump,
1255  MaterialCutFaceGloss,
1256 
1257  Camera = 0x04000000,
1258  };
1259 
1260 private:
1261  AttributeLock() {}
1262 };
1263 
1264 class HPS_API Drawing
1265 {
1266 public:
1269  enum class Handedness
1270  {
1271  NoHandedness,
1272  Left,
1273  Right
1274  };
1275 
1278  enum class Overlay
1279  {
1281  NoOverlay,
1284  NormalOverlay,
1287  OverlayWithZValues,
1288 
1293  InPlace,
1294  };
1295 
1298  enum class ClipOperation
1299  {
1300  Keep,
1301  Remove,
1302  };
1303 
1306  enum class ClipSpace
1307  {
1308  Window,
1309  World,
1310  Object,
1311  };
1312 
1313 private:
1314  Drawing() {}
1315 };
1316 
1317 
1318 class HPS_API HiddenLine
1319 {
1320 public:
1324  enum class Algorithm
1325  {
1326  None,
1327  ZBuffer,
1328  ZSort,
1329  };
1330 
1331 private:
1332  HiddenLine() {}
1333 };
1334 
1335 
1337 class HPS_API Selection
1338 {
1339 public:
1342  enum class Level
1343  {
1344  Segment,
1345  Entity,
1346  Subentity,
1347  };
1348 
1351  enum class Algorithm
1352  {
1353  Visual,
1354  Analytic
1355  };
1356 
1359  enum class Granularity
1360  {
1361  General,
1362  Detailed
1363  };
1364 
1365 private:
1367  Selection();
1368 };
1369 
1370 
1374 
1375 //Begin Camera
1377 class HPS_API Camera
1378 {
1379 public:
1388  enum class Projection {
1389  Default=1,
1390  Perspective,
1391  Orthographic,
1392  Stretched,
1393  };
1396 private:
1397  Camera();
1398 };
1399 
1400 
1401 //Begin Selectability
1403 class HPS_API Selectability
1404 {
1405 public:
1409  enum class Value
1410  {
1411  Off=0,
1412  On,
1413  ForcedOn
1414  };
1415 
1416 private:
1417  Selectability();
1418 };
1419 
1420 // Begin Transparency
1422 class HPS_API Transparency
1423 {
1424 public:
1428  enum class Method
1429  {
1430  Off,
1431  Blended,
1432  ScreenDoor
1433  };
1434 
1438  enum class Algorithm
1439  {
1440  NoSorting,
1441  Painters,
1442  ZSortNicest,
1443  ZSortFastest,
1444  DepthPeeling
1445  };
1446 
1450  enum class AreaUnits
1451  {
1452  Percent,
1453  Pixels
1454  };
1455 
1456 private:
1457  Transparency() {}
1458 };
1459 
1460 
1461 
1462 //Begin Marker Attributes
1464 class HPS_API Marker
1465 {
1466 public:
1470  enum class SizeUnits
1471  {
1472  ScaleFactor,
1473  ObjectSpace,
1474  SubscreenRelative,
1475  WindowRelative,
1476  WorldSpace,
1477  Points,
1478  Pixels
1479 
1480  };
1481 private:
1482  Marker();
1483 };
1484 
1485 //Begin Sphere Attributes
1487 class HPS_API Sphere
1488 {
1489 public:
1490 
1491 private:
1492  Sphere();
1493 };
1494 
1495 
1496 //Begin Lighting Attributes
1498 class HPS_API Lighting
1499 {
1500 public:
1505  {
1506  Phong,
1507  Gouraud,
1508  Flat
1509  };
1510 
1511 private:
1512  Lighting();
1513 };
1514 
1516 class HPS_API Text
1517 {
1518 public:
1521  enum class Alignment
1522  {
1523  TopLeft,
1524  CenterLeft,
1525  BottomLeft,
1526  TopCenter,
1527  Center,
1528  BottomCenter,
1529  TopRight,
1530  CenterRight,
1531  BottomRight
1532  };
1533 
1536  enum class ReferenceFrame
1537  {
1538  WorldAligned,
1539  PathAligned
1540  };
1541 
1544  enum class Justification
1545  {
1546  LeftJustified,
1547  RightJustified,
1548  CenterJustified
1549  };
1550 
1553  enum class Transform
1554  {
1556  Transformable,
1559  NonTransformable,
1561  CharacterPositionOnly,
1564  CharacterPositionAdjusted
1565  };
1566 
1569  enum class Renderer
1570  {
1571  DefaultRenderer,
1572  DriverRenderer,
1573  TruetypeRenderer,
1574  };
1575 
1578  enum class Preference
1579  {
1580  Default,
1581  Vector,
1582  Raster,
1583  Exterior
1584  };
1585 
1588  enum class Rotation
1589  {
1590  NoRotation,
1591  Rotate,
1592  FollowPath
1593  };
1594 
1595 
1598  enum class SizeUnits
1599  {
1600  ObjectSpace,
1601  SubscreenRelative,
1602  WindowRelative,
1603  WorldSpace,
1604  Points,
1605  Pixels
1606  };
1607 
1611  {
1612  ObjectSpace,
1613  SubscreenRelative,
1614  WindowRelative,
1615  WorldSpace,
1616  Points,
1617  Pixels,
1618  Percent
1619  };
1620 
1623  enum class GreekingUnits
1624  {
1625  ObjectSpace,
1626  SubscreenRelative,
1627  WindowRelative,
1628  WorldSpace,
1629  Points,
1630  Pixels
1631  };
1632 
1635  enum class GreekingMode
1636  {
1637  Nothing,
1638  Lines,
1639  Box
1640  };
1641 
1644  enum class RegionAlignment
1645  {
1646  RegionTop,
1647  RegionCenter,
1648  RegionBottom
1649  };
1650 
1651 private:
1653  Text();
1654 };
1655 
1656 // Begin Line Attributes
1657 
1659 class HPS_API Line
1660 {
1661 public:
1665  enum class SizeUnits
1666  {
1667  ScaleFactor,
1668  ObjectSpace,
1669  SubscreenRelative,
1670  WindowRelative,
1671  WorldSpace,
1672  Points,
1673  Pixels
1674  };
1675 private:
1676  Line();
1677 };
1678 
1679 
1680 // Begin Edge Attributes
1681 
1683 class HPS_API Edge
1684 {
1685 public:
1689  enum class SizeUnits
1690  {
1691  ScaleFactor,
1692  ObjectSpace,
1693  SubscreenRelative,
1694  WindowRelative,
1695  WorldSpace,
1696  Points,
1697  Pixels
1698  };
1699 private:
1700  Edge();
1701 };
1702 
1703 
1705 class HPS_API CuttingSection
1706 {
1707 public:
1710  enum class Mode
1711  {
1712  None,
1713  Round,
1714  Square,
1715  Plane
1716  };
1717 
1720  enum class CappingLevel
1721  {
1722  Entity,
1723  Segment,
1724  SegmentTree
1725  };
1726 
1729  enum class CuttingLevel
1730  {
1731  Global,
1732  Local,
1733  };
1734 
1738  {
1739  Explicit,
1740  Implicit,
1741  };
1742 
1745  enum class GatheringLevel
1746  {
1747  Segment,
1748  SegmentTree
1749  };
1750 
1751 private:
1753  CuttingSection();
1754 };
1755 
1757 class HPS_API ContourLine
1758 {
1759 public:
1763  enum class Mode
1764  {
1765  Repeating,
1766  Explicit,
1767  };
1768 
1769 private:
1770  ContourLine();
1771 };
1772 
1775 enum class IOResult
1776 {
1777  Success,
1778  Failure,
1779  FileNotFound,
1780  UnableToOpenFile,
1781  InvalidOptions,
1782  InvalidSegment,
1783  InProgress,
1784  Canceled,
1785  UnableToLoadLibraries,
1786  VersionIncompatibility,
1787  InitializationFailed,
1788  UnsupportedFormat,
1789 };
1790 
1792 class HPS_API LinePattern
1793 {
1794 public:
1797  enum class SizeUnits
1798  {
1799  ObjectSpace,
1800  SubscreenRelative,
1801  WindowRelative,
1802  WorldSpace,
1803  Points,
1804  Pixels,
1805  ScaleFactor
1806  };
1807 
1810  enum class InsetBehavior
1811  {
1812  Overlap,
1813  Trim,
1814  Inline
1815  };
1816 
1820  enum class Join
1821  {
1822  MitreJoin,
1823  RoundJoin,
1824  BevelJoin
1825  };
1826 
1829  enum class Cap
1830  {
1833  ButtCap,
1836  SquareCap,
1839  RoundCap,
1841  MitreCap
1842  };
1843 
1846  enum class Justification
1847  {
1850  Center,
1852  Stretch
1853  };
1854 
1857  enum class Modifier
1858  {
1859  GlyphName,
1860  Enumerated
1861  };
1862 
1863 
1878  enum class Default
1879  {
1880  Solid,
1881  DashDot,
1882  Dashed,
1883  Dotted,
1884  Dash2Dot,
1885  Dash3Dot,
1886  LongDash,
1887  LongDashShortDash,
1888  LongDash2ShortDash,
1889  FineDot,
1890  };
1891 
1892 private:
1894  LinePattern();
1895 };
1896 
1897 
1898 //Begin Glyphs
1900 class HPS_API Glyph
1901 {
1902 public:
1905  enum class Fill
1906  {
1907  Unfilled,
1908  ContinuousFill,
1909  NewFill
1910  };
1911 
1914  enum class ColorSource
1915  {
1916  Normal,
1917  Explicit,
1918  Indexed
1919  };
1920 
1924  enum class Default
1925  {
1926  Circle,
1927  CircleWithDot,
1928  CircleWithPlus,
1929  CircleWithTimes,
1930  CircleWithCircle,
1931  SolidCircle,
1932  Dot,
1933  Plus,
1934  Times,
1935  Splat,
1936  Box,
1937  BoxWithDot,
1938  BoxWithTimes,
1939  SolidBox,
1940  Diamond,
1941  DiamondWithDot,
1942  DiamondWithPlus,
1943  SolidDiamond,
1944  TriangleUp,
1945  TriangleUpWithDot,
1946  SolidTriangleUp,
1947  TriangleDown,
1948  TriangleDownWithDot,
1949  SolidTriangleDown,
1950  TriangleRight,
1951  TriangleRightWithDot,
1952  SolidTriangleRight,
1953  TriangleLeft,
1954  TriangleLeftWithDot,
1955  SolidTriangleLeft,
1956  TriangleUpV,
1957  SolidTriangleUpV,
1958  TriangleDownV,
1959  SolidTriangleDownV,
1960  TriangleRightV,
1961  SolidTriangleRightV,
1962  TriangleLeftV,
1963  SolidTriangleLeftV,
1964  LetterY,
1965  LetterZ,
1966  CircleLetterY,
1967  CircleLetterZ,
1968  VerticalBar,
1969  HorizontalBar,
1970  SlantLeft,
1971  SlantRight,
1972  WidePlus,
1973  SolidWidePlus,
1974  WideTimes,
1975  SolidWideTimes,
1976  Pound,
1977  };
1978 
1979 private:
1981  Glyph();
1982 };
1983 
1984 
1986 class HPS_API Bounding
1987 {
1988 public:
1992  enum class Type
1993  {
1994  None,
1995  Sphere,
1996  Cuboid
1997  };
1998 
1999 private:
2000  Bounding() {}
2001 };
2002 
2004 class HPS_API Grid
2005 {
2006 public:
2009  enum class Type
2010  {
2011  Quadrilateral,
2012  Radial
2013  };
2014 
2015 private:
2016  Grid();
2017 };
2018 
2019 
2021 {
2022 public:
2023  enum class UserData
2024  {
2025  Nothing,
2026  Discard,
2027  Preserve,
2028  Merge,
2029  Localize,
2030  };
2031 
2032  enum class Scope
2033  {
2034  SubSegments,
2035  SubsegmentsAndIncludes,
2036  };
2037 
2038  enum class Expansion
2039  {
2040  None,
2041  Includes,
2042  References,
2043  IncludesAndReferences,
2044  };
2045 
2046  enum class Matrix
2047  {
2048  Nothing,
2049  Localize,
2050  Collapse,
2051  };
2052 
2053  enum class Reorganization
2054  {
2055  None,
2056  Attribute,
2057  Spatial,
2058  AttributeSpatial,
2059  };
2060 };
2061 
2062  typedef double Time;
2063 
2064 #ifdef _MSC_VER
2065 # ifndef HPS_INLINE
2066 # define HPS_INLINE __forceinline
2067 # endif
2068 #else
2069 # define HPS_INLINE inline
2070 #endif
2071 
2072 #ifndef HPS_UNREFERENCED
2073 #define HPS_UNREFERENCED(param) ((void)(param))
2074 #endif
2075 
2076 
2077 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2078 
2079 template<typename T>
2080 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2081 {
2082  return degrees * (T)(PI / 180.0);
2083 }
2084 
2085 template<typename T>
2086 HPS_INLINE T Radians_To_Degrees(T const & radians)
2087 {
2088  return radians * (T)(180.0 / PI);
2089 }
2090 
2091 template<typename T>
2092 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2093  T a = Degrees_To_Radians(angle);
2094  cosine = cos(a);
2095  sine = sin(a);
2096 }
2097 
2098 template<typename T>
2099 HPS_INLINE T Cos(T const & angle) {
2100  return cos (Degrees_To_Radians(angle));
2101 }
2102 
2103 template<typename T>
2104 HPS_INLINE T Sin(T const & angle) {
2105  return sin (Degrees_To_Radians(angle));
2106 }
2107 
2108 template<typename T>
2109 HPS_INLINE T ACos(T const & x) {
2110  if (x > 1)
2111  return 0;
2112  if (x < -1)
2113  return 180;
2114  return Radians_To_Degrees(acos(x));
2115 }
2116 
2117 template<typename T>
2118 HPS_INLINE T ATan2(T const & y, T const & x) {
2119  if (x == 0 && y == 0)
2120  return 0;
2121  return Radians_To_Degrees(atan2(y, x));
2122 }
2123 
2124 
2125 template <typename F> struct Float_Traits {};
2126 template <> struct Float_Traits<float> {
2127  typedef double Alternative;
2128  static const int Type = 1;
2129  static float Epsilon () { return 1.0e-30f; }
2130 };
2131 template <> struct Float_Traits<double> {
2132  typedef float Alternative;
2133  static const int Type = 2;
2134  static double Epsilon () { return 1.0e-300; }
2135 };
2136 
2137 
2138 
2140 class HPS_API Float {
2141 private:
2142  enum Parts {
2143 # if HOOPS_BIGENDIAN
2144  High, Low
2145 # else
2146  Low, High
2147 # endif
2148  };
2149 
2150  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2151  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2152  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2153  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2154  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2155 
2156  static HPS_INLINE bool is_nan(int32_t const & v) {
2157  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2158  return exp == 0x7F800000 && mantissa != 0;
2159  }
2160  static HPS_INLINE bool is_nan(uint32_t const & v) {
2161  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2162  return exp == 0x7F800000 && mantissa != 0;
2163  }
2164  static HPS_INLINE bool is_nan(int32_t const * v) {
2165  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2166  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2167  }
2168  static HPS_INLINE bool is_nan(uint32_t const * v) {
2169  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2170  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2171  }
2172 
2173  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2174  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2175  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2176  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2177 public:
2178 
2180  static const float Infinity;
2182  static const float NegativeInfinity;
2183 
2185  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2186  static HPS_INLINE bool IsInfinite(double const & a) {
2187  uint32_t v[2];
2188  memcpy (v, &a, sizeof(double));
2189  return is_infinite (v);
2190  }
2191 
2193  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2194  static HPS_INLINE bool IsNAN(double const & a) {
2195  uint32_t v[2];
2196  memcpy (v, &a, sizeof(double));
2197  return is_nan (v);
2198  }
2199 
2201  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2202  static HPS_INLINE bool IsAbnormal(double const & a) {
2203  uint32_t v[2];
2204  memcpy (v, &a, sizeof(double));
2205  return is_special (v);
2206  }
2207 
2210  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2211  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2212 
2213 #ifndef HOOPS_DEFINED
2214  template <typename Alloc>
2215  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2216  {
2217  if (a.size() != b.size())
2218  return false;
2219 
2220  auto it1 = a.begin();
2221  auto it2 = b.begin();
2222  auto const end = a.end();
2223  for ( ; it1 != end; ++it1, ++it2)
2224  {
2225  if (!Equals(*it1, *it2, tolerance))
2226  return false;
2227  }
2228  return true;
2229  }
2230 #endif
2231 
2232  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2233  return extract_uint32_t(a) & 0x80000000;
2234  }
2235  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2236  uint32_t v[2];
2237  memcpy (v, &a, sizeof(double));
2238  return v[High] & 0x80000000;
2239  }
2240 
2241  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2242  uint32_t v = extract_uint32_t(a);
2243  v &= 0x7FFFFFFF;
2244  v |= sign_bit;
2245  inject_uint32_t(a, v);
2246  }
2247  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2248  uint32_t v[2];
2249  memcpy (v, &a, sizeof(double));
2250  v[High] &= 0x7FFFFFFF;
2251  v[High] |= sign_bit;
2252  memcpy (&a, v, sizeof(double));
2253  }
2254 
2255 
2256  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2257  uint32_t v = extract_uint32_t(a);
2258 
2259  v &= 0x7FFFFFFF;
2260  if (v < 0x3B800000)
2261  return 0;
2262 
2263  v--;
2264 
2265  uint32_t exp = v >> 23;
2266  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2267 
2268  return (unsigned char) (man >> (16 + 126 - exp));
2269  }
2270 
2271  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2272  uint32_t v = extract_uint32_t(a);
2273 
2274  v &= 0x7FFFFFFF;
2275  if (v < 0x3B800000)
2276  return 0;
2277 
2278  v--;
2279 
2280  uint32_t exp = v >> 23;
2281  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2282 
2283  uint32_t x = (man >> (16 + 126 - exp));
2284 
2285  return (unsigned char) ((x * (mix+1)) >> 8);
2286  }
2287 
2288 
2289  static HPS_INLINE bool match(float const & a, float const & b) {
2290  uint32_t va = extract_uint32_t(a);
2291  uint32_t vb = extract_uint32_t(b);
2292 
2293  if (((va | vb) & 0x7FFFFFFF) == 0)
2294  return true;
2295 
2296  return va == vb;
2297  }
2298  static HPS_INLINE bool match(double const & a, double const & b) {
2299  return a == b;
2300  }
2301 
2302 
2303  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2304  uint32_t va = extract_uint32_t(a);
2305  uint32_t vb = extract_uint32_t(b);
2306 
2307  uint32_t a_sign = va & 0x80000000;
2308  uint32_t b_sign = vb & 0x80000000;
2309 
2310  (int32_t&)a_sign >>= 31;
2311  (int32_t&)b_sign >>= 31;
2312 
2313  uint32_t mash = (a_sign&b_sign);
2314 
2315  va ^= mash;
2316  vb ^= mash;
2317 
2318  if ((int32_t&)vb < (int32_t&)va)
2319  memcpy(&a, &b, sizeof(float));
2320  }
2321  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2322  if (b < a)
2323  a = b;
2324  }
2325 
2326  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2327  uint32_t va = extract_uint32_t(a);
2328  uint32_t vb = extract_uint32_t(b);
2329 
2330  uint32_t a_sign = va & 0x80000000;
2331  uint32_t b_sign = vb & 0x80000000;
2332 
2333  (int32_t&)a_sign >>= 31;
2334  (int32_t&)b_sign >>= 31;
2335 
2336  uint32_t mash = (a_sign&b_sign);
2337 
2338  va ^= mash;
2339  vb ^= mash;
2340 
2341  if ((int32_t&)vb > (int32_t&)va)
2342  memcpy(&a, &b, sizeof(float));
2343  }
2344  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2345  if (b > a)
2346  a = b;
2347  }
2348 
2349 
2350  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2351  uint32_t i;
2352  memcpy(&i, &a, sizeof(float));
2353  return i;
2354  }
2355 
2356  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2357  memcpy(&a, &i, sizeof(float));
2358  }
2359 
2360  static HPS_INLINE float C2F(unsigned char x) {
2361  //return (float)x * (1.0f/255.0f);
2362  return char_to_float[x];
2363  }
2364 
2365 
2366  // SSE convenience functions
2367  static HPS_INLINE void pack_4(float const & f, float * m) {
2368  memcpy(&m[0], &f, sizeof(float));
2369  memcpy(&m[1], &f, sizeof(float));
2370  memcpy(&m[2], &f, sizeof(float));
2371  memcpy(&m[3], &f, sizeof(float));
2372  }
2373 
2374  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2375  memcpy(&m[0], &f0, sizeof(float));
2376  memcpy(&m[1], &f1, sizeof(float));
2377  memcpy(&m[2], &f2, sizeof(float));
2378  memcpy(&m[3], &f3, sizeof(float));
2379  }
2380 
2381  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2382  memcpy(f0, m, sizeof(float)*4);
2383  }
2384 
2385  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2386  memcpy(&f0, &m[0], sizeof(float));
2387  memcpy(&f1, &m[1], sizeof(float));
2388  memcpy(&f2, &m[2], sizeof(float));
2389  memcpy(&f3, &m[3], sizeof(float));
2390  }
2391 
2392 private:
2393  static const float char_to_float[256];
2394 
2395  Float();
2396 };
2397 
2398 
2400 
2401 
2402 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2403 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2404 
2405 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2406 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2407 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2408 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2409 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2410 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2411 
2412 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2413 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2414 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d) { return Min(Min(a, b, c),d); }
2415 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d, T const & e) { return Min(Min(a,b,c,d),e); }
2416 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Min(Min(a,b,c,d,e),f); }
2417 
2418 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2419 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2420 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d) { return Max(Max(a, b, c),d); }
2421 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d, T const & e) { return Max(Max(a,b,c,d),e); }
2422 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Max(Max(a,b,c,d,e),f); }
2423 
2424 template <typename T> HPS_INLINE T const & Clamp(T const & x, T const & min, T const & max) { return x < min ? min : x > max ? max : x; }
2425 
2426 
2427 template <> HPS_INLINE float Abs<float> (float const & a) {
2428  uint32_t v = Float::extract_uint32_t(a);
2429  v &= 0x7FFFFFFF;
2430  float f;
2431  Float::inject_uint32_t(f,v);
2432  return f;
2433 }
2434 
2435 template <> HPS_INLINE int Sign<float> (float const & a) {
2436  uint32_t v = Float::extract_uint32_t(a);
2437 
2438  if ((v & 0x7FFFFFFF) == 0)
2439  return 0;
2440 
2441  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2442 }
2443 
2444 template <> HPS_INLINE int Compare<float> (float const & a, float const & b) {
2445  int a_sign = Sign(a);
2446  int b_sign = Sign(b);
2447 
2448  if (a_sign != b_sign)
2449  return Compare(a_sign, b_sign);
2450 
2451  uint32_t v = Float::extract_uint32_t(a);
2452  uint32_t u = Float::extract_uint32_t(b);
2453 
2454  return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2455 }
2456 
2457 template <> HPS_INLINE float const & Min<float> (float const & a, float const & b) {
2458  if (Compare(a,b)>0)
2459  return b;
2460  return a;
2461 }
2462 
2463 template <> HPS_INLINE float const & Max<float> (float const & a, float const & b) {
2464  if (Compare(a,b)>0)
2465  return a;
2466  return b;
2467 }
2468 
2469 
2471 
2472 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2473  int32_t va = Float::extract_uint32_t(a);
2474  int32_t vb = Float::extract_uint32_t(b);
2475 
2476  if (is_special(va) || is_special(vb)) {
2477  if (is_infinite(va) || is_infinite(vb))
2478  return va == vb; // final check is for sign bits same
2479  if (is_nan(va) || is_nan(vb))
2480  return false;
2481  }
2482 
2483  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2484  if ((va & 0x7FFFFFFF) == 0)
2485  return (vb & 0x7FFFFFFF) < close_to_zero;
2486  else if ((vb & 0x7FFFFFFF) == 0)
2487  return (va & 0x7FFFFFFF) < close_to_zero;
2488 
2489  uint32_t sign_mask = va ^ vb;
2490  (int32_t &)sign_mask >>= 31;
2491 
2492  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2493  int32_t v1 = tolerance + diff;
2494  int32_t v2 = tolerance - diff;
2495  return (v1|v2) >= 0;
2496 }
2497 
2498 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2499  int32_t va[2], vb[2];
2500  memcpy (va, &a, sizeof(double));
2501  memcpy (vb, &b, sizeof(double));
2502 
2503  if (is_special(va) || is_special(vb)) {
2504  if (is_infinite(va) || is_infinite(vb))
2505  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2506  if (is_nan(va) || is_nan(vb))
2507  return false;
2508  }
2509 
2510  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2511  return Abs(a - b) < 0.000000000000005;
2512 
2513  if (extract_sign_bit(a) != extract_sign_bit(b))
2514  return a == b;
2515 
2516  if (va[High] != vb[High])
2517  return false;
2518 
2519  return Abs(va[Low] - vb[Low]) <= tolerance;
2520 }
2521 
2523 
2524 
2525 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2526 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2527 
2528 template <typename T>
2529 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2530  while (count-- > 0)
2531  if (Is_Abnormal (*t++))
2532  return true;
2533  return false;
2534 }
2535 
2536 template <typename T>
2537 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2538  return count >= 0 && Is_Abnormal((size_t)count, t);
2539 }
2540 
2541 
2543 
2544 
2545 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2546 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2547 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2548 template <typename F> class HPS_TEMPLATE_API Point_2D;
2549 
2550 
2551 template <typename F>
2552 class HPS_TEMPLATE_API Point_3D {
2553  public:
2554  F x;
2555  F y;
2556  F z;
2557 
2558  Point_3D () {}
2559  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2560 
2561  template <typename D>
2562  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2563 
2564  explicit Point_3D (Vector_3D<F> const & v);
2565  explicit Point_3D (Vector_2D<F> const & v);
2566  explicit Point_3D (Point_2D<F> const & that);
2567 
2568  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2569 
2570  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2571  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2572 
2573  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2574  return Float::Equals(x, p.x, in_tolerance) &&
2575  Float::Equals(y, p.y, in_tolerance) &&
2576  Float::Equals(z, p.z, in_tolerance);
2577  }
2578 
2579 
2580  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2581  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2582  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2583  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2584 
2585  F & operator[] (size_t i) { return (&x)[i]; }
2586  F const & operator[] (size_t i) const { return (&x)[i]; }
2587 
2588  Point_3D & operator+= (Vector_3D<F> const & v);
2589  Point_3D & operator-= (Vector_3D<F> const & v);
2590  Point_3D & operator*= (Vector_3D<F> const & v);
2591  Point_3D & operator/= (Vector_3D<F> const & v);
2592  Point_3D const operator* (Vector_3D<F> const & v) const;
2593  Point_3D const operator/ (Vector_3D<F> const & v) const;
2594 
2595  Point_3D & operator+= (Vector_2D<F> const & v);
2596  Point_3D & operator-= (Vector_2D<F> const & v);
2597  Point_3D & operator*= (Vector_2D<F> const & v);
2598  Point_3D & operator/= (Vector_2D<F> const & v);
2599  Point_3D const operator* (Vector_2D<F> const & v) const;
2600  Point_3D const operator/ (Vector_2D<F> const & v) const;
2601 
2602  Vector_3D<F> const operator- (Point_3D const & p) const;
2603 
2604  Point_3D const operator+ (Vector_3D<F> const & v) const;
2605  Point_3D const operator- (Vector_3D<F> const & v) const;
2606 
2607  Point_3D const operator+ (Vector_2D<F> const & v) const;
2608  Point_3D const operator- (Vector_2D<F> const & v) const;
2609 
2610  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2611  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2612 };
2613 
2614 typedef Point_3D<float> Point;
2615 typedef Point_3D<double> DPoint;
2616 
2617 
2618 
2619 template <typename F, typename S>
2620 HPS_INLINE Point_3D<F> operator* (S s, Point_3D<F> const & a) { return Point_3D<F> (F(s * a.x), F(s * a.y), F(s * a.z)); }
2621 
2622 template <typename F>
2623 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2624  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2625 }
2626 
2627 template <typename F>
2628 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2629  return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2630 }
2631 
2632 template <typename F>
2633 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2634  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2635 }
2636 
2637 
2638 template <typename F>
2639 class HPS_TEMPLATE_API Point_2D {
2640 public:
2641  F x;
2642  F y;
2643 
2644  Point_2D () {}
2645  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2646 
2647  template <typename D>
2648  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2649 
2650  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2651  explicit Point_2D (Vector_2D<F> const & v);
2652 
2653  Point_2D const operator- () const { return Point_2D (-x, -y); }
2654 
2655  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2656  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2657 
2658  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2659  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2660  }
2661 
2662 
2663  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2664  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2665  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2666  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2667 
2668  F & operator[] (size_t i) { return (&x)[i]; }
2669  F const & operator[] (size_t i) const { return (&x)[i]; }
2670 
2671  Point_2D & operator+= (Vector_2D<F> const & v);
2672  Point_2D & operator-= (Vector_2D<F> const & v);
2673  Point_2D & operator*= (Vector_2D<F> const & v);
2674  Point_2D & operator/= (Vector_2D<F> const & v);
2675  Point_2D const operator* (Vector_2D<F> const & v) const;
2676  Point_2D const operator/ (Vector_2D<F> const & v) const;
2677 
2678  Vector_2D<F> const operator- (Point_2D const & p) const;
2679 
2680  Point_2D const operator+ (Vector_2D<F> const & v) const;
2681  Point_2D const operator- (Vector_2D<F> const & v) const;
2682 
2683  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2684  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2685 };
2686 
2687 typedef Point_2D<float> Point2D;
2688 typedef Point_2D<double> DPoint2D;
2689 
2690 template <typename F>
2691 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2692 
2693 template <typename F, typename S>
2694 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F> const & a) { return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2695 
2696 template <typename F>
2697 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2698  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2699 }
2700 
2701 template <typename F>
2702 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2703  return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2704 }
2705 
2706 template <typename F>
2707 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2708  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2709 }
2710 
2711 
2712 template <typename F>
2713 class HPS_TEMPLATE_API Vector_3D {
2714  public:
2715  F x;
2716  F y;
2717  F z;
2718 
2719  Vector_3D () {}
2720  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2721  template <typename D>
2722  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2723  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2724  explicit Vector_3D(Plane_3D<F> const & p);
2725 
2726  explicit Vector_3D (Vector_2D<F> const & that);
2727 
2728  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2729 
2730  bool operator== (Vector_3D const & v) const {
2731  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2732  }
2733  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2734 
2735  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2736  return Float::Equals(x, v.x, in_tolerance) &&
2737  Float::Equals(y, v.y, in_tolerance) &&
2738  Float::Equals(z, v.z, in_tolerance);
2739  }
2740 
2741  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2742  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2743  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2744  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2745 
2746  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2747  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2748  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2749  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2750 
2751  F & operator[] (size_t i) { return (&x)[i]; }
2752  F const & operator[] (size_t i) const { return (&x)[i]; }
2753 
2754  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2755 
2756  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2757 
2758  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2759 
2760  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2761 
2762  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2763  if (check_range) {
2764  F range = Max (Abs (x), Abs (y), Abs (z));
2765  if (range > F(1.0e10))
2766  operator/= (range);
2767  }
2768 
2769  F len = (F)Length();
2770  if (len > epsilon)
2771  operator/= (len);
2772  else
2773  *this = Zero();
2774  return *this;
2775  }
2776  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2777 
2778  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2779  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2780 
2781  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2782 
2783  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2784  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2785  }
2786 
2787 
2788  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2789  return Vector_3D (x * v.x, y * v.y, z * v.z);
2790  }
2791 
2792  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2793  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2794  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2795  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2796  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2797 };
2798 
2799 typedef Vector_3D<float> Vector;
2800 typedef Vector_3D<double> DVector;
2801 
2802 
2803 template <typename F, typename S>
2804 HPS_INLINE Vector_3D<F> operator* (S s, Vector_3D<F> const & v) {return Vector_3D<F> (F(s * v.x), F(s * v.y), F(s * v.z)); }
2805 
2806 template <typename F>
2807 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2808  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2809 }
2810 
2811 
2812 template <typename F>
2813 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2814 
2815 template <typename F>
2816 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F> const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2817 template <typename F>
2818 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F> const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2819 
2820 template <typename F>
2821 HPS_INLINE Vector_3D<F> const Point_3D<F>::operator- (Point_3D<F> const & p) const { return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2822 
2823 template <typename F>
2824 HPS_INLINE Point_3D<F> const Point_3D<F>::operator+ (Vector_3D<F> const & v) const { return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2825 template <typename F>
2826 HPS_INLINE Point_3D<F> const Point_3D<F>::operator- (Vector_3D<F> const & v) const { return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2827 
2828 template <typename F>
2829 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F> const & v) { x *= v.x; y *= v.y; z *= v.z; return *this; }
2830 template <typename F>
2831 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F> const & v) { x /= v.x; y /= v.y; z /= v.z; return *this; }
2832 template <typename F>
2833 HPS_INLINE Point_3D<F> const Point_3D<F>::operator* (Vector_3D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2834 template <typename F>
2835 HPS_INLINE Point_3D<F> const Point_3D<F>::operator/ (Vector_3D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2836 
2837 
2838 
2839 template <typename F>
2840 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2841  return a + (b - a) * t;
2842 }
2843 
2844 template <typename F>
2845 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2846  return Vector_3D<F>(a + (b - a) * t).Normalize();
2847 }
2848 
2849 
2850 
2851 template <typename F>
2852 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2853  return (p2 - p1).Length();
2854 }
2855 
2856 template <typename F>
2857 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2858  return (p2 - p1).LengthSquared();
2859 }
2860 
2861 template <typename F>
2862 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2863  F p = static_cast<F>((c - b).LengthSquared());
2864  F q = static_cast<F>((c - a).LengthSquared());
2865  F r = static_cast<F>((b - a).LengthSquared());
2866 
2867  return Point_3D<F>(
2868  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2869  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2870 }
2871 
2872 
2873 
2874 template <typename F>
2875 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2876  bool success = true;
2877  for (size_t i = 0; i < count; ++i) {
2878  if (vectors->Normalize() == Vector_3D<F>::Zero())
2879  success = false;
2880  vectors++;
2881  }
2882  return success;
2883 }
2884 
2885 
2886 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2887 
2888 template <typename F>
2889 class HPS_TEMPLATE_API Vector_2D {
2890 public:
2891  F x;
2892  F y;
2893 
2894  Vector_2D () {}
2895  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2896  template <typename D>
2897  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2898 
2899  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2900  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2901  explicit Vector_2D (Plane_2D<F> const & p);
2902 
2903  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2904 
2905  bool operator== (Vector_2D const & v) const {
2906  return Float::match(x, v.x) && Float::match(y, v.y);
2907  }
2908  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2909 
2910  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2911  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2912  }
2913 
2914  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2915  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2916  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2917  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2918 
2919  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2920  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
2921  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
2922  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
2923 
2924  F & operator[] (size_t i) { return (&x)[i]; }
2925  F const & operator[] (size_t i) const { return (&x)[i]; }
2926 
2927  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2928 
2929  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
2930 
2931  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2932  if (check_range) {
2933  F range = Max (Abs (x), Abs (y));
2934  if (range > F(1.0e10))
2935  operator/= (range);
2936  }
2937 
2938  F len = (F)Length();
2939  if (len > epsilon)
2940  operator/= (len);
2941  else
2942  *this = Zero();
2943  return *this;
2944  }
2945  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2946 
2947  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
2948  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
2949 
2950  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
2951 
2952 
2953  HPS_INLINE float Cross (Vector_2D const & v) const {
2954  return x * v.y - y * v.x;
2955  }
2956 
2957  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
2958  return Vector_2D (x * v.x, y * v.y);
2959  }
2960 
2961  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
2962  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
2963 
2964  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
2965  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
2966 };
2967 
2968 typedef Vector_2D<float> Vector2D;
2970 
2971 template <typename F, typename S>
2972 HPS_INLINE Vector_2D<F> operator* (S s, Vector_2D<F> const & v) {return Vector_2D<F> (F(s * v.x), F(s * v.y)); }
2973 
2974 template <typename F>
2975 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
2976  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2977 }
2978 
2979 
2980 template <typename F>
2981 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
2982 
2983 template <typename F>
2984 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
2985 
2986 template <typename F>
2987 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
2988 template <typename F>
2989 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
2990 
2991 template <typename F>
2992 HPS_INLINE Point_3D<F> const Point_3D<F>::operator+ (Vector_2D<F> const & v) const { return Point_3D<F> (x + v.x, y + v.y, z); }
2993 template <typename F>
2994 HPS_INLINE Point_3D<F> const Point_3D<F>::operator- (Vector_2D<F> const & v) const { return Point_3D<F> (x - v.x, y - v.y, z); }
2995 
2996 template <typename F>
2997 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
2998 template <typename F>
2999 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3000 
3001 template <typename F>
3002 HPS_INLINE Point_3D<F> const Point_3D<F>::operator* (Vector_2D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z); }
3003 template <typename F>
3004 HPS_INLINE Point_3D<F> const Point_3D<F>::operator/ (Vector_2D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z); }
3005 
3006 
3007 template <typename F>
3008 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3009 template <typename F>
3010 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3011 
3012 template <typename F>
3013 HPS_INLINE Vector_2D<F> const Point_2D<F>::operator- (Point_2D<F> const & p) const { return Vector_2D<F> (x - p.x, y - p.y); }
3014 
3015 template <typename F>
3016 HPS_INLINE Point_2D<F> const Point_2D<F>::operator+ (Vector_2D<F> const & v) const { return Point_2D<F> (x + v.x, y + v.y); }
3017 template <typename F>
3018 HPS_INLINE Point_2D<F> const Point_2D<F>::operator- (Vector_2D<F> const & v) const { return Point_2D<F> (x - v.x, y - v.y); }
3019 
3020 template <typename F>
3021 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3022 template <typename F>
3023 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3024 template <typename F>
3025 HPS_INLINE Point_2D<F> const Point_2D<F>::operator* (Vector_2D<F> const & v) const { return Point_2D<F> (x * v.x, y * v.y); }
3026 template <typename F>
3027 HPS_INLINE Point_2D<F> const Point_2D<F>::operator/ (Vector_2D<F> const & v) const { return Point_2D<F> (x / v.x, y / v.y); }
3028 
3029 
3030 
3031 
3032 
3033 template <typename F>
3034 class HPS_TEMPLATE_API Plane_3D {
3035  public:
3036  F a;
3037  F b;
3038  F c;
3039  F d;
3040 
3041  Plane_3D () {}
3042  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3043  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3044  Plane_3D (Vector_3D<F> const & v, Point_3D<F> const & p) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
3045  Plane_3D (Point_3D<F> const & p, Vector_3D<F> const & v) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
3046  template <typename D>
3047  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3048 
3049  Plane_3D (size_t count, Point_3D<F> const * points) {
3050  if (count >= 3) {
3051  // The 3 coefficients A, B, and C are proportional to the areas of the
3052  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3053 
3054  // run around the polygon, collecting trapezoidal areas
3055  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3056 
3057  // take care of the swing point first
3058  Point_3D<F> const * p0 = &points[count-1];
3059 
3061  Vector_3D<F> normal = Vector_3D<F>::Zero();
3062 
3063  for (size_t i=0; i<count; ++i) {
3064  Point_3D<F> const * p1 = &points[i];
3065 
3066  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3067  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3068  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3069 
3070  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3071 
3072  p0 = p1;
3073  }
3074 
3075  // ("should" always be != 0)
3076  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3077  /* finish finding the average */
3078  double inv_count = 1.0 / (double)count;
3079  ctr *= inv_count;
3080 
3081  *this = Plane_3D(normal, Point_3D<F>(ctr));
3082  return;
3083  }
3084  }
3085 
3086  *this = Plane_3D::Zero();
3087  }
3088 
3089 
3090  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3091 
3092  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3093  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3094 
3095  F & operator[] (size_t i) { return (&a)[i]; }
3096  F const & operator[] (size_t i) const { return (&a)[i]; }
3097 
3098  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3099  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3100  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3101  }
3102 
3103  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3104  F len = (F)Vector_3D<F>(*this).Length();
3105  if (len > epsilon)
3106  operator/= (len);
3107  else
3108  *this = Zero();
3109  return *this;
3110  }
3111 
3112  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3113  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3114  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3115 
3116  if (val1 >= eps) {
3117  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3118  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3119  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3120  }
3121  else
3122  return p1;
3123  }
3124 
3125  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3126  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3127  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3128 
3129  return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3130  }
3131 
3132  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3133 
3134 
3135  private:
3136  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3137  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3138  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3139  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3140 };
3141 
3142 typedef Plane_3D<float> Plane;
3143 typedef Plane_3D<double> DPlane;
3144 
3145 
3146 template <typename F>
3147 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3148  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3149 }
3150 
3151 
3152 template <typename F>
3153 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3154  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3155 }
3156 template <typename F>
3157 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3158  return plane * point;
3159 }
3160 
3161 template <typename F>
3162 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3163  return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3164 }
3165 
3166 template <typename F>
3167 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3168 
3169 
3170 
3171 
3172 
3173 
3174 template <typename F>
3175 class HPS_TEMPLATE_API Plane_2D {
3176 public:
3177  F a;
3178  F b;
3179  F c;
3180 
3181  Plane_2D () {}
3182  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3183  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3184  Plane_2D (Vector_2D<F> const & v, Point_2D<F> const & p) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
3185  Plane_2D (Point_2D<F> const & p, Vector_2D<F> const & v) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
3186  template <typename D>
3187  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3188 
3189  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3190 
3191  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3192  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3193 
3194  F & operator[] (size_t i) { return (&a)[i]; }
3195  F const & operator[] (size_t i) const { return (&a)[i]; }
3196 
3197  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3198  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3199  }
3200 
3201  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3202  F len = (F)Vector_2D<F>(*this).Length();
3203  if (len > epsilon)
3204  operator/= (len);
3205  else
3206  *this = Zero();
3207  return *this;
3208  }
3209 
3210  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3211 
3212 
3213 private:
3214  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3215  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3216  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3217  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3218 };
3219 
3220 typedef Plane_2D<float> Plane2D;
3221 typedef Plane_2D<double> DPlane2D;
3222 
3223 
3224 template <typename F>
3225 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3226  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3227 }
3228 
3229 
3230 template <typename F>
3231 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3232  return plane.a * point.x + plane.b * point.y + plane.c;
3233 }
3234 template <typename F>
3235 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3236  return plane * point;
3237 }
3238 
3239 template <typename F>
3240 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3241  return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3242 }
3243 
3244 template <typename F>
3245 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3246 
3247 
3248 
3249 
3250 struct Rectangle;
3251 
3252 struct HPS_API IntRectangle {
3253  int left;
3254  int right;
3255  int bottom;
3256  int top;
3257 
3258  IntRectangle()
3259  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3260  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3261 
3262  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3263  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3264 
3265  IntRectangle(IntRectangle const & that)
3266  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3267 
3268  explicit IntRectangle(Rectangle const & that);
3269 
3270  bool operator==(IntRectangle const & rect) const {
3271  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3272  }
3273 
3274  bool operator!=(IntRectangle const & rect) const {
3275  return !(*this == rect);
3276  }
3277 
3278  HPS_INLINE int PixelWidth() const {
3279  return right - left + 1;
3280  }
3281 
3282  HPS_INLINE int PixelHeight() const {
3283  return top - bottom + 1;
3284  }
3285 
3286  HPS_INLINE int Width() const {
3287  return right - left;
3288  }
3289 
3290  HPS_INLINE int Height() const {
3291  return top - bottom;
3292  }
3293 
3294  HPS_INLINE int Area() const {
3295  return Width() * Height();
3296  }
3297 
3298  HPS_INLINE Point2D Center() const {
3299  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3300  }
3301 
3302  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3303  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3304  }
3305 
3306  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3307  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3308  }
3309 
3310  HPS_INLINE IntRectangle & Expand(int border) {
3311  left -= border;
3312  right += border;
3313  bottom -= border;
3314  top += border;
3315  return *this;
3316  }
3317 
3318  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3319  left -= rect.left;
3320  right += rect.right;
3321  bottom -= rect.bottom;
3322  top += rect.top;
3323  return *this;
3324  }
3325 
3326  HPS_INLINE IntRectangle & Contract(int border) {
3327  left += border;
3328  right -= border;
3329  bottom += border;
3330  top -= border;
3331  return *this;
3332  }
3333 
3334  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3335  left += rect.left;
3336  right -= rect.right;
3337  bottom += rect.bottom;
3338  top -= rect.top;
3339  return *this;
3340  }
3341 
3342  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3343  left = Max(left, rect.left);
3344  right = Min(right, rect.right);
3345  bottom = Max(bottom, rect.bottom);
3346  top = Min(top, rect.top);
3347  return *this;
3348  }
3349 
3350  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3351  left = Min(left, rect.left);
3352  right = Max(right, rect.right);
3353  bottom = Min(bottom, rect.bottom);
3354  top = Max(top, rect.top);
3355  return *this;
3356  }
3357 
3358 
3359  static HPS_INLINE IntRectangle Invalid() {
3360  return IntRectangle();
3361  }
3362 
3363  static HPS_INLINE IntRectangle Zero() {
3364  return IntRectangle(0, 0, 0, 0);
3365  }
3366 
3367 };
3368 
3369 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3370  IntRectangle temp = a;
3371  return temp.Expand(border);
3372 }
3373 
3374 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3375  IntRectangle temp = a;
3376  return temp.Expand(border);
3377 }
3378 
3379 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3380  IntRectangle temp = a;
3381  return temp.Contract(border);
3382 }
3383 
3384 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3385  IntRectangle temp = a;
3386  return temp.Contract(border);
3387 }
3388 
3389 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3390  IntRectangle temp = a;
3391  return temp.Intersect(b);
3392 }
3393 
3394 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3395  IntRectangle temp = a;
3396  return temp.Union(b);
3397 }
3398 
3399 struct HPS_API Rectangle {
3400  float left;
3401  float right;
3402  float bottom;
3403  float top;
3404 
3405  Rectangle()
3406  : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3407  bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3408 
3409  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3410  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3411 
3412  Rectangle(Rectangle const & that)
3413  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3414 
3415  explicit Rectangle(IntRectangle const & that)
3416  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3417 
3418  HPS_INLINE Rectangle(size_t count, Point const * points) {
3419  left = points->x;
3420  right = points->x;
3421  top = points->y;
3422  bottom = points->y;
3423  --count;
3424  if (count > 0) {
3425  ++points;
3426  Merge(count, points);
3427  }
3428  }
3429 
3430  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3431  left = points->x;
3432  right = points->x;
3433  top = points->y;
3434  bottom = points->y;
3435  --count;
3436  if (count > 0) {
3437  ++points;
3438  Merge(count, points);
3439  }
3440  }
3441 
3442  HPS_INLINE float Width() const {
3443  return right - left;
3444  }
3445 
3446  HPS_INLINE float Height() const {
3447  return top - bottom;
3448  }
3449 
3450  HPS_INLINE float Area() const {
3451  return Width() * Height();
3452  }
3453 
3454  HPS_INLINE Point2D Center() const {
3455  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3456  }
3457 
3458  HPS_INLINE void Merge(size_t count, Point const * points) {
3459 
3460  while (count > 1) {
3461  if (Compare(points[0].x, points[1].x)>0) {
3462  Float::replace_if_smaller(left, points[1].x);
3463  Float::replace_if_larger(right, points[0].x);
3464  }
3465  else {
3466  Float::replace_if_smaller(left, points[0].x);
3467  Float::replace_if_larger(right, points[1].x);
3468  }
3469 
3470  if (Compare(points[0].y, points[1].y)>0) {
3471  Float::replace_if_smaller(bottom, points[1].y);
3472  Float::replace_if_larger(top, points[0].y);
3473  }
3474  else {
3475  Float::replace_if_smaller(bottom, points[0].y);
3476  Float::replace_if_larger(top, points[1].y);
3477  }
3478 
3479  points += 2;
3480  count -= 2;
3481  }
3482 
3483  if (count > 0)
3484  Merge(*points);
3485  }
3486 
3487  HPS_INLINE void Merge(Point const & point) {
3488  Float::replace_if_smaller(left, point.x);
3489  Float::replace_if_smaller(bottom, point.y);
3490  Float::replace_if_larger(right, point.x);
3491  Float::replace_if_larger(top, point.y);
3492  }
3493 
3494  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3495 
3496  while (count > 1) {
3497  if (Compare(points[0].x, points[1].x)>0) {
3498  Float::replace_if_smaller(left, points[1].x);
3499  Float::replace_if_larger(right, points[0].x);
3500  }
3501  else {
3502  Float::replace_if_smaller(left, points[0].x);
3503  Float::replace_if_larger(right, points[1].x);
3504  }
3505 
3506  if (Compare(points[0].y, points[1].y)>0) {
3507  Float::replace_if_smaller(bottom, points[1].y);
3508  Float::replace_if_larger(top, points[0].y);
3509  }
3510  else {
3511  Float::replace_if_smaller(bottom, points[0].y);
3512  Float::replace_if_larger(top, points[1].y);
3513  }
3514 
3515  points += 2;
3516  count -= 2;
3517  }
3518 
3519  if (count > 0)
3520  Merge(*points);
3521  }
3522 
3523  HPS_INLINE void Merge(Point2D const & point) {
3524  Float::replace_if_smaller(left, point.x);
3525  Float::replace_if_smaller(bottom, point.y);
3526  Float::replace_if_larger(right, point.x);
3527  Float::replace_if_larger(top, point.y);
3528  }
3529 
3530  bool operator==(Rectangle const & rect) const {
3531  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3532  }
3533 
3534  bool operator!=(Rectangle const & rect) const {
3535  return !(*this == rect);
3536  }
3537 
3538  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3539  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3540  }
3541 
3542  HPS_INLINE bool Contains(Point const & contained) const {
3543  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3544  }
3545 
3546  HPS_INLINE bool Contains(Point2D const & contained) const {
3547  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3548  }
3549 
3550  HPS_INLINE bool Contains(Rectangle const & rect) {
3551  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3552  }
3553 
3554  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3555  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3556  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3557  }
3558 
3559  HPS_INLINE Rectangle & Expand(float border) {
3560  left -= border;
3561  right += border;
3562  bottom -= border;
3563  top += border;
3564  return *this;
3565  }
3566 
3567  HPS_INLINE Rectangle & Expand(int border) {
3568  Expand((float)border);
3569  return *this;
3570  }
3571 
3572  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3573  left -= rect.left;
3574  right += rect.right;
3575  bottom -= rect.bottom;
3576  top += rect.top;
3577  return *this;
3578  }
3579 
3580  HPS_INLINE Rectangle & Contract(int border) {
3581  left += border;
3582  right -= border;
3583  bottom += border;
3584  top -= border;
3585  return *this;
3586  }
3587 
3588  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3589  left += rect.left;
3590  right -= rect.right;
3591  bottom += rect.bottom;
3592  top -= rect.top;
3593  return *this;
3594  }
3595 
3596  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3597  left = Max(left, rect.left);
3598  right = Min(right, rect.right);
3599  bottom = Max(bottom, rect.bottom);
3600  top = Min(top, rect.top);
3601  return *this;
3602  }
3603 
3604  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3605  left = Min(left, rect.left);
3606  right = Max(right, rect.right);
3607  bottom = Min(bottom, rect.bottom);
3608  top = Max(top, rect.top);
3609  return *this;
3610  }
3611 
3612  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3613  float scale = (scope.right - scope.left) * 0.5f;
3614  float trans = (scope.right + scope.left) * 0.5f;
3615 
3616  left = left * scale + trans;
3617  right = right * scale + trans;
3618 
3619  scale = (scope.top - scope.bottom) * 0.5f;
3620  trans = (scope.top + scope.bottom) * 0.5f;
3621 
3622  bottom = bottom * scale + trans;
3623  top = top * scale + trans;
3624  return *this;
3625  }
3626 
3627  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3628  float tmp = 2.0f/(scope.right - scope.left);
3629  right = (right - scope.left) * tmp - 1.0f;
3630  left = (left - scope.left) * tmp - 1.0f;
3631 
3632  tmp = 2.0f/(scope.top - scope.bottom);
3633  top = (top - scope.bottom) * tmp - 1.0f;
3634  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3635  return *this;
3636  }
3637 
3638  static HPS_INLINE Rectangle FullScope() {
3639  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3640  }
3641 
3642  static HPS_INLINE Rectangle InvalidScope() {
3643  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3644  }
3645 
3646  static HPS_INLINE Rectangle Zero() {
3647  return Rectangle(0, 0, 0, 0);
3648  }
3649 
3650 };
3651 
3652 
3653 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3654  IntRectangle temp;
3655  temp.left = Floor (a.left);
3656  temp.right = Floor (a.right);
3657  temp.bottom = Floor (a.bottom);
3658  temp.top = Floor (a.top);
3659  return temp;
3660 }
3661 
3662 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3663  Rectangle temp = a;
3664  return temp.Expand(border);
3665 }
3666 
3667 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3668  Rectangle temp = a;
3669  return temp.Expand(border);
3670 }
3671 
3672 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3673  Rectangle temp = a;
3674  return temp.Contract(border);
3675 }
3676 
3677 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3678  Rectangle temp = a;
3679  return temp.Contract(border);
3680 }
3681 
3682 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3683  Rectangle temp = a;
3684  return temp.Intersect(b);
3685 }
3686 
3687 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3688  Rectangle temp = a;
3689  return temp.Union(b);
3690 }
3691 
3692 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3693  Rectangle temp = a;
3694  return temp.Inscribe_Scope(scope);
3695 }
3696 
3697 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3698  Rectangle temp = a;
3699  return temp.Circumscribe_Scope(scope);
3700 }
3701 
3702 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3703  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3704 
3705 
3706 
3707 
3708 template <typename F>
3709 struct Sphere_3D;
3710 
3711 template <typename F>
3712 struct HPS_TEMPLATE_API Cuboid_3D {
3717 
3718 
3722  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3723 
3724  template <typename D>
3725 
3730  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3731 
3732 
3737  Cuboid_3D (Sphere_3D<F> const & that);
3738 
3744  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3745 
3751  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3752  if (count == 0) {
3753  min = Limit_Point();
3754  max = -Limit_Point();
3755  return;
3756  }
3757  min = max = *points++;
3758  --count;
3759  if (count>0)
3760  Merge(count, points);
3761  }
3762 
3767  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3768 
3772  HPS_INLINE bool IsValid() const {
3773  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3774  }
3775 
3779  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3780 
3784  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3785 
3790  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3791 
3796  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3797 
3802  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3803  points[0] = Point_3D<F> (min.x, min.y, min.z);
3804  points[1] = Point_3D<F> (min.x, min.y, max.z);
3805  points[2] = Point_3D<F> (min.x, max.y, min.z);
3806  points[3] = Point_3D<F> (min.x, max.y, max.z);
3807  points[4] = Point_3D<F> (max.x, min.y, min.z);
3808  points[5] = Point_3D<F> (max.x, min.y, max.z);
3809  points[6] = Point_3D<F> (max.x, max.y, min.z);
3810  points[7] = Point_3D<F> (max.x, max.y, max.z);
3811  }
3812 
3816  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3817 
3821  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3822 
3828  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3829  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3830  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3831  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3832  }
3833 
3839  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3840  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3841  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3842  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3843  }
3844 
3851  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3852  //ASSERT (0 <= dimension && dimension <= 2);
3853  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3854  }
3855 
3863  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3864  //ASSERT (0 <= dimension && dimension <= 2);
3865  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3866  }
3867 
3874  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
3875  return LineIntersecting(start, direction, true);
3876  }
3877 
3884  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
3885  Vector_3D<F> const direction = point2 - point1;
3886  return LineIntersecting(point1, direction, false);
3887  }
3888 
3894  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3895  Float::replace_if_smaller(min.x, cuboid.min.x);
3896  Float::replace_if_smaller(min.y, cuboid.min.y);
3897  Float::replace_if_smaller(min.z, cuboid.min.z);
3898  Float::replace_if_larger(max.x, cuboid.max.x);
3899  Float::replace_if_larger(max.y, cuboid.max.y);
3900  Float::replace_if_larger(max.z, cuboid.max.z);
3901  }
3902 
3908  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
3909 
3915  HPS_INLINE void Merge(Point_3D<F> const & point) {
3916  Float::replace_if_smaller(min.x, point.x);
3917  Float::replace_if_smaller(min.y, point.y);
3918  Float::replace_if_smaller(min.z, point.z);
3919  Float::replace_if_larger(max.x, point.x);
3920  Float::replace_if_larger(max.y, point.y);
3921  Float::replace_if_larger(max.z, point.z);
3922  }
3923 
3930  void Merge(size_t count, Point_3D<F> const * points) {
3931  while (count > 1) {
3932  if (Compare(points[0].x, points[1].x)>0) {
3933  Float::replace_if_smaller(min.x, points[1].x);
3934  Float::replace_if_larger(max.x, points[0].x);
3935  }
3936  else {
3937  Float::replace_if_smaller(min.x, points[0].x);
3938  Float::replace_if_larger(max.x, points[1].x);
3939  }
3940 
3941  if (Compare(points[0].y, points[1].y)>0) {
3942  Float::replace_if_smaller(min.y, points[1].y);
3943  Float::replace_if_larger(max.y, points[0].y);
3944  }
3945  else {
3946  Float::replace_if_smaller(min.y, points[0].y);
3947  Float::replace_if_larger(max.y, points[1].y);
3948  }
3949 
3950  if (Compare(points[0].z, points[1].z)>0) {
3951  Float::replace_if_smaller(min.z, points[1].z);
3952  Float::replace_if_larger(max.z, points[0].z);
3953  }
3954  else {
3955  Float::replace_if_smaller(min.z, points[0].z);
3956  Float::replace_if_larger(max.z, points[1].z);
3957  }
3958 
3959  points += 2;
3960  count -= 2;
3961  }
3962 
3963  if (count > 0)
3964  Merge(*points);
3965  }
3966 
3972  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
3973  return (contained.min.x >= min.x &&
3974  contained.min.y >= min.y &&
3975  contained.min.z >= min.z &&
3976  contained.max.x <= max.x &&
3977  contained.max.y <= max.y &&
3978  contained.max.z <= max.z);
3979  }
3980 
3986  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
3987  return (contained.x >= min.x &&
3988  contained.y >= min.y &&
3989  contained.z >= min.z &&
3990  contained.x <= max.x &&
3991  contained.y <= max.y &&
3992  contained.z <= max.z);
3993  }
3994 
4001  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4002  return (contained.x >= min.x - epsilon &&
4003  contained.y >= min.y - epsilon &&
4004  contained.z >= min.z - epsilon &&
4005  contained.x <= max.x + epsilon &&
4006  contained.y <= max.y + epsilon &&
4007  contained.z <= max.z + epsilon);
4008  }
4009 
4015  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4016  Float::replace_if_larger(min.x, cuboid.min.x);
4017  Float::replace_if_larger(min.y, cuboid.min.y);
4018  Float::replace_if_larger(min.z, cuboid.min.z);
4019  Float::replace_if_smaller(max.x, cuboid.max.x);
4020  Float::replace_if_smaller(max.y, cuboid.max.y);
4021  Float::replace_if_smaller(max.z, cuboid.max.z);
4022  return *this;
4023  }
4024 
4030  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4031  Float::replace_if_smaller(min.x, cuboid.min.x);
4032  Float::replace_if_smaller(min.y, cuboid.min.y);
4033  Float::replace_if_smaller(min.z, cuboid.min.z);
4034  Float::replace_if_larger(max.x, cuboid.max.x);
4035  Float::replace_if_larger(max.y, cuboid.max.y);
4036  Float::replace_if_larger(max.z, cuboid.max.z);
4037  return *this;
4038  }
4039 
4045  HPS_INLINE Cuboid_3D & Expand(F border) {
4046  Vector_3D<F> delta (border, border, border);
4047  min -= delta;
4048  max += delta;
4049  return *this;
4050  }
4051 
4057  HPS_INLINE Cuboid_3D & Contract(F border) {
4058  Vector_3D<F> delta (border, border, border);
4059  min += delta;
4060  max -= delta;
4061  return *this;
4062  }
4063 
4064 private:
4065  HPS_INLINE static Point_3D<F> Limit_Point () {
4066  F const limit = std::numeric_limits<F>::max();
4067  return Point_3D<F> (limit, limit, limit);
4068  }
4069 
4070  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4071 };
4072 
4073 typedef Cuboid_3D<float> SimpleCuboid;
4074 typedef Cuboid_3D<double> DSimpleCuboid;
4075 
4076 
4077 template <typename F>
4078 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4079  Cuboid_3D<F> temp = a;
4080  return temp.Intersect(b);
4081 }
4082 
4083 template <typename F>
4084 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4085  Cuboid_3D<F> temp = a;
4086  return temp.Union(b);
4087 }
4088 
4089 template <typename F>
4090 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4091  Cuboid_3D<F> temp = a;
4092  return temp.Expand(border);
4093 }
4094 
4095 template <typename F>
4096 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4097  Cuboid_3D<F> temp = a;
4098  return temp.Contract(border);
4099 }
4100 
4101 
4102 
4103 template <typename F>
4104 struct HPS_TEMPLATE_API Sphere_3D {
4105  Point_3D<F> center;
4106  F radius;
4107 
4108  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4109 
4110  template <typename D>
4111  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4112 
4113  Sphere_3D (Cuboid_3D<F> const & cuboid) :
4114  center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4115 
4116  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4117 
4118  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4119  Cuboid_3D<F> cuboid(count, points);
4120  center = Midpoint(cuboid.min, cuboid.max);
4121  Engulf (count, points);
4122  }
4123 
4124  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4125  Engulf (count, points);
4126  }
4127 
4128  HPS_INLINE bool IsValid() const {
4129  return radius >= 0;
4130  }
4131 
4132  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4133 
4134  void Invalidate() {radius = -1;}
4135 
4136  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4137  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4138 
4139  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4140 
4141  HPS_INLINE void Merge(Point_3D<F> const & point) {
4142  Vector_3D<F> dir = point - center;
4143  F distance = (F)dir.Length();
4144 
4145  if (distance > radius) {
4146  F t = F(0.5) * (distance - radius);
4147  center += t * dir.Normalize();
4148  radius += t;
4149  }
4150  }
4151 
4152  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4153 
4154  for (size_t i = 0; i < count; ++i) {
4155  Vector_3D<F> dir = *points - center;
4156  F distance = (F)dir.Length();
4157 
4158  if (distance > radius) {
4159  F t = F(0.5) * (distance - radius);
4160  center += t * dir.Normalize();
4161  radius += t;
4162  }
4163 
4164  ++points;
4165  }
4166  }
4167 
4168  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4169  Vector_3D<F> dir = sphere.center - center;
4170  F distance = (F)dir.Length();
4171 
4172  if (distance + sphere.radius > radius) {
4173  if (distance + radius > sphere.radius) {
4174  F t = F(0.5 * (sphere.radius + distance - radius));
4175  center += t * dir.Normalize();
4176  radius += t;
4177  }
4178  else {
4179  center = sphere.center;
4180  radius = sphere.radius;
4181  }
4182  }
4183  }
4184 
4185  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4186 
4187 private:
4188  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4189  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4190  for (size_t i = 0; i < count; ++i) {
4191  double dsq = (*points++ - center).LengthSquared();
4192  if ((F)dsq > radius * radius)
4193  radius = (F)sqrt(dsq);
4194  }
4195  }
4196 };
4197 
4198 typedef Sphere_3D<float> SimpleSphere;
4199 typedef Sphere_3D<double> DSimpleSphere;
4200 
4201 
4202 template <typename F>
4203 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4204  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4205  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4206 }
4207 
4208 
4209 
4210 
4211 class RGB24Color;
4212 class RGBA32Color;
4213 class RGBAS32Color;
4214 class RGBAColor;
4215 
4216 class HPS_API RGBColor {
4217 public:
4218  float red;
4219  float green;
4220  float blue;
4221 
4222  HPS_INLINE RGBColor () {}
4223  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4224  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4225  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4226  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4227  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4228  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4229 
4230  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4231  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4232  float Distance(RGBColor const & other_color) const;
4233  HPS_INLINE bool IsValid() const {
4234  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4235  }
4236 
4237  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4238  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4239 
4240  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4241  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4242 
4243  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4244  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4245  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4246  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4247  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4248  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4249 
4250  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4251  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4252  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4253  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4254  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4255  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4256  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4257  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4258 
4259  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4260  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4261  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4262 
4263  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4264  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4265  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4266 
4267  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4268  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4269  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4270 };
4271 
4272 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4273 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4274 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4275 
4276 
4277 class HPS_API RGBAColor {
4278 public:
4279 
4280  float red;
4281  float green;
4282  float blue;
4283  float alpha;
4285  HPS_INLINE RGBAColor () {}
4286  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4287  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4288 
4289  HPS_INLINE RGBAColor (RGBColor const & c) {
4290  memcpy(this, &c, sizeof(RGBColor)); //-V512
4291  alpha = 1.0f;
4292  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4293  }
4294  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4295  memcpy(this, &c, sizeof(RGBColor));
4296  memcpy(&alpha, &a, sizeof(float));
4297  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4298  }
4299  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4300  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4301 
4302  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4303  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4304  HPS_INLINE bool IsValid() const {
4305  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4306  }
4307 
4314  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4315 
4322  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4323 
4324  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4325  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4326  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4327  }
4328 
4329  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4330  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4331  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4332  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4333  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4334  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4335 
4336  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4337  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4338  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4339  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4340  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4341  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4342  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4343  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4344 
4345  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4346  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4347  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4348  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4349  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4350  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4351 
4352  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4353  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4354  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4355  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4356 };
4357 
4358 
4359 
4361 public:
4362  enum Order {
4363  Order_ABGR,
4364  Order_RGBA,
4365  Order_BGRA
4366  };
4367 
4368 #ifdef _MSC_VER
4369  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4370  unsigned char b, g, r, a;
4371 #endif
4372 
4373 #ifdef __linux__
4374  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4375  unsigned char r, g, b, a;
4376 #endif
4377 
4378 #ifdef __APPLE_CC__
4379  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4380  unsigned char r, g, b, a;
4381 #endif
4382 };
4383 
4384 
4385 
4387 public:
4388 
4389  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4390  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4391  r = gray;
4392  g = gray;
4393  b = gray;
4394  a = aa;
4395  }
4396  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4397  r = rr;
4398  g = gg;
4399  b = bb;
4400  a = aa;
4401  }
4402  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4403 
4404  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4405  {
4406  r = Float::unit_to_byte(c.red);
4407  g = Float::unit_to_byte(c.green);
4408  b = Float::unit_to_byte(c.blue);
4409  a = 255;
4410  }
4411 
4412  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4413 
4414  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4415 
4416  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4417  {
4418  r = Float::unit_to_byte(c.red);
4419  g = Float::unit_to_byte(c.green);
4420  b = Float::unit_to_byte(c.blue);
4421  a = Float::unit_to_byte(alpha);
4422  }
4423  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4424  {
4425  r = Float::unit_to_byte(c.red);
4426  g = Float::unit_to_byte(c.green);
4427  b = Float::unit_to_byte(c.blue);
4428  a = aa;
4429  }
4430  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4431  {
4432  r = Float::unit_to_byte(c.red);
4433  g = Float::unit_to_byte(c.green);
4434  b = Float::unit_to_byte(c.blue);
4435  a = Float::unit_to_byte(c.alpha);
4436  }
4437  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4438  {
4439  r = Float::unit_to_byte(c.red);
4440  g = Float::unit_to_byte(c.green);
4441  b = Float::unit_to_byte(c.blue);
4442  a = Float::unit_to_byte_scaled(c.alpha, mix);
4443  }
4444 
4445  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4446  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4447  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4448 
4449  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4450  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4451 
4452  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4453  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4454  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4455 
4456  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4457 };
4458 
4460 public:
4461  unsigned char r;
4462  unsigned char g;
4463  unsigned char b;
4464  unsigned char a;
4465 
4466  HPS_INLINE RGBA32Color () {}
4467  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4468  : r (gray), g (gray), b (gray), a (aa) {}
4469  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4470  : r (rr), g (gg), b (bb), a (aa) {}
4471  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4472  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4473  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4474  r = Float::unit_to_byte(c.red);
4475  g = Float::unit_to_byte(c.green);
4476  b = Float::unit_to_byte(c.blue);
4477  a = 255;
4478  }
4479  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4480  r = Float::unit_to_byte(c.red);
4481  g = Float::unit_to_byte(c.green);
4482  b = Float::unit_to_byte(c.blue);
4483  a = Float::unit_to_byte(alpha);
4484  }
4485  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4486  r = Float::unit_to_byte(c.red);
4487  g = Float::unit_to_byte(c.green);
4488  b = Float::unit_to_byte(c.blue);
4489  a = aa;
4490  }
4491  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4492  r = Float::unit_to_byte(c.red);
4493  g = Float::unit_to_byte(c.green);
4494  b = Float::unit_to_byte(c.blue);
4495  a = Float::unit_to_byte(c.alpha);
4496  }
4497  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4498  r = Float::unit_to_byte(c.red);
4499  g = Float::unit_to_byte(c.green);
4500  b = Float::unit_to_byte(c.blue);
4501  a = Float::unit_to_byte_scaled(c.alpha, mix);
4502  }
4503 
4504  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4505  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4506 
4507  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4508  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4509 
4510  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4511  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4512 
4513  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4514 };
4515 
4516 
4518 {
4519 public:
4520  unsigned char r;
4521  unsigned char g;
4522  unsigned char b;
4523 
4524  HPS_INLINE RGB24Color () {}
4525  explicit HPS_INLINE RGB24Color (unsigned char gray)
4526  : r (gray), g (gray), b (gray) {}
4527  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4528  : r (rr), g (gg), b (bb) {}
4529  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4530  r = Float::unit_to_byte(c.red);
4531  g = Float::unit_to_byte(c.green);
4532  b = Float::unit_to_byte(c.blue);
4533  }
4534 
4535  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4536  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4537 
4538  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4539  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4540 };
4541 
4542 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4543  red = Float::C2F(c32.r);
4544  green = Float::C2F(c32.g);
4545  blue = Float::C2F(c32.b);
4546 }
4547 
4548 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4549  red = Float::C2F(c32.r);
4550  green = Float::C2F(c32.g);
4551  blue = Float::C2F(c32.b);
4552 }
4553 
4554 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4555  red = c.red;
4556  green = c.green;
4557  blue = c.blue;
4558 }
4559 
4560 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4561  red = Float::C2F(c24.r);
4562  green = Float::C2F(c24.g);
4563  blue = Float::C2F(c24.b);
4564 }
4565 
4566 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4567 {
4568  r = c.r;
4569  g = c.g;
4570  b = c.b;
4571  a = 255;
4572 }
4573 
4574 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4575 {
4576  r = c.r;
4577  g = c.g;
4578  b = c.b;
4579  a = c.a;
4580 }
4581 
4582 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4583  red = Float::C2F(c32.r);
4584  green = Float::C2F(c32.g);
4585  blue = Float::C2F(c32.b);
4586  alpha = Float::C2F(c32.a);
4587 }
4588 
4589 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4590  red = Float::C2F(c32.r);
4591  green = Float::C2F(c32.g);
4592  blue = Float::C2F(c32.b);
4593  alpha = Float::C2F(c32.a);
4594 }
4595 
4596 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4597  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4598 }
4599 
4600 
4601 
4602 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4603  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4604 }
4605 
4606 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4607  return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4608 }
4609 
4610 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4611  return RGBAS32Color(
4612  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4613  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4614  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4615  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4616 }
4617 
4618 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4619  return RGBA32Color(
4620  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4621  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4622  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4623  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4624 }
4625 
4626 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4627  return RGB24Color(
4628  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4629  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4630  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4631 }
4632 
4633 
4634 
4635 class HPS_API Quaternion {
4636 public:
4637  float w;
4638  float x;
4639  float y;
4640  float z;
4641 
4642  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4643 
4644  Quaternion(float in_w, float in_x, float in_y, float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4645 
4646  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4647 
4648  Quaternion const & Normalize() {
4649  float mag = Norm();
4650 
4651  if (mag > 0) {
4652  w /= mag;
4653  x /= mag;
4654  y /= mag;
4655  z /= mag;
4656  }
4657  return *this;
4658  }
4659 
4660 
4661  Quaternion operator* (Quaternion const & in_right) const {
4662  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4663  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4664  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4665  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4666  }
4667 
4668  Quaternion operator* (float in_right) const {
4669  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4670  }
4671 
4672  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4673  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4674  }
4675 
4676  Quaternion operator/ (float in_right) const {
4677  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4678  }
4679 
4680  Quaternion operator- (Quaternion const & in_right) const {
4681  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4682  }
4683 
4684  Quaternion operator+ (Quaternion const & in_right) const {
4685  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4686  }
4687 
4688  inline float Norm() const {
4689  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4690  }
4691 
4692 
4693  Quaternion Log() const {
4694  Quaternion ret;
4695  float mag_q = Norm();
4696  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4697 
4698  ret.w = static_cast<float>(log(mag_q));
4699 
4700  if (mag_V > 0) {
4701  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4702 
4703  ret.x = x * scale;
4704  ret.y = y * scale;
4705  ret.z = z * scale;
4706  }
4707  else
4708  ret.x = ret.y = ret.z = 0;
4709 
4710  return ret;
4711  }
4712 
4713  Quaternion Exp() const {
4714  Quaternion ret;
4715  float ea = static_cast<float>(exp(w));
4716  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4717  float scale = ea * sin(mag_V) / mag_V;
4718 
4719  ret.w = ea * cos(mag_V);
4720  ret.x = scale * x;
4721  ret.y = scale * y;
4722  ret.z = scale * z;
4723 
4724  return ret;
4725  }
4726 
4727  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4728  Quaternion ret = *this + in_fraction * (in_right - *this);
4729  return ret.Normalize();
4730  }
4731 
4732 
4733  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4734  Quaternion q3;
4735  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4736 
4737  if (in_shortest_path_only && dot < 0) {
4738  dot = -dot;
4739  q3 = -1 * in_right;
4740  }
4741  else
4742  q3 = in_right;
4743 
4744  if (dot > -0.95f && dot < 0.95f) {
4745  float angle = static_cast<float>(acos(dot));
4746  float sina = static_cast<float>(sin(angle));
4747  float sinat = static_cast<float>(sin(angle*in_fraction));
4748  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4749 
4750  return (*this * sinaomt + q3 * sinat) / sina;
4751  }
4752  else //if the angle is small, we use linear interpolation
4753  return Lerp(q3, in_fraction);
4754  }
4755 
4756 
4757  /*
4758  Spherical cubic interpolation between two Quaternions
4759  \param in_right The Quaternion for interpolation.
4760  \param in_control1 The first control point.
4761  \param in_control2 The second control point.
4762  \param in_fraction Interpolation distance (0 - 1).
4763  \return Result of interpolation.
4764  */
4765  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4766  Quaternion q1 = Slerp(in_right , in_fraction, false);
4767  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4768 
4769  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4770  }
4771 
4778  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4779  Quaternion qni(-x, -y, -z, w);
4780 
4781  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4782  }
4783 
4784 };
4785 
4787 {
4788  size_t dot_dc_count;
4789  size_t dot_3d_count;
4790  size_t line_dc_count;
4791  size_t line_3d_count;
4792  size_t triangle_dc_count;
4793  size_t triangle_3d_count;
4794  size_t polygon_dc_count;
4795  size_t polygon_3d_count;
4796  size_t polyhedron_count;
4797  size_t deleted_display_list_count;
4798  size_t display_list_line_3d_count;
4799  size_t display_list_triangle_3d_count;
4800  size_t display_list_vertex_3d_count;
4801  size_t display_list_tristrip_count;
4802  size_t non_display_list_tristrip_count;
4803  size_t culled_display_list_tristrip_count;
4804  size_t raster_count;
4805  size_t segment_count;
4806  size_t frustum_culled_segment_count;
4807  size_t extent_culled_segment_count;
4808  size_t vector_culled_segment_count;
4809  Time update_time;
4810 };
4811 
4812 typedef unsigned char byte;
4813 typedef signed char sbyte;
4814 typedef intptr_t WindowHandle;
4815 typedef int64_t TouchID;
4816 typedef intptr_t PlatformData;
4817 
4818 /*
4819 HPS Lexicon:
4820 
4821 Concept Class -- A class that contains only enums and possibly static functions. The
4822  constructor is usually private because they are not intended to be instantiated.
4823 
4824 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4825  database objects is subject to locking to prevent threading deadlocks. (2) The class
4826  of the same name, offering static functions to initiate operations that take place
4827  within the database.
4828 
4829 Key -- A reference counted smart pointer to an object in the database. The
4830 
4831 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4832  option group, or other type. Modifying a kit has no effect on the database unless
4833  and until it is applied. Kits should generally be passed by reference because they
4834  are potentially very large and copying them can be arduous.
4835 
4836 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4837  pointers should generally be passed by value to ensure the reference count is
4838  correct.
4839 
4840 User Space -- The external space occupied by all user code. User space objects are not
4841  in the database and are not subject to locking.
4842 
4843 */
4844 
4848 class SegmentKey;
4849 class AttributesControl;
4850 class LineKit;
4851 class LineKey;
4852 class TextKey;
4853 class TextKit;
4854 class Key;
4855 class VisibilityControl;
4856 class CameraControl;
4857 class SelectabilityControl;
4858 class TransparencyKit;
4859 class TransparencyControl;
4860 class CullingKit;
4861 class CullingControl;
4862 class GlyphKit;
4864 class GlyphDefinition;
4865 class GeometryInsertControl;
4866 class GlyphElement;
4867 class TextAttributeControl;
4868 class TextAttributeKit;
4869 class LineAttributeKit;
4870 class LineAttributeControl;
4871 class EdgeAttributeKit;
4872 class EdgeAttributeControl;
4873 class CurveAttributeKit;
4874 class CurveAttributeControl;
4875 class GlyphPoint;
4876 class MatrixKit;
4878 class TextureMatrixControl;
4879 class TextureDefinition;
4880 class MaterialMappingKit;
4882 class MaterialKit;
4883 class MarkerKit;
4884 class MarkerKey;
4885 class DistantLightKit;
4886 class DistantLightKey;
4887 class CuttingSectionKit;
4888 class CuttingSectionKey;
4891 class CylinderAttributeKit;
4893 class Cylinder;
4894 class CylinderKey;
4895 class CylinderKit;
4896 class SphereKey;
4897 class SphereKit;
4898 class SphereAttributeKit;
4900 class PolygonKit;
4901 class PolygonKey;
4902 class CircleKey;
4903 class CircleKit;
4904 class CircularArcKey;
4905 class CircularArcKit;
4906 class CircularWedgeKey;
4907 class CircularWedgeKit;
4908 class IncludeKey;
4909 class InfiniteLineKey;
4910 class InfiniteLineKit;
4911 class SpotlightKey;
4912 class SpotlightKit;
4913 class NURBSCurveKey;
4914 class NURBSCurveKit;
4915 class NURBSSurfaceKey;
4916 class NURBSSurfaceKit;
4917 class TrimKit;
4918 class TrimElement;
4919 class EllipseKey;
4920 class EllipseKit;
4921 class EllipticalArcKey;
4922 class EllipticalArcKit;
4923 class ShellKit;
4924 class ShellKey;
4925 class Shell;
4926 class MeshKit;
4927 class MeshKey;
4928 class WindowKey;
4929 class Database;
4932 class Driver;
4933 class Search;
4934 class PerformanceKit;
4935 class PerformanceControl;
4938 class DrawingAttributeKit;
4940 class PortfolioKey;
4941 class Selection;
4942 class SelectionOptionsKit;
4943 class SelectionResults;
4944 class SelectionItem;
4945 class SelectionControl;
4946 class HighlightControl;
4947 class HighlightOptionsKit;
4948 class ImageDefinition;
4949 class ImageKit;
4950 class TextureDefinition;
4951 class TextureOptionsKit;
4952 class NamedStyleDefinition;
4954 class GlyphDefinition;
4955 class LinePatternOptionsKit;
4956 class LinePatternDefinition;
4957 class LinePatternKit;
4958 class LinePatternElement;
4960 class CubeMapDefinition;
4961 class ShaderKit;
4962 class ShaderDefinition;
4963 class EmergencyHandler;
4964 class EventDispatcher;
4965 class EventHandler;
4966 class Event;
4967 class StandAloneWindowKey;
4969 class ApplicationWindowKey;
4971 class OffScreenWindowKey;
4974 class VisualEffectsControl;
4977 class ObjectPoint;
4978 class WorldPoint;
4979 class CameraPoint;
4980 class NormalizedPoint;
4981 class ScreenRangePoint;
4982 class InnerWindowPoint;
4983 class InnerPixelPoint;
4984 class WindowPoint;
4985 class PixelPoint;
4986 class VisibilityKit;
4987 class CameraKit;
4988 class SelectabilityKit;
4989 class MarkerAttributeKit;
4990 class LightingAttributeKit;
4991 class VisualEffectsKit;
4992 class PostProcessEffectsKit;
4993 class Portfolio;
4994 class SubwindowControl;
4995 class SubwindowKit;
4996 class World;
4997 class DebuggingControl;
4998 class DebuggingKit;
4999 class KeyPath;
5000 class ContourLineKit;
5001 class ContourLineControl;
5002 class UTF8;
5003 class StyleControl;
5004 class PortfolioControl;
5005 class Condition;
5006 class ConditionControl;
5007 class WindowInfoKit;
5008 class WindowInfoControl;
5009 class FontInfoState;
5010 class FontInfoControl;
5011 class SearchOptionsKit;
5012 class AttributeLockControl;
5013 class AttributeLockKit;
5014 class ReferenceKey;
5015 class StyleKey;
5016 class BoundingKit;
5017 class BoundingControl;
5018 class TransformMaskKit;
5019 class TransformMaskControl;
5020 class ColorInterpolationKit;
5022 class UpdateOptionsKit;
5023 class UpdateOptionsControl;
5024 class GeometryKey;
5025 class TreeContext;
5028 class GridKit;
5029 class GridKey;
5032 
5036 
5037 
5040 class HPS_API GlyphPoint
5041 {
5042 public:
5043 
5045  GlyphPoint();
5046 
5051  GlyphPoint(sbyte in_x, sbyte in_y);
5052 
5057  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5058 
5063  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5064 
5069  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5070 
5071  sbyte x;
5072  sbyte y;
5073 };
5074 
5077 enum class Type : uint32_t
5078 {
5079  None = 0x00000000,
5080  GenericMask = 0xffffff00,
5081 
5082  World = 0x00000001,
5083  UTF8 = 0x00000002,
5084  EventDispatcher = 0x00000003,
5085  EventHandler = 0x00000004,
5086  EventNotifier = 0x00000005,
5087  UpdateNotifier = 0x00000006,
5088  SearchResults = 0x00000008,
5089  FontSearchResults = 0x00000009,
5090  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
5091  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5092  SelectionResults = 0x0000000c,
5093  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5094  SelectionItem = 0x0000000e,
5095  TreeContext = 0x0000000f,
5096  StreamToolkit = 0x00000010,
5097 
5098  IONotifier = 0x04000100,
5099  StreamImportNotifier = 0x04000101,
5100  STLImportNotifier = 0x04000102,
5101  OBJImportNotifier = 0x04000103,
5102  ExchangeImportNotifier = 0x04000104,
5103  SketchupImportNotifier = 0x04000105,
5104  ParasolidImportNotifier = 0x04000106,
5105  ExchangeTranslationNotifier = 0x04000107,
5106  ExchangeExportNotifier = 0x04000108,
5107  StreamExportNotifier = 0x04000109,
5108  ExchangeReloadNotifier = 0x0400010a,
5109 
5110  Kit = 0x01000000,
5111  MarkerKit = 0x01000010,
5112  SphereAttributeKit = 0x01000011,
5113  TextAttributeKit = 0x01000012,
5114  TransparencyKit = 0x01000013,
5115  VisibilityKit = 0x01000014,
5116  VisualEffectsKit = 0x01000015,
5117  CuttingSectionAttributeKit = 0x01000016,
5118  CircleKit = 0x01000017,
5119  CircularArcKit = 0x01000018,
5120  CircularWedgeKit = 0x01000019,
5121  CuttingSectionKit = 0x0100001a,
5122  CylinderKit = 0x0100001b,
5123  DistantLightKit = 0x0100001c,
5124  EllipseKit = 0x0100001d,
5125  EllipticalArcKit = 0x0100001e,
5126  InfiniteLineKit = 0x0100001f,
5127  LineKit = 0x01000020,
5128  NURBSCurveKit = 0x01000021,
5129  MeshKit = 0x01000022,
5130  NURBSSurfaceKit = 0x01000023,
5131  PolygonKit = 0x01000024,
5132  SphereKit = 0x01000025,
5133  SpotlightKit = 0x01000026,
5134  ShellKit = 0x01000027,
5135  TextKit = 0x01000028,
5136  MaterialKit = 0x01000029,
5137  TrimKit = 0x0100002a,
5138  TextureOptionsKit = 0x0100002c,
5139  LinePatternKit = 0x0100002d,
5140  GlyphKit = 0x0100002e,
5141  ImageKit = 0x0100002f,
5142  LinePatternOptionsKit = 0x01000030,
5143  CameraKit = 0x01000031,
5144  BoundingKit = 0x01000032,
5145  CullingKit = 0x01000033,
5146  CurveAttributeKit = 0x01000034,
5147  CylinderAttributeKit = 0x01000035,
5148  EdgeAttributeKit = 0x01000036,
5149  LightingAttributeKit = 0x01000037,
5150  LineAttributeKit = 0x01000038,
5151  MarkerAttributeKit = 0x01000039,
5152  MaterialMappingKit = 0x0100003a,
5153  MatrixKit = 0x0100003b,
5154  NURBSSurfaceAttributeKit = 0x0100003c,
5155  PostProcessEffectsKit = 0x0100003d,
5156  SelectabilityKit = 0x0100003e,
5157  SelectionOptionsKit = 0x0100003f,
5158  StandAloneWindowOptionsKit = 0x01000040,
5159  OffScreenWindowOptionsKit = 0x01000041,
5160  ApplicationWindowOptionsKit = 0x01000042,
5161  HighlightOptionsKit = 0x01000043,
5162  LinePatternParallelKit = 0x01000044,
5163  SubwindowKit = 0x01000045,
5164  PerformanceKit = 0x01000046,
5165  HiddenLineAttributeKit = 0x01000047,
5166  DrawingAttributeKit = 0x01000048,
5167  ShaderKit = 0x01000049,
5168  DebuggingKit = 0x0100004a,
5169  ContourLineKit = 0x0100004b,
5170  StreamImportOptionsKit = 0x0100004c,
5171  StreamImportResultsKit = 0x0100004d,
5172  StreamExportOptionsKit = 0x0100004e,
5173  StreamExportResultsKit = 0x0100004f,
5174  WindowInfoKit = 0x01000050,
5175  ImageImportOptionsKit = 0x01000051,
5176  SearchOptionsKit = 0x01000052,
5177  ShaderImportOptionsKit = 0x01000053,
5178  HardcopyExportOptionsKit = 0x01000055,
5179  AttributeLockKit = 0x01000056,
5180  TransformMaskKit = 0x01000057,
5181  ColorInterpolationKit = 0x01000058,
5182  UpdateOptionsKit = 0x01000059,
5183  ImageExportOptionsKit = 0x0100005a,
5184  OBJImportOptionsKit = 0x0100005b,
5185  OBJImportResultsKit = 0x0100005c,
5186  STLImportOptionsKit = 0x0100005d,
5187  STLImportResultsKit = 0x0100005e,
5188  ShellOptimizationOptionsKit = 0x0100005f,
5189  ShellRelationOptionsKit = 0x01000060,
5190  ShellRelationResultsKit = 0x01000061,
5191  GridKit = 0x01000062,
5192  CutGeometryGatheringOptionsKit = 0x01000063,
5193  SegmentOptimizationOptionsKit = 0x01000064,
5194 
5195 
5196  LinePatternElement = 0x03000000,
5197  SolidLinePatternElement = 0x03000001,
5198  BlankLinePatternElement = 0x03000002,
5199  GlyphLinePatternElement = 0x03000003,
5200 
5201  GlyphElement = 0x05000000,
5202  DotGlyphElement = 0x05000001,
5203  LineGlyphElement = 0x05000002,
5204  EllipseGlyphElement = 0x05000003,
5205  CircularArcGlyphElement = 0x05000004,
5206  InfiniteLineGlyphElement = 0x05000005,
5207 
5208  TrimElement = 0x07000000,
5209 
5210  Condition = 0x09000000,
5211  NOTCondition = 0x09000001,
5212  ANDCondition = 0x09000002,
5213  ORCondition = 0x09000003,
5214  XORCondition = 0x09000004,
5215  EQCondition = 0x09000005,
5216  NEQCondition = 0x09000006,
5217  GTCondition = 0x09000007,
5218  LTCondition = 0x09000008,
5219  GTEQCondition = 0x09000009,
5220  LTEQCondition = 0x0900000A,
5221 
5222  MouseState = 0x01001001,
5223  TouchState = 0x01001002,
5224  KeyboardState = 0x01001003,
5225  FontInfoState = 0x01001004,
5226 
5227  KeyPath = 0x01000F01,
5228 
5229  Key = 0x10000000,
5230  IncludeKey = 0x10000001,
5231  PortfolioKey = 0x10000002,
5232  StyleKey = 0x10000003,
5233 
5234  SegmentKey = 0x10200000,
5235  WindowKey = 0x10600000,
5236  StandAloneWindowKey = 0x10600001,
5237  OffScreenWindowKey = 0x10600002,
5238  ApplicationWindowKey = 0x10600003,
5239 
5240  GeometryKey = 0x10100000,
5241  ReferenceKey = 0x10100001,
5242  CircleKey = 0x10100002,
5243  CircularArcKey = 0x10100003,
5244  CircularWedgeKey = 0x10100004,
5245  CuttingSectionKey = 0x10100005,
5246  CylinderKey = 0x10100006,
5247  EllipseKey = 0x10100007,
5248  EllipticalArcKey = 0x10100008,
5249  InfiniteLineKey = 0x10100009,
5250  LineKey = 0x1010000a,
5251  DistantLightKey = 0x1010000b,
5252  SpotlightKey = 0x1010000c,
5253  MarkerKey = 0x1010000d,
5254  MeshKey = 0x1010000e,
5255  NURBSCurveKey = 0x1010000f,
5256  NURBSSurfaceKey = 0x10100010,
5257  PolygonKey = 0x10100011,
5258  ShellKey = 0x10100012,
5259  SphereKey = 0x10100013,
5260  TextKey = 0x10100014,
5261  GridKey = 0x10100015,
5262 
5263  Definition = 0x20000000,
5264  NamedStyleDefinition = 0x20000001,
5265  TextureDefinition = 0x20000002,
5266  LinePatternDefinition = 0x20000003,
5267  GlyphDefinition = 0x20000004,
5268  CubeMapDefinition = 0x20000005,
5269  ImageDefinition = 0x20000006,
5270  MaterialPaletteDefinition = 0x20000007,
5271  ShaderDefinition = 0x20000008,
5272 
5273  Control = 0x50000000,
5274  CameraControl = 0x50000001,
5275  SelectabilityControl = 0x50000002,
5276  MarkerAttributeControl = 0x50000003,
5277  SphereAttributeControl = 0x50000004,
5278  LightingAttributeControl = 0x50000005,
5279  CylinderAttributeControl = 0x50000006,
5280  TextAttributeControl = 0x50000007,
5281  LineAttributeControl = 0x50000008,
5282  EdgeAttributeControl = 0x50000009,
5283  CurveAttributeControl = 0x5000000a,
5284  ModellingMatrixControl = 0x5000000b,
5285  TextureMatrixControl = 0x5000000c,
5286  CullingControl = 0x5000000d,
5287  TransparencyControl = 0x5000000e,
5288  MaterialMappingControl = 0x5000000f,
5289  NURBSSurfaceAttributeControl = 0x50000010,
5290  PostProcessEffectsControl = 0x50000011,
5291  BoundingControl = 0x50000012,
5292  VisualEffectsControl = 0x50000013,
5293  SelectionOptionsControl = 0x50000014,
5294  HighlightOptionsControl = 0x50000015,
5295  DefinitionControl = 0x50000016,
5296  SelectionControl = 0x50000017,
5297  HighlightControl = 0x50000018,
5298  StandAloneWindowOptionsControl = 0x50000019,
5299  OffScreenWindowOptionsControl = 0x5000001a,
5300  ApplicationWindowOptionsControl = 0x5000001b,
5301  VisibilityControl = 0x5000001c,
5302  SubwindowControl = 0x5000001d,
5303  PerformanceControl = 0x5000001e,
5304  HiddenLineAttributeControl = 0x5000001f,
5305  DrawingAttributeControl = 0x50000020,
5306  DebuggingControl = 0x50000021,
5307  ContourLineControl = 0x50000022,
5308  StyleControl = 0x50000023,
5309  ConditionControl = 0x50000024,
5310  PortfolioControl = 0x50000025,
5311  WindowInfoControl = 0x50000026,
5312  AttributeLockControl = 0x50000027,
5313  TransformMaskControl = 0x50000028,
5314  ColorInterpolationControl = 0x50000029,
5315  UpdateOptionsControl = 0x50000030,
5316  CuttingSectionAttributeControl = 0x50000031,
5317 
5318  LibraryMask = 0x80FF0000,
5319 
5320  Sprocket = 0x80000000,
5321  Canvas = 0x80000001,
5322  Layout = 0x80000002,
5323  View = 0x80000003,
5324  Model = 0x80000004,
5325  Operator = 0x80000005,
5326  SprocketPath = 0x80000007,
5327 
5328  SprocketControl = 0xD0000000,
5329  OperatorControl = 0xD0000008,
5330  NavigationCubeControl = 0xD0000009,
5331  AxisTriadControl = 0xD000000A,
5332 
5333  Metadata = 0x80001000,
5334  IntegerMetadata = 0x80001001,
5335  UnsignedIntegerMetadata = 0x80001002,
5336  DoubleMetadata = 0x80001003,
5337  StringMetadata = 0x80001004,
5338  TimeMetadata = 0x80001005,
5339  BooleanMetadata = 0x80001006,
5340 
5341  Component = 0x80000200,
5342  Filter = 0x80000600,
5343  Capture = 0x80000a00,
5344  CADModel = 0x80000300,
5345  ComponentPath = 0x81001000,
5346 
5347  ExchangeMask = 0x80020000,
5348  ExchangeComponent = 0x80021200,
5349  ExchangeFilter = 0x80020601,
5350  ExchangeCapture = 0x80020a01,
5351  ExchangeCADModel = 0x80020301,
5352  ExchangeConfiguration = 0x81020001,
5353  ExchangeImportOptionsKit = 0x81020002,
5354  ExchangeExportACISOptionsKit = 0x81020003,
5355  ExchangeExportIGESOptionsKit = 0x81020004,
5356  ExchangeExportJTOptionsKit = 0x81020005,
5357  ExchangeExportParasolidOptionsKit = 0x81020006,
5358  ExchangeExportPRCOptionsKit = 0x81020007,
5359  ExchangeExportSTEPOptionsKit = 0x81020008,
5360  ExchangeExportSTLOptionsKit = 0x81020009,
5361  ExchangeExportU3DOptionsKit = 0x8102000a,
5362  ExchangeExportXMLOptionsKit = 0x8102000b,
5363  ExchangeTessellationOptionsKit = 0x8102000c,
5364  ExchangeSheet = 0x80021201,
5365  ExchangeModelFileImportOptionsKit = 0x8102000d,
5366 
5367  PublishMask = 0x80040000,
5368  PublishDocumentKit = 0x81040001,
5369  PublishPageKit = 0x81040002,
5370  PublishTemplateKit = 0x81040003,
5371  PublishAnnotationKit = 0x81040004,
5372  PublishArtworkKit = 0x81040005,
5373  PublishViewKit = 0x81040006,
5374  PublishTextKit = 0x81040007,
5375  PublishImageKit = 0x81040008,
5376  PublishTableKit = 0x81040009,
5377  PublishExportOptionsKit = 0x8104000a,
5378  PublishLinkKit = 0x8104000b,
5379  PublishButtonKit = 0x8104000c,
5380  PublishTextFieldKit = 0x8104000d,
5381  PublishSlideTableKit = 0x8104000e,
5382  PublishCheckBoxKit = 0x8104000f,
5383  PublishRadioButtonKit = 0x81040010,
5384  PublishListBoxKit = 0x81040011,
5385  PublishDropDownListKit = 0x81040012,
5386  PublishSignatureFieldKit = 0x81040013,
5387 
5388  PublishDocumentKey = 0x80040001,
5389  PublishPageControl = 0x80040002,
5390 
5391  SceneTree = 0x80008001,
5392  SceneTreeItem = 0x80008002,
5393 
5394  ComponentTree = 0x80008003,
5395  ComponentTreeItem = 0x80008004,
5396 
5397  SketchupMask = 0x80100000,
5398  SketchupImportOptionsKit = 0x81100001,
5399  SketchupImportResultsKit = 0x81100002,
5400 
5401  ParasolidMask = 0x80200000,
5402  ParasolidComponent = 0x80201201,
5403  ParasolidCADModel = 0x80200302,
5404  ParasolidImportOptionsKit = 0x81200003,
5405  ParasolidFacetTessellationKit = 0x81200004,
5406  ParasolidLineTessellationKit = 0x81200005,
5407  ParasolidExportOptionsKit = 0x81200006,
5408 
5409  IONotifierData = 0x84000200,
5410  StreamImportNotifierData = 0x84000201,
5411  STLImportNotifierData = 0x84000202,
5412  OBJImportNotifierData = 0x84000203,
5413  ExchangeImportNotifierData = 0x84020204,
5414  SketchupImportNotifierData = 0x84100205,
5415  ParasolidImportNotifierData = 0x84200206,
5416  ExchangeTranslationNotifierData = 0x84020207,
5417  ExchangeExportNotifierData = 0x84020208,
5418  StreamExportNotifierData = 0x84000209,
5419 };
5420 
5422 class HPS_API Memory
5423 {
5424 public:
5430  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5431 
5432 
5437  static void Free(void * in_pointer);
5438 
5439 private:
5441  Memory();
5442 };
5443 
5444 
5446 template <typename T>
5447 class NO_HPS_API Allocator
5448 {
5449 public:
5450  typedef T value_type;
5451  typedef value_type * pointer;
5452  typedef value_type const * const_pointer;
5453  typedef value_type & reference;
5454  typedef value_type const & const_reference;
5455  typedef size_t size_type;
5456  typedef ptrdiff_t difference_type;
5457 
5458 
5459  Allocator() {}
5460  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5461  ~Allocator() {}
5462 
5463  template <typename U> Allocator(Allocator<U> const &) {}
5464 
5465  template <typename U>
5466  struct rebind
5467  {
5468  typedef Allocator<U> other;
5469  };
5470 
5471 
5472  pointer address(reference x) const { return &x; }
5473  const_pointer address(const_reference x) const { return &x; }
5474 
5475  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5476  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5477 
5478 #if defined(_MSC_VER) || defined (__APPLE__)
5479  void construct(pointer p, const_reference x) { new(p) T(x); }
5480 #else
5481  template<typename U, typename... Args>
5482  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5483 #endif
5484  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5485 
5486  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5487 };
5488 
5489 template <typename T, typename U>
5490 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5491 
5492 template <typename T, typename U>
5493 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5494 
5496 class Exception : public std::runtime_error
5497 {
5498 public:
5499  Exception(char const * in_info) : std::runtime_error(in_info) { }
5500 };
5501 
5502 
5505 {
5506 public:
5507  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5508  Exception(in_info) {}
5509 };
5510 
5511 
5515 {
5516 public:
5517  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5518  Exception(in_info) {}
5519 };
5520 
5521 
5524 {
5525 public:
5526  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5527  Exception(in_info) {}
5528 };
5529 
5530 
5533 {
5534 public:
5535  InvalidLicenseException(char const * in_info) :
5536  Exception(in_info) {}
5537 };
5538 
5539 
5542 {
5543 public:
5544  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5545  Exception(in_info) {}
5546 };
5547 
5549 class IOException : public Exception
5550 {
5551 public:
5555  IOException(char const * in_info, IOResult in_result)
5556  : Exception(in_info), result(in_result) {}
5557 
5558  IOResult result;
5559 };
5560 
5561 
5563 class HPS_API Object
5564 {
5565 public:
5566 
5567  Object();
5568 
5569  virtual ~Object();
5570 
5571  Object & operator=(Object const & other_object);
5572 
5576  Object(Object && in_that);
5577 
5578 
5582  Object & operator=(Object && in_that);
5583 
5587  HPS::Type Type() const;
5588 
5592  virtual HPS::Type ObjectType() const { return HPS::Type::None; }
5593 
5596  virtual bool Empty() const {return (impl_ == 0);};
5597 
5599  virtual void Reset();
5600 
5604  bool HasType(HPS::Type in_mask) const;
5605 
5608  intptr_t GetClassID() const;
5609 
5613  intptr_t GetInstanceID() const;
5614 
5615  template <typename T>
5616  static intptr_t ClassID()
5617  {
5618  static const intptr_t ret = T().GetClassID();
5619  return ret;
5620  }
5621 private:
5622 
5623  friend class HPSI::Impl;
5624  friend class HPSI::KeyImpl;
5625  friend class HPSI::TicketImpl;
5626 
5627  HPSI::Impl * impl_;
5628 };
5629 
5630 
5632 class HPS_API Control : public Object
5633 {
5634  HPS::Type ObjectType() const {return HPS::Type::Control;}
5635 
5636 
5637 
5638 protected:
5639  Control() {}
5640 
5644  Control(Control && in_that) : Object(std::move(in_that)) {}
5645 
5649  Control & operator=(Control && in_that)
5650  {
5651  this->Object::operator=(std::move(in_that));
5652  return *this;
5653  }
5654 };
5655 
5656 
5658 class HPS_API ObjectPoint : public Point
5659 {
5660 public:
5661 
5663  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5664 
5666  ObjectPoint(Point const & in_point):Point(in_point){}
5667 
5669  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5670 
5672  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5673 
5675  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5676 
5678  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5679 
5681  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5682 
5684  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5685 
5687  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5688 
5690  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5691 
5693  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5694 
5695 private:
5696 
5697  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5698  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5699  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5700  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5701  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5702  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5703  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5704  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5705 
5706 };
5707 
5709 class HPS_API WorldPoint : public Point
5710 {
5711 public:
5713  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5714 
5716  WorldPoint(Point const & in_point):Point(in_point){}
5717 
5719  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5720 
5722  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5723 
5725  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5726 
5728  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5729 
5731  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5732 
5734  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5735 
5737  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5738 
5740  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5741 
5743  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5744 
5745 private:
5746 
5747  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5748  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5749  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5750  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5751  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5752  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5753  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5754  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5755 
5756 };
5757 
5759 class HPS_API CameraPoint : public Point
5760 {
5761 public:
5763  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5764 
5766  CameraPoint(Point const & in_point):Point(in_point){}
5767 
5769  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5770 
5772  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5773 
5775  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5776 
5778  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5779 
5781  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5782 
5784  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5785 
5787  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5788 
5790  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5791 
5793  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5794 
5795 private:
5796  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5797  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5798  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5799  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5800  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5801  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5802  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5803  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5804 
5805 };
5806 
5808 class HPS_API NormalizedPoint : public Point
5809 {
5810 public:
5811 
5813  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5814 
5816  NormalizedPoint(Point const & in_point):Point(in_point){}
5817 
5819  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5820 
5822  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5823 
5825  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5826 
5828  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5829 
5831  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5832 
5834  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5835 
5837  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5838 
5840  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5841 
5843  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5844 
5845 private:
5846  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5847  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5848  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5849  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5850  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5851  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5852  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5853  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5854 };
5855 
5857 class HPS_API ScreenRangePoint : public Point
5858 {
5859 public:
5861  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5862 
5864  ScreenRangePoint(Point const & in_point):Point(in_point){}
5865 
5867  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5868 
5870  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5871 
5873  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5874 
5876  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5877 
5879  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5880 
5882  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5883 
5885  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5886 
5888  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5889 
5891  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5892 
5893 private:
5894  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5895  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5896  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5897  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5898  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5899  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5900  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5901  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5902 
5903 };
5904 
5906 class HPS_API InnerWindowPoint : public Point
5907 {
5908 public:
5909 
5911  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5912 
5914  InnerWindowPoint(Point const & in_point):Point(in_point){}
5915 
5917  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5918 
5920  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5921 
5923  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5924 
5926  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5927 
5929  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5930 
5932  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5933 
5935  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5936 
5938  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5939 
5941  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5942 
5943 private:
5944  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5945  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5946  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5947  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5948  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5949  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5950  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5951  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5952 };
5953 
5955 class HPS_API InnerPixelPoint : public Point
5956 {
5957 public:
5958 
5960  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5961 
5963  InnerPixelPoint(Point const & in_point):Point(in_point){}
5964 
5966  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5967 
5969  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5970 
5972  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5973 
5975  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5976 
5978  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5979 
5981  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5982 
5984  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5985 
5987  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5988 
5990  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
5991 
5992 private:
5993  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5994  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5995  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5996  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5997  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5998  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5999  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6000  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6001 
6002 };
6003 
6005 class HPS_API WindowPoint : public Point
6006 {
6007 public:
6008 
6010  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6011 
6013  WindowPoint(Point const & in_point):Point(in_point){}
6014 
6016  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6017 
6019  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6020 
6022  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6023 
6025  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6026 
6028  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6029 
6031  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6032 
6034  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6035 
6037  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6038 
6040  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6041 
6042 private:
6043  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6044  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6045  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6046  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6047  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6048  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6049  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6050  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6051 };
6052 
6053 
6055 class HPS_API PixelPoint : public Point
6056 {
6057 public:
6059  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6060 
6062  PixelPoint(Point const & in_point):Point(in_point){}
6063 
6065  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6066 
6068  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6069 
6071  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6072 
6074  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6075 
6077  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6078 
6080  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6081 
6083  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6084 
6086  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6087 
6089  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6090 
6091 private:
6092  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6093  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6094  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6095  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6096  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6097  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6098  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6099  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6100 
6101 };
6102 
6105 class HPS_API Event
6106 {
6107 public:
6111  enum class Status
6112  {
6113  InProgress,
6114  Completed,
6115  Failed
6116  };
6117 
6119  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6120 
6121  virtual ~Event();
6122 
6124  intptr_t GetClassID() const;
6125 
6128  virtual Event * Clone() const=0;
6129 
6131  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6132 
6135  virtual intptr_t Freshen() const { return 0; }
6136 
6138  intptr_t GetChannel() const { return channel; }
6139 
6141  Time GetTimeStamp() const { return time_stamp; }
6142 
6144  bool IsConsumable() const { return consumable; }
6145 
6146  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6147  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6148 
6149 protected:
6150  intptr_t channel;
6151  bool consumable;
6152 
6153 private:
6154  friend class HPSI::EventDispatcherImpl;
6155  Time time_stamp;
6156 };
6157 
6158 
6161 class HPS_API EventNotifier : public Object
6162 {
6163 public:
6164 
6166  EventNotifier();
6167 
6170  EventNotifier(EventNotifier const & in_that);
6171 
6175  EventNotifier(EventNotifier && in_that);
6176 
6180  EventNotifier & operator=(EventNotifier && in_that);
6181 
6182  virtual ~EventNotifier();
6183 
6184  HPS::Type ObjectType() const {return HPS::Type::EventNotifier;};
6185 
6189  EventNotifier & operator=(EventNotifier const & in_that);
6190 
6193  virtual void Assign(EventNotifier const & in_that);
6194 
6196  void Wait() const;
6197 
6200  Event::Status Status() const;
6201 };
6202 
6204 enum class KeyboardCode
6205 {
6206  None = 0,
6207 
6208  Backspace = 8,
6209  Tab = 9,
6210  Clear = 11,
6211  Return = 13,
6212  Shift = 16,
6213  Control = 17,
6214  Alt = 18,
6215  Pause = 19,
6216  Escape = 27,
6217 
6218  Space = 32,
6219  ExclamationMark,
6220  DoubleQuote,
6221  Number,
6222  Dollar,
6223  Percent,
6224  Ampersand,
6225  SingleQuote,
6226  OpenParen,
6227  CloseParen,
6228 
6229  Asterisk,
6230  Plus,
6231  Comma,
6232  Hyphen,
6233  Period,
6234  Slash,
6235 
6236  D0,
6237  D1,
6238  D2,
6239  D3,
6240  D4,
6241  D5,
6242  D6,
6243  D7,
6244  D8,
6245  D9,
6246 
6247  Colon,
6248  Semicolon,
6249  LessThan,
6250  Equal,
6251  GreaterThan,
6252  QuestionMark,
6253  AtSymbol,
6254 
6255  A,
6256  B,
6257  C,
6258  D,
6259  E,
6260  F,
6261  G,
6262  H,
6263  I,
6264  J,
6265  K,
6266  L,
6267  M,
6268  N,
6269  O,
6270  P,
6271  Q,
6272  R,
6273  S,
6274  T,
6275  U,
6276  V,
6277  W,
6278  X,
6279  Y,
6280  Z,
6281 
6282  OpenBrackets,
6283  Backslash,
6284  CloseBrackets,
6285  Caret,
6286  Underscore,
6287  Backtick,
6288 
6289  a,
6290  b,
6291  c,
6292  d,
6293  e,
6294  f,
6295  g,
6296  h,
6297  i,
6298  j,
6299  k,
6300  l,
6301  m,
6302  n,
6303  o,
6304  p,
6305  q,
6306  r,
6307  s,
6308  t,
6309  u,
6310  v,
6311  w,
6312  x,
6313  y,
6314  z,
6315 
6316  OpenBrace,
6317  VerticalBar,
6318  ClosingBrace,
6319  Tilde,
6320  Delete,
6321 
6322  Insert=1024,
6323  Home,
6324  End,
6325  PageUp,
6326  PageDown,
6327 
6328  Help,
6329 
6330  Left,
6331  Up,
6332  Right,
6333  Down,
6334 
6335  NumPad0,
6336  NumPad1,
6337  NumPad2,
6338  NumPad3,
6339  NumPad4,
6340  NumPad5,
6341  NumPad6,
6342  NumPad7,
6343  NumPad8,
6344  NumPad9,
6345 
6346  F1,
6347  F2,
6348  F3,
6349  F4,
6350  F5,
6351  F6,
6352  F7,
6353  F8,
6354  F9,
6355  F10,
6356  F11,
6357  F12,
6358  F13,
6359  F14,
6360  F15,
6361  F16,
6362  F17,
6363  F18,
6364  F19,
6365  F20,
6366  F21,
6367  F22,
6368  F23,
6369  F24,
6370 
6371  // these are not implemented
6372 // CapsLock, //!< The Caps Lock key.
6373 //
6374 // NumLock, //!< The Num Lock key.
6375 // ScrollLock, //!< The Scroll Lock key.
6376 // LeftShift, //!< The left Shift key.
6377 // RightShift, //!< The right Shift key.
6378 // LeftCtrl, //!< The left CTRL key.
6379 // RightCtrl, //!< The right CTRL key.
6380 // LeftAlt, //!< The left ALT key.
6381 // RightAlt, //!< The right ALT key.
6382 //
6383 // Select, //!< The Select key.
6384 // Print, //!< The Print key.
6385 // Execute, //!< The Execute key.
6386 // PrintScreen, //!< The Print Screen key.
6387 };
6388 
6389 
6391 class NO_HPS_API Touch
6392 {
6393 public:
6394 
6397  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6398 
6403  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6404  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6405 
6409  inline bool operator==(Touch const & in_that) const
6410  {
6411  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6412  }
6413 
6417  inline bool operator!=(Touch const & in_that) const
6418  {
6419  return !(*this == in_that);
6420  }
6421 
6422  TouchID ID;
6424  size_t TapCount;
6425 };
6426 
6427 
6428 typedef std::vector<Point, Allocator<Point> > PointArray;
6429 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6430 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6431 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6432 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6433 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6434 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6435 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6436 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6437 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6438 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6439 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6440 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6441 typedef std::vector<int, Allocator<int> > IntArray;
6442 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6443 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6444 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6445 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6446 typedef std::vector<float, Allocator<float> > FloatArray;
6447 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6448 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6449 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6450 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6451 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6452 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6453 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6454 typedef std::vector<bool, Allocator<bool> > BoolArray;
6455 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6456 typedef std::vector<Key, Allocator<Key> > KeyArray;
6457 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6458 typedef std::vector<char, Allocator<char> > CharArray;
6459 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6460 typedef std::vector<byte, Allocator<byte> > ByteArray;
6461 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6462 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6463 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6464 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6465 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6466 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6467 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6468 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6469 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6470 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6471 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6472 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6473 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6474 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6475 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6476 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6477 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6478 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6479 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6480 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6481 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6482 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6483 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6484 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6485 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6486 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6487 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6488 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6489 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6490 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6491 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6492 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6493 
6494 
6496 class HPS_API SearchResultsIterator : public Object
6497 {
6498 public:
6499 
6502 
6506  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6507 
6512 
6516  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6517 
6519 
6520  HPS::Type ObjectType() const {return HPS::Type::SearchResultsIterator;}
6521 
6526  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6527 
6532  void Set(SearchResultsIterator const & in_search_results_iterator);
6533 
6535  void Next();
6536 
6539  SearchResultsIterator & operator++();
6540 
6543  SearchResultsIterator operator++(int in_val);
6544 
6547  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6548 
6551  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6552 
6556  bool IsValid() const;
6557 
6559  void Reset();
6560 
6564  Key GetItem() const;
6565 
6568  Key operator*() const;
6569 
6572  SearchTypeArray GetResultTypes() const;
6573 };
6574 
6576 class HPS_API SearchResults : public Object
6577 {
6578 public:
6580  SearchResults();
6581 
6584  SearchResults(SearchResults const & in_search_results);
6585 
6589  SearchResults(SearchResults && in_that);
6590 
6594  SearchResults & operator=(SearchResults && in_that);
6595 
6597  virtual void Reset();
6598 
6600  ~SearchResults();
6601 
6602  HPS::Type ObjectType() const {return HPS::Type::SearchResults;}
6603 
6607  void Assign(SearchResults const & in_search_results);
6608 
6612  SearchResults & operator=(SearchResults const & in_search_results);
6613 
6616  size_t GetCount() const;
6617 
6620  SearchResultsIterator GetIterator() const;
6621 };
6622 
6624 class HPS_API FontSearchResultsIterator : public Object
6625 {
6626 public:
6627 
6630 
6634  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6635 
6640 
6645  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6646 
6647 
6651  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6652 
6654 
6655  HPS::Type ObjectType() const {return HPS::Type::FontSearchResultsIterator;}
6656 
6657 
6662  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6663 
6665  void Next();
6666 
6669  FontSearchResultsIterator & operator++();
6670 
6673  FontSearchResultsIterator operator++(int in_val);
6674 
6677  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6678 
6681  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6682 
6686  bool IsValid() const;
6687 
6689  void Reset();
6690 
6694  FontInfoState GetItem() const;
6695 
6698  FontInfoState operator*() const;
6699 
6700 };
6701 
6703 class HPS_API FontSearchResults : public Object
6704 {
6705 public:
6706 
6709 
6712  FontSearchResults(FontSearchResults const & in_search_results);
6713 
6718 
6722  FontSearchResults & operator=(FontSearchResults && in_that);
6723 
6725  virtual void Reset();
6726 
6728  ~FontSearchResults();
6729 
6730  HPS::Type ObjectType() const {return HPS::Type::FontSearchResults;}
6731 
6735  void Assign(FontSearchResults const & in_search_results);
6736 
6737 
6741  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6742 
6745  size_t GetCount() const;
6746 
6749  FontSearchResultsIterator GetIterator() const;
6750 };
6751 
6753 class HPS_API UTF8
6754 {
6755 public:
6756 
6758  UTF8();
6759 
6761  ~UTF8();
6762 
6769  UTF8(char const * in_string, char const * in_locale = 0);
6770 
6773  UTF8(wchar_t const * in_string);
6774 
6777  UTF8(UTF8 const & in_that);
6778 
6781  UTF8(UTF8 && in_that);
6782 
6786  UTF8 & Assign(UTF8 && in_utf8);
6787 
6790  inline UTF8 & operator= (UTF8 && in_utf8)
6791  {
6792  return Assign(std::move(in_utf8));
6793  }
6794 
6799  size_t ToWStr(wchar_t * out_wide_string) const;
6800 
6804  size_t ToWStr(WCharArray & out_wide_string) const;
6805 
6808  inline bool IsValid() const
6809  {
6810  return (_length > 0);
6811  }
6812 
6815  inline bool Empty() const
6816  {
6817  return (_length == 0);
6818  }
6819 
6821  void Clear();
6822 
6824  void Reset() { Clear(); }
6825 
6829  inline size_t GetLength() const
6830  {
6831  return _length;
6832  }
6833 
6837  inline size_t GetWStrLength() const
6838  {
6839  return ToWStr(0);
6840  }
6841 
6844  inline char const * GetBytes() const
6845  {
6846  return _text;
6847  }
6848 
6851  inline operator char const * () const
6852  {
6853  return _text;
6854  }
6855 
6858  char At(size_t in_index) const
6859  {
6860  if(!IsValid())
6861  throw InvalidObjectException();
6862  else if(in_index >= _length)
6863  throw IndexOutOfRangeException();
6864  else
6865  return _text[in_index];
6866  }
6867 
6871  UTF8 & Assign(UTF8 const & in_utf8);
6872 
6876  inline UTF8 & operator= (UTF8 const & in_utf8)
6877  {
6878  return Assign(in_utf8);
6879  }
6880 
6884  UTF8 & operator+= (UTF8 const & in_utf8);
6885 
6889  UTF8 & operator+= (char const * in_utf8);
6890 
6894  UTF8 operator+ (UTF8 const & in_utf8) const;
6895 
6899  UTF8 operator+ (char const * in_utf8) const;
6900 
6904  bool operator== (UTF8 const & in_utf8) const;
6905 
6909  bool operator!= (UTF8 const & in_utf8) const
6910  {
6911  return !(*this == in_utf8);
6912  }
6913 
6917  bool operator== (char const * in_utf8) const;
6918 
6922  bool operator!= (char const * in_utf8) const
6923  {
6924  return !(*this == in_utf8);
6925  }
6926 
6931  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
6932  {
6933  return in_right == in_left;
6934  }
6935 
6940  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
6941  {
6942  return in_right != in_left;
6943  }
6944 
6949  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
6950  {
6951  return in_right == UTF8(in_left);
6952  }
6953 
6958  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
6959  {
6960  return in_right != UTF8(in_left);
6961  }
6962 
6967  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
6968  {
6969  return UTF8(in_left) + in_right;
6970  }
6971 
6976  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
6977  {
6978  return UTF8(in_left) + in_right;
6979  }
6980 
6981 
6984  size_t GetHash() const;
6985 
6986 private:
6987 
6988  size_t internal_encode(wchar_t const * in_wide_string);
6989  size_t internal_decode(wchar_t * out_wide_string) const;
6990 
6991  char * _text;
6992  size_t _length;
6993  mutable size_t _hash_key;
6994  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
6995  char _buffer[_buffer_size];
6996 };
6997 
6999 struct UTF8Hasher {
7000  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7001  {
7002  return in_utf8.GetHash();
7003  }
7004 };
7005 
7008 class HPS_API Condition : public Object
7009 {
7010 public:
7011 
7012  enum class Intrinsic
7013  {
7014  Extent,
7015  DrawPass
7016  };
7017 
7019  Condition();
7020 
7023  Condition(char const * in_utf8);
7024 
7027  Condition(float in_number);
7028 
7031  Condition(HPS::Condition::Intrinsic in_special);
7032 
7035  Condition(Condition const & in_that);
7036 
7040  Condition(Condition && in_that);
7041 
7045  Condition & operator=(Condition && in_that);
7046 
7047  HPS::Type ObjectType() const { return HPS::Type::Condition; }
7048 
7052  bool ShowCondition(UTF8 & out_condition) const;
7053 
7057  bool ShowNumber(float & out_number) const;
7058 
7062  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7063 
7067  bool ShowOperands(ConditionArray & out_operands) const;
7068 
7072  Condition & operator=(Condition const & in_that);
7073 
7077  bool Equals(Condition const & in_that) const;
7078 
7082  bool operator==(Condition const & in_that) const;
7083 
7087  bool operator!=(Condition const & in_that) const;
7088 
7092  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7093 
7097  bool IsSatisfiedBy(char const * in_condition) const;
7098 
7102  Condition OR(Condition const & in_operand2) const;
7103 
7107  Condition XOR(Condition const & in_operand2) const;
7108 
7112  Condition AND(Condition const & in_operand2) const;
7113 
7117  Condition EQ(Condition const & in_operand2) const;
7118 
7122  Condition NEQ(Condition const & in_operand2) const;
7123 
7127  Condition GT(Condition const & in_operand2) const;
7128 
7132  Condition LT(Condition const & in_operand2) const;
7133 
7137  Condition GTEQ(Condition const & in_operand2) const;
7138 
7142  Condition LTEQ(Condition const & in_operand2) const;
7143 
7146  Condition operator !() const;
7147 
7151  Condition operator ||(Condition const & in_operand2) const;
7152 
7156  Condition operator ^(Condition const & in_operand2) const;
7157 
7161  Condition operator &&(Condition const & in_operand2) const;
7162 
7163 
7167  static Condition NOT(Condition const & in_operand);
7168 
7173  static Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7174 
7175 
7180  static Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7181 
7186  static Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7187 
7192  static Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7193 
7198  static Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7199 
7204  static Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7205 
7210  static Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7211 
7216  static Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7217 
7222  static Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7223 
7224  friend HPS_API Condition NOT(Condition const & in_operand);
7225  friend HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7226  friend HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7227  friend HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7228 
7229  friend HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7230  friend HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7231  friend HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7232  friend HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7233  friend HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7234  friend HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7235 };
7236 
7237 
7241 HPS_API Condition NOT(Condition const & in_operand);
7242 
7247 HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7248 
7253 HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7254 
7259 HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7260 
7265 HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7266 
7271 HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7272 
7277 HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7278 
7283 HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7284 
7289 HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7290 
7295 HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7296 
7297 
7298 
7302 class HPS_API Key : public Object
7303 {
7304 public:
7305 
7307  Key();
7308 
7310  Key(Key const & in_that);
7311 
7313  explicit Key(Control const & in_control);
7314 
7318  Key(Key && in_that);
7319 
7323  Key & operator=(Key && in_that);
7324 
7326  virtual ~Key();
7327 
7328  HPS::Type ObjectType() const {return HPS::Type::Key;};
7329 
7331  bool HasOwner() const;
7332 
7334  SegmentKey Up() const;
7335 
7337  SegmentKey Owner() const;
7338 
7340  void Delete();
7341 
7343  void MoveTo(SegmentKey const & in_new_owner);
7344 
7347  Key CopyTo(SegmentKey const & in_destination) const;
7348 
7350  Key & operator=(Key const & in_that);
7351 
7353  virtual void Assign(Key const & in_that);
7354 
7356  bool Equals(Key const & in_that) const;
7357 
7359  bool operator!= (Key const & in_that) const;
7360 
7362  bool operator== (Key const & in_that) const;
7363 
7366  size_t GetHash() const;
7367 };
7368 
7370 struct KeyHasher {
7371  inline size_t operator()(const HPS::Key & in_key) const
7372  {
7373  return in_key.GetHash();
7374  }
7375 };
7376 
7377 
7380 class HPS_API SegmentKey : public Key
7381 {
7382 public:
7384  SegmentKey();
7385 
7387  SegmentKey(SegmentKey const & in_that);
7388 
7390  SegmentKey & operator=(SegmentKey const & other);
7391 
7395  SegmentKey(SegmentKey && in_that);
7396 
7400  SegmentKey & operator=(SegmentKey && in_that);
7401 
7403  explicit SegmentKey(Key const & in_that);
7404 
7406  ~SegmentKey();
7407 
7408  HPS::Type ObjectType() const {return HPS::Type::SegmentKey;};
7409 
7411  UTF8 Name() const;
7412 
7415  SegmentKey & SetName(char const * in_name);
7416 
7419  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7420 
7423  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7424 
7426  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7427 
7429  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7430 
7432  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7433 
7434 
7435 
7437  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7438 
7440  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7441 
7443  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7444 
7445 
7447  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7448 
7450  size_t Find(SearchOptionsKit const & in_options) const;
7451 
7452 
7455  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7456 
7460  IncludeKey IncludeSegment(SegmentKey const & in_seg, Condition const & in_condition);
7461 
7462 
7468  ReferenceKey ReferenceGeometry(Key const & in_key);
7469 
7477  ReferenceKey ReferenceGeometry(Key const & in_key, Condition const & in_condition);
7478 
7479 
7481  size_t ShowSubsegments() const;
7482 
7484  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7485 
7489  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7490 
7494  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7495 
7499  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7500 
7504  size_t ShowStylers(StyleKeyArray & out_styles) const;
7505 
7509  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7510 
7514  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7515 
7516 
7517 
7519  StyleControl GetStyleControl();
7520 
7522  StyleControl const GetStyleControl() const;
7523 
7524 
7526  PortfolioControl GetPortfolioControl();
7527 
7529  PortfolioControl const GetPortfolioControl() const;
7530 
7531 
7533  SegmentKey & SetCondition(char const * in_condition);
7534 
7536  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7537 
7539  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7540 
7542  SegmentKey & UnsetConditions();
7543 
7545  bool ShowConditions(UTF8Array & out_conditions) const;
7546 
7548  ConditionControl GetConditionControl();
7549 
7551  ConditionControl const GetConditionControl() const;
7552 
7553 
7555  SegmentKey & SetMaterialPalette(char const * in_name);
7556 
7558  SegmentKey & UnsetMaterialPalette();
7559 
7561  bool ShowMaterialPalette(UTF8 & out_name) const;
7562 
7563 
7570  SegmentKey & SetPriority(int in_priority);
7571 
7574  SegmentKey & UnsetPriority();
7575 
7579  bool ShowPriority(int & out_priority) const;
7580 
7585  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7586 
7592  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7593 
7598  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7599 
7603  SegmentKey & UnsetUserData(intptr_t in_index);
7604 
7609  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7610 
7614  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
7615 
7618  SegmentKey & UnsetAllUserData();
7619 
7621  size_t ShowUserDataCount() const;
7622 
7627  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
7628 
7632  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7633 
7638  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7639 
7640 
7642  LineKey InsertLine(LineKit const & in_kit);
7643 
7645  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7646 
7648  LineKey InsertLine(PointArray const & in_pts);
7649 
7651  LineKey InsertLine(Point const & pt1, Point const & pt2);
7652 
7653 
7655  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7656 
7658  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);
7659 
7661  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7662 
7664  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7665 
7666 
7671  SphereKey InsertSphere(SphereKit const & in_kit);
7672 
7680  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));
7681 
7683  CircleKey InsertCircle(CircleKit const & in_kit);
7684 
7686  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7687 
7689  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7690 
7691 
7693  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7694 
7696  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7697 
7698 
7700  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7701 
7703  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7704 
7705 
7707  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7708 
7710  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7711 
7712 
7714  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7715 
7717  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float start, float end);
7718 
7719 
7721  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7722 
7724  PolygonKey InsertPolygon(PointArray const & in_pts);
7725 
7727  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7728 
7729 
7731  ShellKey InsertShell(ShellKit const & in_kit);
7732 
7734  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7735 
7737  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7738 
7740  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
7741 
7743  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
7744 
7746  MeshKey InsertMesh(MeshKit const & in_kit);
7747 
7749  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7750 
7752  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7753 
7754 
7756  MarkerKey InsertMarker(Point const & in_position);
7757 
7759  MarkerKey InsertMarker(MarkerKit const & in_kit);
7760 
7761 
7763  DistantLightKey InsertDistantLight(Vector const & in_direction);
7764 
7766  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7767 
7768 
7770  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7771 
7773  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7774 
7776  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7777 
7779  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7780 
7781 
7783  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7784 
7786  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7787 
7788 
7790  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7791 
7793  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7794 
7795 
7797  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7798 
7800  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);
7801 
7803  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);
7804 
7805 
7807  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7808 
7810  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);
7811 
7813  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[]);
7814 
7816  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);
7817 
7819  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[]);
7820 
7821 
7823  TextKey InsertText(TextKit const & in_kit);
7824 
7830  TextKey InsertText(Point const & in_position, char const * in_text);
7831 
7832 
7833 
7835  GridKey InsertGrid(GridKit const & in_kit);
7836 
7838  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);
7839 
7840 
7841 
7849  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7850 
7858  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7859 
7867  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7868 
7876  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7877 
7885  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7886 
7894  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7895 
7900  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7901 
7906  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7907 
7912  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7913 
7918  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7919 
7924  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7925 
7930  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7931 
7932 
7934  SegmentKey & SetAttributeLocks(AttributeLockKit const & in_kit);
7935 
7937  SegmentKey & UnsetAttributeLocks();
7938 
7942  bool ShowAttributeLocks(AttributeLockKit & out_kit) const;
7943 
7945  AttributeLockControl GetAttributeLockControl();
7946 
7948  AttributeLockControl const GetAttributeLockControl() const;
7949 
7950 
7952  SegmentKey & SetBoundings(BoundingKit const & in_kit);
7953 
7955  SegmentKey & UnsetBoundings();
7956 
7960  bool ShowBoundings(BoundingKit & out_kit) const;
7961 
7963  BoundingControl GetBoundingControl();
7964 
7966  BoundingControl const GetBoundingControl() const;
7967 
7968 
7970  SegmentKey & SetCamera(CameraKit const & in_kit);
7971 
7973  SegmentKey & UnsetCamera();
7974 
7976  bool ShowCamera(CameraKit & out_kit) const;
7977 
7979  CameraControl GetCameraControl();
7980 
7982  CameraControl const GetCameraControl() const;
7983 
7985  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
7986 
7988  SegmentKey & UnsetColorInterpolation();
7989 
7991  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
7992 
7994  ColorInterpolationControl GetColorInterpolationControl();
7995 
7997  ColorInterpolationControl const GetColorInterpolationControl() const;
7998 
7999 
8001  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8002 
8004  SegmentKey & UnsetContourLine();
8005 
8007  bool ShowContourLine(ContourLineKit & out_kit) const;
8008 
8010  ContourLineControl GetContourLineControl();
8011 
8013  ContourLineControl const GetContourLineControl() const;
8014 
8015 
8017  SegmentKey & SetCulling(CullingKit const & in_kit);
8018 
8020  SegmentKey & UnsetCulling();
8021 
8025  bool ShowCulling(CullingKit & out_kit) const;
8026 
8028  CullingControl GetCullingControl();
8029 
8031  CullingControl const GetCullingControl() const;
8032 
8033 
8035  SegmentKey & SetCurveAttributes(CurveAttributeKit const & in_kit);
8036 
8038  SegmentKey & UnsetCurveAttributes();
8039 
8041  bool ShowCurveAttributes(CurveAttributeKit & out_kit) const;
8042 
8044  CurveAttributeControl GetCurveAttributeControl();
8045 
8047  CurveAttributeControl const GetCurveAttributeControl() const;
8048 
8049 
8051  SegmentKey & SetCuttingSectionAttributes(CuttingSectionAttributeKit const & in_kit);
8052 
8054  SegmentKey & UnsetCuttingSectionAttributes();
8055 
8057  bool ShowCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
8058 
8060  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8061 
8063  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8064 
8065 
8067  SegmentKey & SetCylinderAttributes(CylinderAttributeKit const & in_kit);
8068 
8070  SegmentKey & UnsetCylinderAttributes();
8071 
8073  bool ShowCylinderAttributes(CylinderAttributeKit & out_kit) const;
8074 
8076  CylinderAttributeControl GetCylinderAttributeControl();
8077 
8079  CylinderAttributeControl const GetCylinderAttributeControl() const;
8080 
8081 
8083  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8084 
8086  SegmentKey & UnsetDrawingAttribute();
8087 
8089  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8090 
8092  DrawingAttributeControl GetDrawingAttributeControl();
8093 
8095  DrawingAttributeControl const GetDrawingAttributeControl() const;
8096 
8097 
8099  SegmentKey & SetEdgeAttributes(EdgeAttributeKit const & in_kit);
8100 
8102  SegmentKey & UnsetEdgeAttributes();
8103 
8105  bool ShowEdgeAttributes(EdgeAttributeKit & out_kit) const;
8106 
8108  EdgeAttributeControl GetEdgeAttributeControl();
8109 
8111  EdgeAttributeControl const GetEdgeAttributeControl() const;
8112 
8113 
8115  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8116 
8118  SegmentKey & UnsetHiddenLineAttribute();
8119 
8121  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8122 
8124  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8125 
8127  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8128 
8129 
8131  SegmentKey & SetLightingAttributes(LightingAttributeKit const & in_kit);
8132 
8134  SegmentKey & UnsetLightingAttributes();
8135 
8137  bool ShowLightingAttributes(LightingAttributeKit & out_kit) const;
8138 
8140  LightingAttributeControl GetLightingAttributeControl();
8141 
8143  LightingAttributeControl const GetLightingAttributeControl() const;
8144 
8145 
8147  SegmentKey & SetLineAttributes(LineAttributeKit const & in_kit);
8148 
8150  SegmentKey & UnsetLineAttributes();
8151 
8153  bool ShowLineAttributes(LineAttributeKit & out_kit) const;
8154 
8156  LineAttributeControl GetLineAttributeControl();
8157 
8159  LineAttributeControl const GetLineAttributeControl() const;
8160 
8161 
8163  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8164 
8166  SegmentKey & UnsetMaterialMapping();
8167 
8169  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8170 
8172  MaterialMappingControl GetMaterialMappingControl();
8173 
8175  MaterialMappingControl const GetMaterialMappingControl() const;
8176 
8177 
8179  SegmentKey & SetMarkerAttributes(MarkerAttributeKit const & in_kit);
8180 
8182  SegmentKey & UnsetMarkerAttributes();
8183 
8185  bool ShowMarkerAttributes(MarkerAttributeKit & out_kit) const;
8186 
8188  MarkerAttributeControl GetMarkerAttributeControl();
8189 
8191  MarkerAttributeControl const GetMarkerAttributeControl() const;
8192 
8193 
8195  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8196 
8198  SegmentKey & UnsetModellingMatrix();
8199 
8201  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8202 
8204  ModellingMatrixControl GetModellingMatrixControl();
8205 
8207  ModellingMatrixControl const GetModellingMatrixControl() const;
8208 
8209 
8211  SegmentKey & SetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit const & in_kit);
8212 
8214  SegmentKey & UnsetNURBSSurfaceAttributes();
8215 
8217  bool ShowNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
8218 
8220  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8221 
8223  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8224 
8225 
8227  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8228 
8230  SegmentKey & UnsetPerformance();
8231 
8233  bool ShowPerformance(PerformanceKit & out_kit) const;
8234 
8236  PerformanceControl GetPerformanceControl();
8237 
8239  PerformanceControl const GetPerformanceControl() const;
8240 
8241 
8243  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8244 
8246  SegmentKey & UnsetSelectability();
8247 
8251  bool ShowSelectability(SelectabilityKit & out_kit) const;
8252 
8254  SelectabilityControl GetSelectabilityControl();
8255 
8257  SelectabilityControl const GetSelectabilityControl() const;
8258 
8259 
8261  SegmentKey & SetSphereAttributes(SphereAttributeKit const & in_kit);
8262 
8264  SegmentKey & UnsetSphereAttributes();
8265 
8269  bool ShowSphereAttributes(SphereAttributeKit & out_kit) const;
8270 
8272  SphereAttributeControl GetSphereAttributeControl();
8273 
8275  SphereAttributeControl const GetSphereAttributeControl() const;
8276 
8277 
8279  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8280 
8282  SegmentKey & UnsetSubwindow();
8283 
8287  bool ShowSubwindow(SubwindowKit & out_kit) const;
8288 
8290  SubwindowControl GetSubwindowControl();
8291 
8293  SubwindowControl const GetSubwindowControl() const;
8294 
8295 
8297  SegmentKey & SetTextAttributes(TextAttributeKit const & in_kit);
8298 
8300  SegmentKey & UnsetTextAttributes();
8301 
8303  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
8304 
8306  TextAttributeControl GetTextAttributeControl();
8307 
8309  TextAttributeControl const GetTextAttributeControl() const;
8310 
8311 
8313  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8314 
8316  SegmentKey & UnsetTextureMatrix();
8317 
8321  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8322 
8324  TextureMatrixControl GetTextureMatrixControl();
8325 
8327  TextureMatrixControl const GetTextureMatrixControl() const;
8328 
8330  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8331 
8333  SegmentKey & UnsetTransformMask();
8334 
8338  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8339 
8341  TransformMaskControl GetTransformMaskControl();
8342 
8344  TransformMaskControl const GetTransformMaskControl() const;
8345 
8346 
8348  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8349 
8351  SegmentKey & UnsetTransparency();
8352 
8356  bool ShowTransparency(TransparencyKit & out_kit) const;
8357 
8359  TransparencyControl GetTransparencyControl();
8360 
8362  TransparencyControl const GetTransparencyControl() const;
8363 
8364 
8366  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8367 
8369  SegmentKey & UnsetVisibility();
8370 
8374  bool ShowVisibility(VisibilityKit & out_kit) const;
8375 
8377  VisibilityControl GetVisibilityControl();
8378 
8380  VisibilityControl const GetVisibilityControl() const;
8381 
8382 
8384  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8385 
8387  SegmentKey & UnsetVisualEffects();
8388 
8392  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8393 
8395  VisualEffectsControl GetVisualEffectsControl();
8396 
8398  VisualEffectsControl const GetVisualEffectsControl() const;
8399 
8400  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8401 };
8402 
8403 
8406 {
8407 public:
8408 
8411 
8415 
8419 
8420  virtual ~SegmentOptimizationOptionsKit();
8421 
8422  HPS::Type ObjectType() const { return HPS::Type::SegmentOptimizationOptionsKit; }
8423 
8426  void Consume(SegmentOptimizationOptionsKit & in_kit);
8427 
8430  void Set(SegmentOptimizationOptionsKit const & in_kit);
8431 
8434  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8435 
8440 
8445 
8448  bool Empty() const;
8449 
8453  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8454 
8458  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8459 
8463  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8464 
8468  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8469 
8473  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8474 
8478  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8479 
8483  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8484 
8488  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8489 
8493  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8494 
8498  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8499 
8503  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8504 
8506  SegmentOptimizationOptionsKit & UnsetUserData();
8507 
8509  SegmentOptimizationOptionsKit & UnsetMatrix();
8510 
8512  SegmentOptimizationOptionsKit & UnsetExpansion();
8513 
8515  SegmentOptimizationOptionsKit & UnsetScope();
8516 
8518  SegmentOptimizationOptionsKit & UnsetReorganization();
8519 
8521  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8522 
8524  SegmentOptimizationOptionsKit & UnsetShellMerging();
8525 
8527  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8528 
8531  SegmentOptimizationOptionsKit & UnsetEverything();
8532 
8533  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8534 
8535  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8536 
8537  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8538 
8539  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8540 
8541  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8542 
8543  bool ShowShellInstancing(bool & out_shell_instancing) const;
8544 
8545  bool ShowShellMerging(bool & out_shell_merging) const;
8546 
8547  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
8548 };
8549 
8550 
8552 class HPS_API Coordinate
8553 {
8554 public:
8555 
8559  enum class Space
8560  {
8561  Object,
8562  World,
8563  Camera,
8564  Normalized,
8565  ScreenRange,
8566  InnerWindow,
8567  InnerPixel,
8568  Window,
8569  Pixel,
8570  };
8571 
8572 private:
8573  Coordinate();
8574 };
8575 
8576 
8577 
8578 
8581 class HPS_API UpdateNotifier : public Object
8582 {
8583 public:
8584 
8585  UpdateNotifier();
8586 
8587  UpdateNotifier(UpdateNotifier const & in_that);
8588 
8592  UpdateNotifier(UpdateNotifier && in_that);
8593 
8597  UpdateNotifier & operator=(UpdateNotifier && in_that);
8598 
8599  virtual ~UpdateNotifier();
8600 
8601  HPS::Type ObjectType() const {return HPS::Type::UpdateNotifier;};
8602 
8604  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8605 
8607  void Assign(UpdateNotifier const & in_that);
8608 
8609  void Wait() const;
8610 
8611  Window::UpdateStatus Status() const;
8612 
8613 };
8614 
8615 
8619 class HPS_API WindowKey : public SegmentKey
8620 {
8621 public:
8622 
8624  WindowKey();
8625 
8627  WindowKey(WindowKey const & in_window);
8628 
8630  WindowKey & operator=(WindowKey const & other);
8631 
8635  WindowKey(WindowKey && in_that);
8636 
8640  WindowKey & operator=(WindowKey && in_that);
8641 
8643  WindowKey(Key const & in_key);
8644 
8646  ~WindowKey();
8647 
8648  HPS::Type ObjectType() const {return HPS::Type::WindowKey;};
8649 
8651  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8652 
8654  size_t FindFonts(FontSearchResults & out_results) const;
8655 
8657  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8658 
8660  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8661 
8663  PostProcessEffectsControl GetPostProcessEffectsControl();
8664 
8666  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8667 
8668 
8670  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8671 
8675  bool ShowDebugging(DebuggingKit & out_kit) const;
8676 
8678  DebuggingControl GetDebuggingControl();
8679 
8681  DebuggingControl const GetDebuggingControl() const;
8682 
8684  WindowInfoControl const GetWindowInfoControl() const;
8685 
8686  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8687 
8689  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8690 
8692  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8693 
8695  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
8696 
8698  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
8699 
8700 
8702  SelectionOptionsControl GetSelectionOptionsControl();
8703 
8705  SelectionOptionsControl const GetSelectionOptionsControl() const;
8706 
8707 
8709  SelectionControl GetSelectionControl();
8710 
8712  SelectionControl const GetSelectionControl() const;
8713 
8715  HighlightControl GetHighlightControl();
8716 
8718  HighlightControl const GetHighlightControl() const;
8719 
8721  UpdateOptionsControl GetUpdateOptionsControl();
8722 
8724  UpdateOptionsControl const GetUpdateOptionsControl() const;
8725 
8727  void Update();
8728 
8733  void Update(UpdateOptionsKit const & in_kit);
8734 
8749  void Update(Window::UpdateControl in_control, Time in_time_limit=-1);
8750 
8754  UpdateNotifier UpdateWithNotifier();
8755 
8759  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
8760 
8766  UpdateNotifier UpdateWithNotifier(Window::UpdateControl in_control, Time in_time_limit=-1);
8767 
8769  EventDispatcher & GetEventDispatcher();
8770 
8772  EventDispatcher const & GetEventDispatcher() const;
8773 
8777  bool ShowSnapshot(ImageKit & out_kit) const;
8778 
8779 private:
8780 
8782  SegmentKey & UnsetAttributeLocks();
8783  SegmentKey & UnsetCamera();
8784  SegmentKey & UnsetColorInterpolation();
8785  SegmentKey & UnsetContourLine();
8786  SegmentKey & UnsetCulling();
8787  SegmentKey & UnsetCurveAttributes();
8788  SegmentKey & UnsetCuttingSectionAttributes();
8789  SegmentKey & UnsetCylinderAttributes();
8790  SegmentKey & UnsetDrawingAttribute();
8791  SegmentKey & UnsetEdgeAttributes();
8792  SegmentKey & UnsetHiddenLineAttribute();
8793  SegmentKey & UnsetLightingAttributes();
8794  SegmentKey & UnsetLineAttributes();
8795  SegmentKey & UnsetMaterialMapping();
8796  SegmentKey & UnsetMarkerAttributes();
8797  SegmentKey & UnsetModellingMatrix();
8798  SegmentKey & UnsetNURBSSurfaceAttributes();
8799  SegmentKey & UnsetPerformance();
8800  SegmentKey & UnsetSelectability();
8801  SegmentKey & UnsetSphereAttributes();
8802  SegmentKey & UnsetSubwindow();
8803  SegmentKey & UnsetTextAttributes();
8804  SegmentKey & UnsetTextureMatrix();
8805  SegmentKey & UnsetTransformMask();
8806  SegmentKey & UnsetTransparency();
8807  SegmentKey & UnsetVisibility();
8808  SegmentKey & UnsetVisualEffects();
8809 
8811  void MoveTo(SegmentKey const & in_new_owner);
8812 
8814  Key CopyTo(SegmentKey const & in_destination) const;
8815 };
8816 
8817 
8818 
8821 class HPS_API KeyPath : public Object
8822 {
8823 public:
8824 
8826  KeyPath();
8827 
8830  KeyPath(KeyArray const & in_path);
8831 
8835  KeyPath(size_t in_path_count, Key const in_path []);
8836 
8838  KeyPath(KeyPath const & in_that);
8839 
8843  KeyPath(KeyPath && in_that);
8844 
8848  KeyPath & operator=(KeyPath && in_that);
8849 
8851  virtual ~KeyPath();
8852 
8853  HPS::Type ObjectType() const { return HPS::Type::KeyPath; }
8854 
8858  KeyPath & operator+=(Key const & in_key);
8859 
8863  KeyPath & operator+=(KeyPath const & in_key_path);
8864 
8868  KeyPath & operator+=(KeyArray const & in_key_array);
8869 
8873  KeyPath & Append(Key const & in_key);
8874 
8878  KeyPath & Append(KeyPath const & in_key_path);
8879 
8883  KeyPath & Append(KeyArray const & in_key_array);
8884 
8888  KeyPath & operator=(KeyPath const & in_that);
8889 
8893  KeyPath & operator=(KeyArray const & in_path);
8894 
8897  void Set(KeyPath const & in_that);
8898 
8902  bool Equals(KeyPath const & in_that) const;
8903 
8907  bool operator!= (KeyPath const & in_that) const;
8908 
8912  bool operator== (KeyPath const & in_that) const;
8913 
8914 
8918  KeyPath & SetKeys(KeyArray const & in_keys);
8919 
8924  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
8925 
8926 
8929  KeyPath & UnsetKeys();
8930 
8931 
8934  bool ShowKeys(KeyArray & out_keys) const;
8935 
8936 
8943  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8944 
8951  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
8952 
8958  bool ComputeTextExtent(const char* in_text, float & out_xfrac, float & out_yfrac) const;
8959 
8960 
8966  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
8967 
8968 
8971  bool ShowNetVisibility(VisibilityKit & out_kit) const;
8972 
8975  bool ShowNetBounding(BoundingKit & out_kit) const;
8976 
8979  bool ShowNetCamera(CameraKit & out_kit) const;
8980 
8983  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
8984 
8987  bool ShowNetContourLine(ContourLineKit & out_kit) const;
8988 
8991  bool ShowNetPerformance(PerformanceKit & out_kit) const;
8992 
8995  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8996 
8999  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9000 
9003  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9004 
9007  bool ShowNetMarkerAttributes(MarkerAttributeKit & out_kit) const;
9008 
9011  bool ShowNetSphereAttributes(SphereAttributeKit & out_kit) const;
9012 
9015  bool ShowNetLightingAttributes(LightingAttributeKit & out_kit) const;
9016 
9019  bool ShowNetCylinderAttributes(CylinderAttributeKit & out_kit) const;
9020 
9023  bool ShowNetCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
9024 
9027  bool ShowNetTextAttributes(TextAttributeKit & out_kit) const;
9028 
9031  bool ShowNetLineAttributes(LineAttributeKit & out_kit) const;
9032 
9035  bool ShowNetEdgeAttributes(EdgeAttributeKit & out_kit) const;
9036 
9039  bool ShowNetCurveAttributes(CurveAttributeKit & out_kit) const;
9040 
9043  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9044 
9047  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9048 
9051  bool ShowNetCulling(CullingKit & out_kit) const;
9052 
9055  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9056 
9059  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9060 
9063  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9064 
9067  bool ShowNetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
9068 
9071  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9072 
9075  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9076 
9079  bool ShowNetAttributeLocks(AttributeLockKit & out_kit) const;
9080 
9083  bool ShowNetConditions(UTF8Array & out_conditions) const;
9084 
9090  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9091 
9092 };
9093 
9094 
9099 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9100 {
9101  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9102 }
9103 
9108 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9109 {
9110  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9111 }
9112 
9117 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9118 {
9119  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9120 }
9121 
9126 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9127 {
9128  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9129 }
9130 
9135 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9136 {
9137  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9138 }
9139 
9144 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9145 {
9146  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9147 }
9148 
9153 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9154 {
9155  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9156 }
9157 
9162 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9163 {
9164  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9165 }
9166 
9171 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9172 {
9173  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9174 }
9175 
9176 
9180 
9182 class HPS_API BoundingKit : public Object
9183 {
9184 public:
9185 
9187  BoundingKit();
9188 
9191  BoundingKit(BoundingKit const & in_kit);
9192 
9196  BoundingKit(BoundingKit && in_that);
9197 
9201  BoundingKit & operator=(BoundingKit && in_that);
9202 
9204  virtual ~BoundingKit();
9205 
9206  HPS::Type ObjectType() const {return HPS::Type::BoundingKit;};
9207 
9211  static BoundingKit GetDefault();
9212 
9215  void Set(BoundingKit const & in_kit);
9216 
9219  void Show(BoundingKit & out_kit) const;
9220 
9224  BoundingKit & operator=(BoundingKit const & in_kit);
9225 
9228  bool Empty() const;
9229 
9233  bool Equals(BoundingKit const & in_kit) const;
9234 
9238  bool operator==(BoundingKit const & in_kit) const;
9239 
9243  bool operator!=(BoundingKit const & in_kit) const;
9244 
9245 
9249  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
9250 
9254  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
9255 
9259  BoundingKit & SetExclusion(bool in_exclude);
9260 
9261 
9264  BoundingKit & UnsetVolume();
9265 
9268  BoundingKit & UnsetExclusion();
9269 
9272  BoundingKit & UnsetEverything();
9273 
9274 
9279  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9280 
9284  bool ShowExclusion(bool & out_exclusion) const;
9285 
9286 };
9287 
9288 
9291 class HPS_API BoundingControl : public Control
9292 {
9293 public:
9294 
9296  explicit BoundingControl(SegmentKey & in_seg);
9297 
9299  BoundingControl(BoundingControl const & in_that);
9300 
9304  BoundingControl(BoundingControl && in_that);
9305 
9309  BoundingControl & operator=(BoundingControl && in_that);
9310 
9312  ~BoundingControl();
9313 
9314  HPS::Type ObjectType() const {return HPS::Type::BoundingControl;};
9315 
9317  BoundingControl & operator=(BoundingControl const & in_that);
9318 
9323  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
9324 
9328  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
9329 
9333  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
9334 
9338  BoundingControl & SetExclusion(bool in_exclusion);
9339 
9340 
9343  BoundingControl & UnsetVolume();
9344 
9347  BoundingControl & UnsetExclusion();
9348 
9351  BoundingControl & UnsetEverything();
9352 
9353 
9358  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9359 
9363  bool ShowExclusion(bool & out_exclusion) const;
9364 
9365 private:
9367  BoundingControl();
9368 };
9369 
9370 
9372 class HPS_API VisibilityKit : public Object
9373 {
9374 public:
9375 
9377  VisibilityKit();
9378 
9381  VisibilityKit(VisibilityKit const & in_kit);
9382 
9386  VisibilityKit(VisibilityKit && in_that);
9387 
9391  VisibilityKit & operator=(VisibilityKit && in_that);
9392 
9394  virtual ~VisibilityKit();
9395 
9396  HPS::Type ObjectType() const {return HPS::Type::VisibilityKit;};
9397 
9401  static VisibilityKit GetDefault();
9402 
9405  void Set(VisibilityKit const & in_kit);
9406 
9409  void Show(VisibilityKit & out_kit) const;
9410 
9414  VisibilityKit & operator=(VisibilityKit const & in_kit);
9415 
9418  bool Empty() const;
9419 
9423  bool Equals(VisibilityKit const & in_kit) const;
9424 
9428  bool operator==(VisibilityKit const & in_kit) const;
9429 
9433  bool operator!=(VisibilityKit const & in_kit) const;
9434 
9435 
9439  VisibilityKit & SetCuttingSections(bool in_state);
9440 
9444  VisibilityKit & SetCutEdges(bool in_state);
9445 
9449  VisibilityKit & SetCutFaces(bool in_state);
9450 
9454  VisibilityKit & SetWindows(bool in_state);
9455 
9459  VisibilityKit & SetText(bool in_state);
9460 
9464  VisibilityKit & SetLines(bool in_state);
9465 
9469  VisibilityKit & SetEdgeLights(bool in_state);
9470 
9474  VisibilityKit & SetMarkerLights(bool in_state);
9475 
9479  VisibilityKit & SetFaceLights(bool in_state);
9480 
9484  VisibilityKit & SetGenericEdges(bool in_state);
9485 
9489  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9490 
9497  VisibilityKit & SetAdjacentEdges(bool in_state);
9498 
9502  VisibilityKit & SetHardEdges(bool in_state);
9503 
9507  VisibilityKit & SetMeshQuadEdges(bool in_state);
9508 
9512  VisibilityKit & SetNonCulledEdges(bool in_state);
9513 
9517  VisibilityKit & SetPerimeterEdges(bool in_state);
9518 
9522  VisibilityKit & SetFaces(bool in_state);
9523 
9527  VisibilityKit & SetVertices(bool in_state);
9528 
9532  VisibilityKit & SetMarkers(bool in_state);
9533 
9537  VisibilityKit & SetShadowCasting(bool in_state);
9538 
9542  VisibilityKit & SetShadowReceiving(bool in_state);
9543 
9547  VisibilityKit & SetShadowEmitting(bool in_state);
9548 
9549 
9553  VisibilityKit & SetCutGeometry(bool in_state);
9554 
9558  VisibilityKit & SetEdges(bool in_state);
9559 
9563  VisibilityKit & SetGeometry(bool in_state);
9564 
9568  VisibilityKit & SetLights(bool in_state);
9569 
9573  VisibilityKit & SetShadows(bool in_state);
9574 
9578  VisibilityKit & SetEverything(bool in_state);
9579 
9580 
9583  VisibilityKit & UnsetCuttingSections();
9584 
9587  VisibilityKit & UnsetCutEdges();
9588 
9591  VisibilityKit & UnsetCutFaces();
9592 
9595  VisibilityKit & UnsetWindows();
9596 
9599  VisibilityKit & UnsetText();
9600 
9603  VisibilityKit & UnsetLines();
9604 
9607  VisibilityKit & UnsetEdgeLights();
9608 
9611  VisibilityKit & UnsetMarkerLights();
9612 
9615  VisibilityKit & UnsetFaceLights();
9616 
9619  VisibilityKit & UnsetGenericEdges();
9620 
9623  VisibilityKit & UnsetInteriorSilhouetteEdges();
9624 
9627  VisibilityKit & UnsetAdjacentEdges();
9628 
9631  VisibilityKit & UnsetHardEdges();
9632 
9635  VisibilityKit & UnsetMeshQuadEdges();
9636 
9639  VisibilityKit & UnsetNonCulledEdges();
9640 
9643  VisibilityKit & UnsetPerimeterEdges();
9644 
9647  VisibilityKit & UnsetFaces();
9648 
9651  VisibilityKit & UnsetVertices();
9652 
9655  VisibilityKit & UnsetMarkers();
9656 
9659  VisibilityKit & UnsetShadowCasting();
9660 
9663  VisibilityKit & UnsetShadowReceiving();
9664 
9667  VisibilityKit & UnsetShadowEmitting();
9668 
9669 
9672  VisibilityKit & UnsetCutGeometry();
9673 
9676  VisibilityKit & UnsetEdges();
9677 
9680  VisibilityKit & UnsetGeometry();
9681 
9684  VisibilityKit & UnsetLights();
9685 
9688  VisibilityKit & UnsetShadows();
9689 
9692  VisibilityKit & UnsetEverything();
9693 
9694 
9698  bool ShowCuttingSections(bool & out_state) const;
9699 
9703  bool ShowCutEdges(bool & out_state) const;
9704 
9708  bool ShowCutFaces(bool & out_state) const;
9709 
9713  bool ShowWindows(bool & out_state) const;
9714 
9718  bool ShowText(bool & out_state) const;
9719 
9723  bool ShowLines(bool & out_state) const;
9724 
9728  bool ShowEdgeLights(bool & out_state) const;
9729 
9733  bool ShowMarkerLights(bool & out_state) const;
9734 
9738  bool ShowFaceLights(bool & out_state) const;
9739 
9743  bool ShowGenericEdges(bool & out_state) const;
9744 
9748  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9749 
9753  bool ShowAdjacentEdges(bool & out_state) const;
9754 
9758  bool ShowHardEdges(bool & out_state) const;
9759 
9763  bool ShowMeshQuadEdges(bool & out_state) const;
9764 
9768  bool ShowNonCulledEdges(bool & out_state) const;
9769 
9773  bool ShowPerimeterEdges(bool & out_state) const;
9774 
9778  bool ShowFaces(bool & out_state) const;
9779 
9783  bool ShowVertices(bool & out_state) const;
9784 
9788  bool ShowMarkers(bool & out_state) const;
9789 
9793  bool ShowShadowCasting(bool & out_state) const;
9794 
9798  bool ShowShadowReceiving(bool & out_state) const;
9799 
9803  bool ShowShadowEmitting(bool & out_state) const;
9804 };
9805 
9806 
9812 class HPS_API VisibilityControl : public Control
9813 {
9814 public:
9815 
9817  explicit VisibilityControl(SegmentKey & in_seg);
9818 
9820  VisibilityControl(VisibilityControl const & in_that);
9821 
9826 
9830  VisibilityControl & operator=(VisibilityControl && in_that);
9831 
9833  ~VisibilityControl();
9834 
9835  HPS::Type ObjectType() const {return HPS::Type::VisibilityControl;};
9836 
9838  VisibilityControl & operator=(VisibilityControl const & in_that);
9839 
9840 
9844  VisibilityControl & SetCuttingSections(bool in_state);
9845 
9849  VisibilityControl & SetCutEdges(bool in_state);
9850 
9854  VisibilityControl & SetCutFaces(bool in_state);
9855 
9859  VisibilityControl & SetWindows(bool in_state);
9860 
9864  VisibilityControl & SetText(bool in_state);
9865 
9869  VisibilityControl & SetLines(bool in_state);
9870 
9874  VisibilityControl & SetEdgeLights(bool in_state);
9875 
9879  VisibilityControl & SetMarkerLights(bool in_state);
9880 
9884  VisibilityControl & SetFaceLights(bool in_state);
9885 
9889  VisibilityControl & SetGenericEdges(bool in_state);
9890 
9894  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
9895 
9899  VisibilityControl & SetAdjacentEdges(bool in_state);
9900 
9904  VisibilityControl & SetHardEdges(bool in_state);
9905 
9909  VisibilityControl & SetMeshQuadEdges(bool in_state);
9910 
9914  VisibilityControl & SetNonCulledEdges(bool in_state);
9915 
9919  VisibilityControl & SetPerimeterEdges(bool in_state);
9920 
9924  VisibilityControl & SetFaces(bool in_state);
9925 
9929  VisibilityControl & SetVertices(bool in_state);
9930 
9934  VisibilityControl & SetMarkers(bool in_state);
9935 
9939  VisibilityControl & SetShadowCasting(bool in_state);
9940 
9944  VisibilityControl & SetShadowReceiving(bool in_state);
9945 
9949  VisibilityControl & SetShadowEmitting(bool in_state);
9950 
9951 
9955  VisibilityControl & SetCutGeometry(bool in_state);
9956 
9960  VisibilityControl & SetEdges(bool in_state);
9961 
9965  VisibilityControl & SetGeometry(bool in_state);
9966 
9970  VisibilityControl & SetLights(bool in_state);
9971 
9975  VisibilityControl & SetShadows(bool in_state);
9976 
9980  VisibilityControl & SetEverything(bool in_state);
9981 
9982 
9985  VisibilityControl & UnsetCuttingSections();
9986 
9989  VisibilityControl & UnsetCutEdges();
9990 
9993  VisibilityControl & UnsetCutFaces();
9994 
9997  VisibilityControl & UnsetWindows();
9998 
10001  VisibilityControl & UnsetText();
10002 
10005  VisibilityControl & UnsetLines();
10006 
10009  VisibilityControl & UnsetEdgeLights();
10010 
10013  VisibilityControl & UnsetMarkerLights();
10014 
10017  VisibilityControl & UnsetFaceLights();
10018 
10021  VisibilityControl & UnsetGenericEdges();
10022 
10025  VisibilityControl & UnsetInteriorSilhouetteEdges();
10026 
10029  VisibilityControl & UnsetAdjacentEdges();
10030 
10033  VisibilityControl & UnsetHardEdges();
10034 
10037  VisibilityControl & UnsetMeshQuadEdges();
10038 
10041  VisibilityControl & UnsetNonCulledEdges();
10042 
10045  VisibilityControl & UnsetPerimeterEdges();
10046 
10049  VisibilityControl & UnsetFaces();
10050 
10053  VisibilityControl & UnsetVertices();
10054 
10057  VisibilityControl & UnsetMarkers();
10058 
10061  VisibilityControl & UnsetShadowCasting();
10062 
10065  VisibilityControl & UnsetShadowReceiving();
10066 
10069  VisibilityControl & UnsetShadowEmitting();
10070 
10071 
10074  VisibilityControl & UnsetCutGeometry();
10075 
10078  VisibilityControl & UnsetEdges();
10079 
10082  VisibilityControl & UnsetGeometry();
10083 
10086  VisibilityControl & UnsetLights();
10087 
10090  VisibilityControl & UnsetShadows();
10091 
10094  VisibilityControl & UnsetEverything();
10095 
10096 
10100  bool ShowCuttingSections(bool & out_state) const;
10101 
10105  bool ShowCutEdges(bool & out_state) const;
10106 
10110  bool ShowCutFaces(bool & out_state) const;
10111 
10115  bool ShowWindows(bool & out_state) const;
10116 
10120  bool ShowText(bool & out_state) const;
10121 
10125  bool ShowLines(bool & out_state) const;
10126 
10130  bool ShowEdgeLights(bool & out_state) const;
10131 
10135  bool ShowMarkerLights(bool & out_state) const;
10136 
10140  bool ShowFaceLights(bool & out_state) const;
10141 
10145  bool ShowGenericEdges(bool & out_state) const;
10146 
10150  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10151 
10155  bool ShowAdjacentEdges(bool & out_state) const;
10156 
10160  bool ShowHardEdges(bool & out_state) const;
10161 
10165  bool ShowMeshQuadEdges(bool & out_state) const;
10166 
10170  bool ShowNonCulledEdges(bool & out_state) const;
10171 
10175  bool ShowPerimeterEdges(bool & out_state) const;
10176 
10180  bool ShowFaces(bool & out_state) const;
10181 
10185  bool ShowVertices(bool & out_state) const;
10186 
10190  bool ShowMarkers(bool & out_state) const;
10191 
10195  bool ShowShadowCasting(bool & out_state) const;
10196 
10200  bool ShowShadowReceiving(bool & out_state) const;
10201 
10205  bool ShowShadowEmitting(bool & out_state) const;
10206 
10207 private:
10210 };
10211 
10212 
10213 
10216 class HPS_API CameraKit : public Object
10217 {
10218 public:
10219 
10221  CameraKit();
10222 
10225  CameraKit(const CameraKit & in_kit);
10226 
10230  CameraKit(CameraKit && in_that);
10231 
10235  CameraKit & operator=(CameraKit && in_that);
10236 
10238  virtual ~CameraKit();
10239 
10240  HPS::Type ObjectType() const {return HPS::Type::CameraKit;};
10241 
10245  static CameraKit GetDefault();
10246 
10249  void Set(CameraKit const & in_kit);
10250 
10253  void Show(CameraKit & out_kit) const;
10254 
10258  CameraKit & operator=(CameraKit const & in_kit);
10259 
10262  bool Empty() const;
10263 
10267  bool Equals(CameraKit const & in_kit) const;
10268 
10272  bool operator==(CameraKit const & in_kit) const;
10273 
10277  bool operator!=(CameraKit const & in_kit) const;
10278 
10282  CameraKit & SetUpVector(Vector const & in_up);
10283 
10287  CameraKit & SetPosition(Point const & in_position);
10288 
10292  CameraKit & SetTarget(Point const & in_target);
10293 
10300  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
10301 
10307  CameraKit & SetField(float in_width, float in_height);
10308 
10318  CameraKit & SetNearLimit(float const in_limit);
10319 
10322  CameraKit & UnsetUpVector();
10323 
10326  CameraKit & UnsetPosition();
10327 
10330  CameraKit & UnsetTarget();
10331 
10334  CameraKit & UnsetProjection();
10335 
10338  CameraKit & UnsetField();
10339 
10342  CameraKit & UnsetNearLimit();
10343 
10346  CameraKit & UnsetEverything();
10347 
10348 
10352  bool ShowUpVector(Vector & out_up) const;
10353 
10357  bool ShowPosition(Point & out_position) const;
10358 
10362  bool ShowTarget(Point & out_target) const;
10363 
10367  bool ShowProjection(Camera::Projection & out_type) const;
10368 
10374  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
10375 
10379  bool ShowWidth(float & out_width) const;
10380 
10384  bool ShowHeight(float & out_height) const;
10385 
10390  bool ShowField(float & out_width, float & out_height) const;
10391 
10395  bool ShowNearLimit(float & out_near_limit) const;
10396 
10403  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
10404 
10411  CameraKit & Orbit(float in_theta, float in_phi);
10412 
10419  CameraKit & Pan(float in_theta, float in_phi);
10420 
10426  CameraKit & Roll(float in_theta);
10427 
10433  CameraKit & Zoom(float in_zoom);
10434 };
10435 
10439 class HPS_API CameraControl : public Control
10440 {
10441 public:
10443  explicit CameraControl(SegmentKey & in_seg);
10444 
10446  CameraControl(CameraControl const & in_that);
10447 
10451  CameraControl(CameraControl && in_that);
10452 
10456  CameraControl & operator=(CameraControl && in_that);
10457 
10459  ~CameraControl();
10460 
10461  HPS::Type ObjectType() const {return HPS::Type::CameraControl;};
10462 
10464  CameraControl & operator=(CameraControl const & in_that);
10465 
10466 
10471  CameraControl & SetUpVector(Vector const & in_up);
10472 
10477  CameraControl & SetPosition(Point const & in_position);
10478 
10483  CameraControl & SetTarget(Point const & in_target);
10484 
10491  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10492 
10498  CameraControl & SetField(float in_width, float in_height);
10499 
10510  CameraControl & SetNearLimit(float in_double);
10511 
10515  CameraControl & UnsetEverything();
10516 
10517 
10521  bool ShowUpVector(Vector & out_up) const;
10522 
10526  bool ShowPosition(Point & out_position) const;
10527 
10531  bool ShowTarget(Point & out_target) const;
10532 
10536  bool ShowProjection(Camera::Projection & out_type) const;
10537 
10543  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10544 
10548  bool ShowWidth(float & out_width) const;
10549 
10553  bool ShowHeight(float & out_height) const;
10554 
10559  bool ShowField(float & out_width, float & out_height) const;
10560 
10564  bool ShowNearLimit(float & out_width) const;
10565 
10572  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10573 
10580  CameraControl & Orbit(float in_theta, float in_phi);
10581 
10588  CameraControl & Pan(float in_theta, float in_phi);
10589 
10595  CameraControl & Roll(float in_theta);
10596 
10602  CameraControl & Zoom(float in_zoom);
10603 
10604 private:
10606  CameraControl();
10607 };
10608 
10609 
10610 
10612 class HPS_API SelectabilityKit : public Object
10613 {
10614 public:
10615 
10617  SelectabilityKit();
10618 
10621  SelectabilityKit(SelectabilityKit const & in_kit);
10622 
10626  SelectabilityKit(SelectabilityKit && in_that);
10627 
10631  SelectabilityKit & operator=(SelectabilityKit && in_that);
10632 
10634  virtual ~SelectabilityKit();
10635 
10636  HPS::Type ObjectType() const {return HPS::Type::SelectabilityKit;};
10637 
10641  static SelectabilityKit GetDefault();
10642 
10645  void Set(SelectabilityKit const & in_kit);
10646 
10649  void Show(SelectabilityKit & out_kit) const;
10650 
10654  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10655 
10658  bool Empty() const;
10659 
10663  bool Equals(SelectabilityKit const & in_kit) const;
10664 
10668  bool operator==(SelectabilityKit const & in_kit) const;
10669 
10673  bool operator!=(SelectabilityKit const & in_kit) const;
10674 
10675 
10679  SelectabilityKit & SetWindows(Selectability::Value in_val);
10680 
10684  SelectabilityKit & SetEdges(Selectability::Value in_val);
10685 
10689  SelectabilityKit & SetFaces(Selectability::Value in_val);
10690 
10694  SelectabilityKit & SetLights(Selectability::Value in_val);
10695 
10699  SelectabilityKit & SetLines(Selectability::Value in_val);
10700 
10704  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10705 
10709  SelectabilityKit & SetVertices(Selectability::Value in_val);
10710 
10714  SelectabilityKit & SetText(Selectability::Value in_val);
10715 
10719  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10720 
10724  SelectabilityKit & SetEverything(Selectability::Value in_val);
10725 
10726 
10729  SelectabilityKit & UnsetWindows();
10730 
10733  SelectabilityKit & UnsetEdges();
10734 
10737  SelectabilityKit & UnsetFaces();
10738 
10741  SelectabilityKit & UnsetLights();
10742 
10745  SelectabilityKit & UnsetLines();
10746 
10749  SelectabilityKit & UnsetMarkers();
10750 
10753  SelectabilityKit & UnsetVertices();
10754 
10757  SelectabilityKit & UnsetText();
10758 
10761  SelectabilityKit & UnsetGeometry();
10762 
10765  SelectabilityKit & UnsetEverything();
10766 
10767 
10771  bool ShowWindows(Selectability::Value & out_val) const;
10772 
10776  bool ShowEdges(Selectability::Value & out_val) const;
10777 
10781  bool ShowFaces(Selectability::Value & out_val) const;
10782 
10786  bool ShowLights(Selectability::Value & out_val) const;
10787 
10791  bool ShowLines(Selectability::Value & out_val) const;
10792 
10796  bool ShowMarkers(Selectability::Value & out_val) const;
10797 
10801  bool ShowVertices(Selectability::Value & out_val) const;
10802 
10806  bool ShowText(Selectability::Value & out_val) const;
10807 };
10808 
10814 class HPS_API SelectabilityControl : public Control
10815 {
10816 public:
10817 
10819  explicit SelectabilityControl(SegmentKey & in_seg);
10820 
10822  SelectabilityControl(SelectabilityControl const & in_that);
10823 
10828 
10832  SelectabilityControl & operator=(SelectabilityControl && in_that);
10833 
10836 
10837  HPS::Type ObjectType() const {return HPS::Type::SelectabilityControl;};
10838 
10840  SelectabilityControl & operator=(SelectabilityControl const & in_that);
10841 
10842 
10846  SelectabilityControl & SetWindows(Selectability::Value in_val);
10847 
10851  SelectabilityControl & SetEdges(Selectability::Value in_val);
10852 
10856  SelectabilityControl & SetFaces(Selectability::Value in_val);
10857 
10861  SelectabilityControl & SetLights(Selectability::Value in_val);
10862 
10866  SelectabilityControl & SetLines(Selectability::Value in_val);
10867 
10871  SelectabilityControl & SetMarkers(Selectability::Value in_val);
10872 
10876  SelectabilityControl & SetVertices(Selectability::Value in_val);
10877 
10881  SelectabilityControl & SetText(Selectability::Value in_val);
10882 
10886  SelectabilityControl & SetGeometry(Selectability::Value in_val);
10887 
10891  SelectabilityControl & SetEverything(Selectability::Value in_val);
10892 
10893 
10896  SelectabilityControl & UnsetWindows();
10897 
10900  SelectabilityControl & UnsetEdges();
10901 
10904  SelectabilityControl & UnsetFaces();
10905 
10908  SelectabilityControl & UnsetLights();
10909 
10912  SelectabilityControl & UnsetLines();
10913 
10916  SelectabilityControl & UnsetMarkers();
10917 
10920  SelectabilityControl & UnsetVertices();
10921 
10924  SelectabilityControl & UnsetText();
10925 
10928  SelectabilityControl & UnsetGeometry();
10929 
10932  SelectabilityControl & UnsetEverything();
10933 
10934 
10938  bool ShowWindows(Selectability::Value & out_val) const;
10939 
10943  bool ShowEdges(Selectability::Value & out_val) const;
10944 
10948  bool ShowFaces(Selectability::Value & out_val) const;
10949 
10953  bool ShowLights(Selectability::Value & out_val) const;
10954 
10958  bool ShowLines(Selectability::Value & out_val) const;
10959 
10963  bool ShowMarkers(Selectability::Value & out_val) const;
10964 
10968  bool ShowVertices(Selectability::Value & out_val) const;
10969 
10973  bool ShowText(Selectability::Value & out_val) const;
10974 
10975 private:
10978 };
10979 
10980 
10982 class HPS_API TransparencyKit : public Object
10983 {
10984 public:
10985 
10987  TransparencyKit();
10988 
10991  TransparencyKit(TransparencyKit const & in_kit);
10992 
10996  TransparencyKit(TransparencyKit && in_that);
10997 
11001  TransparencyKit & operator=(TransparencyKit && in_that);
11002 
11004  virtual ~TransparencyKit();
11005 
11006  HPS::Type ObjectType() const {return HPS::Type::TransparencyKit;};
11007 
11011  static TransparencyKit GetDefault();
11012 
11015  void Set(TransparencyKit const & in_kit);
11016 
11019  void Show(TransparencyKit & out_kit) const;
11020 
11024  TransparencyKit & operator=(TransparencyKit const & in_kit);
11025 
11028  bool Empty() const;
11029 
11033  bool Equals(TransparencyKit const & in_kit) const;
11034 
11038  bool operator==(TransparencyKit const & in_kit) const;
11039 
11043  bool operator!=(TransparencyKit const & in_kit) const;
11044 
11045 
11049  TransparencyKit & SetMethod(Transparency::Method in_style);
11050 
11054  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
11055 
11060  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
11061 
11067  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11068 
11073  TransparencyKit & SetDepthWriting(bool in_state);
11074 
11075 
11078  TransparencyKit & UnsetMethod();
11079 
11082  TransparencyKit & UnsetAlgorithm();
11083 
11086  TransparencyKit & UnsetDepthPeelingLayers();
11087 
11090  TransparencyKit & UnsetDepthPeelingMinimumArea();
11091 
11094  TransparencyKit & UnsetDepthWriting();
11095 
11098  TransparencyKit & UnsetEverything();
11099 
11100 
11104  bool ShowMethod(Transparency::Method & out_style) const;
11105 
11109  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11110 
11114  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11115 
11120  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11121 
11125  bool ShowDepthWriting(bool & out_state) const;
11126 };
11127 
11133 class HPS_API TransparencyControl : public Control
11134 {
11135 public:
11136 
11138  explicit TransparencyControl(SegmentKey & in_seg);
11139 
11141  TransparencyControl(TransparencyControl const & in_that);
11142 
11147 
11151  TransparencyControl & operator=(TransparencyControl && in_that);
11152 
11155 
11156  HPS::Type ObjectType() const {return HPS::Type::TransparencyControl;};
11157 
11159  TransparencyControl & operator=(TransparencyControl const & in_that);
11160 
11164  TransparencyControl & SetMethod(Transparency::Method in_style);
11165 
11169  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
11170 
11175  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
11176 
11182  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11183 
11188  TransparencyControl & SetDepthWriting(bool in_state);
11189 
11190 
11193  TransparencyControl & UnsetMethod();
11194 
11197  TransparencyControl & UnsetAlgorithm();
11198 
11201  TransparencyControl & UnsetDepthPeelingLayers();
11202 
11205  TransparencyControl & UnsetDepthPeelingMinimumArea();
11206 
11209  TransparencyControl & UnsetDepthWriting();
11210 
11213  TransparencyControl & UnsetEverything();
11214 
11215 
11219  bool ShowMethod(Transparency::Method & out_style) const;
11220 
11224  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11225 
11229  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11230 
11235  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11236 
11240  bool ShowDepthWriting(bool & out_state) const;
11241 
11242 private:
11245 };
11246 
11248 class HPS_API ColorInterpolationKit : public Object
11249 {
11250 public:
11251 
11254 
11257 
11262 
11266  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
11267 
11269  virtual ~ColorInterpolationKit();
11270 
11271  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationKit;};
11272 
11273  static ColorInterpolationKit GetDefault();
11274 
11276  void Set(ColorInterpolationKit const & in_kit);
11277 
11279  void Show(ColorInterpolationKit & out_kit) const;
11280 
11282  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
11283 
11285  bool Empty() const;
11286 
11288  bool Equals(ColorInterpolationKit const & in_kit) const;
11289 
11291  bool operator==(ColorInterpolationKit const & in_kit) const;
11292 
11294  bool operator!=(ColorInterpolationKit const & in_kit) const;
11295 
11296 
11300  ColorInterpolationKit & SetFaceColor(bool in_state);
11301 
11305  ColorInterpolationKit & SetEdgeColor(bool in_state);
11306 
11310  ColorInterpolationKit & SetVertexColor(bool in_state);
11311 
11315  ColorInterpolationKit & SetFaceIndex(bool in_state);
11316 
11320  ColorInterpolationKit & SetEdgeIndex(bool in_state);
11321 
11325  ColorInterpolationKit & SetVertexIndex(bool in_state);
11326 
11327 
11330  ColorInterpolationKit & UnsetFaceColor();
11331 
11334  ColorInterpolationKit & UnsetEdgeColor();
11335 
11338  ColorInterpolationKit & UnsetVertexColor();
11339 
11342  ColorInterpolationKit & UnsetFaceIndex();
11343 
11346  ColorInterpolationKit & UnsetEdgeIndex();
11347 
11350  ColorInterpolationKit & UnsetVertexIndex();
11351 
11354  ColorInterpolationKit & UnsetEverything();
11355 
11356 
11360  bool ShowFaceColor(bool & out_state) const;
11361 
11365  bool ShowEdgeColor(bool & out_state) const;
11366 
11370  bool ShowVertexColor(bool & out_state) const;
11371 
11375  bool ShowFaceIndex(bool & out_state) const;
11376 
11380  bool ShowEdgeIndex(bool & out_state) const;
11381 
11385  bool ShowVertexIndex(bool & out_state) const;
11386 };
11387 
11388 
11392 class HPS_API ColorInterpolationControl : public Control
11393 {
11394 public:
11395 
11397  explicit ColorInterpolationControl(SegmentKey & in_seg);
11398 
11401 
11406 
11410  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11411 
11414 
11415  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationControl;};
11416 
11417 
11421  ColorInterpolationControl & SetFaceColor(bool in_state);
11422 
11426  ColorInterpolationControl & SetEdgeColor(bool in_state);
11427 
11431  ColorInterpolationControl & SetVertexColor(bool in_state);
11432 
11436  ColorInterpolationControl & SetFaceIndex(bool in_state);
11437 
11441  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11442 
11446  ColorInterpolationControl & SetVertexIndex(bool in_state);
11447 
11448 
11451  ColorInterpolationControl & UnsetFaceColor();
11452 
11455  ColorInterpolationControl & UnsetEdgeColor();
11456 
11459  ColorInterpolationControl & UnsetVertexColor();
11460 
11463  ColorInterpolationControl & UnsetFaceIndex();
11464 
11467  ColorInterpolationControl & UnsetEdgeIndex();
11468 
11471  ColorInterpolationControl & UnsetVertexIndex();
11472 
11475  ColorInterpolationControl & UnsetEverything();
11476 
11477 
11481  bool ShowFaceColor(bool & out_state) const;
11482 
11486  bool ShowEdgeColor(bool & out_state) const;
11487 
11491  bool ShowVertexColor(bool & out_state) const;
11492 
11496  bool ShowFaceIndex(bool & out_state) const;
11497 
11501  bool ShowEdgeIndex(bool & out_state) const;
11502 
11506  bool ShowVertexIndex(bool & out_state) const;
11507 
11508 private:
11511 };
11512 
11513 
11515 class HPS_API CullingKit : public Object
11516 {
11517 public:
11518 
11520  CullingKit();
11521 
11524  CullingKit(CullingKit const & in_kit);
11525 
11529  CullingKit(CullingKit && in_that);
11530 
11534  CullingKit & operator=(CullingKit && in_that);
11535 
11537  virtual ~CullingKit();
11538 
11539  HPS::Type ObjectType() const {return HPS::Type::CullingKit;};
11540 
11544  static CullingKit GetDefault();
11545 
11548  void Set(CullingKit const & in_kit);
11549 
11552  void Show(CullingKit & out_kit) const;
11553 
11557  CullingKit & operator=(CullingKit const & in_kit);
11558 
11561  bool Empty() const;
11562 
11566  bool Equals(CullingKit const & in_kit) const;
11567 
11571  bool operator==(CullingKit const & in_kit) const;
11572 
11576  bool operator!=(CullingKit const & in_kit) const;
11577 
11582  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11583 
11588  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11589 
11594  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11595 
11600  CullingKit & SetExtent(unsigned int in_pixels);
11601 
11605  CullingKit & SetBackFace(bool in_state);
11606 
11613  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11614 
11621  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11622 
11629  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11630 
11636  CullingKit & SetVector(HPS::Vector const & in_vector);
11637 
11641  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11642 
11646  CullingKit & SetFrustum(bool in_state);
11647 
11650  CullingKit & UnsetDeferralExtent();
11651 
11654  CullingKit & UnsetExtent();
11655 
11658  CullingKit & UnsetBackFace();
11659 
11662  CullingKit & UnsetVector();
11663 
11666  CullingKit & UnsetVectorTolerance();
11667 
11670  CullingKit & UnsetFrustum();
11671 
11674  CullingKit & UnsetEverything();
11675 
11680  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11681 
11686  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11687 
11691  bool ShowBackFace(bool & out_state) const;
11692 
11698  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11699 
11703  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11704 
11708  bool ShowFrustum(bool & out_state) const;
11709 };
11710 
11714 class HPS_API CullingControl : public Control
11715 {
11716 public:
11717 
11719  explicit CullingControl(SegmentKey & in_seg);
11720 
11722  CullingControl(CullingControl const & in_that);
11723 
11725  ~CullingControl();
11726 
11730  CullingControl(CullingControl && in_that);
11731 
11735  CullingControl & operator=(CullingControl && in_that);
11736 
11737  HPS::Type ObjectType() const {return HPS::Type::CullingControl;};
11738 
11740  CullingControl & operator=(CullingControl const & in_that);
11741 
11748  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11749 
11756  CullingControl & SetDeferralExtent(unsigned int in_pixels);
11757 
11762  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
11763 
11768  CullingControl & SetExtent(unsigned int in_pixels);
11769 
11774  CullingControl & SetBackFace(bool in_state);
11775 
11782  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11783 
11790  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11791 
11798  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11799 
11805  CullingControl & SetVector(HPS::Vector const & in_vector);
11806 
11810  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
11811 
11815  CullingControl & SetFrustum(bool in_state);
11816 
11819  CullingControl & UnsetDeferralExtent();
11820 
11823  CullingControl & UnsetExtent();
11824 
11827  CullingControl & UnsetBackFace();
11828 
11831  CullingControl & UnsetVector();
11832 
11835  CullingControl & UnsetVectorTolerance();
11836 
11839  CullingControl & UnsetFrustum();
11840 
11843  CullingControl & UnsetEverything();
11844 
11849  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11850 
11855  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11856 
11860  bool ShowBackFace(bool & out_state) const;
11861 
11867  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11868 
11872  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11873 
11877  bool ShowFrustum(bool & out_state) const;
11878 
11879 private:
11881  CullingControl();
11882 };
11883 
11884 
11885 
11886 
11888 class HPS_API MarkerAttributeKit : public Object
11889 {
11890 public:
11891 
11894 
11897  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
11898 
11903 
11907  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
11908 
11910  virtual ~MarkerAttributeKit();
11911 
11912  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeKit;};
11913 
11917  static MarkerAttributeKit GetDefault();
11918 
11921  void Set(MarkerAttributeKit const & in_kit);
11922 
11925  void Show(MarkerAttributeKit & out_kit) const;
11926 
11930  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
11931 
11934  bool Empty() const;
11935 
11939  bool Equals(MarkerAttributeKit const & in_kit) const;
11940 
11944  bool operator==(MarkerAttributeKit const & in_kit) const;
11945 
11949  bool operator!=(MarkerAttributeKit const & in_kit) const;
11950 
11951 
11955  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
11956 
11961  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
11962 
11963 
11966  MarkerAttributeKit & UnsetSymbol();
11967 
11970  MarkerAttributeKit & UnsetSize();
11971 
11974  MarkerAttributeKit & UnsetEverything();
11975 
11976 
11980  bool ShowSymbol(UTF8 & out_glyph_name) const;
11981 
11986  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
11987 };
11988 
11994 class HPS_API MarkerAttributeControl : public Control
11995 {
11996 public:
11997 
11999  explicit MarkerAttributeControl(SegmentKey & in_seg);
12000 
12003 
12008 
12012  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
12013 
12016 
12017  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeControl;};
12018 
12020  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
12021 
12025  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
12026 
12031  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12032 
12033 
12036  MarkerAttributeControl & UnsetSymbol();
12037 
12040  MarkerAttributeControl & UnsetSize();
12041 
12044  MarkerAttributeControl & UnsetEverything();
12045 
12046 
12050  bool ShowSymbol(UTF8 & out_glyph_name) const;
12051 
12056  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12057 
12058 private:
12061 };
12062 
12063 
12065 class HPS_API SphereAttributeKit : public Object
12066 {
12067 public:
12068 
12071 
12074  SphereAttributeKit(SphereAttributeKit const & in_kit);
12075 
12080 
12084  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
12085 
12087  virtual ~SphereAttributeKit();
12088 
12089  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeKit;};
12090 
12094  static SphereAttributeKit GetDefault();
12095 
12098  void Set(SphereAttributeKit const & in_kit);
12099 
12102  void Show(SphereAttributeKit & out_kit) const;
12103 
12107  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
12108 
12111  bool Empty() const;
12112 
12116  bool Equals(SphereAttributeKit const & in_kit) const;
12117 
12121  bool operator==(SphereAttributeKit const & in_kit) const;
12122 
12126  bool operator!=(SphereAttributeKit const & in_kit) const;
12127 
12128 
12132  SphereAttributeKit & SetTessellation(size_t in_facets);
12133 
12134 
12137  SphereAttributeKit & UnsetTessellation();
12138 
12141  SphereAttributeKit & UnsetEverything();
12142 
12143 
12147  bool ShowTessellation(size_t & out_facets) const;
12148 };
12149 
12150 
12153 class HPS_API SphereAttributeControl : public Control
12154 {
12155 public:
12156 
12158  explicit SphereAttributeControl(SegmentKey const & in_seg);
12159 
12162 
12167 
12171  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
12172 
12175 
12176  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeControl;};
12177 
12179  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
12180 
12181 
12186  SphereAttributeControl & SetTessellation(size_t in_facets);
12187 
12188 
12191  SphereAttributeControl & UnsetTessellation();
12192 
12195  SphereAttributeControl & UnsetEverything();
12196 
12197 
12201  bool ShowTessellation(size_t & out_facets) const;
12202 
12203 private:
12206 };
12207 
12208 
12210 class HPS_API LightingAttributeKit : public Object
12211 {
12212 public:
12213 
12216 
12220 
12225 
12229  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
12230 
12232  virtual ~LightingAttributeKit();
12233 
12234  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeKit;};
12235 
12239  static LightingAttributeKit GetDefault();
12240 
12243  void Set(LightingAttributeKit const & in_kit);
12244 
12247  void Show(LightingAttributeKit & out_kit) const;
12248 
12252  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
12253 
12256  bool Empty() const;
12257 
12261  bool Equals(LightingAttributeKit const & in_kit) const;
12262 
12266  bool operator==(LightingAttributeKit const & in_kit) const;
12267 
12271  bool operator!=(LightingAttributeKit const & in_kit) const;
12272 
12273 
12277  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12278 
12279 
12282  LightingAttributeKit & UnsetInterpolationAlgorithm();
12283 
12286  LightingAttributeKit & UnsetEverything();
12287 
12288 
12292  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12293 };
12294 
12295 
12296 
12302 class HPS_API LightingAttributeControl : public Control
12303 {
12304 public:
12305 
12307  explicit LightingAttributeControl(SegmentKey & in_seg);
12308 
12311 
12316 
12320  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
12321 
12324 
12325  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeControl;};
12326 
12328  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
12329 
12330 
12334  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12335 
12336 
12339  LightingAttributeControl & UnsetInterpolationAlgorithm();
12340 
12343  LightingAttributeControl & UnsetEverything();
12344 
12345 
12349  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12350 
12351 private:
12354 };
12355 
12356 
12357 
12359 class HPS_API CylinderAttributeKit : public Object
12360 {
12361 public:
12362 
12365 
12369 
12374 
12378  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
12379 
12381  virtual ~CylinderAttributeKit();
12382 
12383  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeKit;};
12384 
12388  static CylinderAttributeKit GetDefault();
12389 
12392  void Set(CylinderAttributeKit const & in_kit);
12393 
12396  void Show(CylinderAttributeKit & out_kit) const;
12397 
12401  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
12402 
12405  bool Empty() const;
12406 
12410  bool Equals(CylinderAttributeKit const & in_kit) const;
12411 
12415  bool operator==(CylinderAttributeKit const & in_kit) const;
12416 
12420  bool operator!=(CylinderAttributeKit const & in_kit) const;
12421 
12422 
12426  CylinderAttributeKit & SetTessellation(size_t in_facets);
12427 
12432  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12433 
12434 
12437  CylinderAttributeKit & UnsetTessellation();
12438 
12441  CylinderAttributeKit & UnsetOrientation();
12442 
12445  CylinderAttributeKit & UnsetEverything();
12446 
12447 
12451  bool ShowTessellation(size_t & out_facets) const;
12452 
12456  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12457 };
12458 
12459 
12460 
12464 class HPS_API CylinderAttributeControl : public Control
12465 {
12466 public:
12467 
12469  explicit CylinderAttributeControl(SegmentKey & in_seg);
12470 
12473 
12478 
12482  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12483 
12486 
12487  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeControl;};
12488 
12490  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12491 
12492 
12496  CylinderAttributeControl & SetTessellation(size_t in_facets);
12497 
12502  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12503 
12504 
12507  CylinderAttributeControl & UnsetTessellation();
12508 
12511  CylinderAttributeControl & UnsetOrientation();
12512 
12515  CylinderAttributeControl & UnsetEverything();
12516 
12517 
12521  bool ShowTessellation(size_t & out_facets) const;
12522 
12526  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12527 
12528 private:
12531 };
12532 
12533 
12534 
12536 class HPS_API CuttingSectionAttributeKit : public Object
12537 {
12538 public:
12539 
12542 
12546 
12551 
12556 
12558  virtual ~CuttingSectionAttributeKit();
12559 
12560  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeKit;};
12561 
12565  static CuttingSectionAttributeKit GetDefault();
12566 
12569  void Set(CuttingSectionAttributeKit const & in_kit);
12570 
12573  void Show(CuttingSectionAttributeKit & out_kit) const;
12574 
12578  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12579 
12582  bool Empty() const;
12583 
12587  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12588 
12592  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12593 
12597  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12598 
12599 
12603  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12604 
12608  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12609 
12613  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12614 
12615 
12618  CuttingSectionAttributeKit & UnsetCuttingLevel();
12619 
12622  CuttingSectionAttributeKit & UnsetCappingLevel();
12623 
12626  CuttingSectionAttributeKit & UnsetMaterialPreference();
12627 
12630  CuttingSectionAttributeKit & UnsetEverything();
12631 
12632 
12636  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12637 
12641  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12642 
12646  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12647 };
12648 
12649 
12650 
12655 {
12656 public:
12657 
12659  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12660 
12663 
12668 
12673 
12676 
12677  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeControl;};
12678 
12681 
12682 
12687 
12692 
12696  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12697 
12698 
12701  CuttingSectionAttributeControl & UnsetCuttingLevel();
12702 
12705  CuttingSectionAttributeControl & UnsetCappingLevel();
12706 
12709  CuttingSectionAttributeControl & UnsetMaterialPreference();
12710 
12713  CuttingSectionAttributeControl & UnsetEverything();
12714 
12715 
12719  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12720 
12724  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12725 
12729  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12730 
12731 private:
12734 };
12735 
12736 
12737 
12739 class HPS_API TextAttributeKit : public Object
12740 {
12741 public:
12742 
12744  TextAttributeKit();
12745 
12748  TextAttributeKit(TextAttributeKit const & in_kit);
12749 
12753  TextAttributeKit(TextAttributeKit && in_that);
12754 
12758  TextAttributeKit & operator=(TextAttributeKit && in_that);
12759 
12761  virtual ~TextAttributeKit();
12762 
12763  HPS::Type ObjectType() const {return HPS::Type::TextAttributeKit;};
12764 
12768  static TextAttributeKit GetDefault();
12769 
12772  void Set(TextAttributeKit const & in_kit);
12773 
12776  void Show(TextAttributeKit & out_kit) const;
12777 
12781  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
12782 
12785  bool Empty() const;
12786 
12790  bool Equals(TextAttributeKit const & in_kit) const;
12791 
12795  bool operator==(TextAttributeKit const & in_kit) const;
12796 
12800  bool operator!=(TextAttributeKit const & in_kit) const;
12801 
12802 
12809 
12814  TextAttributeKit & SetBold(bool in_state);
12815 
12820  TextAttributeKit & SetItalic(bool in_state);
12821 
12825  TextAttributeKit & SetOverline(bool in_state);
12826 
12830  TextAttributeKit & SetStrikethrough(bool in_state);
12831 
12835  TextAttributeKit & SetUnderline(bool in_state);
12836 
12842  TextAttributeKit & SetSlant(float in_angle);
12843 
12848  TextAttributeKit & SetLineSpacing(float in_multiplier);
12849 
12854  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12855 
12860  TextAttributeKit & SetRotation(float in_angle);
12861 
12867  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12868 
12874  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12875 
12882  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12883 
12890 
12900  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12901 
12911  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
12912 
12917  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
12918 
12925  TextAttributeKit & SetFont(char const * in_name);
12926 
12930  TextAttributeKit & SetTransform(Text::Transform in_trans);
12931 
12935  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
12936 
12941  TextAttributeKit & SetPreference(Text::Preference in_pref);
12942 
12950  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
12951 
12956  TextAttributeKit & SetPath(Vector const & in_path);
12957 
12965  TextAttributeKit & SetSpacing(float in_multiplier);
12966 
12967 
12970  TextAttributeKit & UnsetAlignment();
12971 
12974  TextAttributeKit & UnsetBold();
12975 
12978  TextAttributeKit & UnsetItalic();
12979 
12982  TextAttributeKit & UnsetOverline();
12983 
12986  TextAttributeKit & UnsetStrikethrough();
12987 
12990  TextAttributeKit & UnsetUnderline();
12991 
12994  TextAttributeKit & UnsetSlant();
12995 
12998  TextAttributeKit & UnsetLineSpacing();
12999 
13002  TextAttributeKit & UnsetRotation();
13003 
13006  TextAttributeKit & UnsetExtraSpace();
13007 
13010  TextAttributeKit & UnsetGreeking();
13011 
13014  TextAttributeKit & UnsetSizeTolerance();
13015 
13018  TextAttributeKit & UnsetSize();
13019 
13022  TextAttributeKit & UnsetFont();
13023 
13026  TextAttributeKit & UnsetTransform();
13027 
13030  TextAttributeKit & UnsetRenderer();
13031 
13034  TextAttributeKit & UnsetPreference();
13035 
13038  TextAttributeKit & UnsetPath();
13039 
13042  TextAttributeKit & UnsetSpacing();
13043 
13046  TextAttributeKit & UnsetEverything();
13047 
13048 
13054  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13055 
13059  bool ShowBold(bool & out_state) const;
13060 
13064  bool ShowItalic(bool & out_state) const;
13065 
13069  bool ShowOverline(bool & out_state) const;
13070 
13074  bool ShowStrikethrough(bool & out_state) const;
13075 
13079  bool ShowUnderline(bool & out_state) const;
13080 
13084  bool ShowSlant(float & out_angle) const;
13085 
13089  bool ShowLineSpacing(float & out_multiplier) const;
13090 
13095  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13096 
13102  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13103 
13110  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13111 
13117  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13118 
13123  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13124 
13128  bool ShowFont(UTF8 & out_name) const;
13129 
13133  bool ShowTransform(Text::Transform & out_trans) const;
13134 
13138  bool ShowRenderer(Text::Renderer & out_rend) const;
13139 
13146  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13147 
13151  bool ShowPath(Vector & out_path) const;
13152 
13156  bool ShowSpacing(float & out_multiplier) const;
13157 };
13158 
13164 class HPS_API TextAttributeControl : public Control
13165 {
13166 public:
13167 
13169  explicit TextAttributeControl(SegmentKey & in_seg);
13170 
13172  TextAttributeControl(TextAttributeControl const & in_that);
13173 
13178 
13182  TextAttributeControl & operator=(TextAttributeControl && in_that);
13183 
13186 
13187  HPS::Type ObjectType() const {return HPS::Type::TextAttributeControl;};
13188 
13190  TextAttributeControl & operator=(TextAttributeControl const & in_that);
13191 
13192 
13199 
13204  TextAttributeControl & SetBold(bool in_state);
13205 
13210  TextAttributeControl & SetItalic(bool in_state);
13211 
13215  TextAttributeControl & SetOverline(bool in_state);
13216 
13220  TextAttributeControl & SetStrikethrough(bool in_state);
13221 
13225  TextAttributeControl & SetUnderline(bool in_state);
13226 
13232  TextAttributeControl & SetSlant(float in_angle);
13233 
13238  TextAttributeControl & SetLineSpacing(float in_multiplier);
13239 
13244  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13245 
13250  TextAttributeControl & SetRotation(float in_angle);
13251 
13257  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13258 
13264  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13265 
13272  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13273 
13280 
13290  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13291 
13301  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13302 
13307  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
13308 
13315  TextAttributeControl & SetFont(char const * in_name);
13316 
13320  TextAttributeControl & SetTransform(Text::Transform in_trans);
13321 
13325  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
13326 
13331  TextAttributeControl & SetPreference(Text::Preference in_pref);
13332 
13340  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13341 
13346  TextAttributeControl & SetPath(Vector const & in_path);
13347 
13355  TextAttributeControl & SetSpacing(float in_multiplier);
13356 
13357 
13360  TextAttributeControl & UnsetAlignment();
13361 
13364  TextAttributeControl & UnsetBold();
13365 
13368  TextAttributeControl & UnsetItalic();
13369 
13372  TextAttributeControl & UnsetOverline();
13373 
13376  TextAttributeControl & UnsetStrikethrough();
13377 
13380  TextAttributeControl & UnsetUnderline();
13381 
13384  TextAttributeControl & UnsetSlant();
13385 
13388  TextAttributeControl & UnsetLineSpacing();
13389 
13392  TextAttributeControl & UnsetRotation();
13393 
13396  TextAttributeControl & UnsetExtraSpace();
13397 
13400  TextAttributeControl & UnsetGreeking();
13401 
13404  TextAttributeControl & UnsetSizeTolerance();
13405 
13408  TextAttributeControl & UnsetSize();
13409 
13412  TextAttributeControl & UnsetFont();
13413 
13416  TextAttributeControl & UnsetTransform();
13417 
13420  TextAttributeControl & UnsetRenderer();
13421 
13424  TextAttributeControl & UnsetPreference();
13425 
13428  TextAttributeControl & UnsetPath();
13429 
13432  TextAttributeControl & UnsetSpacing();
13433 
13436  TextAttributeControl & UnsetEverything();
13437 
13438 
13444  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13445 
13449  bool ShowBold(bool & out_state) const;
13450 
13454  bool ShowItalic(bool & out_state) const;
13455 
13459  bool ShowOverline(bool & out_state) const;
13460 
13464  bool ShowStrikethrough(bool & out_state) const;
13465 
13469  bool ShowUnderline(bool & out_state) const;
13470 
13474  bool ShowSlant(float & out_angle) const;
13475 
13479  bool ShowLineSpacing(float & out_multiplier) const;
13480 
13485  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13486 
13492  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13493 
13500  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13501 
13507  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13508 
13513  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13514 
13518  bool ShowFont(UTF8 & out_name) const;
13519 
13523  bool ShowTransform(Text::Transform & out_trans) const;
13524 
13528  bool ShowRenderer(Text::Renderer & out_rend) const;
13529 
13536  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13537 
13541  bool ShowPath(Vector & out_path) const;
13542 
13546  bool ShowSpacing(float & out_multiplier) const;
13547 
13548 private:
13551 };
13552 
13553 
13554 
13555 
13556 
13558 class HPS_API LineAttributeKit : public Object
13559 {
13560 public:
13561 
13563  LineAttributeKit();
13564 
13567  LineAttributeKit(LineAttributeKit const & in_kit);
13568 
13572  LineAttributeKit(LineAttributeKit && in_that);
13573 
13577  LineAttributeKit & operator=(LineAttributeKit && in_that);
13578 
13580  virtual ~LineAttributeKit();
13581 
13582  HPS::Type ObjectType() const {return HPS::Type::LineAttributeKit;};
13583 
13587  static LineAttributeKit GetDefault();
13588 
13591  void Set(LineAttributeKit const & in_kit);
13592 
13595  void Show(LineAttributeKit & out_kit) const;
13596 
13600  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13601 
13604  bool Empty() const;
13605 
13609  bool Equals(LineAttributeKit const & in_kit) const;
13610 
13614  bool operator==(LineAttributeKit const & in_kit) const;
13615 
13619  bool operator!=(LineAttributeKit const & in_kit) const;
13620 
13621 
13625  LineAttributeKit & SetPattern(char const * in_name);
13626 
13631  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13632 
13637  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13638 
13639 
13642  LineAttributeKit & UnsetPattern();
13643 
13646  LineAttributeKit & UnsetWeight();
13647 
13650  LineAttributeKit & UnsetEverything();
13651 
13652 
13657  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13658 
13663  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13664 };
13665 
13671 class HPS_API LineAttributeControl : public Control
13672 {
13673 public:
13674 
13676  explicit LineAttributeControl(SegmentKey & in_seg);
13677 
13679  LineAttributeControl(LineAttributeControl const & in_that);
13680 
13685 
13689  LineAttributeControl & operator=(LineAttributeControl && in_that);
13690 
13693 
13694  HPS::Type ObjectType() const {return HPS::Type::LineAttributeControl;};
13695 
13697  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13698 
13699 
13703  LineAttributeControl & SetPattern(char const * in_pattern);
13704 
13709  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13710 
13715  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13716 
13717 
13720  LineAttributeControl & UnsetPattern();
13721 
13724  LineAttributeControl & UnsetWeight();
13725 
13728  LineAttributeControl & UnsetEverything();
13729 
13730 
13735  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13736 
13741  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13742 
13743 private:
13746 };
13747 
13748 
13749 
13751 class HPS_API EdgeAttributeKit : public Object
13752 {
13753 public:
13754 
13756  EdgeAttributeKit();
13757 
13760  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
13761 
13765  EdgeAttributeKit(EdgeAttributeKit && in_that);
13766 
13770  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
13771 
13773  virtual ~EdgeAttributeKit();
13774 
13775  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeKit;};
13776 
13780  static EdgeAttributeKit GetDefault();
13781 
13784  void Set(EdgeAttributeKit const & in_kit);
13785 
13788  void Show(EdgeAttributeKit & out_kit) const;
13789 
13793  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
13794 
13797  bool Empty() const;
13798 
13802  bool Equals(EdgeAttributeKit const & in_kit) const;
13803 
13807  bool operator==(EdgeAttributeKit const & in_kit) const;
13808 
13812  bool operator!=(EdgeAttributeKit const & in_kit) const;
13813 
13814 
13818  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
13819 
13824  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13825 
13826 
13829  EdgeAttributeKit & UnsetPattern();
13830 
13833  EdgeAttributeKit & UnsetWeight();
13834 
13837  EdgeAttributeKit & UnsetEverything();
13838 
13839 
13843  bool ShowPattern(UTF8 & out_pattern_name) const;
13844 
13849  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13850 };
13851 
13857 class HPS_API EdgeAttributeControl : public Control
13858 {
13859 public:
13860 
13862  explicit EdgeAttributeControl(SegmentKey & in_seg);
13863 
13865  EdgeAttributeControl(EdgeAttributeControl const & in_that);
13866 
13871 
13875  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
13876 
13879 
13880  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeControl;};
13881 
13883  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
13884 
13888  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
13889 
13894  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13895 
13896 
13899  EdgeAttributeControl & UnsetPattern();
13900 
13903  EdgeAttributeControl & UnsetWeight();
13904 
13907  EdgeAttributeControl & UnsetEverything();
13908 
13909 
13913  bool ShowPattern(UTF8 & out_pattern_name) const;
13914 
13919  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13920 
13921 private:
13924 };
13925 
13926 
13928 class HPS_API CurveAttributeKit : public Object
13929 {
13930 public:
13931 
13934 
13937  CurveAttributeKit(CurveAttributeKit const & in_kit);
13938 
13943 
13947  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
13948 
13950  virtual ~CurveAttributeKit();
13951 
13952  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeKit;};
13953 
13957  static CurveAttributeKit GetDefault();
13958 
13961  void Set(CurveAttributeKit const & in_kit);
13962 
13965  void Show(CurveAttributeKit & out_kit) const;
13966 
13970  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
13971 
13974  bool Empty() const;
13975 
13979  bool Equals(CurveAttributeKit const & in_kit) const;
13980 
13984  bool operator==(CurveAttributeKit const & in_kit) const;
13985 
13989  bool operator!=(CurveAttributeKit const & in_kit) const;
13990 
13991  //Set
13992  CurveAttributeKit & SetBudget(size_t in_budget);
13993 
14000  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14001 
14008  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
14009 
14010 
14017  CurveAttributeKit & SetViewDependent(bool in_state);
14018 
14022  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
14023 
14028  CurveAttributeKit & SetMaximumAngle(float in_degrees);
14029 
14034  CurveAttributeKit & SetMaximumLength(float in_length);
14035 
14036 
14039  CurveAttributeKit & UnsetBudget();
14040 
14043  CurveAttributeKit & UnsetContinuedBudget();
14044 
14047  CurveAttributeKit & UnsetViewDependent();
14048 
14051  CurveAttributeKit & UnsetMaximumDeviation();
14052 
14055  CurveAttributeKit & UnsetMaximumAngle();
14056 
14059  CurveAttributeKit & UnsetMaximumLength();
14060 
14063  CurveAttributeKit & UnsetEverything();
14064 
14065 
14069  bool ShowBudget(size_t & out_budget) const;
14070 
14075  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14076 
14080  bool ShowViewDependent(bool & out_state) const;
14081 
14086  bool ShowMaximumDeviation(float & out_deviation) const;
14087 
14092  bool ShowMaximumAngle(float & out_degrees) const;
14093 
14098  bool ShowMaximumLength(float & out_length) const;
14099 };
14100 
14101 
14105 class HPS_API CurveAttributeControl : public Control
14106 {
14107 public:
14108 
14110  explicit CurveAttributeControl(SegmentKey & in_seg);
14111 
14114 
14119 
14123  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
14124 
14127 
14128  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeControl;};
14129 
14131  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
14132 
14136  CurveAttributeControl & SetBudget(size_t in_budget);
14137 
14144  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14145 
14152  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
14153 
14160  CurveAttributeControl & SetViewDependent(bool in_state);
14161 
14165  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
14166 
14171  CurveAttributeControl & SetMaximumAngle(float in_degrees);
14172 
14177  CurveAttributeControl & SetMaximumLength(float in_length);
14178 
14179 
14182  CurveAttributeControl & UnsetBudget();
14183 
14186  CurveAttributeControl & UnsetContinuedBudget();
14187 
14190  CurveAttributeControl & UnsetViewDependent();
14191 
14194  CurveAttributeControl & UnsetMaximumDeviation();
14195 
14198  CurveAttributeControl & UnsetMaximumAngle();
14199 
14202  CurveAttributeControl & UnsetMaximumLength();
14203 
14206  CurveAttributeControl & UnsetEverything();
14207 
14208 
14212  bool ShowBudget(size_t & out_budget) const;
14213 
14218  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14219 
14223  bool ShowViewDependent(bool & out_state) const;
14224 
14229  bool ShowMaximumDeviation(float & out_deviation) const;
14230 
14235  bool ShowMaximumAngle(float & out_degrees) const;
14236 
14241  bool ShowMaximumLength(float & out_length) const;
14242 
14243 private:
14246 };
14247 
14248 
14249 
14250 
14252 class HPS_API MatrixKit : public Object
14253 {
14254 public:
14255 
14257  MatrixKit();
14258 
14261  MatrixKit(MatrixKit const & in_kit);
14262 
14266  MatrixKit(MatrixKit && in_that);
14267 
14271  MatrixKit & operator=(MatrixKit && in_that);
14272 
14276  MatrixKit(FloatArray const & in_matrix_source);
14277 
14281  MatrixKit(float const in_matrix_source []);
14282 
14285  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
14286 
14288  virtual ~MatrixKit();
14289 
14290  HPS::Type ObjectType() const {return HPS::Type::MatrixKit;};
14291 
14294  static MatrixKit GetDefault();
14295 
14298  void Set(MatrixKit const & in_kit);
14299 
14302  void Show(MatrixKit & out_kit) const;
14303 
14307  MatrixKit & operator=(MatrixKit const & in_kit);
14308 
14311  bool Empty() const;
14312 
14316  bool Equals(MatrixKit const & in_kit) const;
14317 
14321  bool operator==(MatrixKit const & in_kit) const;
14322 
14326  bool operator!=(MatrixKit const & in_kit) const;
14327 
14333  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
14334 
14339  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14340 
14344  MatrixKit & SetElements(FloatArray const & in_matrix);
14345 
14350  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
14351 
14352 
14355  MatrixKit & UnsetEverything();
14356 
14357 
14363  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14364 
14369  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14370 
14374  bool ShowElements(FloatArray & out_matrix) const;
14375 
14379  bool ShowDeterminant(float & out_determinant) const;
14380 
14384  bool ShowInverse(MatrixKit & out_matrix) const;
14385 
14390  bool ShowAdjoint(MatrixKit & out_matrix) const;
14391 
14392 
14398  MatrixKit & Rotate(float in_x, float in_y, float in_z);
14399 
14404  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
14405 
14411  MatrixKit & Translate(float in_x, float in_y, float in_z);
14412 
14418  MatrixKit & Scale(float in_x, float in_y, float in_z);
14419 
14423  MatrixKit & Concatenate(MatrixKit const & in_kit);
14424 
14427  MatrixKit & Normalize();
14428 
14431  MatrixKit & Invert();
14432 
14436  MatrixKit & Adjoint();
14437 
14438 
14442  MatrixKit Multiply(MatrixKit const & in_right) const;
14443 
14447  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14448 
14452  MatrixKit Multiply(float in_scalar) const;
14453 
14457  MatrixKit const & MultiplyAndAssign(float in_scalar);
14458 
14462  MatrixKit operator*(MatrixKit const & in_right) const;
14463 
14467  MatrixKit const & operator*=(MatrixKit const & in_right);
14468 
14472  MatrixKit operator*(float in_scalar) const;
14473 
14477  MatrixKit const & operator*=(float in_scalar);
14478 
14479 
14483  Point Transform(Point const & in_source) const;
14484 
14488  PointArray Transform(PointArray const & in_source) const;
14489 
14494  PointArray Transform(size_t in_count, Point const in_source []) const;
14495 
14499  Vector Transform(Vector const & in_source) const;
14500 
14504  VectorArray Transform(VectorArray const & in_source) const;
14505 
14510  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14511 
14515  Plane Transform(Plane const & in_source) const;
14516 
14520  PlaneArray Transform(PlaneArray const & in_source) const;
14521 
14526  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14527 };
14528 
14532 class HPS_API ModellingMatrixControl : public Control
14533 {
14534 public:
14535 
14537  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14538 
14540  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14541 
14544 
14549 
14553  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14554 
14557 
14558  HPS::Type ObjectType() const {return HPS::Type::ModellingMatrixControl;};
14559 
14561  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14562 
14568  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14569 
14574  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14575 
14579  ModellingMatrixControl & SetElements(FloatArray const & in_matrix);
14580 
14585  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14586 
14587 
14590  ModellingMatrixControl & UnsetEverything();
14591 
14592 
14598  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14599 
14604  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14605 
14609  bool ShowElements(FloatArray & out_matrix) const;
14610 
14614  bool ShowDeterminant(float & out_determinant) const;
14615 
14619  bool ShowInverse(MatrixKit & out_matrix) const;
14620 
14625  bool ShowAdjoint(MatrixKit & out_matrix) const;
14626 
14632  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14633 
14638  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14639 
14645  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14646 
14652  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14653 
14657  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14658 
14661  ModellingMatrixControl & Normalize();
14662 
14665  ModellingMatrixControl & Invert();
14666 
14670  ModellingMatrixControl & Adjoint();
14671 
14672 private:
14675 };
14676 
14679 class HPS_API TextureMatrixControl : public Control
14680 {
14681 public:
14682 
14684  explicit TextureMatrixControl(SegmentKey & in_seg);
14685 
14687  TextureMatrixControl(const TextureMatrixControl & in_that);
14688 
14693 
14697  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
14698 
14701 
14702  HPS::Type ObjectType() const {return HPS::Type::TextureMatrixControl;};
14703 
14705  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
14706 
14707 
14713  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14714 
14719  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14720 
14724  TextureMatrixControl & SetElements(FloatArray const & in_matrix);
14725 
14730  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14731 
14732 
14735  TextureMatrixControl & UnsetEverything();
14736 
14737 
14743  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14744 
14749  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14750 
14754  bool ShowElements(FloatArray & out_matrix) const;
14755 
14759  bool ShowDeterminant(float & out_determinant) const;
14760 
14764  bool ShowInverse(MatrixKit & out_matrix) const;
14765 
14770  bool ShowAdjoint(MatrixKit & out_matrix) const;
14771 
14777  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
14778 
14783  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14784 
14790  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
14791 
14797  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
14798 
14802  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
14803 
14806  TextureMatrixControl & Normalize();
14807 
14810  TextureMatrixControl & Invert();
14811 
14815  TextureMatrixControl & Adjoint();
14816 
14817 private:
14820 };
14821 
14822 
14825 class HPS_API MaterialMappingKit : public Object
14826 {
14827 public:
14828 
14831 
14834  MaterialMappingKit(MaterialMappingKit const & in_kit);
14835 
14840 
14844  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
14845 
14847  ~MaterialMappingKit();
14848 
14849  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingKit;};
14850 
14854  static MaterialMappingKit GetDefault();
14855 
14858  void Set(MaterialMappingKit const & in_kit);
14859 
14862  void Show(MaterialMappingKit & out_kit) const;
14863 
14867  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
14868 
14871  bool Empty() const;
14872 
14876  bool Equals(MaterialMappingKit const & in_kit) const;
14877 
14881  bool operator==(MaterialMappingKit const & in_kit) const;
14882 
14886  bool operator!=(MaterialMappingKit const & in_kit) const;
14887 
14888  //Set
14889 
14893  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
14894 
14900  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
14901 
14902 
14906  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
14907 
14913  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
14914 
14920  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14921 
14926  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
14927 
14934  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14935 
14944  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);
14945 
14949  MaterialMappingKit & SetBackFaceGloss(float in_value);
14950 
14954  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
14955 
14960  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
14961 
14967  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14968 
14973  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
14974 
14981  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14982 
14991  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);
14992 
14996  MaterialMappingKit & SetFrontFaceGloss(float in_value);
14997 
15001  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
15002 
15007  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
15008 
15009 
15013  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15014 
15020  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
15021 
15027  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15028 
15033  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
15034 
15041  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15042 
15051  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);
15052 
15056  MaterialMappingKit & SetCutFaceGloss(float in_value);
15057 
15061  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
15062 
15067  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
15068 
15073  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
15074 
15080  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15081 
15088  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15089 
15098  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);
15099 
15103  MaterialMappingKit & SetEdgeGloss(float in_value);
15104 
15108  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
15109 
15114  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
15115 
15120  MaterialMappingKit & SetFaceAlpha(float in_alpha);
15121 
15127  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15128 
15135  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15136 
15145  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);
15146 
15150  MaterialMappingKit & SetFaceGloss(float in_value);
15151 
15155  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
15156 
15161  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
15162 
15166  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
15167 
15168 
15169 
15170 
15171 
15175  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
15176 
15182  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
15183 
15184 
15188  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
15189 
15195  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
15196 
15197 
15201  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
15202 
15208  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
15209 
15210 
15214  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
15215 
15221  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
15222 
15227  MaterialMappingKit & SetVertexAlpha(float in_alpha);
15228 
15234  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15235 
15242  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15243 
15252  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);
15253 
15257  MaterialMappingKit & SetVertexGloss(float in_value);
15258 
15262  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
15263 
15268  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
15269 
15273  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
15274 
15275 
15279  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
15280 
15286  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
15287 
15288 
15292  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15293 
15299  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
15300 
15301  //Aggregate Sets
15302 
15306  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15307 
15312  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
15313 
15314 
15318  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15319 
15325  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
15326 
15327 
15328  //Unset
15329 
15332  MaterialMappingKit & UnsetAmbientLightUpColor();
15333 
15334 
15337  MaterialMappingKit & UnsetAmbientLightDownColor();
15338 
15339 
15342  MaterialMappingKit & UnsetBackFaceMaterial();
15343 
15346  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
15347 
15350  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15351 
15354  MaterialMappingKit & UnsetFrontFaceMaterial();
15355 
15358  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
15359 
15362  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15363 
15364 
15365 
15368  MaterialMappingKit & UnsetCutEdgeColor();
15369 
15370 
15373  MaterialMappingKit & UnsetCutFaceMaterial();
15374 
15377  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
15378 
15381  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15382 
15383 
15386  MaterialMappingKit & UnsetEdgeMaterial();
15387 
15390  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
15391 
15394  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15395 
15396 
15399  MaterialMappingKit & UnsetFaceMaterial();
15400 
15403  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
15404 
15407  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15408 
15409 
15412  MaterialMappingKit & UnsetLightColor();
15413 
15414 
15417  MaterialMappingKit & UnsetLineColor();
15418 
15419 
15422  MaterialMappingKit & UnsetMarkerColor();
15423 
15424 
15427  MaterialMappingKit & UnsetTextColor();
15428 
15429 
15432  MaterialMappingKit & UnsetVertexMaterial();
15433 
15436  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15437 
15440  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15441 
15442 
15445  MaterialMappingKit & UnsetWindowColor();
15446 
15447 
15450  MaterialMappingKit & UnsetWindowContrastColor();
15451 
15452 
15453  //Aggregate Unsets
15454 
15457  MaterialMappingKit & UnsetCutGeometryColor();
15458 
15461  MaterialMappingKit & UnsetAmbientLightColor();
15462 
15465  MaterialMappingKit & UnsetEverything();
15466 
15467 
15468  //Show
15469 
15475  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15476 
15482  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15483 
15484 
15492  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15493 
15502  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;
15503 
15509  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15510 
15511 
15519  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15520 
15529  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;
15530 
15536  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15537 
15538 
15539 
15545  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15546 
15547 
15555  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15556 
15565  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;
15566 
15572  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15573 
15574 
15582  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15583 
15592  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;
15593 
15599  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15600 
15601 
15609  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15610 
15619  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;
15620 
15626  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15627 
15628 
15634  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15635 
15636 
15642  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15643 
15644 
15650  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15651 
15652 
15658  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15659 
15660 
15668  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15669 
15678  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;
15679 
15685  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15686 
15687 
15693  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15694 
15695 
15701  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15702 };
15703 
15704 
15710 class HPS_API MaterialMappingControl : public Control
15711 {
15712 public:
15713 
15715  explicit MaterialMappingControl(SegmentKey & in_seg);
15716 
15719 
15724 
15728  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
15729 
15732 
15733  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingControl;};
15734 
15736  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
15737 
15738  //Set
15739 
15743  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15744 
15750  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
15751 
15752 
15756  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15757 
15763  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
15764 
15769  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
15770 
15776  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15777 
15784  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15785 
15794  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);
15795 
15799  MaterialMappingControl & SetBackFaceGloss(float in_value);
15800 
15804  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
15805 
15810  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
15811 
15812 
15817  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
15818 
15824  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15825 
15832  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15833 
15842  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);
15843 
15847  MaterialMappingControl & SetFrontFaceGloss(float in_value);
15848 
15852  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
15853 
15858  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
15859 
15860 
15864  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15865 
15871  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
15872 
15877  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
15878 
15884  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15885 
15892  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15893 
15902  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);
15903 
15907  MaterialMappingControl & SetCutFaceGloss(float in_value);
15908 
15912  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
15913 
15918  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
15919 
15924  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
15925 
15931  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15932 
15939  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15940 
15949  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);
15950 
15954  MaterialMappingControl & SetEdgeGloss(float in_value);
15955 
15959  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
15960 
15965  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
15966 
15972  MaterialMappingControl & SetFaceAlpha(float in_alpha);
15973 
15980  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15981 
15988  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15989 
15998  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);
15999 
16003  MaterialMappingControl & SetFaceGloss(float in_value);
16004 
16008  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
16009 
16014  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
16015 
16019  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
16020 
16021 
16025  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
16026 
16032  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
16033 
16034 
16038  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
16039 
16045  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
16046 
16047 
16051  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
16052 
16058  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
16059 
16060 
16064  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
16065 
16071  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
16072 
16073 
16078  MaterialMappingControl & SetVertexAlpha(float in_alpha);
16079 
16080 
16086  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16087 
16094  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16095 
16104  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);
16105 
16109  MaterialMappingControl & SetVertexGloss(float in_value);
16110 
16114  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
16115 
16120  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
16121 
16125  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
16126 
16127 
16131  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
16132 
16138  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
16139 
16140 
16144  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16145 
16151  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
16152 
16153  //Aggregate Sets
16154 
16158  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16159 
16164  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
16165 
16166 
16170  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16171 
16177  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
16178 
16179 
16180  //Unset
16181 
16184  MaterialMappingControl & UnsetAmbientLightUpColor();
16185 
16186 
16189  MaterialMappingControl & UnsetAmbientLightDownColor();
16190 
16191 
16194  MaterialMappingControl & UnsetFrontFaceMaterial();
16195 
16198  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
16199 
16202  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16203 
16204 
16207  MaterialMappingControl & UnsetBackFaceMaterial();
16208 
16211  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
16212 
16215  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16216 
16217 
16220  MaterialMappingControl & UnsetCutEdgeColor();
16221 
16222 
16225  MaterialMappingControl & UnsetCutFaceMaterial();
16226 
16229  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
16230 
16233  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16234 
16235 
16238  MaterialMappingControl & UnsetEdgeMaterial();
16239 
16242  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
16243 
16246  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
16247 
16248 
16251  MaterialMappingControl & UnsetFaceMaterial();
16252 
16255  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
16256 
16259  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
16260 
16261 
16264  MaterialMappingControl & UnsetLightColor();
16265 
16266 
16269  MaterialMappingControl & UnsetLineColor();
16270 
16271 
16274  MaterialMappingControl & UnsetMarkerColor();
16275 
16276 
16279  MaterialMappingControl & UnsetTextColor();
16280 
16281 
16284  MaterialMappingControl & UnsetVertexMaterial();
16285 
16288  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
16289 
16292  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
16293 
16294 
16297  MaterialMappingControl & UnsetWindowColor();
16298 
16299 
16302  MaterialMappingControl & UnsetWindowContrastColor();
16303 
16304 
16305  //Aggregate Unsets
16306 
16309  MaterialMappingControl & UnsetCutGeometryColor();
16310 
16313  MaterialMappingControl & UnsetAmbientLightColor();
16314 
16317  MaterialMappingControl & UnsetEverything();
16318 
16319 
16320  //Show
16321 
16327  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16328 
16329 
16335  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16336 
16337 
16345  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16346 
16355  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;
16356 
16362  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16363 
16364 
16372  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16373 
16382  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;
16383 
16389  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16390 
16391 
16397  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16398 
16399 
16407  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16408 
16417  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;
16418 
16424  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16425 
16426 
16434  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16435 
16444  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;
16445 
16451  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16452 
16453 
16461  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16462 
16471  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;
16472 
16478  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16479 
16480 
16486  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16487 
16488 
16494  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16495 
16496 
16502  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16503 
16504 
16510  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16511 
16512 
16520  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16521 
16530  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;
16531 
16537  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16538 
16539 
16545  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16546 
16547 
16553  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16554 
16555 private:
16557 };
16558 
16559 
16562 class HPS_API PortfolioControl : public Control
16563 {
16564 public:
16566  explicit PortfolioControl(SegmentKey & in_seg);
16567 
16569  PortfolioControl(PortfolioControl const & in_that);
16570 
16574  PortfolioControl(PortfolioControl && in_that);
16575 
16579  PortfolioControl & operator=(PortfolioControl && in_that);
16580 
16582  ~PortfolioControl();
16583 
16584  HPS::Type ObjectType() const { return HPS::Type::PortfolioControl; };
16585 
16587  PortfolioControl & operator=(PortfolioControl const & in_that);
16588 
16590  size_t GetCount() const;
16591 
16592 
16597  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16598 
16601  bool Pop();
16602 
16606  bool Pop(PortfolioKey & out_portfolio);
16607 
16608 
16612  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16613 
16617  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16618 
16623  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16624 
16625 
16628  PortfolioControl & UnsetTop();
16629 
16632  PortfolioControl & UnsetEverything();
16633 
16634 
16638  bool ShowTop(PortfolioKey & out_portfolio) const;
16639 
16643  bool Show(PortfolioKeyArray & out_portfolios) const;
16644 
16645 private:
16646  PortfolioControl();
16647 };
16648 
16649 
16650 
16653 class HPS_API StyleControl : public Control
16654 {
16655 public:
16657  explicit StyleControl(SegmentKey & in_seg);
16658 
16660  StyleControl(StyleControl const & in_that);
16661 
16665  StyleControl(StyleControl && in_that);
16666 
16670  StyleControl & operator=(StyleControl && in_that);
16671 
16673  ~StyleControl();
16674 
16675  HPS::Type ObjectType() const { return HPS::Type::StyleControl; };
16676 
16678  StyleControl & operator=(StyleControl const & in_that);
16679 
16681  size_t GetCount() const;
16682 
16683 
16685  StyleKey PushNamed(char const * in_style_name);
16686 
16688  StyleKey PushNamed(char const * in_style_name, Condition const & in_condition);
16689 
16691  StyleKey AppendNamed(char const * in_style_name, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16692 
16696  StyleKey PushSegment(SegmentKey const & in_style_source);
16697 
16701  StyleKey PushSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16702 
16705  StyleKey AppendSegment(SegmentKey const & in_style_source, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16706 
16707 
16708 
16711  bool Pop();
16712 
16719  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition);
16720 
16724  void Flush(SegmentKey const & in_style_source);
16725 
16732  void Flush(SegmentKey const & in_style_source, Condition const & in_condition);
16733 
16737  void Flush(char const * in_style_name);
16738 
16745  void Flush(char const * in_style_name, Condition const & in_condition);
16746 
16747 
16750  StyleKey SetNamed(char const * in_style_name);
16751 
16755  StyleKey SetNamed(char const * in_style_name, Condition const & in_condition);
16756 
16757 
16760  StyleKey SetSegment(SegmentKey const & in_style_source);
16761 
16765  StyleKey SetSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16766 
16767 
16773  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionArray const & in_conditions);
16774 
16779  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
16780 
16787  void Set(size_t in_count, Style::Type const in_types[], SegmentKey const in_segment_sources[], UTF8 const in_style_names[], Condition const in_conditions[]);
16788 
16789 
16790 
16792  void UnsetTop();
16793 
16795  void UnsetAllSegment();
16796 
16798  void UnsetAllNamed();
16799 
16801  void UnsetEverything();
16802 
16803 
16810  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition) const;
16811 
16815  bool ShowTop(StyleKey & out_style) const;
16816 
16823  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions) const;
16824 
16828  bool Show(StyleKeyArray & out_styles) const;
16829 
16834  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions) const;
16835 
16839  bool ShowAllSegment(StyleKeyArray & out_styles) const;
16840 
16845  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions) const;
16846 
16850  bool ShowAllNamed(StyleKeyArray & out_styles) const;
16851 
16852 private:
16853  StyleControl();
16854 };
16855 
16856 
16859 class HPS_API ConditionControl : public Control
16860 {
16861 public:
16863  explicit ConditionControl(SegmentKey & in_seg);
16864 
16866  ConditionControl(ConditionControl const & in_that);
16867 
16871  ConditionControl(ConditionControl && in_that);
16872 
16876  ConditionControl & operator=(ConditionControl && in_that);
16877 
16879  ~ConditionControl();
16880 
16881 
16882  HPS::Type ObjectType() const { return HPS::Type::ConditionControl; };
16883 
16885  ConditionControl & operator=(ConditionControl const & in_that);
16886 
16889  size_t GetCount() const;
16890 
16894  ConditionControl & AddCondition(char const * in_condition);
16895 
16896 
16900  ConditionControl & SetCondition(char const * in_condition);
16901 
16905  ConditionControl & SetConditions(UTF8Array const & in_conditions);
16906 
16911  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
16912 
16913 
16917  ConditionControl & UnsetCondition(char const * in_condition);
16918 
16921  ConditionControl & UnsetEverything();
16922 
16923 
16927  bool ShowCondition(char const * in_condition) const;
16928 
16932  bool ShowConditions(UTF8Array & out_conditions) const;
16933 
16934 private:
16936  ConditionControl();
16937 };
16938 
16939 
16942 class HPS_API MaterialKit : public Object
16943 {
16944 public:
16945 
16947  MaterialKit();
16948 
16951  MaterialKit(MaterialKit const & in_kit);
16952 
16956  MaterialKit(MaterialKit && in_that);
16957 
16961  MaterialKit & operator=(MaterialKit && in_that);
16962 
16964  ~MaterialKit();
16965 
16966  HPS::Type ObjectType() const {return HPS::Type::MaterialKit;};
16967 
16970  void Set(MaterialKit const & in_kit);
16971 
16974  void Show(MaterialKit & out_kit) const;
16975 
16979  MaterialKit & operator=(MaterialKit const & in_kit);
16980 
16983  bool Empty() const;
16984 
16988  bool Equals(MaterialKit const & in_kit) const;
16989 
16993  bool operator==(MaterialKit const & in_kit) const;
16994 
16998  bool operator!=(MaterialKit const & in_kit) const;
16999 
17000 
17001  //Set
17002 
17006  MaterialKit & SetDiffuse(RGBColor const & in_color);
17007 
17011  MaterialKit & SetDiffuse(RGBAColor const & in_color);
17012 
17016  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
17017 
17021  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
17022 
17027  MaterialKit & SetDiffuseAlpha(float in_alpha);
17028 
17035  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
17036 
17044  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
17045 
17050  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
17051 
17057  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
17058 
17065  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
17066 
17074  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
17075 
17076 
17080  MaterialKit & SetShader(char const * in_shader_name);
17081 
17082 
17083 
17087  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
17088 
17092  MaterialKit & SetSpecular(char const * in_texture_name);
17093 
17098  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
17099 
17100 
17101 
17105  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
17106 
17110  MaterialKit & SetMirror(char const * in_texture_name);
17111 
17116  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
17117 
17118 
17119 
17123  MaterialKit & SetTransmission(char const * in_texture_name);
17124 
17129  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17130 
17131 
17132 
17136  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
17137 
17141  MaterialKit & SetEmission(char const * in_texture_name);
17142 
17147  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17148 
17149 
17150 
17154  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
17155 
17160  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
17161 
17165  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
17166 
17171  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
17172 
17175  MaterialKit & SetEnvironmentTexture();
17176 
17177 
17181  MaterialKit & SetBump(char const * in_texture_name);
17182 
17183 
17184 
17191  MaterialKit & SetGloss(float in_gloss);
17192 
17195  MaterialKit & UnsetDiffuseColorRGB();
17196 
17199  MaterialKit & UnsetDiffuseColor();
17200 
17203  MaterialKit & UnsetDiffuseAlpha();
17204 
17207  MaterialKit & UnsetDiffuseTexture();
17208 
17212  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
17213 
17216  MaterialKit & UnsetShader();
17217 
17220  MaterialKit & UnsetSpecular();
17221 
17224  MaterialKit & UnsetMirror();
17225 
17228  MaterialKit & UnsetTransmission();
17229 
17232  MaterialKit & UnsetEmission();
17233 
17236  MaterialKit & UnsetEnvironment();
17237 
17240  MaterialKit & UnsetBump();
17241 
17244  MaterialKit & UnsetGloss();
17245 
17248  MaterialKit & UnsetEverything();
17249 
17250 
17253  bool ShowDiffuse() const;
17254 
17258  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
17259 
17263  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
17264 
17268  bool ShowDiffuseAlpha(float & out_alpha) const;
17269 
17276  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17277 
17285  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17286 
17293  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
17294 
17298  bool ShowShader(UTF8 & out_shader_name) const;
17299 
17308  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17309 
17318  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17319 
17320 
17321 
17330  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17331 
17332 
17341  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17342 
17343 
17352  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17353 
17354 
17358  bool ShowBump(UTF8 & out_texture_name) const;
17359 
17364  bool ShowGloss(float & out_gloss) const;
17365 };
17366 
17367 
17369 class HPS_API NURBSSurfaceAttributeKit : public Object
17370 {
17371 public:
17372 
17375 
17379 
17384 
17388  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
17389 
17391  virtual ~NURBSSurfaceAttributeKit();
17392 
17393  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeKit;};
17394 
17398  static NURBSSurfaceAttributeKit GetDefault();
17399 
17402  void Set(NURBSSurfaceAttributeKit const & in_kit);
17403 
17406  void Show(NURBSSurfaceAttributeKit & out_kit) const;
17407 
17411  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17412 
17415  bool Empty() const;
17416 
17420  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17421 
17425  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17426 
17430  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17431 
17432 
17436  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17437 
17442  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17443 
17447  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17448 
17452  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17453 
17457  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17458 
17463  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17464 
17465 
17468  NURBSSurfaceAttributeKit & UnsetBudget();
17469 
17472  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17473 
17476  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17477 
17480  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17481 
17484  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17485 
17488  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17489 
17492  NURBSSurfaceAttributeKit & UnsetEverything();
17493 
17497  bool ShowBudget(size_t & out_budget) const;
17498 
17502  bool ShowMaximumDeviation(float & out_deviation) const;
17503 
17507  bool ShowMaximumAngle(float & out_degrees) const;
17508 
17512  bool ShowMaximumWidth(float & out_width) const;
17513 
17517  bool ShowTrimBudget(size_t & out_budget) const;
17518 
17522  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17523 };
17524 
17531 {
17532 public:
17533 
17535  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17536 
17539 
17544 
17549 
17552 
17553  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeControl;};
17554 
17556  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17557 
17561  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17562 
17567  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17568 
17572  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17573 
17577  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17578 
17582  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17583 
17588  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17589 
17590 
17593  NURBSSurfaceAttributeControl & UnsetBudget();
17594 
17597  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17598 
17601  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17602 
17605  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17606 
17609  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17610 
17613  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17614 
17617  NURBSSurfaceAttributeControl & UnsetEverything();
17618 
17619 
17623  bool ShowBudget(size_t & out_budget) const;
17624 
17628  bool ShowMaximumDeviation(float & out_deviation) const;
17629 
17633  bool ShowMaximumAngle(float & out_degrees) const;
17634 
17638  bool ShowMaximumWidth(float & out_width) const;
17639 
17643  bool ShowTrimBudget(size_t & out_budget) const;
17644 
17648  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17649 
17650 private:
17653 };
17654 
17655 
17656 
17658 class HPS_API PerformanceKit : public Object
17659 {
17660 public:
17661 
17663  PerformanceKit();
17664 
17667  PerformanceKit(PerformanceKit const & in_kit);
17668 
17672  PerformanceKit(PerformanceKit && in_that);
17673 
17677  PerformanceKit & operator=(PerformanceKit && in_that);
17678 
17680  virtual ~PerformanceKit();
17681 
17682  HPS::Type ObjectType() const {return HPS::Type::PerformanceKit;};
17683 
17687  static PerformanceKit GetDefault();
17688 
17691  void Set(PerformanceKit const & in_kit);
17692 
17695  void Show(PerformanceKit & out_kit) const;
17696 
17700  PerformanceKit & operator=(PerformanceKit const & in_kit);
17701 
17704  bool Empty() const;
17705 
17709  bool Equals(PerformanceKit const & in_kit) const;
17710 
17714  bool operator==(PerformanceKit const & in_kit) const;
17715 
17719  bool operator!=(PerformanceKit const & in_kit) const;
17720 
17721 
17726 
17731  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
17732 
17733 
17736  PerformanceKit & UnsetDisplayLists();
17737 
17740  PerformanceKit & UnsetStaticModel();
17741 
17744  PerformanceKit & UnsetEverything();
17745 
17749  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17750 
17754  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17755 };
17756 
17757 
17763 class HPS_API PerformanceControl : public Control
17764 {
17765 public:
17766 
17768  explicit PerformanceControl(SegmentKey & in_seg);
17769 
17771  PerformanceControl(PerformanceControl const & in_that);
17772 
17777 
17781  PerformanceControl & operator=(PerformanceControl && in_that);
17782 
17784  ~PerformanceControl();
17785 
17786  HPS::Type ObjectType() const {return HPS::Type::PerformanceControl;};
17787 
17789  PerformanceControl & operator=(PerformanceControl const & in_that);
17790 
17791 
17796 
17801  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
17802 
17803 
17806  PerformanceControl & UnsetDisplayLists();
17807 
17810  PerformanceControl & UnsetStaticModel();
17811 
17814  PerformanceControl & UnsetEverything();
17815 
17816 
17820  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17821 
17825  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17826 
17827 private:
17830 };
17831 
17832 
17833 
17835 class HPS_API HiddenLineAttributeKit : public Object
17836 {
17837 public:
17838 
17841 
17845 
17850 
17854  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
17855 
17857  virtual ~HiddenLineAttributeKit();
17858 
17859  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeKit;};
17860 
17864  static HiddenLineAttributeKit GetDefault();
17865 
17868  void Set(HiddenLineAttributeKit const & in_kit);
17869 
17872  void Show(HiddenLineAttributeKit & out_kit) const;
17873 
17877  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
17878 
17881  bool Empty() const;
17882 
17886  bool Equals(HiddenLineAttributeKit const & in_kit) const;
17887 
17891  bool operator==(HiddenLineAttributeKit const & in_kit) const;
17892 
17896  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
17897 
17898 
17902  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
17903 
17909  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
17910 
17920  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
17921 
17925  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
17926 
17930  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
17931 
17935  HiddenLineAttributeKit & SetRenderText(bool in_state);
17936 
17941  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
17942 
17948  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
17949 
17953  HiddenLineAttributeKit & SetVisibility(bool in_state);
17954 
17959  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
17960 
17966  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
17967 
17968 
17971  HiddenLineAttributeKit & UnsetColor();
17972 
17975  HiddenLineAttributeKit & UnsetDimFactor();
17976 
17979  HiddenLineAttributeKit & UnsetFaceDisplacement();
17980 
17983  HiddenLineAttributeKit & UnsetLinePattern();
17984 
17987  HiddenLineAttributeKit & UnsetRenderFaces();
17988 
17991  HiddenLineAttributeKit & UnsetRenderText();
17992 
17995  HiddenLineAttributeKit & UnsetAlgorithm();
17996 
17999  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
18000 
18003  HiddenLineAttributeKit & UnsetVisibility();
18004 
18007  HiddenLineAttributeKit & UnsetWeight();
18008 
18011  HiddenLineAttributeKit & UnsetTransparencyCutoff();
18012 
18015  HiddenLineAttributeKit & UnsetEverything();
18016 
18017 
18021  bool ShowColor(RGBAColor & out_color) const;
18022 
18026  bool ShowDimFactor(float & out_zero_to_one) const;
18027 
18031  bool ShowFaceDisplacement(float & out_buckets) const;
18032 
18036  bool ShowLinePattern(UTF8 & out_pattern) const;
18037 
18041  bool ShowRenderFaces(bool & out_state) const;
18042 
18046  bool ShowRenderText(bool & out_state) const;
18047 
18051  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18052 
18056  bool ShowSilhouetteCleanup(bool & out_state) const;
18057 
18061  bool ShowVisibility(bool & out_state) const;
18062 
18067  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18068 
18072  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18073 };
18074 
18075 
18081 class HPS_API HiddenLineAttributeControl : public Control
18082 {
18083 public:
18084 
18086  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
18087 
18090 
18095 
18100 
18103 
18104  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeControl;};
18105 
18107  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
18108 
18112  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
18113 
18119  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
18120 
18130  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
18131 
18135  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
18136 
18140  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
18141 
18145  HiddenLineAttributeControl & SetRenderText(bool in_state);
18146 
18151  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18152 
18158  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
18159 
18163  HiddenLineAttributeControl & SetVisibility(bool in_state);
18164 
18169  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18170 
18176  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
18177 
18178 
18181  HiddenLineAttributeControl & UnsetColor();
18182 
18185  HiddenLineAttributeControl & UnsetDimFactor();
18186 
18189  HiddenLineAttributeControl & UnsetFaceDisplacement();
18190 
18193  HiddenLineAttributeControl & UnsetLinePattern();
18194 
18197  HiddenLineAttributeControl & UnsetRenderFaces();
18198 
18201  HiddenLineAttributeControl & UnsetRenderText();
18202 
18205  HiddenLineAttributeControl & UnsetAlgorithm();
18206 
18209  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
18210 
18213  HiddenLineAttributeControl & UnsetVisibility();
18214 
18217  HiddenLineAttributeControl & UnsetWeight();
18218 
18221  HiddenLineAttributeControl & UnsetTransparencyCutoff();
18222 
18225  HiddenLineAttributeControl & UnsetEverything();
18226 
18227 
18231  bool ShowColor(RGBAColor & out_color) const;
18232 
18236  bool ShowDimFactor(float & out_zero_to_one) const;
18237 
18241  bool ShowFaceDisplacement(float & out_buckets) const;
18242 
18246  bool ShowLinePattern(UTF8 & out_pattern) const;
18247 
18251  bool ShowRenderFaces(bool & out_state) const;
18252 
18256  bool ShowRenderText(bool & out_state) const;
18257 
18261  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18262 
18266  bool ShowSilhouetteCleanup(bool & out_state) const;
18267 
18271  bool ShowVisibility(bool & out_state) const;
18272 
18277  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18278 
18282  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18283 
18284 private:
18287 };
18288 
18289 
18290 
18292 class HPS_API DrawingAttributeKit : public Object
18293 {
18294 public:
18295 
18298 
18301  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
18302 
18307 
18311  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
18312 
18314  virtual ~DrawingAttributeKit();
18315 
18316  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeKit;};
18317 
18321  static DrawingAttributeKit GetDefault();
18322 
18325  void Set(DrawingAttributeKit const & in_kit);
18326 
18329  void Show(DrawingAttributeKit & out_kit) const;
18330 
18334  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
18335 
18338  bool Empty() const;
18339 
18343  bool Equals(DrawingAttributeKit const & in_kit) const;
18344 
18348  bool operator==(DrawingAttributeKit const & in_kit) const;
18349 
18353  bool operator!=(DrawingAttributeKit const & in_kit) const;
18354 
18370  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
18371 
18377  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
18378 
18391  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
18392 
18399  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
18400 
18405  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
18406 
18413  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18414 
18419  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18420 
18427  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18428 
18433  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18434 
18438  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18439 
18444  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18445 
18451  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18452 
18459  DrawingAttributeKit & SetClipRegion(size_t in_number_of_points, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18460 
18466  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18467 
18470  DrawingAttributeKit & UnsetPolygonHandedness();
18471 
18474  DrawingAttributeKit & UnsetWorldHandedness();
18475 
18478  DrawingAttributeKit & UnsetDepthRange();
18479 
18482  DrawingAttributeKit & UnsetFaceDisplacement();
18483 
18486  DrawingAttributeKit & UnsetGeneralDisplacement();
18487 
18490  DrawingAttributeKit & UnsetVertexDisplacement();
18491 
18494  DrawingAttributeKit & UnsetOverlay();
18495 
18498  DrawingAttributeKit & UnsetDeferral();
18499 
18502  DrawingAttributeKit & UnsetClipRegion();
18503 
18506  DrawingAttributeKit & UnsetEverything();
18507 
18511  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18512 
18516  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18517 
18522  bool ShowDepthRange(float & out_near, float & out_far) const;
18523 
18528  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18529 
18534  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18535 
18540  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18541 
18545  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18546 
18550  bool ShowDeferral(int & out_defer_batch) const;
18551 
18557  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18558 
18559 };
18560 
18561 
18573 class HPS_API DrawingAttributeControl : public Control
18574 {
18575 public:
18576 
18578  explicit DrawingAttributeControl(SegmentKey & in_seg);
18579 
18582 
18587 
18591  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18592 
18595 
18596  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeControl;};
18597 
18599  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18600 
18610  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18611 
18617  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18618 
18631  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18632 
18639  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18640 
18645  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18646 
18653  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18654 
18659  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
18660 
18667  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
18668 
18673  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
18674 
18678  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
18679 
18685  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18686 
18693  DrawingAttributeControl & SetClipRegion(size_t in_number_of_points, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18694 
18700  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18701 
18706  DrawingAttributeControl & SetDeferral(int in_deferral);
18709  DrawingAttributeControl & UnsetPolygonHandedness();
18710 
18713  DrawingAttributeControl & UnsetWorldHandedness();
18714 
18717  DrawingAttributeControl & UnsetDepthRange();
18718 
18721  DrawingAttributeControl & UnsetFaceDisplacement();
18722 
18725  DrawingAttributeControl & UnsetGeneralDisplacement();
18726 
18729  DrawingAttributeControl & UnsetVertexDisplacement();
18730 
18733  DrawingAttributeControl & UnsetOverlay();
18734 
18737  DrawingAttributeControl & UnsetDeferral();
18738 
18741  DrawingAttributeControl & UnsetClipRegion();
18742 
18745  DrawingAttributeControl & UnsetEverything();
18746 
18747 
18751  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18752 
18756  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18757 
18762  bool ShowDepthRange(float & out_x, float & out_y) const;
18763 
18768  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18769 
18774  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18775 
18780  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18781 
18785  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18786 
18790  bool ShowDeferral(int & out_defer_batch) const;
18791 
18797  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation);
18798 
18799 private:
18802 };
18803 
18804 
18806 class HPS_API PostProcessEffectsKit : public Object
18807 {
18808 public:
18809 
18812 
18816 
18821 
18825  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
18826 
18828  virtual ~PostProcessEffectsKit();
18829 
18830  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsKit;};
18831 
18835  static PostProcessEffectsKit GetDefault();
18836 
18839  void Set(PostProcessEffectsKit const & in_kit);
18840 
18843  void Show(PostProcessEffectsKit & out_kit) const;
18844 
18848  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
18849 
18852  bool Empty() const;
18853 
18857  bool Equals(PostProcessEffectsKit const & in_kit) const;
18858 
18862  bool operator==(PostProcessEffectsKit const & in_kit) const;
18863 
18867  bool operator!=(PostProcessEffectsKit const & in_kit) const;
18868 
18869 
18877  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18878 
18885  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18886 
18893  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18894 
18900  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
18901 
18908  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
18909 
18915  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
18916 
18924  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
18925 
18932  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
18933 
18941  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
18942 
18949  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
18950 
18953  PostProcessEffectsKit & UnsetAmbientOcclusion();
18954 
18957  PostProcessEffectsKit & UnsetBloom();
18958 
18961  PostProcessEffectsKit & UnsetDepthOfField();
18962 
18965  PostProcessEffectsKit & UnsetSilhouetteEdges();
18966 
18969  PostProcessEffectsKit & UnsetEyeDomeLighting();
18970 
18973  PostProcessEffectsKit & UnsetEverything();
18974 
18975 
18982  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
18983 
18990  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
18991 
18998  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
18999 
19007  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19008 
19016  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19017 };
19018 
19019 
19023 class HPS_API PostProcessEffectsControl : public Control
19024 {
19025 public:
19026 
19028  explicit PostProcessEffectsControl(WindowKey & in_seg);
19029 
19032 
19037 
19041  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
19042 
19045 
19046  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsControl;};
19047 
19049  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
19050 
19051 
19059  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19060 
19067  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19068 
19075  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19076 
19082  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19083 
19090  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19091 
19097  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19098 
19106  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19107 
19114  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19115 
19122  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19123 
19130  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
19131 
19132 
19135  PostProcessEffectsControl & UnsetAmbientOcclusion();
19136 
19139  PostProcessEffectsControl & UnsetBloom();
19140 
19143  PostProcessEffectsControl & UnsetDepthOfField();
19144 
19147  PostProcessEffectsControl & UnsetSilhouetteEdges();
19148 
19151  PostProcessEffectsControl & UnsetEyeDomeLighting();
19152 
19155  PostProcessEffectsControl & UnsetEverything();
19156 
19157 
19164  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19165 
19172  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19173 
19180  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19181 
19189  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19190 
19198  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19199 
19200 private:
19203 };
19204 
19206 class HPS_API TransformMaskKit : public Object
19207 {
19208 public:
19209 
19211  TransformMaskKit();
19212 
19214  TransformMaskKit(TransformMaskKit const & in_kit);
19215 
19219  TransformMaskKit(TransformMaskKit && in_that);
19220 
19224  TransformMaskKit & operator=(TransformMaskKit && in_that);
19225 
19227  virtual ~TransformMaskKit();
19228 
19229  HPS::Type ObjectType() const {return HPS::Type::TransformMaskKit;};
19230 
19231  static TransformMaskKit GetDefault();
19232 
19234  void Set(TransformMaskKit const & in_kit);
19235 
19237  void Show(TransformMaskKit & out_kit) const;
19238 
19240  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
19241 
19243  bool Empty() const;
19244 
19246  bool Equals(TransformMaskKit const & in_kit) const;
19247 
19249  bool operator==(TransformMaskKit const & in_kit) const;
19250 
19252  bool operator!=(TransformMaskKit const & in_kit) const;
19253 
19254 
19258  TransformMaskKit & SetCameraRotation(bool in_state);
19259 
19263  TransformMaskKit & SetCameraScale(bool in_state);
19264 
19268  TransformMaskKit & SetCameraTranslation(bool in_state);
19269 
19273  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
19274 
19278  TransformMaskKit & SetCameraProjection(bool in_state);
19279 
19283  TransformMaskKit & SetCameraOffset(bool in_state);
19284 
19288  TransformMaskKit & SetCameraNearLimit(bool in_state);
19289 
19293  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
19294 
19298  TransformMaskKit & SetModellingMatrixScale(bool in_state);
19299 
19303  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
19304 
19308  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
19309 
19310 
19314  TransformMaskKit & SetCameraEverything(bool in_state);
19315 
19319  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
19320 
19324  TransformMaskKit & SetEverything(bool in_state);
19325 
19326 
19329  TransformMaskKit & UnsetCameraRotation();
19330 
19333  TransformMaskKit & UnsetCameraScale();
19334 
19337  TransformMaskKit & UnsetCameraTranslation();
19338 
19341  TransformMaskKit & UnsetCameraPerspectiveScale();
19342 
19345  TransformMaskKit & UnsetCameraProjection();
19346 
19349  TransformMaskKit & UnsetCameraOffset();
19350 
19353  TransformMaskKit & UnsetCameraNearLimit();
19354 
19357  TransformMaskKit & UnsetCameraEverything();
19358 
19361  TransformMaskKit & UnsetModellingMatrixRotation();
19362 
19365  TransformMaskKit & UnsetModellingMatrixScale();
19366 
19369  TransformMaskKit & UnsetModellingMatrixTranslation();
19370 
19373  TransformMaskKit & UnsetModellingMatrixOffset();
19374 
19377  TransformMaskKit & UnsetModellingMatrixEverything();
19378 
19381  TransformMaskKit & UnsetEverything();
19382 
19383 
19387  bool ShowCameraRotation(bool & out_state) const;
19388 
19392  bool ShowCameraScale(bool & out_state) const;
19393 
19397  bool ShowCameraTranslation(bool & out_state) const;
19398 
19402  bool ShowCameraPerspectiveScale(bool & out_state) const;
19403 
19407  bool ShowCameraProjection(bool & out_state) const;
19408 
19412  bool ShowCameraOffset(bool & out_state) const;
19413 
19417  bool ShowCameraNearLimit(bool & out_state) const;
19418 
19422  bool ShowModellingMatrixRotation(bool & out_state) const;
19423 
19427  bool ShowModellingMatrixScale(bool & out_state) const;
19428 
19432  bool ShowModellingMatrixTranslation(bool & out_state) const;
19433 
19437  bool ShowModellingMatrixOffset(bool & out_state) const;
19438 };
19439 
19440 
19445 class HPS_API TransformMaskControl : public Control
19446 {
19447 public:
19448 
19450  explicit TransformMaskControl(SegmentKey & in_seg);
19451 
19453  TransformMaskControl(TransformMaskControl const & in_that);
19454 
19459 
19463  TransformMaskControl & operator=(TransformMaskControl && in_that);
19464 
19467 
19468  HPS::Type ObjectType() const {return HPS::Type::TransformMaskControl;};
19469 
19470 
19474  TransformMaskControl & SetCameraRotation(bool in_state);
19475 
19479  TransformMaskControl & SetCameraScale(bool in_state);
19480 
19484  TransformMaskControl & SetCameraTranslation(bool in_state);
19485 
19489  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19490 
19494  TransformMaskControl & SetCameraProjection(bool in_state);
19495 
19499  TransformMaskControl & SetCameraOffset(bool in_state);
19500 
19504  TransformMaskControl & SetCameraNearLimit(bool in_state);
19505 
19509  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19510 
19514  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19515 
19519  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19520 
19524  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19525 
19526 
19530  TransformMaskControl & SetCameraEverything(bool in_state);
19531 
19535  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19536 
19540  TransformMaskControl & SetEverything(bool in_state);
19541 
19542 
19545  TransformMaskControl & UnsetCameraRotation();
19546 
19549  TransformMaskControl & UnsetCameraScale();
19550 
19553  TransformMaskControl & UnsetCameraTranslation();
19554 
19557  TransformMaskControl & UnsetCameraPerspectiveScale();
19558 
19561  TransformMaskControl & UnsetCameraProjection();
19562 
19565  TransformMaskControl & UnsetCameraOffset();
19566 
19569  TransformMaskControl & UnsetCameraNearLimit();
19570 
19573  TransformMaskControl & UnsetCameraEverything();
19574 
19577  TransformMaskControl & UnsetModellingMatrixRotation();
19578 
19581  TransformMaskControl & UnsetModellingMatrixScale();
19582 
19585  TransformMaskControl & UnsetModellingMatrixTranslation();
19586 
19589  TransformMaskControl & UnsetModellingMatrixOffset();
19590 
19593  TransformMaskControl & UnsetModellingMatrixEverything();
19594 
19597  TransformMaskControl & UnsetEverything();
19598 
19599 
19603  bool ShowCameraRotation(bool & out_state) const;
19604 
19608  bool ShowCameraScale(bool & out_state) const;
19609 
19613  bool ShowCameraTranslation(bool & out_state) const;
19614 
19618  bool ShowCameraPerspectiveScale(bool & out_state) const;
19619 
19623  bool ShowCameraProjection(bool & out_state) const;
19624 
19628  bool ShowCameraOffset(bool & out_state) const;
19629 
19633  bool ShowCameraNearLimit(bool & out_state) const;
19634 
19638  bool ShowModellingMatrixRotation(bool & out_state) const;
19639 
19643  bool ShowModellingMatrixScale(bool & out_state) const;
19644 
19648  bool ShowModellingMatrixTranslation(bool & out_state) const;
19649 
19653  bool ShowModellingMatrixOffset(bool & out_state) const;
19654 
19655 private:
19658 };
19659 
19660 
19661 
19663 class HPS_API VisualEffectsKit : public Object
19664 {
19665 public:
19666 
19668  VisualEffectsKit();
19669 
19672  VisualEffectsKit(VisualEffectsKit const & in_kit);
19673 
19677  VisualEffectsKit(VisualEffectsKit && in_that);
19678 
19682  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
19683 
19685  virtual ~VisualEffectsKit();
19686 
19687  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsKit;};
19688 
19692  static VisualEffectsKit GetDefault();
19693 
19696  void Set(VisualEffectsKit const & in_kit);
19697 
19700  void Show(VisualEffectsKit & out_kit) const;
19701 
19705  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
19706 
19709  bool Empty() const;
19710 
19714  bool Equals(VisualEffectsKit const & in_kit) const;
19715 
19719  bool operator==(VisualEffectsKit const & in_kit) const;
19720 
19724  bool operator!=(VisualEffectsKit const & in_kit) const;
19725 
19729  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
19730 
19734  VisualEffectsKit & SetAntiAliasing(bool in_state);
19735 
19745  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19746 
19755  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19756 
19763  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19764 
19770  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19771 
19775  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19776 
19780  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19781 
19785  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19786 
19797  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);
19798 
19808  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19809 
19813  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19814 
19818  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19819 
19820 
19823  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
19824 
19827  VisualEffectsKit & UnsetAntiAliasing();
19828 
19831  VisualEffectsKit & UnsetShadowMaps();
19832 
19835  VisualEffectsKit & UnsetSimpleShadow();
19836 
19839  VisualEffectsKit & UnsetSimpleShadowPlane();
19840 
19843  VisualEffectsKit & UnsetSimpleShadowLightDirection();
19844 
19847  VisualEffectsKit & UnsetSimpleShadowColor();
19848 
19851  VisualEffectsKit & UnsetSimpleReflection();
19852 
19855  VisualEffectsKit & UnsetSimpleReflectionPlane();
19856 
19859  VisualEffectsKit & UnsetSimpleReflectionVisibility();
19860 
19863  VisualEffectsKit & UnsetEverything();
19864 
19868  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19869 
19873  bool ShowAntiAliasing(bool & out_state) const;
19874 
19882  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19883 
19890  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19891 
19895  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
19896 
19900  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
19901 
19905  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
19906 
19915  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;
19916 
19917 
19921  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
19922 
19926  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
19927 };
19928 
19929 
19935 class HPS_API VisualEffectsControl : public Control
19936 {
19937 public:
19938 
19940  explicit VisualEffectsControl(SegmentKey & in_seg);
19941 
19943  VisualEffectsControl(VisualEffectsControl const & in_that);
19944 
19949 
19953  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
19954 
19957 
19958  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsControl;};
19959 
19961  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
19962 
19966  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
19967 
19971  VisualEffectsControl & SetAntiAliasing(bool in_state);
19972 
19982  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19983 
19992  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19993 
20000  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
20001 
20007  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20008 
20012  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20013 
20017  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20018 
20022  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20023 
20034  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);
20035 
20045  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20046 
20050  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20051 
20055  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20056 
20057 
20060  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
20061 
20064  VisualEffectsControl & UnsetAntiAliasing();
20065 
20068  VisualEffectsControl & UnsetShadowMaps();
20069 
20072  VisualEffectsControl & UnsetSimpleShadow();
20073 
20076  VisualEffectsControl & UnsetSimpleShadowPlane();
20077 
20080  VisualEffectsControl & UnsetSimpleShadowLightDirection();
20081 
20084  VisualEffectsControl & UnsetSimpleShadowColor();
20085 
20088  VisualEffectsControl & UnsetSimpleReflection();
20089 
20092  VisualEffectsControl & UnsetSimpleReflectionPlane();
20093 
20096  VisualEffectsControl & UnsetSimpleReflectionVisibility();
20097 
20100  VisualEffectsControl & UnsetEverything();
20101 
20102 
20106  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20107 
20111  bool ShowAntiAliasing(bool & out_state) const;
20112 
20120  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20121 
20128  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20129 
20133  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20134 
20138  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20139 
20143  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20144 
20153  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;
20154 
20158  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20159 
20163  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20164 
20165 private:
20168 };
20169 
20170 
20171 
20173 class HPS_API ContourLineKit : public Object
20174 {
20175 public:
20176 
20178  ContourLineKit();
20179 
20182  ContourLineKit(ContourLineKit const & in_kit);
20183 
20187  ContourLineKit(ContourLineKit && in_that);
20188 
20192  ContourLineKit & operator=(ContourLineKit && in_that);
20193 
20195  virtual ~ContourLineKit();
20196 
20197  HPS::Type ObjectType() const { return HPS::Type::ContourLineKit; };
20198 
20202  static ContourLineKit GetDefault();
20203 
20206  void Set(ContourLineKit const & in_kit);
20207 
20210  void Show(ContourLineKit & out_kit) const;
20211 
20215  ContourLineKit & operator=(ContourLineKit const & in_kit);
20216 
20219  bool Empty() const;
20220 
20224  bool Equals(ContourLineKit const & in_kit) const;
20225 
20229  bool operator==(ContourLineKit const & in_kit) const;
20230 
20234  bool operator!=(ContourLineKit const & in_kit) const;
20235 
20236 
20240  ContourLineKit & SetVisibility(bool in_state);
20241 
20246  ContourLineKit & SetPositions(float in_interval, float in_offset);
20247 
20251  ContourLineKit & SetPositions(FloatArray const & in_positions);
20252 
20257  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
20258 
20262  ContourLineKit & SetColors(RGBColorArray const & in_colors);
20263 
20268  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
20269 
20273  ContourLineKit & SetColors(RGBColor const & in_color);
20274 
20278  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
20279 
20284  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20285 
20289  ContourLineKit & SetPatterns(char const * in_pattern);
20290 
20295  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20296 
20302  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20303 
20308  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20309 
20313  ContourLineKit & SetLighting(bool in_state);
20314 
20315 
20318  ContourLineKit & UnsetVisibility();
20319 
20322  ContourLineKit & UnsetPositions();
20323 
20326  ContourLineKit & UnsetColors();
20327 
20330  ContourLineKit & UnsetPatterns();
20331 
20334  ContourLineKit & UnsetWeights();
20335 
20338  ContourLineKit & UnsetLighting();
20339 
20342  ContourLineKit & UnsetEverything();
20343 
20344 
20348  bool ShowVisibility(bool & out_state) const;
20349 
20355  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20356 
20360  bool ShowColors(RGBColorArray & out_colors) const;
20361 
20365  bool ShowPatterns(UTF8Array & out_patterns) const;
20366 
20371  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20372 
20376  bool ShowLighting(bool & out_state) const;
20377 };
20378 
20382 class HPS_API ContourLineControl : public Control
20383 {
20384 public:
20385 
20387  explicit ContourLineControl(SegmentKey & in_seg);
20388 
20390  ContourLineControl(ContourLineControl const & in_that);
20391 
20396 
20400  ContourLineControl & operator=(ContourLineControl && in_that);
20401 
20403  ~ContourLineControl();
20404 
20405  HPS::Type ObjectType() const { return HPS::Type::ContourLineControl; };
20406 
20408  ContourLineControl & operator=(ContourLineControl const & in_that);
20409 
20410 
20414  ContourLineControl & SetVisibility(bool in_state);
20415 
20420  ContourLineControl & SetPositions(float in_interval, float in_offset);
20421 
20425  ContourLineControl & SetPositions(FloatArray const & in_positions);
20426 
20431  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20432 
20436  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20437 
20442  ContourLineControl & SetColors(size_t in_count, RGBColor const in_rgb_colors[]);
20443 
20447  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20448 
20452  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20453 
20458  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20459 
20463  ContourLineControl & SetPatterns(char const * in_pattern);
20464 
20469  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20470 
20476  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20477 
20482  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20483 
20487  ContourLineControl & SetLighting(bool in_state);
20488 
20489 
20492  ContourLineControl & UnsetVisibility();
20493 
20496  ContourLineControl & UnsetPositions();
20497 
20500  ContourLineControl & UnsetColors();
20501 
20504  ContourLineControl & UnsetPatterns();
20505 
20508  ContourLineControl & UnsetWeights();
20509 
20512  ContourLineControl & UnsetLighting();
20513 
20516  ContourLineControl & UnsetEverything();
20517 
20518 
20522  bool ShowVisibility(bool & out_state) const;
20523 
20529  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20530 
20534  bool ShowColors(RGBColorArray & out_colors) const;
20535 
20539  bool ShowPatterns(UTF8Array & out_patterns) const;
20540 
20545  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20546 
20550  bool ShowLighting(bool & out_state) const;
20551 
20552 private:
20555 };
20556 
20557 
20558 
20560 class HPS_API SubwindowKit : public Object
20561 {
20562 public:
20563 
20565  SubwindowKit();
20566 
20568  SubwindowKit(SubwindowKit const & in_kit);
20569 
20573  SubwindowKit(SubwindowKit && in_that);
20574 
20578  SubwindowKit & operator=(SubwindowKit && in_that);
20579 
20581  virtual ~SubwindowKit();
20582 
20583  HPS::Type ObjectType() const {return HPS::Type::SubwindowKit;}
20584 
20588  static SubwindowKit GetDefault();
20589 
20592  void Set(SubwindowKit const & in_kit);
20593 
20596  void Show(SubwindowKit & out_kit) const;
20597 
20601  SubwindowKit & operator=(SubwindowKit const & in_kit);
20602 
20605  bool Empty() const;
20606 
20610  bool Equals(SubwindowKit const & in_kit) const;
20611 
20615  bool operator==(SubwindowKit const & in_kit) const;
20616 
20620  bool operator!=(SubwindowKit const & in_kit) const;
20621 
20622 
20632  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20633 
20640  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20641 
20646  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
20647 
20652  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20653 
20659  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20660 
20665  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20666 
20669  SubwindowKit & UnsetSubwindow();
20670 
20673  SubwindowKit & UnsetBackground();
20674 
20677  SubwindowKit & UnsetBorder();
20678 
20681  SubwindowKit & UnsetRenderingAlgorithm();
20682 
20685  SubwindowKit & UnsetModelCompareMode();
20686 
20689  SubwindowKit & UnsetEverything();
20690 
20695  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
20696 
20701  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20702 
20706  bool ShowBorder(Subwindow::Border & out_border_type) const;
20707 
20711  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20712 
20718  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20719 };
20720 
20721 
20722 
20728 class HPS_API SubwindowControl : public Control
20729 {
20730 public:
20731 
20733  explicit SubwindowControl(SegmentKey & in_seg);
20734 
20736  SubwindowControl(SubwindowControl const & in_that);
20737 
20741  SubwindowControl(SubwindowControl && in_that);
20742 
20746  SubwindowControl & operator=(SubwindowControl && in_that);
20747 
20749  ~SubwindowControl();
20750 
20751  HPS::Type ObjectType() const {return HPS::Type::SubwindowControl;}
20752 
20754  SubwindowControl & operator=(SubwindowControl const & in_that);
20755 
20766  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
20767 
20774  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20775 
20780  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
20781 
20787  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20788 
20794  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20795 
20800  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20801 
20804  SubwindowControl & UnsetSubwindow();
20805 
20808  SubwindowControl & UnsetBackground();
20809 
20812  SubwindowControl & UnsetBorder();
20813 
20816  SubwindowControl & UnsetRenderingAlgorithm();
20817 
20820  SubwindowControl & UnsetModelCompareMode();
20821 
20824  SubwindowControl & UnsetEverything();
20825 
20826 
20831  bool ShowSubwindow(Rectangle & out_window_position, Subwindow::Type & out_subwindow_type) const;
20832 
20837  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20838 
20842  bool ShowBorder(Subwindow::Border & out_border_type) const;
20843 
20847  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20848 
20854  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20855 
20856 private:
20858  SubwindowControl();
20859 };
20860 
20861 
20862 
20864 class HPS_API DebuggingKit : public Object
20865 {
20866 public:
20867 
20869  DebuggingKit();
20870 
20872  DebuggingKit(DebuggingKit const & in_kit);
20873 
20877  DebuggingKit(DebuggingKit && in_that);
20878 
20882  DebuggingKit & operator=(DebuggingKit && in_that);
20883 
20885  virtual ~DebuggingKit();
20886 
20887  HPS::Type ObjectType() const {return HPS::Type::DebuggingKit;}
20888 
20892  static DebuggingKit GetDefault();
20893 
20896  void Set(DebuggingKit const & in_kit);
20897 
20900  void Show(DebuggingKit & out_kit) const;
20901 
20905  DebuggingKit & operator=(DebuggingKit const & in_kit);
20906 
20909  bool Empty() const;
20910 
20914  bool Equals(DebuggingKit const & in_kit) const;
20915 
20919  bool operator==(DebuggingKit const & in_kit) const;
20920 
20924  bool operator!=(DebuggingKit const & in_kit) const;
20925 
20926 
20930  DebuggingKit & SetResourceMonitor(bool in_display);
20931 
20932 
20935  DebuggingKit & UnsetResourceMonitor();
20936 
20939  DebuggingKit & UnsetEverything();
20940 
20941 
20945  bool ShowResourceMonitor(bool & out_display) const;
20946 };
20947 
20948 
20951 class HPS_API DebuggingControl : public Control
20952 {
20953 public:
20954 
20956  explicit DebuggingControl(WindowKey & in_window);
20957 
20959  DebuggingControl(DebuggingControl const & in_that);
20960 
20964  DebuggingControl(DebuggingControl && in_that);
20965 
20969  DebuggingControl & operator=(DebuggingControl && in_that);
20970 
20972  ~DebuggingControl();
20973 
20974  HPS::Type ObjectType() const {return HPS::Type::DebuggingControl;}
20975 
20977  DebuggingControl & operator=(DebuggingControl const & in_that);
20978 
20983  DebuggingControl & SetResourceMonitor(bool in_display);
20984 
20988  bool ShowResourceMonitor(bool & out_display) const;
20989 
20993  bool ShowLastUpdateInfo(UpdateInfo & out_info);
20994 
20995 private:
20997  DebuggingControl();
20998 };
20999 
21000 
21002 class HPS_API WindowInfoKit : public Object
21003 {
21004 public:
21005 
21007  WindowInfoKit();
21008 
21010  WindowInfoKit(WindowInfoKit const & in_kit);
21011 
21015  WindowInfoKit(WindowInfoKit && in_that);
21016 
21020  WindowInfoKit & operator=(WindowInfoKit && in_that);
21021 
21023  virtual ~WindowInfoKit();
21024 
21025  HPS::Type ObjectType() const {return HPS::Type::WindowInfoKit;}
21026 
21029  void Set(WindowInfoKit const & in_kit);
21030 
21033  void Show(WindowInfoKit & out_kit) const;
21034 
21038  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
21039 
21042  bool Empty() const;
21043 
21047  bool Equals(WindowInfoKit const & in_kit) const;
21048 
21052  bool operator==(WindowInfoKit const & in_kit) const;
21053 
21057  bool operator!=(WindowInfoKit const & in_kit) const;
21058 
21059 
21064  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
21065 
21070  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
21071 
21076  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
21077 
21082  WindowInfoKit & SetWindowSize(float in_width, float in_height);
21083 
21084 
21087  WindowInfoKit & UnsetPhysicalPixels();
21088 
21091  WindowInfoKit & UnsetPhysicalSize();
21092 
21095  WindowInfoKit & UnsetWindowPixels();
21096 
21099  WindowInfoKit & UnsetWindowSize();
21100 
21103  WindowInfoKit & UnsetEverything();
21104 
21105 
21110  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21111 
21116  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21117 
21122  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21123 
21128  bool ShowWindowSize(float & out_width, float & out_height) const;
21129 
21135  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21136 
21140  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21141 
21145  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21146 };
21147 
21148 
21151 class HPS_API WindowInfoControl : public Control
21152 {
21153 public:
21154 
21156  explicit WindowInfoControl(WindowKey & in_window);
21157 
21159  WindowInfoControl(WindowInfoControl const & in_that);
21160 
21165 
21169  WindowInfoControl & operator=(WindowInfoControl && in_that);
21170 
21172  ~WindowInfoControl();
21173 
21174  HPS::Type ObjectType() const {return HPS::Type::WindowInfoControl;}
21175 
21177  WindowInfoControl & operator=(WindowInfoControl const & in_that);
21178 
21183  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21184 
21189  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21190 
21195  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21196 
21201  bool ShowWindowSize(float & out_width, float & out_height) const;
21202 
21208  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21209 
21213  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21214 
21218  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21219 
21224  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
21225 
21230  bool ShowLastUpdateTime(Time & out_time) const;
21231 
21235  bool ShowDepthPeelingLayers(size_t & out_layers) const;
21236 
21240  bool ShowVideoMemory(size_t & out_video_memory) const;
21241 
21245  bool ShowDepthBufferSize(size_t & out_bits) const;
21246 
21250  bool ShowMaxLights(size_t & out_lights) const;
21251 
21255  bool ShowColorBitPlanes(size_t & out_planes) const;
21256 
21257 private:
21260 };
21261 
21263 class HPS_API FontInfoState : public Object
21264 {
21265 public:
21266 
21268  FontInfoState();
21269 
21271  FontInfoState(FontInfoState const & in_kit);
21272 
21276  FontInfoState(FontInfoState && in_that);
21277 
21281  FontInfoState & operator=(FontInfoState && in_that);
21282 
21284  virtual ~FontInfoState();
21285 
21286  HPS::Type ObjectType() const {return HPS::Type::FontInfoState;}
21287 
21290  void Assign(FontInfoState const & in_that);
21291 
21294  void Set(FontInfoState const & in_kit);
21295 
21298  void Show(FontInfoState & out_kit) const;
21299 
21303  FontInfoState & operator=(FontInfoState const & in_kit);
21304 
21307  bool Empty() const;
21308 
21312  bool Equals(FontInfoState const & in_kit) const;
21313 
21317  bool operator==(FontInfoState const & in_kit) const;
21318 
21322  bool operator!=(FontInfoState const & in_kit) const;
21323 
21326  UTF8 GetName() const;
21327 
21330  bool GetShellConvertibility() const;
21331 };
21332 
21333 
21338 class HPS_API AttributeLockKit : public Object
21339 {
21340 public:
21341 
21343  AttributeLockKit();
21344 
21346  AttributeLockKit(AttributeLockKit const & in_kit);
21347 
21351  AttributeLockKit(AttributeLockKit && in_that);
21352 
21356  AttributeLockKit & operator=(AttributeLockKit && in_that);
21357 
21359  virtual ~AttributeLockKit();
21360 
21361  HPS::Type ObjectType() const {return HPS::Type::AttributeLockKit;}
21362 
21366  static AttributeLockKit GetDefault();
21367 
21370  void Set(AttributeLockKit const & in_kit);
21371 
21374  void Show(AttributeLockKit & out_kit) const;
21375 
21379  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
21380 
21383  bool Empty() const;
21384 
21388  bool Equals(AttributeLockKit const & in_kit) const;
21389 
21393  bool operator==(AttributeLockKit const & in_kit) const;
21394 
21398  bool operator!=(AttributeLockKit const & in_kit) const;
21399 
21405  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
21406 
21411  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21412 
21418  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21419 
21425  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21426 
21427 
21430  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21431 
21434  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
21435 
21438  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21439 
21442  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21443 
21446  AttributeLockKit & UnsetEverything();
21447 
21448 
21453  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21454 
21459  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21460 
21465  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21466 
21471  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21472 };
21473 
21474 
21479 class HPS_API AttributeLockControl : public Control
21480 {
21481 public:
21482 
21484  explicit AttributeLockControl(SegmentKey & in_seg);
21485 
21490 
21494  AttributeLockControl & operator=(AttributeLockControl && in_that);
21495 
21497  AttributeLockControl(AttributeLockControl const & in_that);
21498 
21501 
21502  HPS::Type ObjectType() const {return HPS::Type::AttributeLockControl;}
21503 
21505  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21506 
21507 
21513  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21514 
21519  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21520 
21526  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21527 
21533  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21534 
21535 
21538  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21539 
21542  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21543 
21546  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21547 
21550  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21551 
21554  AttributeLockControl & UnsetEverything();
21555 
21556 
21561  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21562 
21567  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21568 
21573  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21574 
21579  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21580 
21581 private:
21584 };
21585 
21589 
21590 class HPS_API GeometryKey : public Key
21591 {
21592 public:
21594  GeometryKey();
21595 
21599  explicit GeometryKey(Key const & in_that);
21600 
21603  GeometryKey(GeometryKey const & in_that);
21604 
21608  GeometryKey & operator=(GeometryKey const & in_that);
21609 
21613  GeometryKey(GeometryKey && in_that);
21614 
21618  GeometryKey & operator=(GeometryKey && in_that);
21619 
21620  ~GeometryKey();
21621 
21622  HPS::Type ObjectType() const { return HPS::Type::GeometryKey; };
21623 
21624 
21628  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21629 
21633  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
21634 
21635 
21636 
21643  GeometryKey & SetPriority(int in_priority);
21644 
21647  GeometryKey & UnsetPriority();
21648 
21652  bool ShowPriority(int & out_priority) const;
21653 
21654 
21660  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21661 
21666  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
21667 
21672  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21673 
21677  GeometryKey & UnsetUserData(intptr_t in_index);
21678 
21683  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21684 
21688  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
21689 
21692  GeometryKey & UnsetAllUserData();
21693 
21695  size_t ShowUserDataCount() const;
21696 
21700  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21701 
21706  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21707 
21712  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21713 
21717  bool ShowBoundings(BoundingKit & out_kit) const;
21718 };
21719 
21720 
21722 class HPS_API LineKit : public Object
21723 {
21724 public:
21726  LineKit();
21727 
21730  LineKit(LineKit const & in_kit);
21731 
21735  LineKit(LineKit && in_that);
21736 
21740  LineKit & operator=(LineKit && in_that);
21741 
21742  virtual ~LineKit();
21743 
21744  HPS::Type ObjectType() const { return HPS::Type::LineKit; };
21745 
21748  void Consume(LineKit & in_kit);
21749 
21752  void Set(LineKit const & in_kit);
21753 
21756  void Show(LineKit & out_kit) const;
21757 
21761  LineKit & operator=(LineKit const & in_kit);
21762 
21765  bool Empty() const;
21766 
21770  bool Equals(LineKit const & in_kit) const;
21771 
21775  bool operator==(LineKit const & in_kit) const;
21776 
21780  bool operator!=(LineKit const & in_kit) const;
21781 
21784  size_t GetPointCount() const;
21785 
21792  LineKit & SetPriority(int in_priority);
21793 
21796  LineKit & UnsetPriority();
21797 
21801  bool ShowPriority(int & out_priority) const;
21802 
21803 
21807  LineKit & SetPoints(PointArray const & in_points);
21808 
21813  LineKit & SetPoints(size_t in_count, Point const in_points []);
21814 
21815 
21818  LineKit & UnsetPoints();
21819 
21822  LineKit & UnsetEverything();
21823 
21824 
21828  bool ShowPoints(PointArray & out_points) const;
21829 
21835  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
21836 
21841  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
21842 
21848  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
21849 
21850 
21856  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21857 
21862  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21863 
21868  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
21869 
21875  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21876 
21882  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21883 
21889  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21890 
21895  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21896 
21901  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21902 
21906  LineKit & UnsetUserData(intptr_t in_index);
21907 
21912  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21913 
21917  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
21918 
21921  LineKit & UnsetAllUserData();
21922 
21924  size_t ShowUserDataCount() const;
21925 
21929  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21930 
21935  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21936 
21941  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21942 };
21943 
21945 class HPS_API LineKey : public GeometryKey
21946 {
21947 public:
21949  LineKey();
21950 
21954  explicit LineKey(Key const & in_that);
21955 
21958  LineKey(LineKey const & in_that);
21959 
21963  LineKey & operator=(LineKey const & in_that);
21964 
21968  LineKey(LineKey && in_that);
21969 
21973  LineKey & operator=(LineKey && in_that);
21974 
21975  ~LineKey();
21976 
21977  HPS::Type ObjectType() const { return HPS::Type::LineKey; };
21978 
21979 
21982  void Consume(LineKit & in_kit);
21983 
21986  void Set(LineKit const & in_kit);
21987 
21990  void Show(LineKit & out_kit) const;
21991 
21994  size_t GetPointCount() const;
21995 
21999  LineKey & SetPoints(PointArray const & in_points);
22000 
22005  LineKey & SetPoints(size_t in_count, Point const in_points []);
22006 
22007 
22011  bool ShowPoints(PointArray & out_points) const;
22012 
22018  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22019 
22024  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22025 
22031  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22032 
22033 
22039  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22040 
22045  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22046 
22051  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22052 
22058  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22059 
22065  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22066 };
22067 
22068 
22069 
22071 class HPS_API MarkerKit : public Object
22072 {
22073 public:
22075  MarkerKit();
22076 
22079  MarkerKit(MarkerKit const & in_kit);
22080 
22084  MarkerKit(MarkerKit && in_that);
22085 
22089  MarkerKit & operator=(MarkerKit && in_that);
22090 
22091  virtual ~MarkerKit();
22092 
22093  HPS::Type ObjectType() const { return HPS::Type::MarkerKit; };
22094 
22097  void Consume(MarkerKit & in_kit);
22098 
22101  void Set(MarkerKit const & in_kit);
22102 
22105  void Show(MarkerKit & out_kit) const;
22106 
22110  MarkerKit & operator=(MarkerKit const & in_kit);
22111 
22114  bool Empty() const;
22115 
22119  bool Equals(MarkerKit const & in_kit) const;
22120 
22124  bool operator==(MarkerKit const & in_kit) const;
22125 
22129  bool operator!=(MarkerKit const & in_kit) const;
22130 
22131 
22138  MarkerKit & SetPriority(int in_priority);
22139 
22142  MarkerKit & UnsetPriority();
22143 
22147  bool ShowPriority(int & out_priority) const;
22148 
22152  MarkerKit & SetPoint(Point const & in_point);
22153 
22154 
22157  MarkerKit & UnsetPoint();
22158 
22161  MarkerKit & UnsetEverything();
22162 
22163 
22167  bool ShowPoint(HPS::Point & out_point) const;
22168 
22174  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22175 
22180  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22181 
22186  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22187 
22191  MarkerKit & UnsetUserData(intptr_t in_index);
22192 
22197  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22198 
22202  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
22203 
22206  MarkerKit & UnsetAllUserData();
22207 
22209  size_t ShowUserDataCount() const;
22210 
22214  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22215 
22220  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22221 
22226  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22227 };
22228 
22230 class HPS_API MarkerKey : public GeometryKey
22231 {
22232 public:
22234  MarkerKey();
22235 
22239  explicit MarkerKey(Key const & in_that);
22240 
22243  MarkerKey(MarkerKey const & in_that);
22244 
22248  MarkerKey & operator=(MarkerKey const & in_that);
22249 
22253  MarkerKey(MarkerKey && in_that);
22254 
22258  MarkerKey & operator=(MarkerKey && in_that);
22259 
22260  ~MarkerKey();
22261 
22262  HPS::Type ObjectType() const { return HPS::Type::MarkerKey; };
22263 
22264 
22267  void Consume(MarkerKit & in_kit);
22268 
22271  void Set(MarkerKit const & in_kit);
22272 
22275  void Show(MarkerKit & out_kit) const;
22276 
22277 
22281  MarkerKey & SetPoint(Point const & in_point);
22282 
22286  bool ShowPoint(Point & out_point) const;
22287 };
22288 
22289 
22290 
22292 class HPS_API DistantLightKit : public Object
22293 {
22294 public:
22296  DistantLightKit();
22297 
22300  DistantLightKit(DistantLightKit const & in_kit);
22301 
22305  DistantLightKit(DistantLightKit && in_that);
22306 
22310  DistantLightKit & operator=(DistantLightKit && in_that);
22311 
22312  virtual ~DistantLightKit();
22313 
22314  HPS::Type ObjectType() const { return HPS::Type::DistantLightKit; };
22315 
22318  void Consume(DistantLightKit & in_kit);
22319 
22322  void Set(DistantLightKit const & in_kit);
22323 
22326  void Show(DistantLightKit & out_kit) const;
22327 
22331  DistantLightKit & operator=(DistantLightKit const & in_kit);
22332 
22335  bool Empty() const;
22336 
22340  bool Equals(DistantLightKit const & in_kit) const;
22341 
22345  bool operator==(DistantLightKit const & in_kit) const;
22346 
22350  bool operator!=(DistantLightKit const & in_kit) const;
22351 
22352 
22359  DistantLightKit & SetPriority(int in_priority);
22360 
22366  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
22367 
22371  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
22372 
22376  DistantLightKit & SetColorByIndex(float in_index);
22377 
22383  DistantLightKit & SetCameraRelative(bool in_state);
22384 
22385 
22388  DistantLightKit & UnsetPriority();
22389 
22392  DistantLightKit & UnsetDirection();
22393 
22396  DistantLightKit & UnsetColor();
22397 
22400  DistantLightKit & UnsetCameraRelative();
22401 
22404  DistantLightKit & UnsetEverything();
22405 
22406 
22410  bool ShowPriority(int & out_priority) const;
22411 
22415  bool ShowDirection(HPS::Vector & out_vector) const;
22416 
22422  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22423 
22427  bool ShowCameraRelative(bool & out_state) const;
22428 
22434  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22435 
22440  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22441 
22446  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22447 
22451  DistantLightKit & UnsetUserData(intptr_t in_index);
22452 
22457  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22458 
22462  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
22463 
22466  DistantLightKit & UnsetAllUserData();
22467 
22469  size_t ShowUserDataCount() const;
22470 
22474  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22475 
22480  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22481 
22486  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22487 };
22488 
22489 
22490 
22492 class HPS_API DistantLightKey : public GeometryKey
22493 {
22494 public:
22496  DistantLightKey();
22497 
22501  explicit DistantLightKey(Key const & in_that);
22502 
22505  DistantLightKey(DistantLightKey const & in_that);
22506 
22510  DistantLightKey & operator=(DistantLightKey const & in_that);
22511 
22515  DistantLightKey(DistantLightKey && in_that);
22516 
22520  DistantLightKey & operator=(DistantLightKey && in_that);
22521 
22522  ~DistantLightKey();
22523 
22524  HPS::Type ObjectType() const { return HPS::Type::DistantLightKey; };
22525 
22528  void Consume(DistantLightKit & in_kit);
22529 
22532  void Set(DistantLightKit const & in_kit);
22533 
22536  void Show(DistantLightKit & out_kit) const;
22537 
22538 
22543  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
22544 
22548  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22549 
22553  DistantLightKey & SetColorByIndex(float in_index);
22554 
22559  DistantLightKey & SetCameraRelative(bool in_state);
22560 
22561 
22564  DistantLightKey & UnsetColor();
22565 
22566 
22570  bool ShowDirection(HPS::Vector & out_vector) const;
22571 
22577  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22578 
22582  bool ShowCameraRelative(bool & out_state) const;
22583 };
22584 
22585 
22586 
22587 
22589 class HPS_API CylinderKit : public Object
22590 {
22591 public:
22593  CylinderKit();
22594 
22597  CylinderKit(CylinderKit const & in_kit);
22598 
22602  CylinderKit(CylinderKit && in_that);
22603 
22607  CylinderKit & operator=(CylinderKit && in_that);
22608 
22609  virtual ~CylinderKit();
22610 
22611  HPS::Type ObjectType() const { return HPS::Type::CylinderKit; };
22612 
22615  void Consume(CylinderKit & in_kit);
22616 
22619  void Set(CylinderKit const & in_kit);
22620 
22623  void Show(CylinderKit & out_kit) const;
22624 
22628  CylinderKit & operator=(CylinderKit const & in_kit);
22629 
22632  bool Empty() const;
22633 
22637  bool Equals(CylinderKit const & in_kit) const;
22638 
22642  bool operator==(CylinderKit const & in_kit) const;
22643 
22647  bool operator!=(CylinderKit const & in_kit) const;
22648 
22651  size_t GetPointCount() const;
22652 
22659  CylinderKit & SetPriority(int in_priority);
22660 
22663  CylinderKit & UnsetPriority();
22664 
22668  bool ShowPriority(int & out_priority) const;
22669 
22670 
22674  CylinderKit & SetPoints(PointArray const & in_points);
22675 
22680  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
22681 
22685  CylinderKit & SetRadii(FloatArray const & in_radii);
22686 
22691  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
22692 
22696  CylinderKit & SetCaps(Cylinder::Capping in_capping);
22697 
22698 
22701  CylinderKit & UnsetPoints();
22702 
22705  CylinderKit & UnsetRadii();
22706 
22709  CylinderKit & UnsetCaps();
22710 
22713  CylinderKit & UnsetEverything();
22714 
22715 
22719  bool ShowPoints(PointArray & out_points) const;
22720 
22726  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22727 
22732  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22733 
22739  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22740 
22744  bool ShowRadii(FloatArray & out_radii) const;
22745 
22749  bool ShowCaps(Cylinder::Capping & out_caps) const;
22750 
22751 
22758  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22759 
22765  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22766 
22773  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22774 
22781  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22782 
22789  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22790 
22797  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22798 
22804  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22805 
22806 
22813  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22814 
22820  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22821 
22828  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22829 
22836  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22837 
22844  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22845 
22852  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22853 
22859  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22860 
22861 
22864  CylinderKit & UnsetVertexColors();
22865 
22870  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22871 
22875  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
22876 
22877 
22881  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
22882 
22888  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22889 
22894  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
22895 
22896 
22908  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22909 
22922  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22923 
22929  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22930 
22935  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22936 
22941  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22942 
22946  CylinderKit & UnsetUserData(intptr_t in_index);
22947 
22952  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22953 
22957  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
22958 
22961  CylinderKit & UnsetAllUserData();
22962 
22964  size_t ShowUserDataCount() const;
22965 
22969  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22970 
22975  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22976 
22981  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22982 };
22983 
22984 
22985 
22987 class HPS_API CylinderKey : public GeometryKey
22988 {
22989 public:
22991  CylinderKey();
22992 
22996  explicit CylinderKey(Key const & in_that);
22997 
23000  CylinderKey(CylinderKey const & in_that);
23001 
23005  CylinderKey & operator=(CylinderKey const & in_that);
23006 
23010  CylinderKey(CylinderKey && in_that);
23011 
23015  CylinderKey & operator=(CylinderKey && in_that);
23016 
23017  ~CylinderKey();
23018 
23019  HPS::Type ObjectType() const { return HPS::Type::CylinderKey; };
23020 
23023  void Consume(CylinderKit & in_kit);
23024 
23027  void Set(CylinderKit const & in_kit);
23028 
23029 
23035  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23036 
23041  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23042 
23047  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
23048 
23054  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23055 
23061  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23062 
23063 
23069  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
23070 
23075  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
23076 
23081  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
23082 
23088  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
23089 
23095  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
23096 
23097 
23100  void Show(CylinderKit & out_kit) const;
23101 
23104  size_t GetPointCount() const;
23105 
23109  bool ShowPoints(PointArray & out_points) const;
23110 
23116  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23117 
23122  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23123 
23129  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23130 
23134  bool ShowRadii(FloatArray & out_radii) const;
23135 
23139  bool ShowCaps(Cylinder::Capping & out_caps) const;
23140 
23141 
23148  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23149 
23156  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23157 
23164  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23165 
23166 
23173  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23174 
23181  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23182 
23189  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23190 
23191 
23194  CylinderKey & UnsetVertexColors();
23195 
23200  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23201 
23205  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
23206 
23212  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23213 
23214 
23226  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23227 
23240  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23241 };
23242 
23243 
23244 
23245 
23247 class HPS_API SphereKit : public Object
23248 {
23249 public:
23251  SphereKit();
23252 
23255  SphereKit(SphereKit const & in_kit);
23256 
23260  SphereKit(SphereKit && in_that);
23261 
23265  SphereKit & operator=(SphereKit && in_that);
23266 
23267  virtual ~SphereKit();
23268 
23269  HPS::Type ObjectType() const { return HPS::Type::SphereKit; };
23270 
23273  void Consume(SphereKit & in_kit);
23274 
23277  void Set(SphereKit const & in_kit);
23278 
23281  void Show(SphereKit & out_kit) const;
23282 
23286  SphereKit & operator=(SphereKit const & in_kit);
23287 
23290  bool Empty() const;
23291 
23295  bool Equals(SphereKit const & in_kit) const;
23296 
23300  bool operator==(SphereKit const & in_kit) const;
23301 
23305  bool operator!=(SphereKit const & in_kit) const;
23306 
23313  SphereKit & SetPriority(int in_priority);
23314 
23317  SphereKit & UnsetPriority();
23318 
23322  bool ShowPriority(int & out_priority) const;
23323 
23327  SphereKit & SetCenter(Point const & in_center);
23328 
23332  SphereKit & SetRadius(float in_radius);
23333 
23338  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23339 
23340 
23343  SphereKit & UnsetCenter();
23344 
23347  SphereKit & UnsetRadius();
23348 
23351  SphereKit & UnsetBasis();
23352 
23355  SphereKit & UnsetEverything();
23356 
23357 
23361  bool ShowCenter(Point & out_center) const;
23362 
23366  bool ShowRadius(float & out_radius) const;
23367 
23372  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23373 
23379  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23380 
23385  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23386 
23391  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23392 
23396  SphereKit & UnsetUserData(intptr_t in_index);
23397 
23402  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23403 
23407  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
23408 
23411  SphereKit & UnsetAllUserData();
23412 
23414  size_t ShowUserDataCount() const;
23415 
23419  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23420 
23425  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23426 
23431  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23432 };
23433 
23435 class HPS_API SphereKey : public GeometryKey
23436 {
23437 public:
23439  SphereKey();
23440 
23444  explicit SphereKey(Key const & in_that);
23445 
23448  SphereKey(SphereKey const & in_that);
23449 
23453  SphereKey & operator=(SphereKey const & in_that);
23454 
23458  SphereKey(SphereKey && in_that);
23459 
23463  SphereKey & operator=(SphereKey && in_that);
23464 
23465  ~SphereKey();
23466 
23467  HPS::Type ObjectType() const {return HPS::Type::SphereKey;};
23468 
23471  void Consume(SphereKit & in_kit);
23472 
23475  void Set(SphereKit const & in_kit);
23476 
23479  void Show(SphereKit & out_kit) const;
23480 
23481 
23485  SphereKey & SetCenter(Point const & in_center);
23486 
23490  SphereKey & SetRadius(float in_radius);
23491 
23496  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23497 
23498 
23502  bool ShowCenter(Point & out_center) const;
23503 
23507  bool ShowRadius(float & out_radius) const;
23508 
23513  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23514 };
23515 
23516 
23517 
23518 
23520 class HPS_API CircleKit : public Object
23521 {
23522 public:
23524  CircleKit();
23525 
23528  CircleKit(CircleKit const & in_kit);
23529 
23533  CircleKit(CircleKit && in_that);
23534 
23538  CircleKit & operator=(CircleKit && in_that);
23539 
23540  virtual ~CircleKit();
23541 
23542  HPS::Type ObjectType() const { return HPS::Type::CircleKit; };
23543 
23546  void Consume(CircleKit & in_kit);
23547 
23550  void Set(CircleKit const & in_kit);
23551 
23554  void Show(CircleKit & out_kit) const;
23555 
23559  CircleKit & operator=(CircleKit const & in_kit);
23560 
23563  bool Empty() const;
23564 
23568  bool Equals(CircleKit const & in_kit) const;
23569 
23573  bool operator==(CircleKit const & in_kit) const;
23574 
23578  bool operator!=(CircleKit const & in_kit) const;
23579 
23586  CircleKit & SetPriority(int const in_priority);
23587 
23590  CircleKit & UnsetPriority();
23591 
23595  bool ShowPriority(int & out_priority) const;
23596 
23597 
23598 
23602  CircleKit & SetCenter(Point const & in_center);
23603 
23607  CircleKit & SetRadius(float in_radius);
23608 
23612  CircleKit & SetNormal(Vector const & in_normal);
23613 
23614 
23617  CircleKit & UnsetCenter();
23618 
23621  CircleKit & UnsetRadius();
23622 
23625  CircleKit & UnsetNormal();
23626 
23629  CircleKit & UnsetEverything();
23630 
23631 
23635  bool ShowCenter(Point & out_center) const;
23636 
23640  bool ShowRadius(float & out_radius) const;
23641 
23645  bool ShowNormal(Vector & out_normal) const;
23646 
23652  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23653 
23658  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23659 
23664  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23665 
23669  CircleKit & UnsetUserData(intptr_t in_index);
23670 
23675  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23676 
23680  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
23681 
23684  CircleKit & UnsetAllUserData();
23685 
23687  size_t ShowUserDataCount() const;
23688 
23692  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23693 
23698  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23699 
23704  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23705 };
23706 
23707 
23710 class HPS_API CircleKey : public GeometryKey
23711 {
23712 public:
23714  CircleKey();
23715 
23719  explicit CircleKey(Key const & in_that);
23720 
23723  CircleKey(CircleKey const & in_that);
23724 
23728  CircleKey & operator=(CircleKey const & in_that);
23729 
23733  CircleKey(CircleKey && in_that);
23734 
23738  CircleKey & operator=(CircleKey && in_that);
23739 
23740  ~CircleKey();
23741 
23742  HPS::Type ObjectType() const { return HPS::Type::CircleKey; };
23743 
23744 
23747  void Consume(CircleKit & in_kit);
23748 
23751  void Set(CircleKit const & in_kit);
23752 
23755  void Show(CircleKit & out_kit) const;
23756 
23757 
23761  CircleKey & SetCenter(Point const & in_center);
23762 
23766  CircleKey & SetRadius(float in_radius);
23767 
23771  CircleKey & SetNormal(Vector const & in_normal);
23772 
23773 
23777  bool ShowCenter(Point & out_center) const;
23778 
23782  bool ShowRadius(float & out_radius) const;
23783 
23787  bool ShowNormal(Vector & out_normal) const;
23788 };
23789 
23790 
23791 
23792 
23794 class HPS_API CircularArcKit : public Object
23795 {
23796 public:
23798  CircularArcKit();
23799 
23802  CircularArcKit(CircularArcKit const & in_kit);
23803 
23807  CircularArcKit(CircularArcKit && in_that);
23808 
23812  CircularArcKit & operator=(CircularArcKit && in_that);
23813 
23814  virtual ~CircularArcKit();
23815 
23816  HPS::Type ObjectType() const { return HPS::Type::CircularArcKit; };
23817 
23820  void Consume(CircularArcKit & in_kit);
23821 
23824  void Set(CircularArcKit const & in_kit);
23825 
23828  void Show(CircularArcKit & out_kit) const;
23829 
23833  CircularArcKit & operator=(CircularArcKit const & in_kit);
23834 
23837  bool Empty() const;
23838 
23842  bool Equals(CircularArcKit const & in_kit) const;
23843 
23847  bool operator==(CircularArcKit const & in_kit) const;
23848 
23852  bool operator!=(CircularArcKit const & in_kit) const;
23853 
23860  CircularArcKit & SetPriority(int in_priority);
23861 
23864  CircularArcKit & UnsetPriority();
23865 
23869  bool ShowPriority(int & out_priority) const;
23870 
23871 
23875  CircularArcKit & SetStart(Point const & in_start);
23876 
23880  CircularArcKit & SetMiddle(Point const & in_middle);
23881 
23885  CircularArcKit & SetEnd(Point const & in_end);
23886 
23887 
23890  CircularArcKit & UnsetStart();
23891 
23894  CircularArcKit & UnsetMiddle();
23895 
23898  CircularArcKit & UnsetEnd();
23899 
23902  CircularArcKit & UnsetEverything();
23903 
23904 
23908  bool ShowStart(Point & out_start) const;
23909 
23913  bool ShowMiddle(Point & out_middle) const;
23914 
23918  bool ShowEnd(Point & out_end) const;
23919 
23925  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23926 
23931  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23932 
23937  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23938 
23942  CircularArcKit & UnsetUserData(intptr_t in_index);
23943 
23948  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23949 
23953  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
23954 
23957  CircularArcKit & UnsetAllUserData();
23958 
23960  size_t ShowUserDataCount() const;
23961 
23965  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23966 
23971  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23972 
23977  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23978 };
23979 
23982 class HPS_API CircularArcKey : public GeometryKey
23983 {
23984 public:
23986  CircularArcKey();
23987 
23991  explicit CircularArcKey(Key const & in_that);
23992 
23995  CircularArcKey(CircularArcKey const & in_that);
23996 
24000  CircularArcKey & operator=(CircularArcKey const & in_that);
24001 
24005  CircularArcKey(CircularArcKey && in_that);
24006 
24010  CircularArcKey & operator=(CircularArcKey && in_that);
24011 
24012  ~CircularArcKey();
24013 
24014  HPS::Type ObjectType() const { return HPS::Type::CircularArcKey; };
24015 
24016 
24019  void Consume(CircularArcKit & in_kit);
24020 
24023  void Set(CircularArcKit const & in_kit);
24024 
24027  void Show(CircularArcKit & out_kit) const;
24028 
24029 
24033  CircularArcKey & SetStart(Point const & in_start);
24034 
24038  CircularArcKey & SetMiddle(Point const & in_middle);
24039 
24043  CircularArcKey & SetEnd(Point const & in_end);
24044 
24045 
24049  bool ShowStart(Point & out_start) const;
24050 
24054  bool ShowMiddle(Point & out_middle) const;
24055 
24059  bool ShowEnd(Point & out_end) const;
24060 };
24061 
24062 
24063 
24065 class HPS_API CircularWedgeKit : public Object
24066 {
24067 public:
24069  CircularWedgeKit();
24070 
24073  CircularWedgeKit(CircularWedgeKit const & in_kit);
24074 
24078  CircularWedgeKit(CircularWedgeKit && in_that);
24079 
24083  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
24084 
24085  virtual ~CircularWedgeKit();
24086 
24087  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKit; };
24088 
24091  void Consume(CircularWedgeKit & in_kit);
24092 
24095  void Set(CircularWedgeKit const & in_kit);
24096 
24099  void Show(CircularWedgeKit & out_kit) const;
24100 
24104  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
24105 
24108  bool Empty() const;
24109 
24113  bool Equals(CircularWedgeKit const & in_kit) const;
24114 
24118  bool operator==(CircularWedgeKit const & in_kit) const;
24119 
24123  bool operator!=(CircularWedgeKit const & in_kit) const;
24124 
24125 
24132  CircularWedgeKit & SetPriority(int in_priority);
24133 
24136  CircularWedgeKit & UnsetPriority();
24137 
24141  bool ShowPriority(int & out_priority) const;
24142 
24143 
24147  CircularWedgeKit & SetStart(Point const & in_start);
24148 
24152  CircularWedgeKit & SetMiddle(Point const & in_middle);
24153 
24157  CircularWedgeKit & SetEnd(Point const & in_end);
24158 
24159 
24162  CircularWedgeKit & UnsetStart();
24163 
24166  CircularWedgeKit & UnsetMiddle();
24167 
24170  CircularWedgeKit & UnsetEnd();
24171 
24174  CircularWedgeKit & UnsetEverything();
24175 
24176 
24180  bool ShowStart(Point & out_start) const;
24181 
24185  bool ShowMiddle(Point & out_middle) const;
24186 
24190  bool ShowEnd(Point & out_end) const;
24191 
24197  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24198 
24203  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24204 
24209  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24210 
24214  CircularWedgeKit & UnsetUserData(intptr_t in_index);
24215 
24220  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24221 
24225  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
24226 
24229  CircularWedgeKit & UnsetAllUserData();
24230 
24232  size_t ShowUserDataCount() const;
24233 
24237  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24238 
24243  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24244 
24249  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24250 };
24251 
24252 
24256 class HPS_API CircularWedgeKey : public GeometryKey
24257 {
24258 public:
24260  CircularWedgeKey();
24261 
24265  explicit CircularWedgeKey(Key const & in_that);
24266 
24269  CircularWedgeKey(CircularWedgeKey const & in_that);
24270 
24274  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
24275 
24279  CircularWedgeKey(CircularWedgeKey && in_that);
24280 
24284  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
24285 
24286  ~CircularWedgeKey();
24287 
24288  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKey; };
24289 
24290 
24293  void Consume(CircularWedgeKit & in_kit);
24294 
24297  void Set(CircularWedgeKit const & in_kit);
24298 
24301  void Show(CircularWedgeKit & out_kit) const;
24302 
24303 
24307  CircularWedgeKey & SetStart(Point const & in_start);
24308 
24312  CircularWedgeKey & SetMiddle(Point const & in_middle);
24313 
24317  CircularWedgeKey & SetEnd(Point const & in_end);
24318 
24319 
24323  bool ShowStart(Point & out_start) const;
24324 
24328  bool ShowMiddle(Point & out_middle) const;
24329 
24333  bool ShowEnd(Point & out_end) const;
24334 };
24335 
24336 
24337 
24339 class HPS_API CuttingSectionKit : public Object
24340 {
24341 public:
24344 
24347  CuttingSectionKit(CuttingSectionKit const & in_kit);
24348 
24353 
24357  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
24358 
24359  virtual ~CuttingSectionKit();
24360 
24361  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKit; };
24362 
24365  void Consume(CuttingSectionKit & in_kit);
24366 
24369  void Set(CuttingSectionKit const & in_kit);
24370 
24373  void Show(CuttingSectionKit & out_kit) const;
24374 
24378  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
24379 
24382  bool Empty() const;
24383 
24387  bool Equals(CuttingSectionKit const & in_kit) const;
24388 
24392  bool operator==(CuttingSectionKit const & in_kit) const;
24393 
24397  bool operator!=(CuttingSectionKit const & in_kit) const;
24398 
24405  CuttingSectionKit & SetPriority(int in_priority);
24406 
24409  CuttingSectionKit & UnsetPriority();
24410 
24414  bool ShowPriority(int & out_priority) const;
24415 
24416 
24420  CuttingSectionKit & SetPlanes(Plane const & in_plane);
24421 
24425  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
24426 
24431  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
24432 
24438  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24439 
24440 
24443  CuttingSectionKit & UnsetPlanes();
24444 
24447  CuttingSectionKit & UnsetVisualization();
24448 
24451  CuttingSectionKit & UnsetEverything();
24452 
24453 
24456  size_t GetPlaneCount() const;
24457 
24461  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24462 
24468  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24469 
24470 
24477  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24478 
24484  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24485 
24492  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24493 
24500  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24501 
24509  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24510 
24516  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24517 
24522  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24523 
24528  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24529 
24533  CuttingSectionKit & UnsetUserData(intptr_t in_index);
24534 
24539  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24540 
24544  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
24545 
24548  CuttingSectionKit & UnsetAllUserData();
24549 
24551  size_t ShowUserDataCount() const;
24552 
24556  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24557 
24562  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24563 
24568  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24569 };
24570 
24571 
24573 class HPS_API CuttingSectionKey : public GeometryKey
24574 {
24575 public:
24578 
24582  explicit CuttingSectionKey(Key const & in_that);
24583 
24586  CuttingSectionKey(CuttingSectionKey const & in_that);
24587 
24591  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24592 
24597 
24601  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24602 
24603  ~CuttingSectionKey();
24604 
24605  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKey; };
24606 
24607 
24610  void Consume(CuttingSectionKit & in_kit);
24611 
24614  void Set(CuttingSectionKit const & in_kit);
24615 
24618  void Show(CuttingSectionKit & out_kit) const;
24619 
24620 
24624  CuttingSectionKey & SetPlanes(Plane const & in_plane);
24625 
24629  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
24630 
24635  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
24636 
24642  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24643 
24644 
24647  size_t GetPlaneCount() const;
24648 
24652  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24653 
24659  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24660 
24661 
24668  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24669 
24675  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24676 
24683  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24684 
24691  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24692 
24700  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24701 };
24702 
24703 
24704 
24706 class HPS_API InfiniteLineKit : public Object
24707 {
24708 public:
24710  InfiniteLineKit();
24711 
24714  InfiniteLineKit(InfiniteLineKit const & in_kit);
24715 
24719  InfiniteLineKit(InfiniteLineKit && in_that);
24720 
24724  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
24725 
24726  virtual ~InfiniteLineKit();
24727 
24728  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKit; };
24729 
24732  void Consume(InfiniteLineKit & in_kit);
24733 
24736  void Set(InfiniteLineKit const & in_kit);
24737 
24740  void Show(InfiniteLineKit & out_kit) const;
24741 
24745  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
24746 
24749  bool Empty() const;
24750 
24754  bool Equals(InfiniteLineKit const & in_kit) const;
24755 
24759  bool operator==(InfiniteLineKit const & in_kit) const;
24760 
24764  bool operator!=(InfiniteLineKit const & in_kit) const;
24765 
24772  InfiniteLineKit & SetPriority(int in_priority);
24773 
24776  InfiniteLineKit & UnsetPriority();
24777 
24781  bool ShowPriority(int & out_priority) const;
24782 
24783 
24787  InfiniteLineKit & SetFirst(Point const & in_first);
24788 
24792  InfiniteLineKit & SetSecond(Point const & in_second);
24793 
24797  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
24798 
24799 
24802  InfiniteLineKit & UnsetFirst();
24803 
24806  InfiniteLineKit & UnsetSecond();
24807 
24810  InfiniteLineKit & UnsetType();
24811 
24814  InfiniteLineKit & UnsetEverything();
24815 
24816 
24820  bool ShowFirst(Point & out_first) const;
24821 
24825  bool ShowSecond(Point & out_second) const;
24826 
24830  bool ShowType(InfiniteLine::Type & out_type) const;
24831 
24837  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24838 
24843  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24844 
24849  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24850 
24854  InfiniteLineKit & UnsetUserData(intptr_t in_index);
24855 
24860  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24861 
24865  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
24866 
24869  InfiniteLineKit & UnsetAllUserData();
24870 
24872  size_t ShowUserDataCount() const;
24873 
24877  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24878 
24883  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24884 
24889  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24890 };
24891 
24892 
24894 class HPS_API InfiniteLineKey : public GeometryKey
24895 {
24896 public:
24898  InfiniteLineKey();
24899 
24903  explicit InfiniteLineKey(Key const & in_that);
24904 
24907  InfiniteLineKey(InfiniteLineKey const & in_that);
24908 
24912  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
24913 
24917  InfiniteLineKey(InfiniteLineKey && in_that);
24918 
24922  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
24923 
24924  ~InfiniteLineKey();
24925 
24926  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKey; };
24927 
24930  void Consume(InfiniteLineKit & in_kit);
24931 
24934  void Set(InfiniteLineKit const & in_kit);
24935 
24938  void Show(InfiniteLineKit & out_kit) const;
24939 
24940 
24944  InfiniteLineKey & SetFirst(Point const & in_first);
24945 
24949  InfiniteLineKey & SetSecond(Point const & in_second);
24950 
24954  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
24955 
24956 
24960  bool ShowFirst(Point & out_first) const;
24961 
24965  bool ShowSecond(Point & out_second) const;
24966 
24970  bool ShowType(InfiniteLine::Type & out_type) const;
24971 };
24972 
24973 
24974 
24978 class HPS_API SpotlightKit : public Object
24979 {
24980 public:
24982  SpotlightKit();
24983 
24986  SpotlightKit(SpotlightKit const & in_kit);
24987 
24991  SpotlightKit(SpotlightKit && in_that);
24992 
24996  SpotlightKit & operator=(SpotlightKit && in_that);
24997 
24998  virtual ~SpotlightKit();
24999 
25000  HPS::Type ObjectType() const { return HPS::Type::SpotlightKit; };
25001 
25005  static SpotlightKit GetDefault();
25006 
25009  void Consume(SpotlightKit & in_kit);
25010 
25013  void Set(SpotlightKit const & in_kit);
25014 
25017  void Show(SpotlightKit & out_kit) const;
25018 
25022  SpotlightKit & operator=(SpotlightKit const & in_kit);
25023 
25026  bool Empty() const;
25027 
25031  bool Equals(SpotlightKit const & in_kit) const;
25032 
25036  bool operator==(SpotlightKit const & in_kit) const;
25037 
25041  bool operator!=(SpotlightKit const & in_kit) const;
25042 
25043 
25050  SpotlightKit & SetPriority(int in_priority);
25051 
25057  SpotlightKit & SetPosition(HPS::Point const & in_position);
25058 
25064  SpotlightKit & SetTarget(HPS::Point const & in_target);
25065 
25069  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
25070 
25074  SpotlightKit & SetColorByIndex(float in_index);
25075 
25082 
25089 
25095  SpotlightKit & SetConcentration(float in_concentration);
25096 
25102  SpotlightKit & SetCameraRelative(bool in_state);
25103 
25104 
25107  SpotlightKit & UnsetPriority();
25108 
25111  SpotlightKit & UnsetPosition();
25112 
25115  SpotlightKit & UnsetTarget();
25116 
25119  SpotlightKit & UnsetColor();
25120 
25123  SpotlightKit & UnsetOuterCone();
25124 
25127  SpotlightKit & UnsetInnerCone();
25128 
25131  SpotlightKit & UnsetConcentration();
25132 
25135  SpotlightKit & UnsetCameraRelative();
25136 
25139  SpotlightKit & UnsetEverything();
25140 
25141 
25145  bool ShowPriority(int & out_priority) const;
25146 
25150  bool ShowPosition(HPS::Point & out_position) const;
25151 
25155  bool ShowTarget(HPS::Point & out_target) const;
25156 
25162  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25163 
25168  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25169 
25174  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25175 
25179  bool ShowConcentration(float & out_concentration) const;
25180 
25184  bool ShowCameraRelative(bool & out_state) const;
25185 
25191  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25192 
25197  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25198 
25203  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25204 
25208  SpotlightKit & UnsetUserData(intptr_t in_index);
25209 
25214  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25215 
25219  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
25220 
25223  SpotlightKit & UnsetAllUserData();
25224 
25226  size_t ShowUserDataCount() const;
25227 
25231  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25232 
25237  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25238 
25243  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25244 };
25245 
25246 
25248 class HPS_API SpotlightKey : public GeometryKey
25249 {
25250 public:
25252  SpotlightKey();
25253 
25257  explicit SpotlightKey(Key const & in_that);
25258 
25261  SpotlightKey(SpotlightKey const & in_that);
25262 
25266  SpotlightKey & operator=(SpotlightKey const & in_that);
25267 
25271  SpotlightKey(SpotlightKey && in_that);
25272 
25276  SpotlightKey & operator=(SpotlightKey && in_that);
25277 
25278  ~SpotlightKey();
25279 
25280  HPS::Type ObjectType() const { return HPS::Type::SpotlightKey; };
25281 
25284  void Consume(SpotlightKit & in_kit);
25285 
25288  void Set(SpotlightKit const & in_kit);
25289 
25292  void Show(SpotlightKit & out_kit) const;
25293 
25294 
25300  SpotlightKey & SetPosition(HPS::Point const & in_position);
25301 
25307  SpotlightKey & SetTarget(HPS::Point const & in_target);
25308 
25312  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
25313 
25317  SpotlightKey & SetColorByIndex(float in_index);
25318 
25325 
25332 
25338  SpotlightKey & SetConcentration(float in_concentration);
25339 
25345  SpotlightKey & SetCameraRelative(bool in_state);
25346 
25347 
25350  SpotlightKey & UnsetColor();
25351 
25352 
25356  bool ShowPosition(HPS::Point & out_position) const;
25357 
25361  bool ShowTarget(HPS::Point & out_target) const;
25362 
25368  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25369 
25374  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25375 
25380  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25381 
25385  bool ShowConcentration(float & out_concentration) const;
25386 
25390  bool ShowCameraRelative(bool & out_state) const;
25391 };
25392 
25393 
25394 
25396 class HPS_API NURBSCurveKit : public Object
25397 {
25398 public:
25400  NURBSCurveKit();
25401 
25404  NURBSCurveKit(NURBSCurveKit const & in_kit);
25405 
25409  NURBSCurveKit(NURBSCurveKit && in_that);
25410 
25414  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
25415 
25416  virtual ~NURBSCurveKit();
25417 
25418  HPS::Type ObjectType() const { return HPS::Type::NURBSCurveKit; };
25419 
25422  void Consume(NURBSCurveKit & in_kit);
25423 
25426  void Set(NURBSCurveKit const & in_kit);
25427 
25430  void Show(NURBSCurveKit & out_kit) const;
25431 
25435  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
25436 
25439  bool Empty() const;
25440 
25444  bool Equals(NURBSCurveKit const & in_kit) const;
25445 
25449  bool operator==(NURBSCurveKit const & in_kit) const;
25450 
25454  bool operator!=(NURBSCurveKit const & in_kit) const;
25455 
25458  size_t GetPointCount() const;
25459 
25466  NURBSCurveKit & SetPriority(int in_priority);
25467 
25470  NURBSCurveKit & UnsetPriority();
25471 
25475  bool ShowPriority(int & out_priority) const;
25476 
25480  NURBSCurveKit & SetDegree(size_t in_degree);
25481 
25485  NURBSCurveKit & SetPoints(PointArray const & in_points);
25486 
25491  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
25492 
25496  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
25497 
25502  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
25503 
25507  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
25508 
25513  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
25514 
25519  NURBSCurveKit & SetParameters(float in_start, float in_end);
25520 
25521 
25524  NURBSCurveKit & UnsetDegree();
25525 
25528  NURBSCurveKit & UnsetPoints();
25529 
25532  NURBSCurveKit & UnsetWeights();
25533 
25536  NURBSCurveKit & UnsetKnots();
25537 
25540  NURBSCurveKit & UnsetParameters();
25541 
25544  NURBSCurveKit & UnsetEverything();
25545 
25546 
25550  bool ShowDegree(size_t & out_degree) const;
25551 
25555  bool ShowPoints(PointArray & out_points) const;
25556 
25562  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25563 
25568  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25569 
25575  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25576 
25580  bool ShowWeights(FloatArray & out_weights) const;
25581 
25585  bool ShowKnots(FloatArray & out_knots) const;
25586 
25591  bool ShowParameters(float & out_start, float & out_end) const;
25592 
25593 
25600  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25601 
25607  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25608 
25615  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25616 
25623  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25624 
25631  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25632 
25633 
25641  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25642 
25649  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25650 
25658  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25659 
25666  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25667 
25674  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25675 
25676 
25682  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25683 
25688  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25689 
25695  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
25696 
25703  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25704 
25711  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25712 
25718  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25719 
25724  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25725 
25730  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25731 
25735  NURBSCurveKit & UnsetUserData(intptr_t in_index);
25736 
25741  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25742 
25746  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
25747 
25750  NURBSCurveKit & UnsetAllUserData();
25751 
25753  size_t ShowUserDataCount() const;
25754 
25758  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25759 
25764  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25765 
25770  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25771 };
25772 
25773 
25775 class HPS_API NURBSCurveKey : public GeometryKey
25776 {
25777 public:
25779  NURBSCurveKey();
25780 
25784  explicit NURBSCurveKey(Key const & in_that);
25785 
25788  NURBSCurveKey(NURBSCurveKey const & in_that);
25789 
25793  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
25794 
25798  NURBSCurveKey(NURBSCurveKey && in_that);
25799 
25803  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
25804 
25805  ~NURBSCurveKey();
25806 
25807  HPS::Type ObjectType() const {return HPS::Type::NURBSCurveKey;};
25808 
25811  void Consume(NURBSCurveKit & in_kit);
25812 
25815  void Set(NURBSCurveKit const & in_kit);
25816 
25819  void Show(NURBSCurveKit & out_kit) const;
25820 
25823  size_t GetPointCount() const;
25824 
25829  NURBSCurveKey & SetParameters(float in_start, float in_end);
25830 
25834  bool ShowDegree(size_t & out_degree) const;
25835 
25839  bool ShowPoints(PointArray & out_points) const;
25840 
25846  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25847 
25852  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25853 
25859  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25860 
25864  bool ShowWeights(FloatArray & out_weights) const;
25865 
25869  bool ShowKnots(FloatArray & out_knots) const;
25870 
25875  bool ShowParameters(float & out_start, float & out_end) const;
25876 
25877 
25885  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25886 
25893  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25894 
25895 
25904  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25905 
25913  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25914 
25915 
25923  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25924 
25931  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25932 };
25933 
25934 
25935 
25937 class HPS_API NURBSSurfaceKit : public Object
25938 {
25939 public:
25941  NURBSSurfaceKit();
25942 
25945  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
25946 
25950  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
25951 
25955  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
25956 
25957  virtual ~NURBSSurfaceKit();
25958 
25959  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKit; };
25960 
25963  void Consume(NURBSSurfaceKit & in_kit);
25964 
25967  void Set(NURBSSurfaceKit const & in_kit);
25968 
25971  void Show(NURBSSurfaceKit & out_kit) const;
25972 
25976  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
25977 
25980  bool Empty() const;
25981 
25985  bool Equals(NURBSSurfaceKit const & in_kit) const;
25986 
25990  bool operator==(NURBSSurfaceKit const & in_kit) const;
25991 
25995  bool operator!=(NURBSSurfaceKit const & in_kit) const;
25996 
25999  size_t GetPointCount() const;
26000 
26007  NURBSSurfaceKit & SetPriority(int in_priority);
26008 
26011  NURBSSurfaceKit & UnsetPriority();
26012 
26016  bool ShowPriority(int & out_priority) const;
26017 
26021  NURBSSurfaceKit & SetUDegree(size_t in_degree);
26022 
26026  NURBSSurfaceKit & SetVDegree(size_t in_degree);
26027 
26031  NURBSSurfaceKit & SetUCount(size_t in_count);
26032 
26036  NURBSSurfaceKit & SetVCount(size_t in_count);
26037 
26041  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
26042 
26047  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
26048 
26053  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
26054 
26060  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
26061 
26066  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
26067 
26073  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
26074 
26079  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
26080 
26086  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
26087 
26091  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
26092 
26097  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
26098 
26099 
26102  NURBSSurfaceKit & UnsetUDegree();
26103 
26106  NURBSSurfaceKit & UnsetVDegree();
26107 
26110  NURBSSurfaceKit & UnsetUCount();
26111 
26114  NURBSSurfaceKit & UnsetVCount();
26115 
26118  NURBSSurfaceKit & UnsetPoints();
26119 
26122  NURBSSurfaceKit & UnsetWeights();
26123 
26126  NURBSSurfaceKit & UnsetUKnots();
26127 
26130  NURBSSurfaceKit & UnsetVKnots();
26131 
26134  NURBSSurfaceKit & UnsetTrims();
26135 
26138  NURBSSurfaceKit & UnsetEverything();
26139 
26140 
26144  bool ShowUDegree(size_t & out_degree) const;
26145 
26149  bool ShowVDegree(size_t & out_degree) const;
26150 
26154  bool ShowUCount(size_t & out_count) const;
26155 
26159  bool ShowVCount(size_t & out_count) const;
26160 
26164  bool ShowPoints(PointArray & out_points) const;
26165 
26171  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26172 
26177  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26178 
26184  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26185 
26189  bool ShowWeights(FloatArray & out_weights) const;
26190 
26194  bool ShowUKnots(FloatArray & out_knots) const;
26195 
26199  bool ShowVKnots(FloatArray & out_knots) const;
26200 
26204  bool ShowTrims(TrimKitArray & out_trims) const;
26205 
26206 
26213  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
26214 
26220  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
26221 
26228  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
26229 
26236  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26237 
26244  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26245 
26246 
26254  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
26255 
26262  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
26263 
26271  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
26272 
26279  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26280 
26287  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26288 
26289 
26296  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26297 
26303  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26304 
26311  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
26312 
26319  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26320 
26327  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26328 
26329 
26336  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26337 
26343  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26344 
26351  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
26352 
26359  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26360 
26367  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26368 
26374  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26375 
26380  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26381 
26386  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26387 
26391  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
26392 
26397  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26398 
26402  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
26403 
26406  NURBSSurfaceKit & UnsetAllUserData();
26407 
26409  size_t ShowUserDataCount() const;
26410 
26414  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26415 
26420  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26421 
26426  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26427 };
26428 
26429 
26431 class HPS_API NURBSSurfaceKey : public GeometryKey
26432 {
26433 public:
26435  NURBSSurfaceKey();
26436 
26440  explicit NURBSSurfaceKey(Key const & in_that);
26441 
26444  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
26445 
26449  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
26450 
26454  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
26455 
26459  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
26460 
26461  ~NURBSSurfaceKey();
26462 
26463  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKey; };
26464 
26467  void Consume(NURBSSurfaceKit & in_kit);
26468 
26471  void Set(NURBSSurfaceKit const & in_kit);
26472 
26475  void Show(NURBSSurfaceKit & out_kit) const;
26476 
26479  size_t GetPointCount() const;
26480 
26485  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
26486 
26490  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
26491 
26492 
26495  NURBSSurfaceKey & UnsetTrims();
26496 
26497 
26501  bool ShowUDegree(size_t & out_degree) const;
26502 
26506  bool ShowVDegree(size_t & out_degree) const;
26507 
26511  bool ShowUCount(size_t & out_count) const;
26512 
26516  bool ShowVCount(size_t & out_count) const;
26517 
26521  bool ShowPoints(PointArray & out_points) const;
26522 
26528  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26529 
26534  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26535 
26541  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26542 
26546  bool ShowWeights(FloatArray & out_weights) const;
26547 
26551  bool ShowUKnots(FloatArray & out_knots) const;
26552 
26556  bool ShowVKnots(FloatArray & out_knots) const;
26557 
26561  bool ShowTrims(TrimKitArray & out_trims) const;
26562 
26563 
26571  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26572 
26579  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26580 
26581 
26590  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26591 
26599  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26600 
26601 
26609  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26610 
26617  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26618 
26619 
26627  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26628 
26635  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26636 };
26637 
26638 
26639 
26641 class HPS_API TrimElement : public Object
26642 {
26643 public:
26645  TrimElement();
26646 
26649  TrimElement(TrimElement const & in_that);
26650 
26654  TrimElement(LineKit const & in_line);
26655 
26659  TrimElement(NURBSCurveKit const & in_curve);
26660 
26664  TrimElement(TrimElement && in_that);
26665 
26669  TrimElement & operator=(TrimElement && in_that);
26670 
26671  ~TrimElement();
26672 
26673  HPS::Type ObjectType() const { return HPS::Type::TrimElement; };
26674 
26677  void Set(TrimElement const & in_that);
26678 
26682  TrimElement & operator=(TrimElement const & in_that);
26683 
26687  bool Equals(TrimElement const & in_that) const;
26688 
26692  bool operator==(TrimElement const & in_that) const;
26693 
26697  bool operator!=(TrimElement const & in_that) const;
26698 
26699 
26703  void SetCurve(LineKit const & in_line);
26704 
26708  void SetCurve(NURBSCurveKit const & in_curve);
26709 
26715  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
26716 };
26717 
26718 
26719 
26721 class HPS_API TrimKit : public Object
26722 {
26723 public:
26725  TrimKit();
26726 
26729  TrimKit(TrimKit const & in_kit);
26730 
26734  TrimKit(TrimKit && in_that);
26735 
26739  TrimKit & operator=(TrimKit && in_that);
26740 
26741  virtual ~TrimKit();
26742 
26743  HPS::Type ObjectType() const { return HPS::Type::TrimKit; };
26744 
26747  void Set(TrimKit const & in_kit);
26748 
26751  void Show(TrimKit & out_kit) const;
26752 
26756  TrimKit & operator=(TrimKit const & in_kit);
26757 
26760  bool Empty() const;
26761 
26765  bool Equals(TrimKit const & in_kit) const;
26766 
26770  bool operator==(TrimKit const & in_kit) const;
26771 
26775  bool operator!=(TrimKit const & in_kit) const;
26776 
26777 
26782  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
26783 
26787  TrimKit & SetShape(TrimElementArray const & in_shape);
26788 
26792  TrimKit & SetOperation(Trim::Operation in_operation);
26793 
26794 
26797  TrimKit & UnsetShape();
26798 
26801  TrimKit & UnsetOperation();
26802 
26805  TrimKit & UnsetEverything();
26806 
26807 
26811  bool ShowShape(TrimElementArray & out_shape) const;
26812 
26816  bool ShowOperation(Trim::Operation & out_operation) const;
26817 };
26818 
26819 
26820 
26822 class HPS_API EllipseKit : public Object
26823 {
26824 public:
26826  EllipseKit();
26827 
26830  EllipseKit(EllipseKit const & in_kit);
26831 
26835  EllipseKit(EllipseKit && in_that);
26836 
26840  EllipseKit & operator=(EllipseKit && in_that);
26841 
26842  virtual ~EllipseKit();
26843 
26844  HPS::Type ObjectType() const { return HPS::Type::EllipseKit; };
26845 
26848  void Consume(EllipseKit & in_kit);
26849 
26852  void Set(EllipseKit const & in_kit);
26853 
26856  void Show(EllipseKit & out_kit) const;
26857 
26861  EllipseKit & operator=(EllipseKit const & in_kit);
26862 
26865  bool Empty() const;
26866 
26870  bool Equals(EllipseKit const & in_kit) const;
26871 
26875  bool operator==(EllipseKit const & in_kit) const;
26876 
26880  bool operator!=(EllipseKit const & in_kit) const;
26881 
26888  EllipseKit & SetPriority(int in_priority);
26889 
26892  EllipseKit & UnsetPriority();
26893 
26897  bool ShowPriority(int & out_priority) const;
26898 
26899 
26903  EllipseKit & SetCenter(Point const & in_center);
26904 
26908  EllipseKit & SetMajor(Point const & in_major);
26909 
26913  EllipseKit & SetMinor(Point const & in_minor);
26914 
26915 
26918  EllipseKit & UnsetCenter();
26919 
26922  EllipseKit & UnsetMajor();
26923 
26926  EllipseKit & UnsetMinor();
26927 
26930  EllipseKit & UnsetEverything();
26931 
26932 
26936  bool ShowCenter(Point & out_center) const;
26937 
26941  bool ShowMajor(Point & out_major) const;
26942 
26946  bool ShowMinor(Point & out_minor) const;
26947 
26953  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26954 
26959  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26960 
26965  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26966 
26970  EllipseKit & UnsetUserData(intptr_t in_index);
26971 
26976  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26977 
26981  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
26982 
26985  EllipseKit & UnsetAllUserData();
26986 
26988  size_t ShowUserDataCount() const;
26989 
26993  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26994 
26999  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27000 
27005  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27006 };
27007 
27008 
27009 
27011 class HPS_API EllipseKey : public GeometryKey
27012 {
27013 public:
27015  EllipseKey();
27016 
27020  explicit EllipseKey(Key const & in_that);
27021 
27024  EllipseKey(EllipseKey const & in_that);
27025 
27029  EllipseKey & operator=(EllipseKey const & other);
27030 
27034  EllipseKey(EllipseKey && in_that);
27035 
27039  EllipseKey & operator=(EllipseKey && in_that);
27040 
27041  ~EllipseKey();
27042 
27043  HPS::Type ObjectType() const { return HPS::Type::EllipseKey; };
27044 
27047  void Consume(EllipseKit & in_kit);
27048 
27051  void Set(EllipseKit const & in_kit);
27052 
27055  void Show(EllipseKit & out_kit) const;
27056 
27057 
27061  EllipseKey & SetCenter(Point const & in_center);
27062 
27066  EllipseKey & SetMajor(Point const & in_major);
27067 
27071  EllipseKey & SetMinor(Point const & in_minor);
27072 
27073 
27077  bool ShowCenter(Point & out_center) const;
27078 
27082  bool ShowMajor(Point & out_major) const;
27083 
27087  bool ShowMinor(Point & out_minor) const;
27088 };
27089 
27090 
27091 
27093 class HPS_API EllipticalArcKit : public Object
27094 {
27095 public:
27097  EllipticalArcKit();
27098 
27101  EllipticalArcKit(EllipticalArcKit const & in_kit);
27102 
27106  EllipticalArcKit(EllipticalArcKit && in_that);
27107 
27111  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
27112 
27113  virtual ~EllipticalArcKit();
27114 
27115  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKit; };
27116 
27119  void Consume(EllipticalArcKit & in_kit);
27120 
27123  void Set(EllipticalArcKit const & in_kit);
27124 
27127  void Show(EllipticalArcKit & out_kit) const;
27128 
27132  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
27133 
27136  bool Empty() const;
27137 
27141  bool Equals(EllipticalArcKit const & in_kit) const;
27142 
27146  bool operator==(EllipticalArcKit const & in_kit) const;
27147 
27151  bool operator!=(EllipticalArcKit const & in_kit) const;
27152 
27159  EllipticalArcKit & SetPriority(int in_priority);
27160 
27163  EllipticalArcKit & UnsetPriority();
27164 
27168  bool ShowPriority(int & out_priority) const;
27169 
27170 
27174  EllipticalArcKit & SetCenter(Point const & in_center);
27175 
27179  EllipticalArcKit & SetMajor(Point const & in_major);
27180 
27184  EllipticalArcKit & SetMinor(Point const & in_minor);
27185 
27193  EllipticalArcKit & SetStart(float in_start);
27194 
27202  EllipticalArcKit & SetEnd(float in_end);
27203 
27204 
27207  EllipticalArcKit & UnsetCenter();
27208 
27211  EllipticalArcKit & UnsetMajor();
27212 
27215  EllipticalArcKit & UnsetMinor();
27216 
27219  EllipticalArcKit & UnsetStart();
27220 
27223  EllipticalArcKit & UnsetEnd();
27224 
27227  EllipticalArcKit & UnsetEverything();
27228 
27229 
27233  bool ShowCenter(Point & out_center) const;
27234 
27238  bool ShowMajor(Point & out_major) const;
27239 
27243  bool ShowMinor(Point & out_minor) const;
27244 
27248  bool ShowStart(float & out_start) const;
27249 
27253  bool ShowEnd(float & out_end) const;
27254 
27260  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27261 
27266  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27267 
27272  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27273 
27277  EllipticalArcKit & UnsetUserData(intptr_t in_index);
27278 
27283  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27284 
27288  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
27289 
27292  EllipticalArcKit & UnsetAllUserData();
27293 
27295  size_t ShowUserDataCount() const;
27296 
27300  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27301 
27306  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27307 
27312  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27313 };
27314 
27315 
27317 class HPS_API EllipticalArcKey : public GeometryKey
27318 {
27319 public:
27321  EllipticalArcKey();
27322 
27326  explicit EllipticalArcKey(Key const & in_that);
27327 
27330  EllipticalArcKey(EllipticalArcKey const & in_that);
27331 
27335  EllipticalArcKey & operator=(EllipticalArcKey const & other);
27336 
27340  EllipticalArcKey(EllipticalArcKey && in_that);
27341 
27345  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
27346 
27347  ~EllipticalArcKey();
27348 
27349  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKey; };
27350 
27351 
27354  void Consume(EllipticalArcKit & in_kit);
27355 
27358  void Set(EllipticalArcKit const & in_kit);
27359 
27362  void Show(EllipticalArcKit & out_kit) const;
27363 
27364 
27368  EllipticalArcKey & SetCenter(Point const & in_center);
27369 
27373  EllipticalArcKey & SetMajor(Point const & in_major);
27374 
27378  EllipticalArcKey & SetMinor(Point const & in_minor);
27379 
27387  EllipticalArcKey & SetStart(float in_start);
27388 
27396  EllipticalArcKey & SetEnd(float in_end);
27397 
27398 
27402  bool ShowCenter(Point & out_center) const;
27403 
27407  bool ShowMajor(Point & out_major) const;
27408 
27412  bool ShowMinor(Point & out_minor) const;
27413 
27417  bool ShowStart(float & out_start) const;
27418 
27422  bool ShowEnd(float & out_end) const;
27423 };
27424 
27425 
27426 
27428 class HPS_API TextKit : public Object
27429 {
27430 public:
27432  TextKit();
27433 
27436  TextKit(TextKit const & in_kit);
27437 
27441  TextKit(TextKit && in_that);
27442 
27446  TextKit & operator=(TextKit && in_that);
27447 
27448  virtual ~TextKit();
27449 
27450  HPS::Type ObjectType() const { return HPS::Type::TextKit; };
27451 
27454  void Consume(TextKit & in_kit);
27455 
27458  void Set(TextKit const & in_kit);
27459 
27462  void Show(TextKit & out_kit) const;
27463 
27467  TextKit & operator=(TextKit const & in_kit);
27468 
27471  bool Empty() const;
27472 
27476  bool Equals(TextKit const & in_kit) const;
27477 
27481  bool operator==(TextKit const & in_kit) const;
27482 
27486  bool operator!=(TextKit const & in_kit) const;
27487 
27494  TextKit & SetPriority(int in_priority);
27495 
27498  TextKit & UnsetPriority();
27499 
27503  bool ShowPriority(int & out_priority) const;
27504 
27508  TextKit & SetPosition(Point const & in_position);
27509 
27513  TextKit & SetText(char const * in_string);
27514 
27518  TextKit & SetColor(RGBAColor const & in_rgba_color);
27519 
27523  TextKit & SetColorByIndex(float in_index);
27524 
27528  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
27529 
27536 
27540  TextKit & SetBold(bool in_state);
27541 
27545  TextKit & SetItalic(bool in_state);
27546 
27550  TextKit & SetOverline(bool in_state);
27551 
27555  TextKit & SetStrikethrough(bool in_state);
27556 
27560  TextKit & SetUnderline(bool in_state);
27561 
27566  TextKit & SetSlant(float in_angle);
27567 
27571  TextKit & SetLineSpacing(float in_multiplier);
27572 
27578  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27579 
27583  TextKit & SetRotation(float in_angle);
27584 
27590  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27591 
27596  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
27597 
27604  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27605 
27611  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27612 
27621  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
27622 
27630  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
27631 
27636  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
27637 
27643  TextKit & SetFont(char const * in_name);
27644 
27648  TextKit & SetTransform(Text::Transform in_trans);
27649 
27653  TextKit & SetRenderer(Text::Renderer in_rend);
27654 
27658  TextKit & SetPreference(Text::Preference in_pref);
27659 
27666  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27667 
27671  TextKit & SetPath(Vector const & in_path);
27672 
27678  TextKit & SetSpacing(float in_multiplier);
27679 
27680 
27683  TextKit & UnsetPosition();
27684 
27687  TextKit & UnsetText();
27688 
27691  TextKit & UnsetColor();
27692 
27695  TextKit & UnsetModellingMatrix();
27696 
27699  TextKit & UnsetAlignment();
27700 
27703  TextKit & UnsetBold();
27704 
27707  TextKit & UnsetItalic();
27708 
27711  TextKit & UnsetOverline();
27712 
27715  TextKit & UnsetStrikethrough();
27716 
27719  TextKit & UnsetUnderline();
27720 
27723  TextKit & UnsetSlant();
27724 
27727  TextKit & UnsetLineSpacing();
27728 
27731  TextKit & UnsetRotation();
27732 
27735  TextKit & UnsetExtraSpace();
27736 
27739  TextKit & UnsetGreeking();
27740 
27743  TextKit & UnsetSizeTolerance();
27744 
27747  TextKit & UnsetSize();
27748 
27751  TextKit & UnsetFont();
27752 
27755  TextKit & UnsetTransform();
27756 
27759  TextKit & UnsetRenderer();
27760 
27763  TextKit & UnsetPreference();
27764 
27767  TextKit & UnsetPath();
27768 
27771  TextKit & UnsetSpacing();
27772 
27775  TextKit & UnsetEverything();
27776 
27777 
27781  bool ShowPosition(Point & out_position) const;
27782 
27786  bool ShowText(UTF8 & out_string) const;
27787 
27793  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27794 
27798  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27799 
27805  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27806 
27810  bool ShowBold(bool & out_state) const;
27811 
27815  bool ShowItalic(bool & out_state) const;
27816 
27820  bool ShowOverline(bool & out_state) const;
27821 
27825  bool ShowStrikethrough(bool & out_state) const;
27826 
27830  bool ShowUnderline(bool & out_state) const;
27831 
27835  bool ShowSlant(float & out_angle) const;
27836 
27840  bool ShowLineSpacing(float & out_multiplier) const;
27841 
27846  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27847 
27853  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27854 
27861  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27862 
27868  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27869 
27874  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27875 
27879  bool ShowFont(UTF8 & out_name) const;
27880 
27884  bool ShowTransform(Text::Transform & out_trans) const;
27885 
27889  bool ShowRenderer(Text::Renderer & out_renderer) const;
27890 
27897  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
27898 
27902  bool ShowPath(Vector & out_path) const;
27903 
27907  bool ShowSpacing(float & out_multiplier) const;
27908 
27909 
27917  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27918 
27925  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
27926 
27933  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27934 
27943  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;
27944 
27957  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);
27958 
27972  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);
27973 
27979  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27980 
27983  TextKit & UnsetRegion();
27984 
27989  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27990 
27995  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27996 
28000  TextKit & UnsetUserData(intptr_t in_index);
28001 
28006  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28007 
28011  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
28012 
28015  TextKit & UnsetAllUserData();
28016 
28018  size_t ShowUserDataCount() const;
28019 
28023  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28024 
28029  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28030 
28035  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28036 };
28037 
28038 
28040 class HPS_API TextKey : public GeometryKey
28041 {
28042 public:
28044  TextKey();
28045 
28049  explicit TextKey(Key const & in_that);
28050 
28053  TextKey(TextKey const & in_that);
28054 
28058  TextKey & operator=(TextKey const & other);
28059 
28063  TextKey(TextKey && in_that);
28064 
28068  TextKey & operator=(TextKey && in_that);
28069 
28070  ~TextKey();
28071 
28072  HPS::Type ObjectType() const {return HPS::Type::TextKey;};
28073 
28076  void Consume(TextKit & in_kit);
28077 
28080  void Set(TextKit const & in_kit);
28081 
28084  void Show(TextKit & out_kit) const;
28085 
28088  TextKey & SetTextAttributes(TextAttributeKit const & in_kit);
28089 
28093  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
28094 
28098  TextKey & SetPosition(Point const & in_position);
28099 
28103  TextKey & SetText(char const * in_string);
28104 
28108  TextKey & SetColor(RGBAColor const & in_rgba_color);
28109 
28113  TextKey & SetColorByIndex(float in_index);
28114 
28118  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
28119 
28126 
28130  TextKey & SetBold(bool in_state);
28131 
28135  TextKey & SetItalic(bool in_state);
28136 
28140  TextKey & SetOverline(bool in_state);
28141 
28145  TextKey & SetStrikethrough(bool in_state);
28146 
28150  TextKey & SetUnderline(bool in_state);
28151 
28156  TextKey & SetSlant(float in_angle);
28157 
28162  TextKey & SetLineSpacing(float in_multiplier);
28163 
28169  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
28170 
28174  TextKey & SetRotation(float in_angle);
28175 
28181  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
28182 
28187  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
28188 
28195  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28196 
28202  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28203 
28212  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
28213 
28221  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
28222 
28227  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
28228 
28234  TextKey & SetFont(char const * in_name);
28235 
28239  TextKey & SetTransform(Text::Transform in_transform);
28240 
28244  TextKey & SetRenderer(Text::Renderer in_renderer);
28245 
28249  TextKey & SetPreference(Text::Preference in_preference);
28250 
28258  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
28259 
28264  TextKey & SetPath(Vector const & in_path);
28265 
28271  TextKey & SetSpacing(float in_multiplier);
28272 
28285  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);
28286 
28300  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);
28301 
28302 
28305  TextKey & UnsetColor();
28306 
28309  TextKey & UnsetModellingMatrix();
28310 
28313  TextKey & UnsetAlignment();
28314 
28317  TextKey & UnsetBold();
28318 
28321  TextKey & UnsetItalic();
28322 
28325  TextKey & UnsetOverline();
28326 
28329  TextKey & UnsetStrikethrough();
28330 
28333  TextKey & UnsetUnderline();
28334 
28337  TextKey & UnsetSlant();
28338 
28341  TextKey & UnsetLineSpacing();
28342 
28345  TextKey & UnsetRotation();
28346 
28349  TextKey & UnsetExtraSpace();
28350 
28353  TextKey & UnsetGreeking();
28354 
28357  TextKey & UnsetSizeTolerance();
28358 
28361  TextKey & UnsetSize();
28362 
28365  TextKey & UnsetFont();
28366 
28369  TextKey & UnsetTransform();
28370 
28373  TextKey & UnsetRenderer();
28374 
28377  TextKey & UnsetPreference();
28378 
28381  TextKey & UnsetPath();
28382 
28385  TextKey & UnsetSpacing();
28386 
28389  TextKey & UnsetRegion();
28390 
28393  TextKey & UnsetEverything();
28394 
28395 
28399  bool ShowPosition(Point & out_position) const;
28400 
28404  bool ShowText(UTF8 & out_string) const;
28405 
28411  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28412 
28416  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28417 
28423  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28424 
28428  bool ShowBold(bool & out_state) const;
28429 
28433  bool ShowItalic(bool & out_state) const;
28434 
28438  bool ShowOverline(bool & out_state) const;
28439 
28443  bool ShowStrikethrough(bool & out_state) const;
28444 
28448  bool ShowUnderline(bool & out_state) const;
28449 
28453  bool ShowSlant(float & out_angle) const;
28454 
28458  bool ShowLineSpacing(float & out_multiplier) const;
28459 
28464  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28465 
28471  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28472 
28479  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28480 
28486  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28487 
28492  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28493 
28497  bool ShowFont(UTF8 & out_name) const;
28498 
28502  bool ShowTransform(Text::Transform & out_trans) const;
28503 
28507  bool ShowRenderer(Text::Renderer & out_renderer) const;
28508 
28515  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28516 
28520  bool ShowPath(Vector & out_path) const;
28521 
28525  bool ShowSpacing(float & out_multiplier) const;
28526 
28535  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;
28536 
28537 
28545  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28546 
28553  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28554 
28561  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28562 };
28563 
28564 
28566 class HPS_API ShellOptimizationOptionsKit : public Object
28567 {
28568 public:
28571 
28575 
28580 
28581  virtual ~ShellOptimizationOptionsKit();
28582 
28583  HPS::Type ObjectType() const { return HPS::Type::ShellOptimizationOptionsKit; };
28584 
28587  void Consume(ShellOptimizationOptionsKit & in_kit);
28588 
28591  void Set(ShellOptimizationOptionsKit const & in_kit);
28592 
28595  void Show(ShellOptimizationOptionsKit & out_kit) const;
28596 
28600  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
28601 
28606 
28609  bool Empty() const;
28610 
28614  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
28615 
28619  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
28620 
28624  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
28625 
28629  static ShellOptimizationOptionsKit GetDefault();
28630 
28631 
28635  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
28636 
28641  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
28642 
28647  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
28648 
28653  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
28654 
28655 
28658  ShellOptimizationOptionsKit & UnsetNormalTolerance();
28659 
28662  ShellOptimizationOptionsKit & UnsetTolerance();
28663 
28666  ShellOptimizationOptionsKit & UnsetOrphanElimination();
28667 
28670  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
28671 
28674  ShellOptimizationOptionsKit & UnsetEverything();
28675 
28676 
28680  bool ShowNormalTolerance(float & out_normal_tolerance) const;
28681 
28686  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
28687 
28691  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
28692 
28697  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
28698 };
28699 
28700 
28704 class HPS_API ShellRelationOptionsKit : public Object
28705 {
28706 public:
28709 
28713 
28718 
28722  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
28723 
28724  virtual ~ShellRelationOptionsKit();
28725 
28726  HPS::Type ObjectType() const { return HPS::Type::ShellRelationOptionsKit; };
28727 
28731  static ShellRelationOptionsKit GetDefault();
28732 
28735  void Consume(ShellRelationOptionsKit & in_kit);
28736 
28739  void Set(ShellRelationOptionsKit const & in_kit);
28740 
28743  void Show(ShellRelationOptionsKit & out_kit) const;
28744 
28748  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
28749 
28752  bool Empty() const;
28753 
28757  bool Equals(ShellRelationOptionsKit const & in_kit) const;
28758 
28762  bool operator==(ShellRelationOptionsKit const & in_kit) const;
28763 
28767  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
28768 
28769 
28773  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
28774 
28778  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
28779 
28784  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
28785 
28789  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
28790 
28791 
28794  ShellRelationOptionsKit & UnsetTolerance();
28795 
28798  ShellRelationOptionsKit & UnsetTest();
28799 
28802  ShellRelationOptionsKit & UnsetTreeContext();
28803 
28806  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
28807 
28810  ShellRelationOptionsKit & UnsetEverything();
28811 
28812 
28816  bool ShowTolerance(float & out_tolerance) const;
28817 
28821  bool ShowTest(Shell::RelationTest & out_test) const;
28822 
28826  bool ShowTreeContext(TreeContext & out_tree_context) const;
28827 
28831  bool ShowNearestFaceCalculation(bool & out_state) const;
28832 };
28833 
28835 class HPS_API ShellRelationResultsKit : public Object
28836 {
28837 public:
28840 
28844 
28849 
28853  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
28854 
28855  virtual ~ShellRelationResultsKit();
28856 
28857  HPS::Type ObjectType() const { return HPS::Type::ShellRelationResultsKit; };
28858 
28861  void Consume(ShellRelationResultsKit & in_kit);
28862 
28865  void Set(ShellRelationResultsKit const & in_kit);
28866 
28869  void Show(ShellRelationResultsKit & out_kit) const;
28870 
28874  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
28875 
28878  bool Empty() const;
28879 
28883  bool Equals(ShellRelationResultsKit const & in_kit) const;
28884 
28888  bool operator==(ShellRelationResultsKit const & in_kit) const;
28889 
28893  bool operator!=(ShellRelationResultsKit const & in_kit) const;
28894 
28895 
28899  bool ShowRelations(ShellRelationArray & out_results) const;
28900 
28904  bool ShowNearestFaces(SizeTArray & out_faces) const;
28905 
28909  bool ShowDistances(FloatArray & out_distances) const;
28910 };
28911 
28912 
28914 class HPS_API ShellKit : public Object
28915 {
28916 public:
28918  ShellKit();
28919 
28922  ShellKit(ShellKit const & in_kit);
28923 
28927  ShellKit(ShellKit && in_that);
28928 
28932  ShellKit & operator=(ShellKit && in_that);
28933 
28934  virtual ~ShellKit();
28935 
28936  HPS::Type ObjectType() const { return HPS::Type::ShellKit; };
28937 
28940  void Consume(ShellKit & in_kit);
28941 
28944  void Set(ShellKit const & in_kit);
28945 
28948  void Show(ShellKit & out_kit) const;
28949 
28952  size_t GetPointCount() const;
28953 
28956  size_t GetFaceCount() const;
28957 
28961  ShellKit & operator=(ShellKit const & in_kit);
28962 
28965  bool Empty() const;
28966 
28970  bool Equals(ShellKit const & in_kit) const;
28971 
28975  bool operator==(ShellKit const & in_kit) const;
28976 
28980  bool operator!=(ShellKit const & in_kit) const;
28981 
28988  ShellKit & SetPriority(int in_priority);
28989 
28992  ShellKit & UnsetPriority();
28993 
28997  bool ShowPriority(int & out_priority) const;
28998 
28999 
29000 
29004  ShellKit & SetPoints(PointArray const & in_points);
29005 
29010  ShellKit & SetPoints(size_t in_count, Point const in_points []);
29011 
29015  ShellKit & SetFacelist(IntArray const & in_facelist);
29016 
29021  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
29022 
29026  ShellKit & SetTristrips(IntArray const & in_tristrips);
29027 
29032  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
29033 
29036  ShellKit & UnsetPoints();
29037 
29040  ShellKit & UnsetFacelist();
29041 
29044  ShellKit & UnsetTristrips();
29045 
29048  ShellKit & UnsetEverything();
29049 
29053  bool ShowPoints(PointArray & out_points) const;
29054 
29060  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29061 
29066  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29067 
29073  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29074 
29078  bool ShowFacelist(IntArray & out_facelist) const;
29079 
29083  bool ShowTristrips(IntArray & out_tristrips) const;
29084 
29090  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
29091 
29092 
29099  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29100 
29106  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29107 
29114  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29115 
29122  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29123 
29130  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29131 
29138  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29139 
29145  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29146 
29147 
29154  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29155 
29161  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29162 
29169  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29170 
29177  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29178 
29185  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29186 
29193  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29194 
29200  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29201 
29202 
29209  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29210 
29216  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29217 
29224  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29225 
29232  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29233 
29240  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29241 
29248  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29249 
29255  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29256 
29257 
29263  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29264 
29269  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29270 
29276  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29277 
29283  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29284 
29289  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29290 
29296  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29297 
29302  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29303 
29304 
29311  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29312 
29319  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29320 
29329  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);
29330 
29338  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29339 
29340 
29346  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29347 
29352  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29353 
29359  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29360 
29366  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29367 
29372  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29373 
29379  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29380 
29385  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29386 
29387 
29390  ShellKit & UnsetMaterialMapping();
29391 
29392 
29395  ShellKit & UnsetVertexColors();
29396 
29401  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29402 
29406  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29407 
29408 
29412  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
29413 
29419  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29420 
29425  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29426 
29427 
29430  ShellKit & UnsetVertexNormals();
29431 
29436  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29437 
29441  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29442 
29443 
29446  ShellKit & UnsetVertexParameters();
29447 
29452  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29453 
29457  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29458 
29459 
29462  ShellKit & UnsetVertexVisibilities();
29463 
29468  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29469 
29473  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29474 
29475 
29478  ShellKit & UnsetVertexEverything();
29479 
29480 
29484  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29485 
29486 
29500  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29501  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29502 
29517  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29518  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29519 
29520 
29529  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29530 
29539  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29540 
29541 
29551  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29552 
29562  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29563 
29573  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
29574 
29584  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29585 
29586 
29595  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29596 
29605  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
29606 
29607 
29608 
29614  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
29615 
29620  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
29621 
29627  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
29628 
29634  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
29635 
29640  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
29641 
29647  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
29648 
29653  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
29654 
29655 
29661  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
29662 
29667  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
29668 
29674  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
29675 
29681  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
29682 
29687  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
29688 
29694  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
29695 
29700  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
29701 
29702 
29708  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29709 
29714  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
29715 
29721  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29722 
29728  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
29729 
29734  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
29735 
29741  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
29742 
29747  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
29748 
29749 
29755  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29756 
29761  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29762 
29768  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29769 
29775  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
29776 
29781  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
29782 
29788  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
29789 
29794  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
29795 
29796 
29799  ShellKit & UnsetFaceColors();
29800 
29805  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
29806 
29810  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
29811 
29812 
29815  ShellKit & UnsetFaceNormals();
29816 
29821  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
29822 
29826  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
29827 
29828 
29831  ShellKit & UnsetFaceVisibilities();
29832 
29837  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
29838 
29842  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
29843 
29844 
29847  ShellKit & UnsetFaceEverything();
29848 
29849 
29859  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29860 
29871  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29872 
29873 
29882  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29883 
29892  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
29893 
29894 
29903  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29904 
29913  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
29914 
29915 
29922  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
29923 
29929  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
29930 
29936  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
29937 
29943  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29944 
29950  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29951 
29952 
29959  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
29960 
29966  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
29967 
29973  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
29974 
29983  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
29984 
29992  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
29993 
29996  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
29997 
30002  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30003 
30008  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30009 
30014  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30015 
30021  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30022 
30027  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30028 
30033  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30034 
30038  ShellKit & UnsetUserData(intptr_t in_index);
30039 
30044  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30045 
30049  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
30050 
30053  ShellKit & UnsetAllUserData();
30054 
30056  size_t ShowUserDataCount() const;
30057 
30061  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30062 
30067  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30068 
30073  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30074 };
30075 
30076 
30077 
30079 class HPS_API ShellKey : public GeometryKey
30080 {
30081 public:
30083  ShellKey();
30084 
30089  explicit ShellKey(Key const & in_that);
30090 
30093  ShellKey(ShellKey const & in_that);
30094 
30098  ShellKey & operator=(ShellKey const & other);
30099 
30103  ShellKey(ShellKey && in_that);
30104 
30108  ShellKey & operator=(ShellKey && in_that);
30109 
30110  ~ShellKey();
30111 
30112  HPS::Type ObjectType() const { return HPS::Type::ShellKey; };
30113 
30116  void Consume(ShellKit & in_kit);
30117 
30120  void Set(ShellKit const & in_kit);
30121 
30124  void Show(ShellKit & out_kit) const;
30125 
30128  size_t GetPointCount() const;
30129 
30132  size_t GetFaceCount() const;
30133 
30134 
30138  ShellKey & SetPoints(PointArray const & in_points);
30139 
30144  ShellKey & SetPoints(size_t in_count, Point const in_points []);
30145 
30149  ShellKey & SetFacelist(IntArray const & in_facelist);
30150 
30155  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
30156 
30160  ShellKey & SetTristrips(IntArray const & in_tristrips);
30161 
30166  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
30167 
30172  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
30173 
30176  ShellKey & UnsetPoints();
30177 
30180  ShellKey & UnsetFacelist();
30181 
30184  ShellKey & UnsetTristrips();
30185 
30188  ShellKey & UnsetMaterialMapping();
30189 
30192  ShellKey & UnsetEverything();
30193 
30197  bool ShowPoints(PointArray & out_points) const;
30198 
30204  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
30205 
30210  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
30211 
30217  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
30218 
30222  bool ShowFacelist(IntArray & out_facelist) const;
30223 
30227  bool ShowTristrips(IntArray & out_tristrips) const;
30228 
30232  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30233 
30234 
30241  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30242 
30249  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30250 
30257  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30258 
30265  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30266 
30273  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30274 
30281  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30282 
30288  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30289 
30290 
30297  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30298 
30305  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30306 
30313  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30314 
30321  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30322 
30329  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30330 
30337  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30338 
30344  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30345 
30346 
30353  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30354 
30361  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30362 
30369  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30370 
30377  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30378 
30385  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30386 
30393  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30394 
30400  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30401 
30402 
30408  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30409 
30415  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30416 
30422  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30423 
30429  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30430 
30435  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30436 
30442  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30443 
30448  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30449 
30450 
30458  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30459 
30466  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30467 
30476  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);
30477 
30485  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30486 
30487 
30493  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30494 
30500  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30501 
30507  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30508 
30514  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30515 
30520  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
30521 
30527  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
30528 
30533  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
30534 
30535 
30538  ShellKey & UnsetVertexColors();
30539 
30544  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
30545 
30549  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
30550 
30551 
30555  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
30556 
30562  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
30563 
30568  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
30569 
30570 
30573  ShellKey & UnsetVertexNormals();
30574 
30579  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
30580 
30584  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
30585 
30586 
30589  ShellKey & UnsetVertexParameters();
30590 
30595  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
30596 
30600  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
30601 
30602 
30605  ShellKey & UnsetVertexVisibilities();
30606 
30611  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
30612 
30616  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
30617 
30618 
30621  ShellKey & UnsetVertexEverything();
30622 
30623 
30637  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30638  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30639 
30654  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30655  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30656 
30657 
30666  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30667 
30676  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
30677 
30678 
30688  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
30689 
30699  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30700 
30710  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
30711 
30721  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30722 
30723 
30732  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30733 
30742  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30743 
30744 
30750  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30751 
30757  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
30758 
30764  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
30765 
30771  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
30772 
30777  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
30778 
30784  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
30785 
30790  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
30791 
30792 
30798  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
30799 
30805  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
30806 
30812  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
30813 
30819  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
30820 
30825  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
30826 
30832  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
30833 
30838  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
30839 
30840 
30846  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30847 
30853  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
30854 
30860  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30861 
30867  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
30868 
30873  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
30874 
30880  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
30881 
30886  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
30887 
30888 
30894  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30895 
30901  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30902 
30908  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30909 
30915  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
30916 
30921  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
30922 
30928  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
30929 
30934  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
30935 
30936 
30939  ShellKey & UnsetFaceColors();
30940 
30945  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
30946 
30950  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
30951 
30952 
30955  ShellKey & UnsetFaceNormals();
30956 
30961  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
30962 
30966  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
30967 
30968 
30971  ShellKey & UnsetFaceVisibilities();
30972 
30977  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
30978 
30982  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
30983 
30984 
30987  ShellKey & UnsetFaceEverything();
30988 
30989 
30999  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31000 
31011  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31012 
31013 
31022  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31023 
31032  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31033 
31034 
31040  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
31041 
31048  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
31049 
31050 
31059  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31060 
31069  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31070 
31071 
31078  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
31079 
31085  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
31086 
31092  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
31093 
31099  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
31100 
31106  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
31107 
31108 
31115  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
31116 
31122  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
31123 
31129  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
31130 
31139  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
31140 
31148  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
31149 
31152  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
31153 
31158  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31159 
31164  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31165 
31170  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31171 };
31172 
31173 
31174 
31176 class HPS_API MeshKit : public Object
31177 {
31178 public:
31180  MeshKit();
31181 
31184  MeshKit(MeshKit const & in_kit);
31185 
31189  MeshKit(MeshKit && in_that);
31190 
31194  MeshKit & operator=(MeshKit && in_that);
31195 
31196  virtual ~MeshKit();
31197 
31198  HPS::Type ObjectType() const { return HPS::Type::MeshKit; };
31199 
31202  void Consume(MeshKit & in_kit);
31203 
31206  void Set(MeshKit const & in_kit);
31207 
31210  void Show(MeshKit & out_kit) const;
31211 
31215  MeshKit & operator=(MeshKit const & in_kit);
31216 
31219  bool Empty() const;
31220 
31224  bool Equals(MeshKit const & in_kit) const;
31225 
31229  bool operator==(MeshKit const & in_kit) const;
31230 
31234  bool operator!=(MeshKit const & in_kit) const;
31235 
31238  size_t GetPointCount() const;
31239 
31246  MeshKit & SetPriority(int in_priority);
31247 
31250  MeshKit & UnsetPriority();
31251 
31255  bool ShowPriority(int & out_priority) const;
31256 
31260  MeshKit & SetPoints(PointArray const & in_points);
31261 
31266  MeshKit & SetPoints(size_t in_count, Point const in_points []);
31267 
31273  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
31274 
31281  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31282 
31286  MeshKit & SetRows(size_t in_rows);
31287 
31291  MeshKit & SetColumns(size_t in_columns);
31292 
31295  MeshKit & UnsetPoints();
31296 
31299  MeshKit & UnsetRows();
31300 
31303  MeshKit & UnsetColumns();
31304 
31307  MeshKit & UnsetEverything();
31308 
31312  bool ShowPoints(PointArray & out_points) const;
31313 
31319  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
31320 
31325  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
31326 
31332  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
31333 
31339  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31340 
31344  bool ShowRows(size_t & out_rows) const;
31345 
31349  bool ShowColumns(size_t & out_columns) const;
31350 
31351 
31357  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
31358 
31365  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31366 
31372  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31373 
31380  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31381 
31388  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31389 
31396  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31397 
31404  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31405 
31411  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31412 
31413 
31420  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31421 
31427  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31428 
31435  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31436 
31443  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31444 
31451  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31452 
31459  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31460 
31466  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31467 
31468 
31475  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31476 
31482  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31483 
31490  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31491 
31498  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31499 
31506  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31507 
31514  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31515 
31521  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31522 
31523 
31529  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31530 
31535  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31536 
31542  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31543 
31549  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31550 
31555  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31556 
31562  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31563 
31568  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31569 
31570 
31577  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31578 
31585  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31586 
31595  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);
31596 
31604  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31605 
31606 
31612  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31613 
31618  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31619 
31625  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31626 
31632  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31633 
31638  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31639 
31645  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31646 
31651  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31652 
31653 
31656  MeshKit & UnsetMaterialMapping();
31657 
31660  MeshKit & UnsetVertexColors();
31661 
31666  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31667 
31671  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31672 
31673 
31677  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
31678 
31684  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
31685 
31690  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
31691 
31692 
31695  MeshKit & UnsetVertexNormals();
31696 
31701  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31702 
31706  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31707 
31708 
31711  MeshKit & UnsetVertexParameters();
31712 
31717  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31718 
31722  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31723 
31724 
31727  MeshKit & UnsetVertexVisibilities();
31728 
31733  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31734 
31738  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31739 
31740 
31743  MeshKit & UnsetVertexEverything();
31744 
31745 
31749  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31750 
31764  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31765  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31766 
31781  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31782  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31783 
31784 
31793  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31794 
31803  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31804 
31805 
31815  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31816 
31826  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31827 
31837  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31838 
31848  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31849 
31850 
31859  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31860 
31869  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31870 
31871 
31877  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31878 
31883  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31884 
31890  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31891 
31897  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
31898 
31903  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
31904 
31910  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
31911 
31916  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
31917 
31918 
31924  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
31925 
31930  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
31931 
31937  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
31938 
31944  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
31945 
31950  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
31951 
31957  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
31958 
31963  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
31964 
31965 
31971  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31972 
31977  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
31978 
31984  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31985 
31991  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
31992 
31997  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
31998 
32004  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32005 
32010  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32011 
32012 
32018  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32019 
32024  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32025 
32031  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32032 
32038  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32039 
32044  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32045 
32051  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32052 
32057  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32058 
32059 
32062  MeshKit & UnsetFaceColors();
32063 
32068  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32069 
32073  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
32074 
32075 
32078  MeshKit & UnsetFaceNormals();
32079 
32084  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32085 
32089  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
32090 
32091 
32094  MeshKit & UnsetFaceVisibilities();
32095 
32100  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32101 
32105  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
32106 
32107 
32110  MeshKit & UnsetFaceEverything();
32111 
32112 
32122  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32123 
32134  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32135 
32136 
32145  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32146 
32155  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32156 
32157 
32166  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32167 
32176  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32177 
32183  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32184 
32189  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32190 
32195  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32196 
32200  MeshKit & UnsetUserData(intptr_t in_index);
32201 
32206  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32207 
32211  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
32212 
32215  MeshKit & UnsetAllUserData();
32216 
32218  size_t ShowUserDataCount() const;
32219 
32223  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32224 
32229  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32230 
32235  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32236 
32237 };
32238 
32239 
32240 
32242 class HPS_API MeshKey : public GeometryKey
32243 {
32244 public:
32246  MeshKey();
32247 
32252  explicit MeshKey(Key const & in_that);
32253 
32256  MeshKey(MeshKey const & in_that);
32257 
32261  MeshKey & operator=(MeshKey const & in_that);
32262 
32266  MeshKey(MeshKey && in_that);
32267 
32271  MeshKey & operator=(MeshKey && in_that);
32272 
32273  ~MeshKey();
32274 
32275  HPS::Type ObjectType() const { return HPS::Type::MeshKey; };
32276 
32279  void Consume(MeshKit & in_kit);
32280 
32283  void Set(MeshKit const & in_kit);
32284 
32287  void Show(MeshKit & out_kit) const;
32288 
32291  size_t GetPointCount() const;
32292 
32298  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
32299 
32306  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
32307 
32311  bool ShowPoints(PointArray & out_points) const;
32312 
32318  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32319 
32324  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32325 
32331  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32332 
32338  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
32339 
32343  bool ShowRows(size_t & out_rows) const;
32344 
32348  bool ShowColumns(size_t & out_columns) const;
32349 
32350 
32355  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
32356 
32359  MeshKey & UnsetMaterialMapping();
32360 
32364  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32365 
32366 
32373  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32374 
32381  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32382 
32389  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32390 
32397  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32398 
32405  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32406 
32413  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32414 
32420  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32421 
32422 
32429  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32430 
32437  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32438 
32445  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32446 
32453  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32454 
32461  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32462 
32469  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32470 
32476  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32477 
32478 
32485  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32486 
32493  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32494 
32501  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32502 
32509  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32510 
32517  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32518 
32525  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32526 
32532  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32533 
32534 
32540  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32541 
32547  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32548 
32554  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32555 
32561  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32562 
32567  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32568 
32574  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32575 
32580  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32581 
32582 
32590  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32591 
32598  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32599 
32608  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);
32609 
32617  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32618 
32619 
32625  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32626 
32632  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32633 
32639  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32640 
32646  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32647 
32652  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32653 
32659  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32660 
32665  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32666 
32667 
32670  MeshKey & UnsetVertexColors();
32671 
32676  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32677 
32681  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32682 
32683 
32687  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
32688 
32694  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
32695 
32700  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
32701 
32702 
32705  MeshKey & UnsetVertexNormals();
32706 
32711  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
32712 
32716  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
32717 
32718 
32721  MeshKey & UnsetVertexParameters();
32722 
32727  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
32728 
32732  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
32733 
32734 
32737  MeshKey & UnsetVertexVisibilities();
32738 
32743  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
32744 
32748  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
32749 
32750 
32753  MeshKey & UnsetVertexEverything();
32754 
32757  MeshKey & UnsetEverything();
32758 
32759 
32773  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32774  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32775 
32790  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32791  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32792 
32793 
32802  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32803 
32812  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32813 
32814 
32824  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32825 
32835  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32836 
32846  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32847 
32857  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32858 
32859 
32868  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32869 
32878  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32879 
32880 
32886  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32887 
32893  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32894 
32900  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
32901 
32907  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32908 
32913  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32914 
32920  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32921 
32926  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32927 
32928 
32934  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32935 
32941  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32942 
32948  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32949 
32955  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32956 
32961  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32962 
32968  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32969 
32974  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32975 
32976 
32982  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32983 
32989  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
32990 
32996  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32997 
33003  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33004 
33009  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33010 
33016  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33017 
33022  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33023 
33024 
33030  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33031 
33037  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33038 
33044  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33045 
33051  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33052 
33057  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33058 
33064  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33065 
33070  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33071 
33072 
33075  MeshKey & UnsetFaceColors();
33076 
33081  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33082 
33086  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
33087 
33088 
33091  MeshKey & UnsetFaceNormals();
33092 
33097  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33098 
33102  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
33103 
33104 
33107  MeshKey & UnsetFaceVisibilities();
33108 
33113  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33114 
33118  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
33119 
33120 
33123  MeshKey & UnsetFaceEverything();
33124 
33125 
33135  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33136 
33147  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33148 
33149 
33158  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33159 
33168  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33169 
33170 
33179  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33180 
33189  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33190 
33199  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[]);
33200 
33208  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);
33209 };
33210 
33211 
33212 
33213 
33215 class HPS_API PolygonKit : public Object
33216 {
33217 public:
33219  PolygonKit();
33220 
33223  PolygonKit(PolygonKit const & in_kit);
33224 
33228  PolygonKit(PolygonKit && in_that);
33229 
33233  PolygonKit & operator=(PolygonKit && in_that);
33234 
33235  virtual ~PolygonKit();
33236 
33237  HPS::Type ObjectType() const { return HPS::Type::PolygonKit; };
33238 
33241  void Consume(PolygonKit & in_kit);
33242 
33245  void Set(PolygonKit const & in_kit);
33246 
33249  void Show(PolygonKit & out_kit) const;
33250 
33254  PolygonKit & operator=(PolygonKit const & in_kit);
33255 
33258  bool Empty() const;
33259 
33263  bool Equals(PolygonKit const & in_kit) const;
33264 
33268  bool operator==(PolygonKit const & in_kit) const;
33269 
33273  bool operator!=(PolygonKit const & in_kit) const;
33274 
33277  size_t GetPointCount() const;
33278 
33285  PolygonKit & SetPriority(int in_priority);
33286 
33289  PolygonKit & UnsetPriority();
33290 
33294  bool ShowPriority(int & out_priority) const;
33295 
33296 
33300  PolygonKit & SetPoints(PointArray const & in_points);
33301 
33306  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
33307 
33310  PolygonKit & UnsetPoints();
33311 
33314  PolygonKit & UnsetEverything();
33315 
33319  bool ShowPoints(PointArray & out_points) const;
33320 
33326  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33327 
33332  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33333 
33339  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33340 
33346  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33347 
33352  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33353 
33358  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
33359 
33365  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33366 
33371  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33372 
33378  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33379 
33384  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33385 
33390  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33391 
33395  PolygonKit & UnsetUserData(intptr_t in_index);
33396 
33401  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33402 
33406  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
33407 
33410  PolygonKit & UnsetAllUserData();
33411 
33413  size_t ShowUserDataCount() const;
33414 
33418  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33419 
33424  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33425 
33430  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33431 };
33432 
33433 
33435 class HPS_API PolygonKey : public GeometryKey
33436 {
33437 public:
33439  PolygonKey();
33440 
33445  explicit PolygonKey(Key const & in_that);
33446 
33449  PolygonKey(PolygonKey const & in_that);
33450 
33454  PolygonKey & operator=(PolygonKey const & in_that);
33455 
33459  PolygonKey(PolygonKey && in_that);
33460 
33464  PolygonKey & operator=(PolygonKey && in_that);
33465 
33466  ~PolygonKey();
33467 
33468  HPS::Type ObjectType() const { return HPS::Type::PolygonKey; };
33469 
33470 
33473  void Consume(PolygonKit & in_kit);
33474 
33477  void Set(PolygonKit const & in_kit);
33478 
33481  void Show(PolygonKit & out_kit) const;
33482 
33485  size_t GetPointCount() const;
33486 
33490  PolygonKey & SetPoints(PointArray const & in_points);
33491 
33496  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
33497 
33501  bool ShowPoints(PointArray & out_points) const;
33502 
33508  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33509 
33514  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33515 
33521  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33522 
33528  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33529 
33534  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33535 
33540  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
33541 
33547  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33548 
33553  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33554 };
33555 
33556 
33557 
33558 
33560 class HPS_API GridKit : public Object
33561 {
33562 public:
33564  GridKit();
33565 
33568  GridKit(GridKit const & in_kit);
33569 
33572  GridKit(GridKit && in_that);
33573 
33574  virtual ~GridKit();
33575 
33576  HPS::Type ObjectType() const { return HPS::Type::GridKit; };
33577 
33580  void Consume(GridKit & in_kit);
33581 
33584  void Set(GridKit const & in_kit);
33585 
33588  void Show(GridKit & out_kit) const;
33589 
33593  GridKit & operator=(GridKit const & in_kit);
33594 
33598  GridKit & operator=(GridKit && in_that);
33599 
33602  bool Empty() const;
33603 
33607  bool Equals(GridKit const & in_kit) const;
33608 
33612  bool operator==(GridKit const & in_kit) const;
33613 
33617  bool operator!=(GridKit const & in_kit) const;
33618 
33619 
33626  GridKit & SetPriority(int in_priority);
33627 
33631  GridKit & SetType(Grid::Type in_type);
33632 
33636  GridKit & SetOrigin(Point const & in_origin);
33637 
33644  GridKit & SetFirstPoint(Point const & in_first_point);
33645 
33653  GridKit & SetSecondPoint(Point const & in_second_point);
33654 
33668  GridKit & SetFirstCount(int in_first_count);
33669 
33680  GridKit & SetSecondCount(int in_second_count);
33681 
33682 
33685  GridKit & UnsetPriority();
33686 
33689  GridKit & UnsetType();
33690 
33693  GridKit & UnsetOrigin();
33694 
33697  GridKit & UnsetFirstPoint();
33698 
33701  GridKit & UnsetSecondPoint();
33702 
33705  GridKit & UnsetFirstCount();
33706 
33709  GridKit & UnsetSecondCount();
33710 
33713  GridKit & UnsetEverything();
33714 
33715 
33719  bool ShowPriority(int & out_priority) const;
33720 
33724  bool ShowType(Grid::Type & out_type) const;
33725 
33729  bool ShowOrigin(Point & out_origin) const;
33730 
33734  bool ShowFirstPoint(Point & out_first_point) const;
33735 
33739  bool ShowSecondPoint(Point & out_second_point) const;
33740 
33744  bool ShowFirstCount(int & out_first_count) const;
33745 
33749  bool ShowSecondCount(int & out_second_count) const;
33750 
33756  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33757 
33762  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33763 
33768  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33769 
33773  GridKit & UnsetUserData(intptr_t in_index);
33774 
33779  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33780 
33784  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
33785 
33788  GridKit & UnsetAllUserData();
33789 
33791  size_t ShowUserDataCount() const;
33792 
33796  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33797 
33802  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33803 
33808  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33809 };
33810 
33811 
33813 class HPS_API GridKey : public GeometryKey
33814 {
33815 public:
33817  GridKey();
33818 
33823  explicit GridKey(Key const & in_that);
33824 
33827  GridKey(GridKey const & in_that);
33828 
33831  GridKey(GridKey && in_that);
33832 
33836  GridKey & operator=(GridKey const & in_that);
33837 
33841  GridKey & operator=(GridKey && in_that);
33842 
33843  ~GridKey();
33844 
33845  HPS::Type ObjectType() const { return HPS::Type::GridKey; };
33846 
33849  void Consume(GridKit & in_kit);
33850 
33853  void Set(GridKit const & in_kit);
33854 
33857  void Show(GridKit & out_kit) const;
33858 
33859 
33863  GridKey & SetType(Grid::Type in_type);
33864 
33868  GridKey & SetOrigin(Point const & in_origin);
33869 
33876  GridKey & SetFirstPoint(Point const & in_first_point);
33877 
33885  GridKey & SetSecondPoint(Point const & in_second_point);
33886 
33900  GridKey & SetFirstCount(int in_first_count);
33901 
33912  GridKey & SetSecondCount(int in_second_count);
33913 
33914 
33915 
33919  bool ShowType(Grid::Type & out_type) const;
33920 
33924  bool ShowOrigin(Point & out_origin) const;
33925 
33929  bool ShowFirstPoint(Point & out_first_point) const;
33930 
33934  bool ShowSecondPoint(Point & out_second_point) const;
33935 
33939  bool ShowFirstCount(int & out_first_count) const;
33940 
33944  bool ShowSecondCount(int & out_second_count) const;
33945 };
33946 
33947 
33948 
33949 
33951 class HPS_API IncludeKey : public Key
33952 {
33953 public:
33955  IncludeKey();
33956 
33961  explicit IncludeKey(Key const & in_that);
33962 
33965  IncludeKey(IncludeKey const & in_that);
33966 
33970  IncludeKey & operator=(IncludeKey const & in_that);
33971 
33975  IncludeKey(IncludeKey && in_that);
33976 
33980  IncludeKey & operator=(IncludeKey && in_that);
33981 
33982  ~IncludeKey();
33983 
33984 
33985  HPS::Type ObjectType() const { return HPS::Type::IncludeKey; };
33986 
33989  SegmentKey GetTarget() const;
33990 
33991 
33996  IncludeKey & SetPriority(int in_priority);
33997 
34005  IncludeKey & SetCondition(Condition const & in_condition);
34006 
34007 
34010  IncludeKey & UnsetPriority();
34011 
34014  IncludeKey & UnsetCondition();
34015 
34016 
34020  bool ShowPriority(int & out_priority) const;
34021 
34025  bool ShowCondition(Condition & out_condition) const;
34026 
34032  IncludeKey & SetFilter(AttributeLock::Type in_type);
34033 
34040  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34041 
34047  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
34048 
34054  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
34055 
34062  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34063 
34069  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34070 
34076  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34077 
34083  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34084 };
34085 
34086 
34087 
34089 class HPS_API StyleKey : public Key
34090 {
34091 public:
34093  StyleKey();
34094 
34099  explicit StyleKey(Key const & in_that);
34100 
34103  StyleKey(StyleKey const & in_that);
34104 
34108  StyleKey & operator=(StyleKey const & other);
34109 
34113  StyleKey(StyleKey && in_that);
34114 
34118  StyleKey & operator=(StyleKey && in_that);
34119 
34120  ~StyleKey();
34121 
34122  HPS::Type ObjectType() const { return HPS::Type::StyleKey; };
34123 
34124 
34130  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
34131 
34132 
34140  StyleKey & SetCondition(Condition const & in_condition);
34141 
34142 
34145  StyleKey & UnsetCondition();
34146 
34147 
34151  bool ShowCondition(Condition & out_condition) const;
34152 
34153 
34159  StyleKey & SetFilter(AttributeLock::Type in_type);
34160 
34167  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34168 
34174  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
34175 
34181  StyleKey & UnsetFilter(AttributeLock::Type in_type);
34182 
34189  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34190 
34196  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34197 
34203  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34204 
34210  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34211 };
34212 
34213 
34214 
34216 class HPS_API ReferenceKey : public GeometryKey
34217 {
34218 public:
34220  ReferenceKey();
34221 
34226  explicit ReferenceKey(Key const & in_that);
34227 
34230  ReferenceKey(ReferenceKey const & in_that);
34231 
34235  ReferenceKey & operator=(ReferenceKey const & in_that);
34236 
34240  ReferenceKey(ReferenceKey && in_that);
34241 
34245  ReferenceKey & operator=(ReferenceKey && in_that);
34246 
34247  ~ReferenceKey();
34248 
34249  HPS::Type ObjectType() const { return HPS::Type::ReferenceKey; };
34250 
34254  Key GetTarget() const;
34255 
34259  size_t ShowTargets(bool masked=true) const;
34260 
34265  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
34266 
34270  size_t ShowGeometryMask() const;
34271 
34276  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
34277 
34281  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
34282 
34285  ReferenceKey & UnsetGeometryMask();
34286 
34289  void SetModellingMatrix(MatrixKit const & in_kit);
34290 
34299  ReferenceKey & SetCondition(Condition const & in_condition);
34300 
34301 
34303  void UnsetModellingMatrix();
34304 
34307  ReferenceKey & UnsetCondition();
34308 
34309 
34313  bool ShowModellingMatrix(MatrixKit & out_kit) const;
34314 
34318  bool ShowCondition(Condition & out_condition) const;
34319 
34320 
34323  ModellingMatrixControl GetModellingMatrixControl();
34324 
34327  ModellingMatrixControl const GetModellingMatrixControl() const;
34328 };
34329 
34330 
34331 
34335 class HPS_API StandAloneWindowOptionsKit : public Object
34336 {
34337 public:
34340 
34344 
34349 
34354 
34355  virtual ~StandAloneWindowOptionsKit();
34356 
34357  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsKit; };
34358 
34362  static StandAloneWindowOptionsKit GetDefault();
34363 
34366  void Set(StandAloneWindowOptionsKit const & in_kit);
34367 
34370  void Show(StandAloneWindowOptionsKit & out_kit) const;
34371 
34375  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
34376 
34379  bool Empty() const;
34380 
34384  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
34385 
34389  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
34390 
34394  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
34395 
34399  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
34400 
34405  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34406 
34410  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
34411 
34416  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
34417 
34421  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
34422 
34426  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
34427 
34430  StandAloneWindowOptionsKit & UnsetDriver();
34431 
34434  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
34435 
34438  StandAloneWindowOptionsKit & UnsetTitle();
34439 
34442  StandAloneWindowOptionsKit & UnsetSubscreen();
34443 
34446  StandAloneWindowOptionsKit & UnsetMobility();
34447 
34450  StandAloneWindowOptionsKit & UnsetFullScreen();
34451 
34454  StandAloneWindowOptionsKit & UnsetEverything();
34455 
34459  bool ShowDriver(Window::Driver & out_driver) const;
34460 
34465  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34466 
34470  bool ShowTitle(UTF8 & out_window_name) const;
34471 
34475  bool ShowSubscreen(Rectangle & out_subscreen) const;
34476 
34480  bool ShowMobility(Window::Mobility & out_mobility) const;
34481 
34485  bool ShowFullScreen(bool & out_state) const;
34486 };
34487 
34488 
34489 
34496 {
34497 public:
34501 
34505 
34510 
34515 
34518 
34519  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsControl; };
34520 
34525 
34530  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
34531 
34535  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
34536 
34540  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
34541 
34545  bool ShowDriver(Window::Driver & out_driver) const;
34546 
34551  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34552 
34556  bool ShowTitle(UTF8 & out_window_name) const;
34557 
34561  bool ShowSubscreen(Rectangle & out_subscreen) const;
34562 
34566  bool ShowMobility(Window::Mobility & out_mobility) const;
34567 
34571  bool ShowFullScreen(bool & out_state) const;
34572 
34573 private:
34576 };
34577 
34578 
34579 
34583 class HPS_API OffScreenWindowOptionsKit : public Object
34584 {
34585 public:
34588 
34592 
34597 
34601  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
34602 
34603  virtual ~OffScreenWindowOptionsKit();
34604 
34605  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsKit; };
34606 
34610  static OffScreenWindowOptionsKit GetDefault();
34611 
34614  void Set(OffScreenWindowOptionsKit const & in_kit);
34615 
34618  void Show(OffScreenWindowOptionsKit & out_kit) const;
34619 
34623  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
34624 
34627  bool Empty() const;
34628 
34632  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
34633 
34637  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
34638 
34642  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
34643 
34647  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
34648 
34653  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34654 
34659  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
34660 
34665  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
34666 
34671  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
34672 
34676  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
34677 
34680  OffScreenWindowOptionsKit & UnsetDriver();
34681 
34684  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
34685 
34688  OffScreenWindowOptionsKit & UnsetHardwareResident();
34689 
34692  OffScreenWindowOptionsKit & UnsetNativeFormat();
34693 
34696  OffScreenWindowOptionsKit & UnsetOpacity();
34697 
34700  OffScreenWindowOptionsKit & UnsetEverything();
34701 
34705  bool ShowDriver(Window::Driver & out_driver) const;
34706 
34711  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34712 
34716  bool ShowHardwareResident(bool & out_state) const;
34717 
34722  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
34723 
34728  bool ShowOpacity(bool & out_state, float & out_opacity) const;
34729 };
34730 
34734 class HPS_API ApplicationWindowOptionsKit : public Object
34735 {
34736 public:
34739 
34743 
34748 
34753 
34754  virtual ~ApplicationWindowOptionsKit();
34755 
34756  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsKit; };
34757 
34761  static ApplicationWindowOptionsKit GetDefault();
34762 
34765  void Set(ApplicationWindowOptionsKit const & in_kit);
34766 
34769  void Show(ApplicationWindowOptionsKit & out_kit) const;
34770 
34774  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
34775 
34778  bool Empty() const;
34779 
34783  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
34784 
34788  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
34789 
34793  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
34794 
34798  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
34799 
34804  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34805 
34809  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
34810 
34814  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
34815 
34818  ApplicationWindowOptionsKit & UnsetDriver();
34819 
34822  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
34823 
34826  ApplicationWindowOptionsKit & UnsetPlatformData();
34827 
34830  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
34831 
34834  ApplicationWindowOptionsKit & UnsetEverything();
34835 
34839  bool ShowDriver(Window::Driver & out_driver) const;
34840 
34845  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34846 
34850  bool ShowPlatformData(PlatformData & out_platform_data) const;
34851 
34855  bool ShowFramebufferRetention(bool & out_retain) const;
34856 
34857 };
34858 
34859 
34860 
34863 {
34864 public:
34868 
34872 
34877 
34882 
34885 
34886  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsControl; };
34887 
34892 
34897  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34898 
34902  bool ShowDriver(Window::Driver & out_driver) const;
34903 
34907  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
34908 
34912  bool ShowPlatformData(PlatformData & out_platform_data) const;
34913 
34917  bool ShowFramebufferRetention(bool & out_retain) const;
34918 
34922  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
34923 
34927  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
34928 
34929 private:
34932 };
34933 
34934 
34935 
34940 class HPS_API StandAloneWindowKey : public WindowKey
34941 {
34942 public:
34945 
34950  StandAloneWindowKey(Key const & in_key);
34951 
34954  StandAloneWindowKey(StandAloneWindowKey const & in_that);
34955 
34960 
34964  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
34965 
34967 
34968  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowKey; };
34969 
34972  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
34973 
34976  StandAloneWindowOptionsControl GetWindowOptionsControl();
34977 
34981  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
34982 
34985  Window::UpdateStatus Pause();
34986 };
34987 
34988 
34989 
34991 class HPS_API ApplicationWindowKey : public WindowKey
34992 {
34993 public:
34996 
35001  ApplicationWindowKey(Key const & in_key);
35002 
35005  ApplicationWindowKey(ApplicationWindowKey const & in_that);
35006 
35011 
35015  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
35016 
35018 
35019  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowKey; };
35020 
35023  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
35024 
35027  ApplicationWindowOptionsControl GetWindowOptionsControl();
35028 
35032  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
35033 };
35034 
35038 
35039 
35040 
35042 class HPS_API GlyphElement : public Object
35043 {
35044 public:
35046  GlyphElement();
35047 
35050  GlyphElement(GlyphElement const & in_that);
35051 
35055  GlyphElement(GlyphElement && in_that);
35056 
35060  GlyphElement & operator=(GlyphElement && in_that);
35061 
35062  virtual ~GlyphElement();
35063 
35064  HPS::Type ObjectType() const { return HPS::Type::GlyphElement; };
35065 
35068  void Set(GlyphElement const & in_that);
35069 
35073  GlyphElement & operator=(GlyphElement const & in_that);
35074 
35078  bool Equals(GlyphElement const & in_that) const;
35079 
35083  bool operator==(GlyphElement const & in_that) const;
35084 
35088  bool operator!=(GlyphElement const & in_that) const;
35089 
35092  void SetFill(Glyph::Fill in_fill);
35093 
35096  void SetIndexedColor(byte in_index);
35097 
35099  void SetNormalColor();
35100 
35103  void SetExplicitColor(RGBAColor const & in_color);
35104 
35108  bool ShowFill(Glyph::Fill & out_fill) const;
35109 
35115  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
35116 };
35117 
35118 
35120 class HPS_API LineGlyphElement : public GlyphElement
35121 {
35122 public:
35124  LineGlyphElement();
35125 
35130  LineGlyphElement(GlyphElement const & in_that);
35131 
35134  LineGlyphElement(LineGlyphElement const & in_that);
35135 
35138  explicit LineGlyphElement(GlyphPointArray const & in_points);
35139 
35143  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
35144 
35148  LineGlyphElement(LineGlyphElement && in_that);
35149 
35153  LineGlyphElement & operator=(LineGlyphElement && in_that);
35154 
35155  ~LineGlyphElement();
35156 
35157  HPS::Type ObjectType() const { return HPS::Type::LineGlyphElement; };
35158 
35161  void SetPoints(GlyphPointArray const & in_points);
35162 
35166  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
35167 
35171  bool ShowPoints(GlyphPointArray & out_points) const;
35172 };
35173 
35175 class HPS_API DotGlyphElement : public GlyphElement
35176 {
35177 public:
35179  DotGlyphElement();
35180 
35185  DotGlyphElement(GlyphElement const & in_that);
35186 
35189  DotGlyphElement(DotGlyphElement const & in_that);
35190 
35193  explicit DotGlyphElement(GlyphPoint const & in_point);
35194 
35198  DotGlyphElement(DotGlyphElement && in_that);
35199 
35203  DotGlyphElement & operator=(DotGlyphElement && in_that);
35204 
35205  ~DotGlyphElement();
35206 
35207  HPS::Type ObjectType() const { return HPS::Type::DotGlyphElement; };
35208 
35211  void SetPoint(GlyphPoint const & in_point);
35212 
35216  bool ShowPoint(GlyphPoint & out_point) const;
35217 };
35218 
35219 
35221 class HPS_API EllipseGlyphElement : public GlyphElement
35222 {
35223 public:
35226 
35231  EllipseGlyphElement(GlyphElement const & in_that);
35232 
35235  EllipseGlyphElement(EllipseGlyphElement const & in_that);
35236 
35240  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35241 
35246 
35250  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
35251 
35253 
35254  HPS::Type ObjectType() const { return HPS::Type::EllipseGlyphElement; };
35255 
35258  void SetLowerLeft(GlyphPoint const & in_point);
35259 
35262  void SetUpperRight(GlyphPoint const & in_point);
35263 
35267  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35268 
35272  bool ShowLowerLeft(GlyphPoint & out_point) const;
35273 
35277  bool ShowUpperRight(GlyphPoint & out_point) const;
35278 };
35279 
35280 
35283 {
35284 public:
35287 
35292  CircularArcGlyphElement(GlyphElement const & in_that);
35293 
35297 
35302  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35303 
35308 
35312  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
35313 
35315 
35316  HPS::Type ObjectType() const { return HPS::Type::CircularArcGlyphElement; };
35317 
35320  void SetStartPoint(GlyphPoint const & in_point);
35321 
35324  void SetIntermediatePoint(GlyphPoint const & in_point);
35325 
35328  void SetEndPoint(GlyphPoint const & in_point);
35329 
35334  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35335 
35339  bool ShowStartPoint(GlyphPoint & out_point) const;
35340 
35344  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
35345 
35349  bool ShowEndPoint(GlyphPoint & out_point) const;
35350 };
35351 
35352 
35353 
35356 {
35357 public:
35360 
35365  InfiniteLineGlyphElement(GlyphElement const & in_that);
35366 
35370 
35374  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
35375 
35380 
35384  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
35385 
35387 
35388  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineGlyphElement; };
35389 
35392  void SetFirstPoint(GlyphPoint const & in_point);
35393 
35396  void SetSecondPoint(GlyphPoint const & in_point);
35397 
35401  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
35402 
35405  void SetInfiniteType(InfiniteLine::Type in_type);
35406 
35410  bool ShowFirstPoint(GlyphPoint & out_point) const;
35411 
35415  bool ShowSecondPoint(GlyphPoint & out_point) const;
35416 
35420  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
35421 };
35422 
35423 
35424 
35426 class HPS_API GlyphKit : public Object
35427 {
35428 public:
35430  GlyphKit();
35431 
35434  GlyphKit(GlyphKit const & in_kit);
35435 
35439  GlyphKit(GlyphKit && in_that);
35440 
35444  GlyphKit & operator=(GlyphKit && in_that);
35445 
35446  virtual ~GlyphKit();
35447 
35448  HPS::Type ObjectType() const { return HPS::Type::GlyphKit; };
35449 
35453  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
35454 
35457  void Set(GlyphKit const & in_kit);
35458 
35461  void Show(GlyphKit & out_kit) const;
35462 
35466  GlyphKit & operator=(GlyphKit const & in_kit);
35467 
35470  bool Empty() const;
35471 
35475  bool Equals(GlyphKit const & in_kit) const;
35476 
35480  bool operator==(GlyphKit const & in_kit) const;
35481 
35485  bool operator!=(GlyphKit const & in_kit) const;
35486 
35490  GlyphKit & SetRadius(sbyte in_radius);
35491 
35496  GlyphKit & SetOffset(GlyphPoint const & in_point);
35497 
35501  GlyphKit & SetElements(GlyphElementArray const & in_def);
35502 
35507  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
35508 
35511  GlyphKit & UnsetRadius();
35512 
35515  GlyphKit & UnsetOffset();
35516 
35519  GlyphKit & UnsetElements();
35520 
35523  GlyphKit & UnsetEverything();
35524 
35528  bool ShowRadius(sbyte & out_radius) const;
35529 
35533  bool ShowOffset(GlyphPoint & out_point) const;
35534 
35538  bool ShowElements(GlyphElementArray & out_def) const;
35539 };
35540 
35544 
35545 
35548 class HPS_API LinePatternOptionsKit : public Object
35549 {
35550 public:
35553 
35557 
35562 
35566  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
35567 
35568  virtual ~LinePatternOptionsKit();
35569 
35570  HPS::Type ObjectType() const { return HPS::Type::LinePatternOptionsKit; };
35571 
35574  void Set(LinePatternOptionsKit const & in_kit);
35575 
35578  void Show(LinePatternOptionsKit & out_kit) const;
35579 
35583  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
35584 
35587  bool Empty() const;
35588 
35592  bool Equals(LinePatternOptionsKit const & in_kit) const;
35593 
35597  bool operator==(LinePatternOptionsKit const & in_kit) const;
35598 
35602  bool operator!=(LinePatternOptionsKit const & in_kit) const;
35603 
35607  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
35608 
35612  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
35613 
35617  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
35618 
35622  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
35623 
35627  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
35628 
35632  LinePatternOptionsKit & SetJoin(char const * in_glyph);
35633 
35637  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
35638 
35642  LinePatternOptionsKit & UnsetStartCap();
35643 
35647  LinePatternOptionsKit & UnsetEndCap();
35648 
35651  LinePatternOptionsKit & UnsetInnerCap();
35652 
35656  LinePatternOptionsKit & UnsetJoin();
35657 
35660  LinePatternOptionsKit & UnsetEverything();
35661 
35667  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35668 
35674  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35675 
35679  bool ShowInnerCap(LinePattern::Cap & out_type) const;
35680 
35686  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
35687 };
35688 
35691 class HPS_API LinePatternElement : public Object
35692 {
35693 public:
35696 
35699  LinePatternElement(LinePatternElement const & in_that);
35700 
35705 
35709  LinePatternElement & operator=(LinePatternElement && in_that);
35710 
35711  ~LinePatternElement();
35712 
35713  HPS::Type ObjectType() const { return HPS::Type::LinePatternElement; };
35714 
35717  void Set(LinePatternElement const & in_that);
35718 
35722  LinePatternElement & operator=(LinePatternElement const & in_that);
35723 
35727  bool Equals(LinePatternElement const & in_that) const;
35728 
35732  bool operator==(LinePatternElement const & in_that) const;
35733 
35737  bool operator!=(LinePatternElement const & in_that) const;
35738 
35742  void SetSize(float in_size, LinePattern::SizeUnits in_units);
35743 
35748  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
35749 };
35750 
35753 {
35754 public:
35757 
35763 
35767 
35771  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35772 
35777 
35781  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
35782 
35784 
35785  HPS::Type ObjectType() const { return HPS::Type::SolidLinePatternElement; };
35786 
35790  void SetColor(RGBAColor const & in_color);
35791 
35795  void SetMaterialByIndex(float in_material_index);
35796 
35802  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
35803 };
35804 
35805 
35808 {
35809 public:
35812 
35818 
35822 
35826  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35827 
35832 
35836  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
35837 
35839 
35840  HPS::Type ObjectType() const { return HPS::Type::BlankLinePatternElement; };
35841 };
35842 
35843 
35846 {
35847 public:
35850 
35856 
35860 
35864  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
35865 
35870 
35874  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
35875 
35877 
35878  HPS::Type ObjectType() const { return HPS::Type::GlyphLinePatternElement; };
35879 
35882  void SetSource(char const * in_source);
35883 
35887  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
35888 
35891  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
35892 
35895  void SetMirror(bool in_state);
35896 
35899  void SetFixed(bool in_state);
35900 
35903  void SetRotation(float in_degrees);
35904 
35908  bool ShowSource(UTF8 & out_source) const;
35909 
35914  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
35915 
35919  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
35920 
35924  bool ShowMirror(bool & out_state) const;
35925 
35929  bool ShowFixed(bool & out_state) const;
35930 
35934  bool ShowRotation(float & out_degrees) const;
35935 };
35936 
35938 class HPS_API LinePatternParallelKit : public Object
35939 {
35940 public:
35943 
35947 
35952 
35956  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
35957 
35958  virtual ~LinePatternParallelKit();
35959 
35960  HPS::Type ObjectType() const { return HPS::Type::LinePatternParallelKit; };
35961 
35964  void Set(LinePatternParallelKit const & in_kit);
35965 
35968  void Show(LinePatternParallelKit & out_kit) const;
35969 
35973  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
35974 
35977  bool Empty() const;
35978 
35982  bool Equals(LinePatternParallelKit const & in_kit) const;
35983 
35987  bool operator==(LinePatternParallelKit const & in_kit) const;
35988 
35992  bool operator!=(LinePatternParallelKit const & in_kit) const;
35993 
35997  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
35998 
36002  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
36003 
36007  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
36008 
36012  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
36013 
36018  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
36019 
36023  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
36024 
36028  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
36029 
36033  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
36034 
36041  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
36042 
36048  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
36049 
36053  LinePatternParallelKit & SetContinuous(bool in_state);
36054 
36057  LinePatternParallelKit & UnsetStartCap();
36058 
36061  LinePatternParallelKit & UnsetEndCap();
36062 
36065  LinePatternParallelKit & UnsetJoin();
36066 
36069  LinePatternParallelKit & UnsetBody();
36070 
36073  LinePatternParallelKit & UnsetAbsoluteLength();
36074 
36077  LinePatternParallelKit & UnsetAbsoluteWeight();
36078 
36081  LinePatternParallelKit & UnsetJustification();
36082 
36085  LinePatternParallelKit & UnsetOffset();
36086 
36089  LinePatternParallelKit & UnsetWeight();
36090 
36093  LinePatternParallelKit & UnsetContinuous();
36094 
36097  LinePatternParallelKit & UnsetEverything();
36098 
36102  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
36103 
36107  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
36108 
36112  bool ShowJoin(GlyphLinePatternElement & out_join) const;
36113 
36117  bool ShowBody(LinePatternElementArray & out_elements) const;
36118 
36122  bool ShowAbsoluteLength(bool & out_state) const;
36123 
36127  bool ShowAbsoluteWeight(bool & out_state) const;
36128 
36132  bool ShowJustification(LinePattern::Justification & out_type) const;
36133 
36139  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36140 
36146  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36147 
36151  bool ShowContinuous(bool & out_state) const;
36152 };
36153 
36154 
36156 class HPS_API LinePatternKit : public Object
36157 {
36158 public:
36160  LinePatternKit();
36161 
36164  LinePatternKit(LinePatternKit const & in_kit);
36165 
36169  LinePatternKit(LinePatternKit && in_that);
36170 
36174  LinePatternKit & operator=(LinePatternKit && in_that);
36175 
36176  virtual ~LinePatternKit();
36177 
36178  HPS::Type ObjectType() const { return HPS::Type::LinePatternKit; };
36179 
36183  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
36184 
36187  void Set(LinePatternKit const & in_kit);
36188 
36191  void Show(LinePatternKit & out_kit) const;
36192 
36196  LinePatternKit & operator=(LinePatternKit const & in_kit);
36197 
36200  bool Empty() const;
36201 
36205  bool Equals(LinePatternKit const & in_kit) const;
36206 
36210  bool operator==(LinePatternKit const & in_kit) const;
36211 
36215  bool operator!=(LinePatternKit const & in_kit) const;
36216 
36220  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
36221 
36226  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
36227 
36231  LinePatternKit & SetJoin(LinePattern::Join in_type);
36232 
36235  LinePatternKit & UnsetParallels();
36236 
36239  LinePatternKit & UnsetJoin();
36240 
36243  LinePatternKit & UnsetEverything();
36244 
36248  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
36249 
36253  bool ShowJoin(LinePattern::Join & out_type) const;
36254 };
36255 
36256 
36257 
36261 
36262 
36264 class HPS_API Definition : public Object
36265 {
36266 public:
36268  Definition();
36269 
36272  Definition(Definition const & in_that);
36273 
36277  Definition & operator=(Definition const & in_that);
36278 
36282  Definition(Definition && in_that);
36283 
36287  Definition & operator=(Definition && in_that);
36288 
36289  virtual ~Definition();
36290 
36291  HPS::Type ObjectType() const { return HPS::Type::Definition; };
36292 
36294  void Undefine();
36295 
36298  PortfolioKey Owner() const;
36299 
36302  UTF8 Name() const;
36303 
36306  virtual void Assign(Definition const & in_that);
36307 
36311  bool Equals(Definition const & in_that) const;
36312 
36316  bool operator==(Definition const & in_that) const;
36317 
36321  bool operator!=(Definition const & in_that) const;
36322 };
36323 
36324 
36327 class HPS_API PortfolioKey : public Key
36328 {
36329 public:
36331  PortfolioKey();
36332 
36337  explicit PortfolioKey(Key const & in_that);
36338 
36341  PortfolioKey(PortfolioKey const & in_that);
36342 
36346  PortfolioKey & operator=(PortfolioKey const & in_that);
36347 
36351  PortfolioKey(PortfolioKey && in_that);
36352 
36356  PortfolioKey & operator=(PortfolioKey && in_that);
36357 
36358  ~PortfolioKey();
36359 
36360  HPS::Type ObjectType() const { return HPS::Type::PortfolioKey; };
36361 
36362  // Define
36363 
36370  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
36371 
36379  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
36380 
36381 
36393  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36394  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36395  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
36396 
36409  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36410  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36411  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
36412 
36413 
36419  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
36420 
36421 
36427  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
36428 
36429 
36435  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
36436 
36443  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
36444 
36445 
36451  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
36452 
36453 
36459  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
36460 
36461 
36467  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
36468 
36469 
36470  // UnDefine
36471 
36475  PortfolioKey & UndefineTexture(char const * in_name);
36476 
36480  PortfolioKey & UndefineCubeMap(char const * in_name);
36481 
36485  PortfolioKey & UndefineImage(char const * in_name);
36486 
36490  PortfolioKey & UndefineNamedStyle(char const * in_name);
36491 
36495  PortfolioKey & UndefineMaterialPalette(char const * in_name);
36496 
36500  PortfolioKey & UndefineGlyph(char const * in_name);
36501 
36505  PortfolioKey & UndefineLinePattern(char const * in_name);
36506 
36510  PortfolioKey & UndefineShader(char const * in_name);
36511 
36512 
36513  // Import collections
36519  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36520 
36521 
36527  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36528 
36534  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36535 
36541  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36542 
36548  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36549 
36555  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36556 
36562  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36563 
36569  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36570 
36576  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36577 
36578 
36579  // Import individual definitions
36583  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
36584 
36588  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
36589 
36593  ImageDefinition ImportImage(ImageDefinition const & in_definition);
36594 
36598  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
36599 
36603  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
36604 
36608  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
36609 
36613  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
36614 
36618  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
36619 
36620 
36621  // Show
36623  size_t GetDefinitionCount() const;
36624 
36626  size_t GetTextureDefinitionCount() const;
36627 
36629  size_t GetCubeMapDefinitionCount() const;
36630 
36632  size_t GetImageDefinitionCount() const;
36633 
36635  size_t GetNamedStyleDefinitionCount() const;
36636 
36638  size_t GetMaterialPaletteDefinitionCount() const;
36639 
36641  size_t GetGlyphDefinitionCount() const;
36642 
36644  size_t GetLinePatternDefinitionCount() const;
36645 
36647  size_t GetShaderDefinitionCount() const;
36648 
36653  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
36654 
36658  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
36659 
36664  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
36665 
36669  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
36670 
36675  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
36676 
36680  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
36681 
36686  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
36687 
36691  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
36692 
36697  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
36698 
36702  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
36703 
36708  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
36709 
36713  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
36714 
36719  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
36720 
36724  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
36725 
36730  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
36731 
36735  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
36736 
36737 private:
36739  void MoveTo(SegmentKey const & in_new_owner);
36740 
36742  Key CopyTo(SegmentKey const & in_destination) const;
36743 };
36744 
36745 
36746 
36748 class HPS_API GlyphDefinition : public Definition
36749 {
36750 public:
36752  GlyphDefinition();
36753 
36758  GlyphDefinition(Definition const & in_that);
36759 
36762  GlyphDefinition(GlyphDefinition const & in_that);
36763 
36767  GlyphDefinition & operator=(GlyphDefinition const & in_that);
36768 
36772  GlyphDefinition(GlyphDefinition && in_that);
36773 
36777  GlyphDefinition & operator=(GlyphDefinition && in_that);
36778 
36779  ~GlyphDefinition();
36780 
36781  HPS::Type ObjectType() const { return HPS::Type::GlyphDefinition; };
36782 
36785  void Set(GlyphKit const & in_kit);
36786 
36789  void Show(GlyphKit & out_kit) const;
36790 };
36791 
36792 
36794 class HPS_API TextureDefinition : public Definition
36795 {
36796 public:
36799 
36804  TextureDefinition(Definition const & in_that);
36805 
36808  TextureDefinition(TextureDefinition const & in_that);
36809 
36813  TextureDefinition & operator=(TextureDefinition const & in_that);
36814 
36819 
36823  TextureDefinition & operator=(TextureDefinition && in_that);
36824 
36825  ~TextureDefinition();
36826 
36827  HPS::Type ObjectType() const { return HPS::Type::TextureDefinition; };
36828 
36831  void SetSource(ImageDefinition const & in_source);
36832 
36835  void ShowSource(ImageDefinition & out_source) const;
36836 
36839  void SetOptions(TextureOptionsKit const & in_options);
36840 
36843  void ShowOptions(TextureOptionsKit & out_options) const;
36844 
36845 };
36846 
36850 class HPS_API TextureOptionsKit : public Object
36851 {
36852 public:
36855 
36858  TextureOptionsKit(TextureOptionsKit const & in_kit);
36859 
36864 
36868  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
36869 
36870  virtual ~TextureOptionsKit();
36871 
36872  HPS::Type ObjectType() const { return HPS::Type::TextureOptionsKit; };
36873 
36877  static TextureOptionsKit GetDefault();
36878 
36881  void Set(TextureOptionsKit const & in_kit);
36882 
36885  void Show(TextureOptionsKit & out_kit) const;
36886 
36890  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
36891 
36894  bool Empty() const;
36895 
36899  bool Equals(TextureOptionsKit const & in_kit) const;
36900 
36904  bool operator==(TextureOptionsKit const & in_kit) const;
36905 
36909  bool operator!=(TextureOptionsKit const & in_kit) const;
36910 
36915  TextureOptionsKit & SetDecal(bool in_state);
36916 
36920  TextureOptionsKit & SetDownSampling(bool in_state);
36921 
36925  TextureOptionsKit & SetModulation(bool in_state);
36926 
36930  TextureOptionsKit & SetParameterOffset(size_t in_offset);
36931 
36935  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
36936 
36940  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
36941 
36945  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
36946 
36950  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
36951 
36955  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
36956 
36959  TextureOptionsKit & UnsetDecal();
36960 
36963  TextureOptionsKit & UnsetDownSampling();
36964 
36967  TextureOptionsKit & UnsetModulation();
36968 
36971  TextureOptionsKit & UnsetParameterOffset();
36972 
36975  TextureOptionsKit & UnsetParameterizationSource();
36976 
36979  TextureOptionsKit & UnsetTiling();
36980 
36983  TextureOptionsKit & UnsetInterpolationFilter();
36984 
36987  TextureOptionsKit & UnsetDecimationFilter();
36988 
36991  TextureOptionsKit & UnsetTransformMatrix();
36992 
36995  TextureOptionsKit & UnsetEverything();
36996 
37000  bool ShowDecal(bool & out_state) const;
37001 
37005  bool ShowDownSampling(bool & out_state) const;
37006 
37010  bool ShowModulation(bool & out_state) const;
37011 
37015  bool ShowParameterOffset(size_t & out_offset) const;
37016 
37020  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
37021 
37025  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
37026 
37030  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
37031 
37035  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
37036 
37040  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37041 };
37042 
37043 
37045 class HPS_API Image
37046 {
37047 public:
37050  enum class Format
37051  {
37052  RGB,
37053  RGBA,
37054  ARGB,
37055  Mapped8,
37056  Grayscale,
37057  Bmp,
37058  Jpeg,
37059  Png,
37060  Targa,
37061  DXT1,
37062  DXT3,
37063  DXT5
37064  };
37065 
37067  class HPS_API ExportOptionsKit : public Object
37068  {
37069  public:
37071  ExportOptionsKit();
37072 
37075  ExportOptionsKit(ExportOptionsKit const & in_kit);
37076 
37080  ExportOptionsKit(ExportOptionsKit && in_that);
37081 
37085  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
37086 
37087  virtual ~ExportOptionsKit();
37088 
37089  HPS::Type ObjectType() const { return HPS::Type::ImageExportOptionsKit; };
37090 
37094  static ExportOptionsKit GetDefault();
37095 
37098  void Set(ExportOptionsKit const & in_kit);
37099 
37102  void Show(ExportOptionsKit & out_kit) const;
37103 
37107  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
37108 
37111  bool Empty() const;
37112 
37116  bool Equals(ExportOptionsKit const & in_kit) const;
37117 
37121  bool operator==(ExportOptionsKit const & in_kit) const;
37122 
37126  bool operator!=(ExportOptionsKit const & in_kit) const;
37127 
37132  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37133 
37138  ExportOptionsKit & SetFormat(Image::Format in_format);
37139 
37142  ExportOptionsKit & UnsetSize();
37143 
37146  ExportOptionsKit & UnsetFormat();
37147 
37150  ExportOptionsKit & UnsetEverything();
37151 
37156  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37157 
37161  bool ShowFormat(Image::Format & out_format) const;
37162  };
37163 
37165  class HPS_API ImportOptionsKit : public Object
37166  {
37167  public:
37169  ImportOptionsKit();
37170 
37173  ImportOptionsKit(ImportOptionsKit const & in_kit);
37174 
37178  ImportOptionsKit(ImportOptionsKit && in_that);
37179 
37183  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37184 
37185  virtual ~ImportOptionsKit();
37186 
37187  HPS::Type ObjectType() const { return HPS::Type::ImageImportOptionsKit; };
37188 
37191  void Set(ImportOptionsKit const & in_kit);
37192 
37195  void Show(ImportOptionsKit & out_kit) const;
37196 
37200  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37201 
37204  bool Empty() const;
37205 
37209  bool Equals(ImportOptionsKit const & in_kit) const;
37210 
37214  bool operator==(ImportOptionsKit const & in_kit) const;
37215 
37219  bool operator!=(ImportOptionsKit const & in_kit) const;
37220 
37227  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37228 
37232  ImportOptionsKit & SetFormat(Image::Format in_format);
37233 
37238  ImportOptionsKit & SetDownSampling(bool in_state);
37239 
37244  ImportOptionsKit & SetCompressionQuality(float in_quality);
37245 
37248  ImportOptionsKit & UnsetSize();
37249 
37252  ImportOptionsKit & UnsetFormat();
37253 
37256  ImportOptionsKit & UnsetDownSampling();
37257 
37260  ImportOptionsKit & UnsetCompressionQuality();
37261 
37264  ImportOptionsKit & UnsetEverything();
37265 
37270  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37271 
37275  bool ShowFormat(Image::Format & out_format) const;
37276 
37280  bool ShowDownSampling(bool & out_state) const;
37281 
37285  bool ShowCompressionQuality(float & out_quality) const;
37286  };
37287 
37289  class HPS_API File
37290  {
37291  public:
37297  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
37298 
37305  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
37306 
37314  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);
37315 
37320  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
37321 
37322  private:
37324  File();
37325  };
37326 
37327 private:
37329  Image();
37330 };
37331 
37332 
37334 class HPS_API ImageKit : public Object
37335 {
37336 public:
37338  ImageKit();
37339 
37342  ImageKit(ImageKit const & in_kit);
37343 
37348  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
37349 
37353  ImageKit(ImageKit && in_that);
37354 
37358  ImageKit & operator=(ImageKit && in_that);
37359 
37360  virtual ~ImageKit();
37361 
37362  HPS::Type ObjectType() const { return HPS::Type::ImageKit; };
37363 
37366  void Set(ImageKit const & in_kit);
37367 
37370  void Show(ImageKit & out_kit) const;
37371 
37375  ImageKit & operator=(ImageKit const & in_kit);
37376 
37379  bool Empty() const;
37380 
37384  bool Equals(ImageKit const & in_kit) const;
37385 
37389  bool operator==(ImageKit const & in_kit) const;
37390 
37394  bool operator!=(ImageKit const & in_kit) const;
37395 
37399  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
37400 
37403  void Convert(HPS::Image::Format in_format);
37404 
37409  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
37410 
37414  ImageKit & SetData(ByteArray const & in_image_data);
37415 
37420  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
37421 
37425  ImageKit & SetFormat(Image::Format in_format);
37426 
37430  ImageKit & SetDownSampling(bool in_state);
37431 
37435  ImageKit & SetCompressionQuality(float in_quality);
37436 
37439  ImageKit & UnsetSize();
37440 
37443  ImageKit & UnsetData();
37444 
37447  ImageKit & UnsetFormat();
37448 
37451  ImageKit & UnsetDownSampling();
37452 
37455  ImageKit & UnsetCompressionQuality();
37456 
37459  ImageKit & UnsetEverything();
37460 
37465  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37466 
37470  bool ShowData(ByteArray & out_image_data) const;
37471 
37475  bool ShowFormat(Image::Format & out_format) const;
37476 
37480  bool ShowDownSampling(bool & out_state) const;
37481 
37485  bool ShowCompressionQuality(float & out_quality) const;
37486 };
37487 
37488 
37494 {
37495 public:
37499 
37504 
37509 
37514 
37516 
37517  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsControl; };
37518 
37522  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
37523 
37528  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
37529 
37534  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
37535 
37539  bool ShowDriver(Window::Driver & out_driver) const;
37540 
37545  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37546 
37551  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37552 
37557  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
37558 
37563  bool ShowImage(ByteArray & out_bytes) const;
37564 
37568  bool ShowHardwareResident(bool & out_state) const;
37569 
37574  bool ShowOpacity(bool & out_state, float & out_opacity) const;
37575 
37580  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
37581 
37582 
37583 private:
37586 };
37587 
37588 
37591 class HPS_API OffScreenWindowKey : public WindowKey
37592 {
37593 public:
37596 
37601  OffScreenWindowKey(Key const & in_key);
37602 
37605  OffScreenWindowKey(OffScreenWindowKey const & in_that);
37606 
37611 
37615  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
37616 
37617  ~OffScreenWindowKey();
37618 
37619  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowKey; };
37620 
37623  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
37624 
37627  OffScreenWindowOptionsControl GetWindowOptionsControl();
37628 
37632  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
37633 };
37634 
37635 
37636 
37637 
37639 class HPS_API ImageDefinition : public Definition
37640 {
37641 public:
37643  ImageDefinition();
37644 
37649  ImageDefinition(Definition const & in_that);
37650 
37653  ImageDefinition(ImageDefinition const & in_that);
37654 
37658  ImageDefinition & operator=(ImageDefinition const & in_that);
37659 
37663  ImageDefinition(ImageDefinition && in_that);
37664 
37668  ImageDefinition & operator=(ImageDefinition && in_that);
37669 
37670  ~ImageDefinition();
37671 
37672  HPS::Type ObjectType() const { return HPS::Type::ImageDefinition; };
37673 
37676  void Set(ImageKit const & in_kit);
37677 
37680  void Show(ImageKit & out_kit) const;
37681 };
37682 
37684 class HPS_API CubeMapDefinition : public Definition
37685 {
37686 public:
37689 
37694  CubeMapDefinition(Definition const & in_that);
37695 
37698  CubeMapDefinition(CubeMapDefinition const & in_that);
37699 
37703  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
37704 
37709 
37713  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
37714 
37715  ~CubeMapDefinition();
37716 
37717  HPS::Type ObjectType() const { return HPS::Type::CubeMapDefinition; };
37718 
37726  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
37727  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
37728  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
37729 
37737  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
37738  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
37739  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
37740 
37744  void ShowSource(ImageDefinitionArray & out_image_sources) const;
37745 
37748  void SetOptions(TextureOptionsKit const & in_options);
37749 
37752  void ShowOptions(TextureOptionsKit & out_options) const;
37753 };
37754 
37755 
37757 class HPS_API NamedStyleDefinition : public Definition
37758 {
37759 public:
37762 
37767  NamedStyleDefinition(Definition const & in_that);
37768 
37771  NamedStyleDefinition(NamedStyleDefinition const & in_that);
37772 
37776  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
37777 
37782 
37786  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
37787 
37789 
37790  HPS::Type ObjectType() const { return HPS::Type::NamedStyleDefinition; };
37791 
37795  SegmentKey GetSource() const;
37796 };
37797 
37798 
37801 {
37802 public:
37805 
37810  MaterialPaletteDefinition(Definition const & in_that);
37811 
37815 
37819  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
37820 
37825 
37829  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
37830 
37832 
37833  HPS::Type ObjectType() const { return HPS::Type::MaterialPaletteDefinition; };
37834 
37837  void Set(MaterialKitArray const & in_source);
37838 
37842  void Set(size_t in_count, MaterialKit const in_source []);
37843 
37846  void Show(MaterialKitArray & out_source) const;
37847 };
37848 
37849 
37850 
37852 class HPS_API LinePatternDefinition : public Definition
37853 {
37854 public:
37857 
37862  LinePatternDefinition(Definition const & in_that);
37863 
37867 
37871  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
37872 
37877 
37881  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
37882 
37884 
37885  HPS::Type ObjectType() const { return HPS::Type::LinePatternDefinition; };
37886 
37889  void Set(LinePatternKit const & in_kit);
37890 
37893  void Show(LinePatternKit & out_kit) const;
37894 };
37895 
37896 
37897 
37899 class HPS_API Shader
37900 {
37901 public:
37904  enum class Parameterization
37905  {
37907  Cylinder,
37909  PhysicalReflection,
37911  Object,
37917  NaturalUV,
37919  ReflectionVector,
37921  SurfaceNormal,
37923  Sphere,
37925  UV,
37927  World
37928  };
37929 
37931  class HPS_API ImportOptionsKit : public Object
37932  {
37933  public:
37935  ImportOptionsKit();
37936 
37939  ImportOptionsKit(ImportOptionsKit const & in_kit);
37940 
37944  ImportOptionsKit(ImportOptionsKit && in_that);
37945 
37949  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37950 
37951  virtual ~ImportOptionsKit();
37952 
37953  HPS::Type ObjectType() const { return HPS::Type::ShaderImportOptionsKit; };
37954 
37957  void Set(ImportOptionsKit const & in_kit);
37958 
37961  void Show(ImportOptionsKit & out_kit) const;
37962 
37966  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37967 
37970  bool Empty() const;
37971 
37975  bool Equals(ImportOptionsKit const & in_kit) const;
37976 
37980  bool operator==(ImportOptionsKit const & in_kit) const;
37981 
37985  bool operator!=(ImportOptionsKit const & in_kit) const;
37986 
37993  ImportOptionsKit & SetMultitexture(bool in_state);
37994 
37998  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
37999 
38003  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
38004 
38008  ImportOptionsKit & UnsetMultitexture();
38009 
38012  ImportOptionsKit & UnsetParameterizationSource();
38013 
38016  ImportOptionsKit & UnsetTransformMatrix();
38017 
38020  ImportOptionsKit & UnsetEverything();
38021 
38027  bool ShowMultitexture(bool & out_state) const;
38028 
38032  bool ShowParameterizationSource(Parameterization & out_source) const;
38033 
38037  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38038  };
38039 
38041  class HPS_API File
38042  {
38043  public:
38049  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
38050 
38051  private:
38053  File();
38054  };
38055 
38056 private:
38058  Shader();
38059 };
38060 
38061 
38063 class HPS_API ShaderKit : public Object
38064 {
38065 public:
38067  ShaderKit();
38068 
38071  ShaderKit(ShaderKit const & in_kit);
38072 
38076  ShaderKit(ShaderKit && in_that);
38077 
38081  ShaderKit & operator=(ShaderKit && in_that);
38082 
38083  virtual ~ShaderKit();
38084 
38085  HPS::Type ObjectType() const { return HPS::Type::ShaderKit; };
38086 
38089  void Set(ShaderKit const & in_kit);
38090 
38093  void Show(ShaderKit & out_kit) const;
38094 
38098  ShaderKit & operator=(ShaderKit const & in_kit);
38099 
38102  bool Empty() const;
38103 
38107  bool Equals(ShaderKit const & in_kit) const;
38108 
38112  bool operator==(ShaderKit const & in_kit) const;
38113 
38117  bool operator!=(ShaderKit const & in_kit) const;
38118 
38122  ShaderKit & SetSource(char const * in_source);
38123 
38130  ShaderKit & SetMultitexture(bool in_state);
38131 
38135  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38136 
38140  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
38141 
38144  ShaderKit & UnsetSource();
38145 
38149  ShaderKit & UnsetMultitexture();
38150 
38153  ShaderKit & UnsetParameterizationSource();
38154 
38157  ShaderKit & UnsetTransformMatrix();
38158 
38161  ShaderKit & UnsetEverything();
38162 
38166  bool ShowSource(UTF8 & out_source) const;
38167 
38173  bool ShowMultitexture(bool & out_state) const;
38174 
38178  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
38179 
38183  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38184 };
38185 
38186 
38188 class HPS_API ShaderDefinition : public Definition
38189 {
38190 public:
38192  ShaderDefinition();
38193 
38198  ShaderDefinition(Definition const & in_that);
38199 
38202  ShaderDefinition(ShaderDefinition const & in_that);
38203 
38207  ShaderDefinition & operator=(ShaderDefinition const & in_that);
38208 
38212  ShaderDefinition(ShaderDefinition && in_that);
38213 
38217  ShaderDefinition & operator=(ShaderDefinition && in_that);
38218 
38219  ~ShaderDefinition();
38220 
38221  HPS::Type ObjectType() const { return HPS::Type::ShaderDefinition; };
38222 
38225  void Set(ShaderKit const & in_kit);
38226 
38229  void Show(ShaderKit & out_kit) const;
38230 };
38231 
38232 
38233 
38234 
38238 
38240 {
38241 public:
38244 
38248 
38253 
38258 
38259  virtual ~CutGeometryGatheringOptionsKit();
38260 
38261  HPS::Type ObjectType() const {return HPS::Type::CutGeometryGatheringOptionsKit;};
38262 
38266  static CutGeometryGatheringOptionsKit GetDefault();
38267 
38270  void Set(CutGeometryGatheringOptionsKit const & in_kit);
38271 
38274  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
38275 
38280 
38283  bool Empty() const;
38284 
38288  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
38289 
38293  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
38294 
38298  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
38299 
38300 
38304  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
38305 
38309  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
38310 
38315 
38316 
38319  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
38320 
38323  CutGeometryGatheringOptionsKit & UnsetOffset();
38324 
38327  CutGeometryGatheringOptionsKit & UnsetLevel();
38328 
38331  CutGeometryGatheringOptionsKit & UnsetEverything();
38332 
38333 
38337  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
38338 
38342  bool ShowOffset(size_t & out_offset) const;
38343 
38347  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
38348 };
38349 
38351 class HPS_API SearchOptionsKit : public Object
38352 {
38353 public:
38355  SearchOptionsKit();
38356 
38359  SearchOptionsKit(SearchOptionsKit const & in_kit);
38360 
38364  SearchOptionsKit(SearchOptionsKit && in_that);
38365 
38369  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
38370 
38371  virtual ~SearchOptionsKit();
38372 
38373  HPS::Type ObjectType() const {return HPS::Type::SearchOptionsKit;};
38374 
38378  static SearchOptionsKit GetDefault();
38379 
38382  void Set(SearchOptionsKit const & in_kit);
38383 
38386  void Show(SearchOptionsKit & out_kit) const;
38387 
38391  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
38392 
38395  bool Empty() const;
38396 
38400  bool Equals(SearchOptionsKit const & in_kit) const;
38401 
38405  bool operator==(SearchOptionsKit const & in_kit) const;
38406 
38410  bool operator!=(SearchOptionsKit const & in_kit) const;
38411 
38415  SearchOptionsKit & SetCriteria(Search::Type in_request);
38416 
38420  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
38421 
38425  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
38426 
38431  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
38432 
38436  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
38437 
38440  SearchOptionsKit & UnsetBehavior();
38441 
38444  SearchOptionsKit & UnsetCriteria();
38445 
38448  SearchOptionsKit & UnsetSearchSpace();
38449 
38452  SearchOptionsKit & UnsetEverything();
38453 
38457  bool ShowBehavior(Search::Behavior & out_behavior) const;
38458 
38462  bool ShowCriteria(SearchTypeArray & out_types) const;
38463 
38467  bool ShowSearchSpace(Search::Space & out_search_space) const;
38468 };
38469 
38473 class HPS_API TreeContext : public Object
38474 {
38475 public:
38478  TreeContext(bool in_create = true);
38479 
38482  TreeContext(TreeContext const & in_that);
38483 
38487  TreeContext(TreeContext && in_that);
38488 
38492  TreeContext & operator=(TreeContext && in_that);
38493 
38495  virtual ~TreeContext();
38496 
38497  HPS::Type ObjectType() const {return HPS::Type::TreeContext;};
38498 
38502  TreeContext & operator=(TreeContext const & in_that);
38503 
38507  bool Equals(TreeContext const & in_that) const;
38508 
38512  bool operator==(TreeContext const & in_that) const;
38513 
38517  bool operator!=(TreeContext const & in_that) const;
38518 
38519 };
38520 
38522 class HPS_API SelectionOptionsKit : public Object
38523 {
38524 public:
38527 
38530  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
38531 
38536 
38540  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
38541 
38542  virtual ~SelectionOptionsKit();
38543 
38544  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsKit;};
38545 
38549  static SelectionOptionsKit GetDefault();
38550 
38553  void Set(SelectionOptionsKit const & in_kit);
38554 
38557  void Show(SelectionOptionsKit & out_kit) const;
38558 
38562  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
38563 
38566  bool Empty() const;
38567 
38571  bool Equals(SelectionOptionsKit const & in_kit) const;
38572 
38576  bool operator==(SelectionOptionsKit const & in_kit) const;
38577 
38581  bool operator!=(SelectionOptionsKit const & in_kit) const;
38582 
38590  SelectionOptionsKit & SetProximity(float in_proximity);
38591 
38597  SelectionOptionsKit & SetLevel(Selection::Level in_level);
38598 
38603  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
38604 
38613  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
38614 
38622  SelectionOptionsKit & SetSorting(bool in_sorted);
38623 
38629  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
38630 
38636  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
38637 
38642  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
38643 
38648  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
38649 
38654  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
38655 
38662  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
38663 
38670  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
38671 
38678  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
38679 
38686  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
38687 
38690  SelectionOptionsKit & UnsetProximity();
38691 
38694  SelectionOptionsKit & UnsetLevel();
38695 
38698  SelectionOptionsKit & UnsetInternalLimit();
38699 
38702  SelectionOptionsKit & UnsetRelatedLimit();
38703 
38706  SelectionOptionsKit & UnsetSorting();
38707 
38710  SelectionOptionsKit & UnsetAlgorithm();
38711 
38714  SelectionOptionsKit & UnsetGranularity();
38715 
38718  SelectionOptionsKit & UnsetScope();
38719 
38722  SelectionOptionsKit & UnsetTreeContext();
38723 
38726  SelectionOptionsKit & UnsetExtentCullingRespected();
38727 
38730  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
38731 
38734  SelectionOptionsKit & UnsetFrustumCullingRespected();
38735 
38738  SelectionOptionsKit & UnsetVectorCullingRespected();
38739 
38740 
38743  SelectionOptionsKit & UnsetEverything();
38744 
38748  bool ShowProximity(float & out_proximity) const;
38749 
38753  bool ShowLevel(Selection::Level & out_level) const;
38754 
38758  bool ShowInternalLimit(size_t & out_limit) const;
38759 
38763  bool ShowRelatedLimit(size_t & out_limit) const;
38764 
38768  bool ShowSorting(bool & out_sorted) const;
38769 
38773  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38774 
38778  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38779 
38783  bool ShowScope(KeyPath & out_start_path) const;
38784 
38788  bool ShowTreeContext(TreeContext & out_tree_context) const;
38789 
38793  bool ShowExtentCullingRespected(bool & out_state) const;
38794 
38798  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38799 
38803  bool ShowFrustumCullingRespected(bool & out_state) const;
38804 
38808  bool ShowVectorCullingRespected(bool & out_state) const;
38809 };
38810 
38811 
38812 
38816 class HPS_API SelectionOptionsControl : public Control
38817 {
38818 public:
38821  explicit SelectionOptionsControl(WindowKey const & in_window);
38822 
38826 
38831 
38835  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
38836 
38838 
38839  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsControl;};
38840 
38844  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
38845 
38851  SelectionOptionsControl & SetProximity(float in_proximity);
38852 
38858  SelectionOptionsControl & SetLevel(Selection::Level in_level);
38859 
38866  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
38867 
38876  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
38877 
38885  SelectionOptionsControl & SetSorting(bool in_sorted);
38886 
38892  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
38893 
38899  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
38900 
38907  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
38908 
38915  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
38916 
38923  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
38924 
38931  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
38932 
38933  // there is no way to unset default values, intentionally
38934 
38938  bool ShowProximity(float & out_proximity) const;
38939 
38943  bool ShowLevel(Selection::Level & out_level) const;
38944 
38948  bool ShowInternalLimit(size_t & out_limit) const;
38949 
38953  bool ShowRelatedLimit(size_t & out_limit) const;
38954 
38958  bool ShowSorting(bool & out_sorted) const;
38959 
38963  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38964 
38968  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38969 
38973  bool ShowExtentCullingRespected(bool & out_state) const;
38974 
38978  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38979 
38983  bool ShowFrustumCullingRespected(bool & out_state) const;
38984 
38988  bool ShowVectorCullingRespected(bool & out_state) const;
38989 
38990 private:
38993 };
38994 
38995 
38996 
38998 class HPS_API SelectionItem : public Object
38999 {
39000 public:
39002  SelectionItem();
39003 
39006  SelectionItem(SelectionItem const & in_that);
39007 
39011  SelectionItem(SelectionItem && in_that);
39012 
39016  SelectionItem & operator=(SelectionItem && in_that);
39017 
39018  virtual ~SelectionItem();
39019 
39020  HPS::Type ObjectType() const {return HPS::Type::SelectionItem;};
39021 
39024  void Set(SelectionItem const & in_that);
39025 
39029  SelectionItem & operator=(SelectionItem const & in_that);
39030 
39034  bool Equals(SelectionItem const & in_that) const;
39035 
39039  bool operator==(SelectionItem const & in_that) const;
39040 
39044  bool operator!=(SelectionItem const & in_that) const;
39045 
39049  bool ShowSelectionLevel(Selection::Level & out_level) const;
39050 
39054  bool ShowSelectedItem(Key & out_selection) const;
39055 
39059  bool ShowPath(KeyPath & out_path) const;
39060 
39064  bool ShowFaces(SizeTArray & out_faces) const;
39065 
39069  bool ShowVertices(SizeTArray & out_vertices) const;
39070 
39075  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
39076 
39080  bool ShowCharacters(SizeTArray & out_characters) const;
39081 
39085  bool ShowSelectionPosition(WindowPoint & out_location) const;
39086 
39090  bool ShowSelectionPosition(WorldPoint & out_location) const;
39091 
39092 };
39093 
39095 class HPS_API SelectionResultsIterator : public Object
39096 {
39097 public:
39100 
39105 
39110 
39114  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
39115 
39117 
39118  HPS::Type ObjectType() const {return HPS::Type::SelectionResultsIterator;}
39119 
39123  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
39124 
39127  void Set(SelectionResultsIterator const & in_that);
39128 
39130  void Next();
39131 
39134  SelectionResultsIterator & operator++();
39135 
39138  SelectionResultsIterator operator++(int in_val);
39139 
39142  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
39143 
39146  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
39147 
39148 
39151  bool IsValid() const;
39152 
39154  void Reset();
39155 
39158  SelectionItem GetItem() const;
39159 
39162  SelectionItem operator*() const;
39163 
39164 
39165 };
39166 
39170 class HPS_API SelectionResults : public Object
39171 {
39172 public:
39174  SelectionResults();
39175 
39178  SelectionResults(SelectionResults const & in_that);
39179 
39183  SelectionResults(SelectionResults && in_that);
39184 
39188  SelectionResults & operator=(SelectionResults && in_that);
39189 
39190  ~SelectionResults();
39191 
39192  HPS::Type ObjectType() const {return HPS::Type::SelectionResults;}
39193 
39196  void Assign(SelectionResults const & in_that);
39197 
39201  SelectionResults & operator=(SelectionResults const & in_that);
39202 
39206  bool Equals(SelectionResults const & in_that) const;
39207 
39211  bool operator==(SelectionResults const & in_that) const;
39212 
39216  bool operator!=(SelectionResults const & in_that) const;
39217 
39219  virtual void Reset();
39220 
39223  Selection::Level GetSelectionLevel() const;
39224 
39227  size_t GetCount() const;
39228 
39231  SelectionResultsIterator GetIterator() const;
39232 
39238  bool Union(SelectionResults const & in_that);
39239 
39244  bool Intersect(SelectionResults const & in_that);
39245 
39251  bool SymmetricDifference(SelectionResults const & in_that);
39252 
39257  bool Difference(SelectionResults const & in_that);
39258 
39261  void Copy(SelectionResults const & in_that);
39262 };
39263 
39266 class HPS_API SelectionControl : public Object
39267 {
39268 public:
39271  explicit SelectionControl(WindowKey const & in_window);
39272 
39275  SelectionControl(SelectionControl const & in_that);
39276 
39280  SelectionControl(SelectionControl && in_that);
39281 
39285  SelectionControl & operator=(SelectionControl && in_that);
39286 
39287  ~SelectionControl();
39288 
39289  HPS::Type ObjectType() const {return HPS::Type::SelectionControl;};
39290 
39294  SelectionControl & operator=(SelectionControl const & in_that);
39295 
39301  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39302 
39307  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
39308 
39314  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39315 
39320  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
39321 
39327  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39328 
39333  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
39334 
39341  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39342 
39348  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39349 
39355  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39356 
39361  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
39362 
39369  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39370 
39376  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39377 
39378 
39379  //Object space selections
39380 
39386  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39387 
39392  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
39393 
39399  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39400 
39405  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
39406 
39407 
39414  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39415 
39421  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
39422 
39423 
39430  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39431 
39437  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
39438 
39439 private:
39441  SelectionControl();
39442 };
39443 
39444 
39445 
39447 class HPS_API HighlightOptionsKit : public Object
39448 {
39449 public:
39452 
39455  HighlightOptionsKit(char const * in_style_name);
39456 
39460  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
39461 
39464  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
39465 
39470 
39474  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
39475 
39476  virtual ~HighlightOptionsKit();
39477 
39478  HPS::Type ObjectType() const {return HPS::Type::HighlightOptionsKit;};
39479 
39483  static HighlightOptionsKit GetDefault();
39484 
39487  void Set(HighlightOptionsKit const & in_kit);
39488 
39491  void Show(HighlightOptionsKit & out_kit) const;
39492 
39496  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
39497 
39500  bool Empty() const;
39501 
39505  bool Equals(HighlightOptionsKit const & in_kit) const;
39506 
39510  bool operator==(HighlightOptionsKit const & in_kit) const;
39511 
39515  bool operator!=(HighlightOptionsKit const & in_kit) const;
39516 
39517 
39521  HighlightOptionsKit & SetStyleName(char const * in_style_name);
39522 
39526  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
39527 
39534  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
39535 
39541  HighlightOptionsKit & SetNotification(bool in_state);
39542 
39543 
39546  HighlightOptionsKit & UnsetStyleName();
39547 
39550  HighlightOptionsKit & UnsetSecondaryStyleName();
39551 
39554  HighlightOptionsKit & UnsetOverlay();
39555 
39558  HighlightOptionsKit & UnsetNotification();
39559 
39562  HighlightOptionsKit & UnsetEverything();
39563 
39564 
39568  bool ShowStyleName(UTF8 & out_style_name) const;
39569 
39573  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
39574 
39578  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
39579 
39583  bool ShowNotification(bool & out_state) const;
39584 };
39585 
39588 class HPS_API HighlightControl : public Control
39589 {
39590 public:
39593  explicit HighlightControl(WindowKey const & in_window);
39594 
39597  HighlightControl(HighlightControl const & in_that);
39598 
39602  HighlightControl(HighlightControl && in_that);
39603 
39607  HighlightControl & operator=(HighlightControl && in_that);
39608 
39609  ~HighlightControl();
39610 
39611  HPS::Type ObjectType() const {return HPS::Type::HighlightControl;};
39612 
39616  HighlightControl & operator=(HighlightControl const & in_that);
39617 
39622  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
39623 
39628  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
39629 
39634  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
39635 
39640  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
39641 
39646  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
39647 
39652  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39653 
39658  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39659 
39664  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39665 
39670  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39671 
39676  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39677 
39681  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
39682 
39685  HighlightControl & UnhighlightEverything();
39686 
39687 private:
39689  HighlightControl();
39690 };
39691 
39693 class HPS_API UpdateOptionsKit : public Object
39694 {
39695 public:
39697  UpdateOptionsKit();
39698 
39701  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
39702 
39706  UpdateOptionsKit(UpdateOptionsKit && in_that);
39707 
39711  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
39712 
39713  virtual ~UpdateOptionsKit();
39714 
39715  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsKit;};
39716 
39720  static UpdateOptionsKit GetDefault();
39721 
39724  void Set(UpdateOptionsKit const & in_kit);
39725 
39728  void Show(UpdateOptionsKit & out_kit) const;
39729 
39733  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
39734 
39737  bool Empty() const;
39738 
39742  bool Equals(UpdateOptionsKit const & in_kit) const;
39743 
39747  bool operator==(UpdateOptionsKit const & in_kit) const;
39748 
39752  bool operator!=(UpdateOptionsKit const & in_kit) const;
39753 
39757  UpdateOptionsKit & SetUpdateControl(HPS::Window::UpdateControl in_control);
39758 
39762  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
39763 
39766  UpdateOptionsKit & UnsetUpdateControl();
39767 
39770  UpdateOptionsKit & UnsetTimeLimit();
39771 
39774  UpdateOptionsKit & UnsetEverything();
39775 
39776 
39780  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39781 
39785  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39786 
39787 };
39788 
39789 
39790 
39796 class HPS_API UpdateOptionsControl : public Control
39797 {
39798 public:
39801  explicit UpdateOptionsControl(WindowKey const & in_window);
39802 
39805  UpdateOptionsControl(UpdateOptionsControl const & in_that);
39806 
39811 
39815  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
39816 
39818 
39819  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsControl;};
39820 
39824  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
39825 
39829  UpdateOptionsControl & SetUpdateControl(HPS::Window::UpdateControl in_control);
39830 
39834  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
39835 
39838  UpdateOptionsControl & UnsetUpdateControl();
39839 
39842  UpdateOptionsControl & UnsetTimeLimit();
39843 
39846  UpdateOptionsControl & UnsetEverything();
39847 
39851  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39852 
39856  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39857 
39858 private:
39861 };
39862 
39865 class HPS_API World : public Object
39866 {
39867 public:
39871  World(char const * in_license);
39872 
39874  ~World();
39875 
39876  HPS::Type ObjectType() const {return HPS::Type::World;};
39877 
39882  World & SetMaterialLibraryDirectory(char const * in_directory);
39883 
39888  World & SetFontDirectory(char const * in_directory);
39889 
39895  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
39896 
39901  World & SetFontDirectories(UTF8Array const & in_directories);
39902 
39908  World & SetDriverConfigFile(char const * in_filename);
39909 
39915  World & SetExchangeLibraryDirectory(char const * in_directory);
39916 
39922  World & SetPublishResourceDirectory(char const * in_directory);
39923 
39928  World & SetParasolidSchemaDirectory(char const * in_directory);
39929 
39932  World & UnsetMaterialLibraryDirectory();
39933 
39936  World & UnsetFontDirectories();
39937 
39940  World & UnsetDriverConfigFile();
39941 
39944  World & UnsetExchangeLibraryDirectory();
39945 
39948  World & UnsetPublishResourceDirectory();
39949 
39952  World & UnsetParasolidSchemaDirectory();
39953 
39957  bool ShowLicense(UTF8 & out_license) const;
39958 
39962  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
39963 
39967  bool ShowFontDirectories(UTF8Array & out_directories) const;
39968 
39972  bool ShowDriverConfigFile(UTF8 & out_filename) const;
39973 
39977  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
39978 
39982  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
39983 
39987  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
39988 
39989 
39990 private:
39992  World();
39993 
39995  virtual void Reset() {}
39996 };
39997 
39998 
40014 class HPS_API EmergencyHandler
40015 {
40016 public:
40017 
40020 
40021  virtual ~EmergencyHandler();
40022 
40024  intptr_t GetClassID() const;
40025 
40028  virtual EmergencyHandler * Clone() const = 0;
40029 
40033  virtual void Handle(const char * message, HPS::Emergency::Code code) const = 0;
40034 
40035  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
40036  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
40037 };
40038 
40039 
40042 class HPS_API Database
40043 {
40044 public:
40049  static void Execute(bool in_once=true);
40050 
40053  static Time GetTime();
40054 
40056  static void Sleep(Time milliseconds);
40057 
40082  static void RelinquishMemory();
40083 
40084 
40110  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
40111 
40119  static void Reset();
40120 
40122  static void Synchronize();
40123 
40126  static WindowKeyArray GetWindowKeys();
40127 
40130  static SegmentKeyArray GetRootSegments();
40131 
40134  static PortfolioKeyArray GetPortfolios();
40135 
40140  static PortfolioKey const GetMaterialLibraryPortfolio();
40141 
40147  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
40148 
40153  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
40154 
40158  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
40159 
40163  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
40164 
40171  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
40172 
40178  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
40179 
40185  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
40186 
40191  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
40192 
40195  static SegmentKey CreateRootSegment();
40196 
40199  static PortfolioKey CreatePortfolio();
40200 
40203  static EventDispatcher CreateEventDispatcher();
40204 
40208  static EventDispatcher CreateEventDispatcher(char const * in_name);
40209 
40215  static size_t SelectByShell(ShellKit const & in_shell,
40216  SelectionOptionsKit const & in_options,
40217  SelectionResults & out_results);
40218 
40224  static size_t SelectByShell(ShellKey const & in_shell,
40225  SelectionOptionsKit const & in_options,
40226  SelectionResults & out_results);
40227 
40234  static size_t SelectByVolume(SimpleCuboid const & in_volume,
40235  SelectionOptionsKit const & in_options,
40236  SelectionResults & out_results);
40237 
40244  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
40245  SelectionOptionsKit const & in_options,
40246  SelectionResults & out_results);
40247 
40250  static EventDispatcher const & GetEventDispatcher();
40251 
40252 
40256  static bool GetInformationEventFilter(HPS::Info::Code in_code);
40257 
40261  static bool GetWarningEventFilter(HPS::Info::Code in_code);
40262 
40266  static bool GetErrorEventFilter(HPS::Info::Code in_code);
40267 
40272  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
40273 
40278  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
40279 
40284  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
40285 
40286 
40289  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
40290 
40292  static void UnsetEmergencyHandler();
40293 
40296  static size_t GetSoftMemoryLimit();
40297 
40301  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
40302 
40306  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
40307 
40308 private:
40310  Database();
40311 };
40312 
40313 
40317 
40318 
40319 
40321 class HPS_API EventDispatcher : public Object
40322 {
40323 public:
40326  EventDispatcher();
40327 
40330  EventDispatcher(EventDispatcher const & in_that);
40331 
40335  EventDispatcher(EventDispatcher && in_that);
40336 
40340  EventDispatcher & operator=(EventDispatcher && in_that);
40341 
40342  virtual ~EventDispatcher();
40343 
40344  HPS::Type ObjectType() const {return HPS::Type::EventDispatcher;};
40345 
40349  EventDispatcher & operator=(EventDispatcher const & in_that);
40350 
40354  bool Equals(EventDispatcher const & in_that) const;
40355 
40359  bool operator==(EventDispatcher const & in_that) const;
40360 
40364  bool operator!=(EventDispatcher const & in_that) const;
40365 
40370  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
40371 
40376  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
40377 
40382  bool UnSubscribe(EventHandler const & in_handler) const;
40383 
40388  bool UnSubscribe(intptr_t in_type) const;
40389 
40393  bool InjectEvent(Event const & in_event) const;
40394 
40399  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
40400 
40403  void Shutdown() const;
40404 
40407  bool IsShutdown() const;
40408 
40409 
40412  void SetName(char const * in_name) const;
40413 
40416  void ShowName(UTF8 & out_name) const;
40417 
40418 private:
40420  virtual void Reset() {}
40421 };
40422 
40423 
40426 class HPS_API EventHandler : public Object
40427 {
40428 public:
40430  EventHandler();
40431 
40434  EventHandler(EventHandler const & in_that);
40435 
40439  EventHandler(EventHandler && in_that);
40440 
40444  EventHandler & operator=(EventHandler && in_that);
40445 
40449  EventHandler & operator=(EventHandler const & in_that);
40450 
40451  virtual ~EventHandler();
40452 
40453  HPS::Type ObjectType() const {return HPS::Type::EventHandler;};
40454 
40459  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40460 
40465  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40466 
40470  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
40471 
40473  void UnSubscribeEverything() const;
40474 
40476  virtual void Reset() { UnSubscribeEverything(); }
40477 
40480  void Shutdown();
40481 
40484  enum class HandleResult
40485  {
40486  Handled,
40487  NotHandled
40488  };
40489 
40494  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
40495 };
40496 
40497 
40498 
40500 class HPS_API TimerTickEvent : public Event
40501 {
40502 public:
40505  {
40506  channel = GetClassID();
40507  consumable = false;
40508  }
40509 
40510 
40513  TimerTickEvent(Event const & in_event) : Event(in_event)
40514  {
40515  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
40516  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40517  }
40518 
40519  ~TimerTickEvent();
40520 
40523  Event * Clone() const
40524  {
40525  TimerTickEvent * new_event = new TimerTickEvent(*this);
40526  return new_event;
40527  }
40528 
40532  virtual bool Drop(Event const * in_that_event) const
40533  {
40534  HPS_UNREFERENCED(in_that_event);
40535  return true;
40536  }
40537 
40538  virtual intptr_t Freshen() const {
40539  return GetClassID();
40540  }
40541 };
40542 
40544 class HPS_API HighlightEvent : public Event
40545 {
40546 public:
40547  enum class Action
40548  {
40549  None = 0,
40550  Highlight,
40551  Unhighlight,
40552  };
40553 
40556  {
40557  channel = GetClassID();
40558  consumable = false;
40559  action = Action::None;
40560  }
40561 
40562  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
40563  : Event(), action(in_action), results(in_results), options(in_options)
40564  {
40565  channel = GetClassID();
40566  consumable = false;
40567  }
40568 
40571  HighlightEvent(Event const & in_event) : Event(in_event)
40572  {
40573  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
40574  {
40575  auto that = static_cast<HighlightEvent const &>(in_event);
40576  action = that.action;
40577  results = that.results;
40578  options = that.options;
40579  }
40580  else
40581  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40582  }
40583 
40584  ~HighlightEvent();
40585 
40588  Event * Clone() const
40589  {
40590  HighlightEvent * new_event = new HighlightEvent(*this);
40591  return new_event;
40592  }
40593 
40594  Action action;
40595  SelectionResults results;
40596  HighlightOptionsKit options;
40597 };
40598 
40600 class HPS_API InformationEvent : public Event
40601 {
40602 public:
40604  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40605 
40608  InformationEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40609 
40613  InformationEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40614 
40617  InformationEvent(Event const & in_event) : Event(in_event)
40618  {
40619  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
40620  {
40621  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
40622  message = event->message;
40623  code = event->code;
40624  }
40625  else
40626  {
40627  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40628  }
40629  }
40630 
40631  ~InformationEvent();
40632 
40635  Event * Clone() const
40636  {
40637  InformationEvent * new_event = new InformationEvent(*this);
40638  return new_event;
40639  }
40640 
40644  virtual bool Equals(InformationEvent const & in_that) const
40645  {
40646  return message == in_that.message && code == in_that.code;
40647  }
40648 
40652  virtual bool operator== (InformationEvent const & in_that) const
40653  {
40654  return Equals(in_that);
40655  }
40656 
40660  virtual bool operator!= (InformationEvent const & in_that) const
40661  {
40662  return !Equals(in_that);
40663  }
40664 
40667 };
40668 
40669 
40671 class HPS_API WarningEvent : public Event
40672 {
40673 public:
40675  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40676 
40679  WarningEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40680 
40684  WarningEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40685 
40688  WarningEvent(Event const & in_event) : Event(in_event)
40689  {
40690  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
40691  {
40692  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
40693  message = event->message;
40694  code = event->code;
40695  }
40696  else
40697  {
40698  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40699  }
40700  }
40701 
40702  ~WarningEvent();
40703 
40706  Event * Clone() const
40707  {
40708  WarningEvent * new_event = new WarningEvent(*this);
40709  return new_event;
40710  }
40711 
40715  virtual bool Equals(WarningEvent const & in_that) const
40716  {
40717  return message == in_that.message && code == in_that.code;
40718  }
40719 
40723  virtual bool operator== (WarningEvent const & in_that) const
40724  {
40725  return Equals(in_that);
40726  }
40727 
40731  virtual bool operator!= (WarningEvent const & in_that) const
40732  {
40733  return !Equals(in_that);
40734  }
40735 
40738 };
40739 
40740 
40742 class HPS_API ErrorEvent : public Event
40743 {
40744 public:
40746  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40747 
40750  ErrorEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40751 
40755  ErrorEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40756 
40759  ErrorEvent(Event const & in_event) : Event(in_event)
40760  {
40761  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
40762  {
40763  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
40764  message = event->message;
40765  code = event->code;
40766  }
40767  else
40768  {
40769  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40770  }
40771  }
40772 
40773  ~ErrorEvent();
40774 
40777  Event * Clone() const
40778  {
40779  ErrorEvent * new_event = new ErrorEvent(*this);
40780  return new_event;
40781  }
40782 
40786  virtual bool Equals(ErrorEvent const & in_that) const
40787  {
40788  return message == in_that.message && code == in_that.code;
40789  }
40790 
40794  virtual bool operator== (ErrorEvent const & in_that) const
40795  {
40796  return Equals(in_that);
40797  }
40798 
40802  virtual bool operator!= (ErrorEvent const & in_that) const
40803  {
40804  return !Equals(in_that);
40805  }
40806 
40809 };
40810 
40811 
40813 class HPS_API StandAloneWindowEvent : public Event
40814 {
40815 public:
40816 
40819  enum class Action
40820  {
40821  Unknown,
40822  Close,
40823  FocusIn,
40824  FocusOut,
40825  };
40826 
40828  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
40829 
40830 
40833  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
40834 
40837  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
40838  {
40839  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40840  {
40841  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
40842  action = event->action;
40843  }
40844  else
40845  {
40846  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40847  }
40848  }
40849 
40851 
40854  Event * Clone() const
40855  {
40856  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
40857  return new_event;
40858  }
40859 
40863  virtual bool Equals(StandAloneWindowEvent const & in_that) const
40864  {
40865  return action == in_that.action;
40866  }
40867 
40871  virtual bool operator== (StandAloneWindowEvent const & in_that) const
40872  {
40873  return Equals(in_that);
40874  }
40875 
40879  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
40880  {
40881  return !Equals(in_that);
40882  }
40883 
40885 };
40886 
40888 class HPS_API FocusLostEvent : public Event
40889 {
40890 public:
40893  Event()
40894  { channel = GetClassID(); }
40895 
40896  ~FocusLostEvent() {};
40897 
40900  Event * Clone() const
40901  {
40902  FocusLostEvent * new_event = new FocusLostEvent(*this);
40903  return new_event;
40904  }
40905 };
40906 
40907 
40909 class HPS_API UpdateCompletedEvent : public Event
40910 {
40911 public:
40913  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
40914 
40916  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
40917 
40920  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
40921  {
40922  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
40923  {
40924  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
40925  update_time = event->update_time;
40926  }
40927  else
40928  {
40929  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40930  }
40931  }
40932 
40933  virtual ~UpdateCompletedEvent();
40934 
40937  Event * Clone() const
40938  {
40939  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
40940  return new_event;
40941  }
40942 
40943  Time update_time;
40944 };
40945 
40947 class HPS_API ImportStatusEvent : public Event
40948 {
40949 public:
40952  : Event()
40953  , import_status_message(HPS::UTF8())
40954  { channel = GetClassID(); }
40955 
40956  ImportStatusEvent(char const * in_message)
40957  : Event()
40958  , import_status_message(in_message)
40959  { channel = GetClassID(); }
40960 
40963  ImportStatusEvent(Event const & in_event) : Event(in_event)
40964  {
40965  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
40966  {
40967  auto event = static_cast<ImportStatusEvent const &>(in_event);
40968  import_status_message = event.import_status_message;
40969  }
40970  else
40971  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40972  }
40973 
40974  ~ImportStatusEvent() {};
40975 
40978  Event * Clone() const
40979  {
40980  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
40981  return new_event;
40982  }
40983 
40984  HPS::UTF8 import_status_message;
40985 };
40986 
40988 class HPS_API ModifierKeys
40989 {
40990 public:
40992  ModifierKeys() : modifiers(_key_none) {}
40993 
40997  bool Equals(ModifierKeys const & in_that) const
40998  {
40999  return modifiers == in_that.modifiers;
41000  }
41001 
41005  bool operator== (ModifierKeys const & in_that) const
41006  {
41007  return Equals(in_that);
41008  }
41009 
41013  bool operator!= (ModifierKeys const & in_that) const
41014  {
41015  return !Equals(in_that);
41016  }
41017 
41020  bool None() const { return modifiers == _key_none; }
41021 
41024  bool Shift() const { return (modifiers & _key_shift) != 0; }
41025 
41028  bool Control() const { return (modifiers & _key_control) != 0; }
41029 
41032  bool Alt() const { return (modifiers & _key_alt) != 0; }
41033 
41036  bool Meta() const { return (modifiers & _key_meta) != 0; }
41037 
41038 
41042  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41043 
41047  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
41048 
41049 
41052  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
41053 
41056  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
41057 
41060  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
41061 
41064  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
41065 
41069  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
41070  {
41071  ModifierKeys ret;
41072  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41073  return ret;
41074  }
41075 
41079  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
41080  {
41081  ModifierKeys ret;
41082  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41083  return ret;
41084  }
41085 
41089  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
41090 
41094  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
41095 
41096 
41099  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
41100 
41103  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
41104 
41107  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
41108 
41111  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
41112 
41113 protected:
41114 
41118  {
41119  _key_none = 0x0000,
41120  _key_shift = 0x0001,
41121  _key_control = 0x0002,
41122  _key_alt = 0x0004,
41123  _key_meta = 0x0008,
41124  };
41125 
41126  int modifiers;
41127 };
41128 
41129 
41132 class HPS_API InputEvent : public Event
41133 {
41134 public:
41135 
41137  InputEvent() : Event() { channel = GetClassID(); }
41138 
41141  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
41142 
41143  ~InputEvent();
41144 
41147  Event * Clone() const
41148  {
41149  InputEvent * new_event = new InputEvent(*this);
41150  return new_event;
41151  }
41152 
41156  virtual bool Equals(InputEvent const & in_that) const
41157  {
41158  return ModifierKeyState == in_that.ModifierKeyState;
41159  }
41160 
41164  virtual bool operator== (InputEvent const & in_that) const
41165  {
41166  return Equals(in_that);
41167  }
41168 
41172  virtual bool operator!= (InputEvent const & in_that) const
41173  {
41174  return !Equals(in_that);
41175  }
41176 
41181  {
41182  return ModifierKeyState;
41183  }
41184 
41186 };
41187 
41189 class HPS_API TouchEvent : public InputEvent
41190 {
41191 public:
41194  enum class Action
41195  {
41196  TouchDown,
41197  TouchUp,
41198  Move,
41199  };
41200 
41202  TouchEvent() : InputEvent() { channel = GetClassID(); }
41203 
41208  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
41209  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41210 
41216  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
41217  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41218 
41225  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
41226  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41227 
41228 
41231  TouchEvent(Event const & in_event) : InputEvent()
41232  {
41233  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
41234  {
41235  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
41236  channel = GetClassID();
41237  CurrentAction = event->CurrentAction;
41238  Touches = event->Touches;
41239  ModifierKeyState = event->ModifierKeyState;
41240  }
41241  else
41242  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
41243  }
41244 
41245  ~TouchEvent();
41246 
41247 
41250  Event * Clone() const
41251  {
41252  TouchEvent * new_event = new TouchEvent(*this);
41253  return new_event;
41254  }
41255 
41259  virtual bool Equals(TouchEvent const & in_that) const
41260  {
41261  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
41262  }
41263 
41267  virtual bool operator== (TouchEvent const & in_that) const
41268  {
41269  return Equals(in_that);
41270  }
41271 
41275  virtual bool operator!= (TouchEvent const & in_that) const
41276  {
41277  return !Equals(in_that);
41278  }
41279 
41283  virtual bool Drop(Event const * in_that_event) const
41284  {
41285  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
41286 
41287  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
41288  && Touches.size() == that_touch_event->Touches.size() )
41289  {
41290  TouchArray these_touches = Touches;
41291  TouchArray those_touches = that_touch_event->Touches;
41292 
41293  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41294  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41295 
41296  for (size_t i = 0 ; i < these_touches.size() ; i++)
41297  {
41298  if (these_touches[i].ID != those_touches[i].ID)
41299  return false;
41300  }
41301  return true;
41302  }
41303 
41304  return false;
41305  }
41306 
41310  void SetTouches(size_t in_touch_count, Touch const in_touches[])
41311  {
41312  Touches.assign(in_touches, in_touches + in_touch_count);
41313  }
41314 
41317  void SetTouches(HPS::TouchArray const & in_touches)
41318  {
41319  Touches = in_touches;
41320  }
41321 
41323  HPS::TouchArray Touches;
41324 
41325 private:
41331  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
41332  {
41333  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
41334  }
41335 };
41336 
41337 
41339 class HPS_API MouseButtons
41340 {
41341 public:
41343  MouseButtons() : buttons(_button_none) {}
41344 
41348  bool Equals(MouseButtons const & in_that) const
41349  {
41350  return buttons == in_that.buttons;
41351  }
41352 
41356  bool operator== (MouseButtons const & in_that) const
41357  {
41358  return Equals(in_that);
41359  }
41360 
41364  bool operator!= (MouseButtons const & in_that) const
41365  {
41366  return !Equals(in_that);
41367  }
41368 
41371  bool None() const { return buttons == _button_none; }
41372 
41375  bool Left() const { return (buttons & _button_left) != 0; }
41376 
41379  bool Right() const { return (buttons & _button_right) != 0; }
41380 
41383  bool Middle() const { return (buttons & _button_middle) != 0; }
41384 
41387  bool X1() const { return (buttons & _button_x1) != 0; }
41388 
41391  bool X2() const { return (buttons & _button_x2) != 0; }
41392 
41393 
41397  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41398 
41402  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
41403 
41406  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
41407 
41410  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
41411 
41414  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
41415 
41418  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
41419 
41422  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
41423 
41427  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
41428  {
41429  MouseButtons ret;
41430  ret.buttons = buttons | in_buttons_to_merge.buttons;
41431  return ret;
41432  }
41433 
41437  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
41438  {
41439  MouseButtons ret;
41440  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41441  return ret;
41442  }
41443 
41447  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
41448 
41452  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
41453 
41454 
41457  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
41458 
41461  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
41462 
41465  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
41466 
41469  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
41470 
41473  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
41474 
41475 protected:
41476 
41479  enum Buttons
41480  {
41481  _button_none = 0x0000,
41482  _button_left = 0x0001,
41483  _button_right = 0x0002,
41484  _button_middle = 0x0004,
41485  _button_x1 = 0x0008,
41486  _button_x2 = 0x0010
41487  };
41488 
41489  int buttons;
41490 };
41491 
41493 class HPS_API MouseEvent : public InputEvent
41494 {
41495 public:
41496 
41499  enum class Action
41500  {
41501  ButtonUp,
41502  ButtonDown,
41503  Move,
41504  Scroll,
41505  Enter,
41506  Leave
41507  };
41508 
41510  MouseEvent() : InputEvent() { channel = GetClassID(); }
41511 
41518  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
41519  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41520 
41528  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)
41529  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41530 
41533  MouseEvent(Event const & in_event) : InputEvent()
41534  {
41535  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
41536  {
41537  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
41538  channel = GetClassID();
41539  CurrentAction = event->CurrentAction;
41540  Location = event->Location;
41541  CurrentButton = event->CurrentButton;
41542  WheelDelta = event->WheelDelta;
41543  ClickCount = event->ClickCount;
41544  }
41545  else
41546  {
41547  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41548  }
41549  }
41550 
41551  ~MouseEvent();
41552 
41555  Event * Clone() const
41556  {
41557  MouseEvent * new_event = new MouseEvent(*this);
41558  return new_event;
41559  }
41560 
41564  virtual bool Equals(MouseEvent const & in_that) const
41565  {
41566  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
41567  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
41568  && Location == in_that.Location && ClickCount == in_that.ClickCount;
41569  }
41570 
41574  virtual bool operator== (MouseEvent const & in_that) const
41575  {
41576  return Equals(in_that);
41577  }
41578 
41582  virtual bool operator!= (MouseEvent const & in_that) const
41583  {
41584  return !Equals(in_that);
41585  }
41586 
41590  virtual bool Drop(Event const * in_that_event) const
41591  {
41592  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
41593 
41594  if (CurrentAction == that_mouse_event->CurrentAction &&
41595  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41596  CurrentButton == that_mouse_event->CurrentButton)
41597  return true;
41598 
41599  return false;
41600  }
41601 
41602  virtual intptr_t Freshen() const {
41603 
41604  if (CurrentAction == Action::Move)
41605  return GetClassID();
41606 
41607  return 0;
41608  }
41609 
41613  float WheelDelta;
41614  size_t ClickCount;
41615 };
41616 
41617 
41619 class HPS_API KeyboardEvent : public InputEvent
41620 {
41621 public:
41624  enum class Action
41625  {
41626  None,
41627  KeyDown,
41628  KeyUp
41629  };
41630 
41632  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
41633 
41638  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41639 
41645  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
41646  : InputEvent(in_modifiers), CurrentAction(in_action)
41647  {
41648  channel = GetClassID();
41649  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41650  }
41651 
41656  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
41657  : InputEvent(in_modifiers), CurrentAction(in_action)
41658  {
41659  channel = GetClassID();
41660  KeyboardCodes = in_keyboardcodes;
41661  }
41662 
41665  KeyboardEvent(Event const & in_event) : InputEvent()
41666  {
41667  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
41668  {
41669  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
41670  channel = GetClassID();
41671  KeyboardCodes = event->KeyboardCodes;
41672  CurrentAction = event->CurrentAction;
41673  }
41674  else
41675  {
41676  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41677  }
41678  }
41679 
41680  ~KeyboardEvent();
41681 
41684  Event * Clone() const
41685  {
41686  KeyboardEvent * new_event = new KeyboardEvent(*this);
41687  return new_event;
41688  }
41689 
41693  virtual bool Equals(KeyboardEvent const & in_that) const
41694  {
41695  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
41696  }
41697 
41701  virtual bool operator== (KeyboardEvent const & in_that) const
41702  {
41703  return Equals(in_that);
41704  }
41705 
41709  virtual bool operator!= (KeyboardEvent const & in_that) const
41710  {
41711  return !Equals(in_that);
41712  }
41713 
41717  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
41718  {
41719  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41720  }
41721 
41724  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
41725  {
41726  KeyboardCodes = in_keyboardcodes;
41727  }
41728 
41729  HPS::KeyboardCodeArray KeyboardCodes;
41731 };
41732 
41733 
41735 class HPS_API MouseState : public Object
41736 {
41737 public:
41739  MouseState();
41740 
41743  MouseState(MouseState const & in_that);
41744 
41748  MouseState(MouseState && in_that);
41749 
41753  MouseState & operator=(MouseState && in_that);
41754 
41755  ~MouseState();
41756 
41757  HPS::Type ObjectType() const {return HPS::Type::MouseState;};
41758 
41761  void Assign(MouseState const & in_that);
41762 
41766  MouseState & operator=(MouseState const & in_that);
41767 
41771  bool Equals(MouseState const & in_that) const;
41772 
41776  bool operator== (MouseState const & in_that) const;
41777 
41781  bool operator!= (MouseState const & in_that) const;
41782 
41787  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
41788 
41795  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
41796 
41799  HPS::MouseEvent GetActiveEvent() const;
41800 
41804  HPS::WindowKey GetEventSource() const;
41805 
41809  HPS::KeyArray GetEventPath() const;
41810 
41813  MouseButtons GetButtons() const;
41814 
41817  WindowPoint GetLocation() const;
41818 
41821  ModifierKeys GetModifierKeys() const;
41822 
41825  void SetActiveEvent(MouseEvent const & in_event);
41826 
41829  void SetEventPath(KeyArray const & in_path);
41830 
41833  void SetButtons(MouseButtons in_buttons);
41834 
41837  void SetLocation(WindowPoint const & in_point);
41838 
41841  void SetModifierKeys(ModifierKeys in_modifiers);
41842 };
41843 
41844 
41845 
41847 class HPS_API TouchState : public Object
41848 {
41849 public:
41851  TouchState();
41852 
41855  TouchState(TouchState const & in_that);
41856 
41860  TouchState(TouchState && in_that);
41861 
41865  TouchState & operator=(TouchState && in_that);
41866 
41867  ~TouchState();
41868 
41869  HPS::Type ObjectType() const {return HPS::Type::TouchState;};
41870 
41873  void Assign(TouchState const & in_that);
41874 
41878  TouchState & operator=(TouchState const & in_that);
41879 
41883  bool Equals(TouchState const & in_that) const;
41884 
41888  bool operator== (TouchState const & in_that) const;
41889 
41893  bool operator!= (TouchState const & in_that) const;
41894 
41900  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
41901 
41904  HPS::TouchEvent GetActiveEvent() const;
41905 
41909  HPS::WindowKey GetEventSource() const;
41910 
41914  HPS::KeyArray GetEventPath() const;
41915 
41918  size_t GetTouchCount() const;
41919 
41922  HPS::TouchArray GetTouches() const;
41923 
41926  ModifierKeys GetModifierKeys() const;
41927 
41930  void SetActiveEvent(TouchEvent const & in_event);
41931 
41934  void SetEventPath(KeyArray const & in_path);
41935 
41938  void SetTouches(TouchArray const & in_touches);
41939 
41942  void SetModifierKeys(ModifierKeys in_modifiers);
41943 };
41944 
41945 
41946 
41948 class HPS_API KeyboardState : public Object
41949 {
41950 public:
41952  KeyboardState();
41953 
41956  KeyboardState(KeyboardState const & in_that);
41957 
41961  KeyboardState(KeyboardState && in_that);
41962 
41966  KeyboardState & operator=(KeyboardState && in_that);
41967 
41968  ~KeyboardState();
41969 
41970  HPS::Type ObjectType() const {return HPS::Type::KeyboardState;};
41971 
41974  void Assign(KeyboardState const & in_that);
41975 
41979  KeyboardState & operator=(KeyboardState const & in_that);
41980 
41984  bool Equals(KeyboardState const & in_that) const;
41985 
41989  bool operator== (KeyboardState const & in_that) const;
41990 
41994  bool operator!= (KeyboardState const & in_that) const;
41995 
42001  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
42002 
42005  HPS::KeyboardEvent GetActiveEvent() const;
42006 
42010  HPS::WindowKey GetEventSource() const;
42011 
42015  HPS::KeyArray GetEventPath() const;
42016 
42019  size_t GetKeyboardCodeCount() const;
42020 
42023  HPS::KeyboardCodeArray GetKeyboardCodes() const;
42024 
42028  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
42029 
42032  ModifierKeys GetModifierKeys() const;
42033 
42036  void SetActiveEvent(KeyboardEvent const & in_event);
42037 
42040  void SetEventPath(KeyArray const & in_path);
42041 
42044  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
42045 
42048  void SetModifierKeys(ModifierKeys in_modifiers);
42049 };
42050 
42051 
42055 
42058 class HPS_API IONotifier : public Object
42059 {
42060 public:
42062  IONotifier();
42063 
42066  IONotifier(IONotifier const & in_that);
42067 
42071  IONotifier(IONotifier && in_that);
42072 
42076  IONotifier & operator=(IONotifier && in_that);
42077 
42078  virtual ~IONotifier();
42079 
42080  HPS::Type ObjectType() const {return HPS::Type::IONotifier;};
42081 
42085  IONotifier & operator=(IONotifier const & in_that);
42086 
42089  void Assign(IONotifier const & in_that);
42090 
42092  void Wait();
42093 
42096  IOResult Status() const;
42097 
42101  IOResult Status(float & out_percent_complete) const;
42102 
42106  void Cancel();
42107 };
42108 
42110 class HPS_API Stream
42111 {
42112 public:
42114  class HPS_API Toolkit : public Object
42115  {
42116  public:
42118  Toolkit();
42119 
42122  Toolkit(Toolkit const & in_toolkit);
42123 
42127  Toolkit(Toolkit && in_toolkit);
42128 
42132  Toolkit & operator=(Toolkit const & in_toolkit);
42133 
42137  Toolkit & operator=(Toolkit && in_toolkit);
42138 
42139  HPS::Type ObjectType() const { return HPS::Type::StreamToolkit; }
42140 
42142  virtual void Restart();
42143  };
42144 
42147  static Toolkit CreateToolkit();
42148 
42150  class HPS_API ImportOptionsKit : public Object
42151  {
42152  public:
42154  ImportOptionsKit();
42155 
42158  ImportOptionsKit(ImportOptionsKit const & in_kit);
42159 
42163  ImportOptionsKit(ImportOptionsKit && in_that);
42164 
42168  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42169 
42170  virtual ~ImportOptionsKit();
42171 
42172  HPS::Type ObjectType() const { return HPS::Type::StreamImportOptionsKit; };
42173 
42176  void Set(ImportOptionsKit const & in_kit);
42177 
42180  void Show(ImportOptionsKit & out_kit) const;
42181 
42185  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42186 
42189  bool Empty() const;
42190 
42194  bool Equals(ImportOptionsKit const & in_kit) const;
42195 
42199  bool operator==(ImportOptionsKit const & in_kit) const;
42200 
42204  bool operator!=(ImportOptionsKit const & in_kit) const;
42205 
42208  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42209 
42212  ImportOptionsKit & UnsetToolkit();
42213 
42217  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42218 
42223  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42224 
42227  ImportOptionsKit & UnsetSegment();
42228 
42232  bool ShowSegment(SegmentKey & out_segment) const;
42233 
42238  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
42239 
42242  ImportOptionsKit & UnsetAlternateRoot();
42243 
42247  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42248 
42253  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42254 
42257  ImportOptionsKit & UnsetPortfolio();
42258 
42262  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42263 
42266  ImportOptionsKit & UnsetEverything();
42267  };
42268 
42270  class HPS_API ImportResultsKit : public Object
42271  {
42272  public:
42274  ImportResultsKit();
42275 
42278  ImportResultsKit(ImportResultsKit const & in_kit);
42279 
42283  ImportResultsKit(ImportResultsKit && in_that);
42284 
42288  ImportResultsKit & operator=(ImportResultsKit && in_that);
42289 
42290  virtual ~ImportResultsKit();
42291 
42292  HPS::Type ObjectType() const { return HPS::Type::StreamImportResultsKit; };
42293 
42296  void Set(ImportResultsKit const & in_kit);
42297 
42300  void Show(ImportResultsKit & out_kit) const;
42301 
42305  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42306 
42309  bool Empty() const;
42310 
42314  bool Equals(ImportResultsKit const & in_kit) const;
42315 
42319  bool operator==(ImportResultsKit const & in_kit) const;
42320 
42324  bool operator!=(ImportResultsKit const & in_kit) const;
42325 
42330  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42331 
42335  ImportResultsKit & UnsetSegment();
42336 
42341  bool ShowSegment(SegmentKey & out_segment) const;
42342 
42347  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
42348 
42352  ImportResultsKit & UnsetAlternateRoot();
42353 
42359  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42360 
42365  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42366 
42370  ImportResultsKit & UnsetPortfolio();
42371 
42377  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42378 
42383  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
42384 
42388  ImportResultsKit & UnsetDefaultCamera();
42389 
42393  bool ShowDefaultCamera(CameraKit & out_camera) const;
42394 
42395 
42401  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
42402 
42406  ImportResultsKit & UnsetAlternateCameras();
42407 
42412  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
42413 
42414 
42417  ImportResultsKit & UnsetEverything();
42418  };
42419 
42421  class HPS_API ExportOptionsKit : public Object
42422  {
42423  public:
42425  ExportOptionsKit();
42426 
42429  ExportOptionsKit(ExportOptionsKit const & in_kit);
42430 
42434  ExportOptionsKit(ExportOptionsKit && in_that);
42435 
42439  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42440 
42444  static ExportOptionsKit GetDefault();
42445 
42446  virtual ~ExportOptionsKit();
42447 
42448  HPS::Type ObjectType() const { return HPS::Type::StreamExportOptionsKit; };
42449 
42452  void Set(ExportOptionsKit const & in_kit);
42453 
42456  void Show(ExportOptionsKit & out_kit) const;
42457 
42461  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42462 
42465  bool Empty() const;
42466 
42470  bool Equals(ExportOptionsKit const & in_kit) const;
42471 
42475  bool operator==(ExportOptionsKit const & in_kit) const;
42476 
42480  bool operator!=(ExportOptionsKit const & in_kit) const;
42481 
42484  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42485 
42493  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
42494 
42502  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
42503 
42509  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
42510 
42518  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
42519 
42527  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
42528 
42534  ExportOptionsKit & SetConnectivityCompression(bool in_state);
42535 
42541  ExportOptionsKit & SetSerializeTristrips(bool in_state);
42542 
42551  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
42552 
42555  ExportOptionsKit & UnsetToolkit();
42556 
42559  ExportOptionsKit & UnsetVertexCompression();
42560 
42563  ExportOptionsKit & UnsetNormalCompression();
42564 
42567  ExportOptionsKit & UnsetParameterCompression();
42568 
42571  ExportOptionsKit & UnsetColorCompression();
42572 
42575  ExportOptionsKit & UnsetIndexCompression();
42576 
42579  ExportOptionsKit & UnsetConnectivityCompression();
42580 
42583  ExportOptionsKit & UnsetImageCompression();
42584 
42587  ExportOptionsKit & UnsetSerializeTristrips();
42588 
42591  ExportOptionsKit & UnsetEverything();
42592 
42596  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42597 
42602  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
42603 
42608  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
42609 
42614  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
42615 
42620  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
42621 
42626  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
42627 
42631  bool ShowConnectivityCompression(bool & out_state) const;
42632 
42637  bool ShowImageCompression(bool & out_state, float & out_quality) const;
42638 
42642  bool ShowSerializeTristrips(bool & out_state) const;
42643  };
42644 
42647  class HPS_API ImportNotifier : public IONotifier
42648  {
42649  public:
42651  ImportNotifier();
42652 
42655  ImportNotifier(ImportNotifier const & in_that);
42656 
42661  ImportNotifier(IONotifier const & in_that);
42662 
42666  ImportNotifier(ImportNotifier && in_that);
42667 
42671  ImportNotifier & operator=(ImportNotifier && in_that);
42672 
42673  virtual ~ImportNotifier();
42674 
42675  HPS::Type ObjectType() const {return HPS::Type::StreamImportNotifier;};
42676 
42680  ImportNotifier & operator=(ImportNotifier const & in_that);
42681 
42684  void Assign(ImportNotifier const & in_that);
42685 
42689  ImportResultsKit GetResults() const;
42690  };
42691 
42694  class HPS_API ExportNotifier : public IONotifier
42695  {
42696  public:
42698  ExportNotifier();
42699 
42702  ExportNotifier(ExportNotifier const & in_that);
42703 
42708  ExportNotifier(IONotifier const & in_that);
42709 
42713  ExportNotifier(ExportNotifier && in_that);
42714 
42718  ExportNotifier & operator=(ExportNotifier && in_that);
42719 
42720  virtual ~ExportNotifier();
42721 
42722  HPS::Type ObjectType() const {return HPS::Type::StreamExportNotifier;};
42723 
42727  ExportNotifier & operator=(ExportNotifier const & in_that);
42728 
42731  void Assign(ExportNotifier const & in_that);
42732  };
42733 
42734 
42736  class HPS_API File
42737  {
42738  public:
42744  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42745 
42752  static ExportNotifier Export(const char * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
42753 
42760  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
42761 
42762  private:
42764  File();
42765  };
42766 private:
42768  Stream();
42769 };
42770 
42774 
42779 class HPS_API Hardcopy
42780 {
42781 public:
42782 
42784  enum class SizeUnits
42785  {
42786  Centimeters,
42787  Inches,
42788  };
42789 
42791  enum class ResolutionUnits
42792  {
42793  DPCM,
42794  DPI,
42795  DotsPerCentimeter = DPCM,
42796  DotsPerInch = DPI,
42797  };
42798 
42800  class HPS_API File
42801  {
42802  public:
42803 
42805  class HPS_API ExportOptionsKit : public Object
42806  {
42807  public:
42809  ExportOptionsKit();
42810 
42813  ExportOptionsKit(ExportOptionsKit const & in_kit);
42814 
42818  ExportOptionsKit(ExportOptionsKit && in_that);
42819 
42823  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42824 
42825  virtual ~ExportOptionsKit();
42826 
42827  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
42828 
42831  void Set(ExportOptionsKit const & in_kit);
42832 
42835  void Show(ExportOptionsKit & out_kit) const;
42836 
42840  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42841 
42844  bool Empty() const;
42845 
42849  bool Equals(ExportOptionsKit const & in_kit) const;
42850 
42854  bool operator==(ExportOptionsKit const & in_kit) const;
42855 
42859  bool operator!=(ExportOptionsKit const & in_kit) const;
42860 
42861 
42862 
42863 
42869  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
42870 
42878  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
42879 
42882  ExportOptionsKit & UnsetSize();
42883 
42884 
42885 
42891  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
42892 
42899  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
42900 
42903  ExportOptionsKit & UnsetResolution();
42904 
42905 
42906 
42909  bool ShowWYSIWYG(bool & out_onoff) const;
42910 
42922  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
42923 
42926  ExportOptionsKit & UnsetWYSIWYG();
42927 
42928 
42931  ExportOptionsKit & UnsetEverything();
42932 
42933 
42937  static ExportOptionsKit GetDefault();
42938  };
42939 
42941  enum class Driver
42942  {
42943  PDF,
42944  Postscript
42945  };
42946 
42952  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
42953  private:
42954  File();
42955  };
42956 
42957 #ifdef _MSC_VER
42958  class HPS_API GDI
42959  {
42960  public:
42961 
42963  class HPS_API ExportOptionsKit : public Object
42964  {
42965  public:
42967  ExportOptionsKit();
42968 
42971  ExportOptionsKit(ExportOptionsKit const & in_kit);
42972 
42976  ExportOptionsKit(ExportOptionsKit && in_that);
42977 
42981  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42982 
42983  virtual ~ExportOptionsKit();
42984 
42985  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
42986 
42989  void Set(ExportOptionsKit const & in_kit);
42990 
42993  void Show(ExportOptionsKit & out_kit) const;
42994 
42998  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42999 
43002  bool Empty() const;
43003 
43007  bool Equals(ExportOptionsKit const & in_kit) const;
43008 
43012  bool operator==(ExportOptionsKit const & in_kit) const;
43013 
43017  bool operator!=(ExportOptionsKit const & in_kit) const;
43018 
43019 
43020 
43021 
43025  bool ShowResolution(float & out_resolution) const;
43026 
43030  ExportOptionsKit & SetResolution(float in_resolution);
43031 
43034  ExportOptionsKit & UnsetResolution();
43035 
43036 
43037 
43038 
43041  bool ShowWYSIWYG(bool & out_onoff) const;
43042 
43046  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
43047 
43050  ExportOptionsKit & UnsetWYSIWYG();
43051 
43052 
43055  ExportOptionsKit & UnsetEverything();
43056  };
43057 
43064  static IOResult Export(intptr_t hdc, intptr_t attribdc, HPS::WindowKey const & window, ExportOptionsKit const & options);
43065 
43066  private:
43067  GDI();
43068  };
43069 #endif
43070 
43071 private:
43072  Hardcopy();
43073 };
43074 
43078 
43080 class HPS_API OBJ
43081 {
43082 public:
43083 
43085  class HPS_API ImportOptionsKit : public Object
43086  {
43087  public:
43089  ImportOptionsKit();
43090 
43093  ImportOptionsKit(ImportOptionsKit const & in_kit);
43094 
43098  ImportOptionsKit(ImportOptionsKit && in_that);
43099 
43103  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43104 
43105  virtual ~ImportOptionsKit();
43106 
43107  HPS::Type ObjectType() const { return HPS::Type::OBJImportOptionsKit; };
43108 
43111  void Set(ImportOptionsKit const & in_kit);
43112 
43115  void Show(ImportOptionsKit & out_kit) const;
43116 
43120  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43121 
43124  bool Empty() const;
43125 
43129  bool Equals(ImportOptionsKit const & in_kit) const;
43130 
43134  bool operator==(ImportOptionsKit const & in_kit) const;
43135 
43139  bool operator!=(ImportOptionsKit const & in_kit) const;
43140 
43145  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43146 
43149  ImportOptionsKit & UnsetSegment();
43150 
43154  bool ShowSegment(SegmentKey & out_segment) const;
43155 
43160  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43161 
43164  ImportOptionsKit & UnsetPortfolio();
43165 
43169  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43170 
43176  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43177 
43180  ImportOptionsKit & UnsetHandedness();
43181 
43185  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43186 
43189  ImportOptionsKit & UnsetEverything();
43190  };
43191 
43193  class HPS_API ImportResultsKit : public Object
43194  {
43195  public:
43197  ImportResultsKit();
43198 
43201  ImportResultsKit(ImportResultsKit const & in_kit);
43202 
43206  ImportResultsKit(ImportResultsKit && in_that);
43207 
43211  ImportResultsKit & operator=(ImportResultsKit && in_that);
43212 
43213  virtual ~ImportResultsKit();
43214 
43215  HPS::Type ObjectType() const { return HPS::Type::OBJImportResultsKit; };
43216 
43219  void Set(ImportResultsKit const & in_kit);
43220 
43223  void Show(ImportResultsKit & out_kit) const;
43224 
43228  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43229 
43232  bool Empty() const;
43233 
43237  bool Equals(ImportResultsKit const & in_kit) const;
43238 
43242  bool operator==(ImportResultsKit const & in_kit) const;
43243 
43247  bool operator!=(ImportResultsKit const & in_kit) const;
43248 
43253  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43254 
43258  ImportResultsKit & UnsetSegment();
43259 
43264  bool ShowSegment(SegmentKey & out_segment) const;
43265 
43270  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43271 
43275  ImportResultsKit & UnsetPortfolio();
43276 
43282  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43283 
43288  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43289 
43293  ImportResultsKit & UnsetHandedness();
43294 
43299  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43300 
43303  ImportResultsKit & UnsetEverything();
43304  };
43305 
43308  class HPS_API ImportNotifier : public IONotifier
43309  {
43310  public:
43312  ImportNotifier();
43313 
43316  ImportNotifier(ImportNotifier const & in_that);
43317 
43322  ImportNotifier(IONotifier const & in_that);
43323 
43327  ImportNotifier(ImportNotifier && in_that);
43328 
43332  ImportNotifier & operator=(ImportNotifier && in_that);
43333 
43334  virtual ~ImportNotifier();
43335 
43336  HPS::Type ObjectType() const {return HPS::Type::OBJImportNotifier;};
43337 
43341  ImportNotifier & operator=(ImportNotifier const & in_that);
43342 
43345  void Assign(ImportNotifier const & in_that);
43346 
43350  ImportResultsKit GetResults() const;
43351  };
43352 
43353 
43355  class HPS_API File
43356  {
43357  public:
43363  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43364 
43365  private:
43367  File();
43368  };
43369 private:
43371  OBJ();
43372 };
43373 
43377 
43379 class HPS_API STL
43380 {
43381 public:
43382 
43384  class HPS_API ImportOptionsKit : public Object
43385  {
43386  public:
43388  ImportOptionsKit();
43389 
43392  ImportOptionsKit(ImportOptionsKit const & in_kit);
43393 
43397  ImportOptionsKit(ImportOptionsKit && in_that);
43398 
43402  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43403 
43404  virtual ~ImportOptionsKit();
43405 
43406  HPS::Type ObjectType() const { return HPS::Type::STLImportOptionsKit; };
43407 
43410  void Set(ImportOptionsKit const & in_kit);
43411 
43414  void Show(ImportOptionsKit & out_kit) const;
43415 
43419  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43420 
43423  bool Empty() const;
43424 
43428  bool Equals(ImportOptionsKit const & in_kit) const;
43429 
43433  bool operator==(ImportOptionsKit const & in_kit) const;
43434 
43438  bool operator!=(ImportOptionsKit const & in_kit) const;
43439 
43443  static ImportOptionsKit GetDefault();
43444 
43449  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43450 
43458  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
43459 
43466  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
43467 
43468 
43471  ImportOptionsKit & UnsetSegment();
43472 
43475  ImportOptionsKit & UnsetOptimization();
43476 
43479  ImportOptionsKit & UnsetEverything();
43480 
43481 
43485  bool ShowSegment(SegmentKey & out_segment) const;
43486 
43491  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
43492  };
43493 
43495  class HPS_API ImportResultsKit : public Object
43496  {
43497  public:
43499  ImportResultsKit();
43500 
43503  ImportResultsKit(ImportResultsKit const & in_kit);
43504 
43508  ImportResultsKit(ImportResultsKit && in_that);
43509 
43513  ImportResultsKit & operator=(ImportResultsKit && in_that);
43514 
43515  virtual ~ImportResultsKit();
43516 
43517  HPS::Type ObjectType() const { return HPS::Type::STLImportResultsKit; };
43518 
43521  void Set(ImportResultsKit const & in_kit);
43522 
43525  void Show(ImportResultsKit & out_kit) const;
43526 
43530  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43531 
43534  bool Empty() const;
43535 
43539  bool Equals(ImportResultsKit const & in_kit) const;
43540 
43544  bool operator==(ImportResultsKit const & in_kit) const;
43545 
43549  bool operator!=(ImportResultsKit const & in_kit) const;
43550 
43555  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43556 
43560  ImportResultsKit & UnsetSegment();
43561 
43566  bool ShowSegment(SegmentKey & out_segment) const;
43567 
43570  ImportResultsKit & UnsetEverything();
43571  };
43572 
43575  class HPS_API ImportNotifier : public IONotifier
43576  {
43577  public:
43579  ImportNotifier();
43580 
43583  ImportNotifier(ImportNotifier const & in_that);
43584 
43589  ImportNotifier(IONotifier const & in_that);
43590 
43594  ImportNotifier(ImportNotifier && in_that);
43595 
43599  ImportNotifier & operator=(ImportNotifier && in_that);
43600 
43601  virtual ~ImportNotifier();
43602 
43603  HPS::Type ObjectType() const {return HPS::Type::STLImportNotifier;};
43604 
43608  ImportNotifier & operator=(ImportNotifier const & in_that);
43609 
43612  void Assign(ImportNotifier const & in_that);
43613 
43617  ImportResultsKit GetResults() const;
43618  };
43619 
43620 
43622  class HPS_API File
43623  {
43624  public:
43630  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43631 
43632  private:
43634  File();
43635  };
43636 private:
43638  STL();
43639 };
43640 
43641 }
43642 
43643 #ifdef _MSC_VER
43644 # pragma warning(pop)
43645 #endif
43646 
43647 #endif
43648 
43649 
HPS::Type ObjectType() const
Definition: hps.h:39876
Rotation
Definition: hps.h:1588
HPS::Type ObjectType() const
Definition: hps.h:26844
bool Empty() const
Definition: hps.h:6815
CameraPoint(Point const &in_point)
Definition: hps.h:5766
Alignment
Definition: hps.h:1521
HPS::Type ObjectType() const
Definition: hps.h:19229
Space
Definition: hps.h:554
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41611
Definition: hps.h:3252
Definition: hps.h:6005
Channel
Definition: hps.h:938
HPS::Type ObjectType() const
Definition: hps.h:24014
Handedness
Definition: hps.h:1269
Definition: hps.h:14105
Definition: hps.h:1044
Definition: hps.h:11888
ColorSource
Definition: hps.h:1914
HPS::Type ObjectType() const
Definition: hps.h:16966
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:41397
HPS::Type ObjectType() const
Definition: hps.h:36178
Event(intptr_t in_channel=0)
Definition: hps.h:6119
Definition: hps.h:18081
HPS::Type ObjectType() const
Definition: hps.h:43336
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3744
float alpha
Definition: hps.h:4283
Definition: hps.h:34583
HPS::Type ObjectType() const
Definition: hps.h:35785
bool operator==(Touch const &in_that) const
Definition: hps.h:6409
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:41418
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41052
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40808
InformationEvent(char const *in_message)
Definition: hps.h:40608
HPS::Type ObjectType() const
Definition: hps.h:38221
HPS::Type ObjectType() const
Definition: hps.h:34249
HPS::Type ObjectType() const
Definition: hps.h:21744
HPS::Type ObjectType() const
Definition: hps.h:23542
HPS::Type ObjectType() const
Definition: hps.h:24288
Action
Definition: hps.h:41194
Orientation
Definition: hps.h:530
Definition: hps.h:20560
Code
Definition: hps.h:127
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1324
Multiline strings will be left justfied.
Definition: hps.h:39693
HPS::Type ObjectType() const
Definition: hps.h:14849
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40863
HPS::Type ObjectType() const
Definition: hps.h:8601
HPS::Type ObjectType() const
Definition: hps.h:28072
Event * Clone() const
Definition: hps.h:40706
Definition: hps.h:13164
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:41528
Definition: hps.h:43080
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40494
ImportStatusEvent()
Definition: hps.h:40951
HPS::Type ObjectType() const
Definition: hps.h:21361
HPS::Type ObjectType() const
Definition: hps.h:35960
Definition: hps.h:13671
HPS::Type ObjectType() const
Definition: hps.h:25807
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41259
HPS::Type ObjectType() const
Definition: hps.h:30112
HPS::Type ObjectType() const
Definition: hps.h:25418
HPS::Type ObjectType() const
Definition: hps.h:11539
static MouseButtons ButtonX2()
Definition: hps.h:41473
Definition: hps.h:19663
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:40755
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41717
Definition: hps.h:43495
Definition: hps.h:37852
Definition: hps.h:19023
HPS::Type ObjectType() const
Definition: hps.h:37672
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5663
Definition: hps.h:1487
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5911
bool Middle() const
Definition: hps.h:41383
Definition: hps.h:460
Driver
Definition: hps.h:147
HPS::Type ObjectType() const
Definition: hps.h:41757
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2185
Definition: hps.h:35282
HPS::Type ObjectType() const
Definition: hps.h:39020
CappingLevel
Definition: hps.h:1720
Definition: hps.h:41619
HPS::Type ObjectType() const
Definition: hps.h:23269
HPS::Type ObjectType() const
Definition: hps.h:35713
Definition: hps.h:9291
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12677
HPS::Type ObjectType() const
Definition: hps.h:41869
HPS::Type ObjectType() const
Definition: hps.h:20405
Definition: hps.h:26431
HPS::Type ObjectType() const
Definition: hps.h:13694
InputEvent()
Definition: hps.h:41137
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5523
static MouseButtons ButtonRight()
Definition: hps.h:41461
HPS::Type ObjectType() const
Definition: hps.h:28857
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3851
Definition: hps.h:5563
Definition: hps.h:35548
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41656
static ModifierKeys KeyMeta()
Definition: hps.h:41111
HPS::Type ObjectType() const
Definition: hps.h:35448
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1498
Definition: hps.h:23435
HPS::Type ObjectType() const
Definition: hps.h:36827
Definition: hps.h:16562
HPS::Type ObjectType() const
Definition: hps.h:42722
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:41348
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3730
Definition: hps.h:34940
HPS::Type ObjectType() const
Definition: hps.h:19468
HPS::Type ObjectType() const
Definition: hps.h:39192
HPS::Type ObjectType() const
Definition: hps.h:23467
HPS::Type ObjectType() const
Definition: hps.h:35019
Definition: hps.h:22292
HPS::Type ObjectType() const
Definition: hps.h:16675
MouseButtons()
Definition: hps.h:41343
HPS::Type ObjectType() const
Definition: hps.h:38261
Definition: hps.h:20173
Time GetTimeStamp() const
Definition: hps.h:6141
Definition: hps.h:43622
void Left(bool in_state)
Definition: hps.h:41406
HPS::Type ObjectType() const
Definition: hps.h:22262
NormalizedPoint(Point const &in_point)
Definition: hps.h:5816
HPS::Type ObjectType() const
Definition: hps.h:23816
Event * Clone() const
Definition: hps.h:40523
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3779
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:41402
Renderer
Definition: hps.h:1569
HPS::Type ObjectType() const
Definition: hps.h:33985
Definition: hps.h:40014
KeyboardEvent()
Definition: hps.h:41632
HPS::Type ObjectType() const
Definition: hps.h:7328
Definition: hps.h:37639
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3972
ObjectPoint(Point const &in_point)
Definition: hps.h:5666
HPS::Type ObjectType() const
Definition: hps.h:17553
Definition: hps.h:33435
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:39796
Definition: hps.h:4360
Definition: hps.h:6624
Definition: hps.h:1318
Definition: hps.h:40544
Definition: hps.h:24256
Point_3D< F > min
Definition: hps.h:3714
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40837
static ModifierKeys KeyAlt()
Definition: hps.h:41107
bool IsConsumable() const
Definition: hps.h:6144
Definition: hps.h:1041
size_t GetHash() const
Definition: hps.h:1659
MaterialPreference
Definition: hps.h:1737
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41645
Mobility
Definition: hps.h:187
HPS::Type ObjectType() const
Definition: hps.h:13187
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5864
Definition: hps.h:14532
InterpolationAlgorithm
Definition: hps.h:1504
Fill
Definition: hps.h:1905
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3767
Definition: hps.h:23710
Definition: hps.h:19206
HPS::Type ObjectType() const
Definition: hps.h:27349
HPS::Type ObjectType() const
Definition: hps.h:19046
char At(size_t in_index) const
Definition: hps.h:6858
Definition: hps.h:39865
Definition: hps.h:4386
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41047
HPS::Type ObjectType() const
Definition: hps.h:35840
Definition: hps.h:122
ReferenceFrame
Definition: hps.h:1536
Definition: hps.h:25775
Bloom Shape.
Definition: hps.h:41948
Definition: hps.h:3712
Definition: hps.h:3709
HPS::Type ObjectType() const
Definition: hps.h:16882
GreekingUnits
Definition: hps.h:1623
Definition: hps.h:18573
Definition: hps.h:7380
HPS::Type ObjectType() const
Definition: hps.h:12089
InnerConeUnits
Definition: hps.h:479
Definition: hps.h:26641
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5960
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3884
static MouseButtons ButtonX1()
Definition: hps.h:41469
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40913
Definition: hps.h:18292
Definition: hps.h:3399
OuterConeUnits
Definition: hps.h:465
Definition: hps.h:6391
void X2(bool in_state)
Definition: hps.h:41422
HPS::Type ObjectType() const
Definition: hps.h:18830
HPS::Type ObjectType() const
Definition: hps.h:40344
HPS::Type ObjectType() const
Definition: hps.h:39289
HPS::Type ObjectType() const
Definition: hps.h:14290
Definition: hps.h:14825
Definition: hps.h:1986
HPS::Type ObjectType() const
Definition: hps.h:33468
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41724
HPS::Type ObjectType() const
Definition: hps.h:26743
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41283
HPS::Type ObjectType() const
Definition: hps.h:12560
HPS::Type ObjectType() const
Definition: hps.h:25000
Definition: hps.h:434
HPS::Type ObjectType() const
Definition: hps.h:36291
Definition: hps.h:21722
Channel
Definition: hps.h:897
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40737
AreaUnits
Definition: hps.h:1450
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3821
Definition: hps.h:38041
HPS::Type ObjectType() const
Definition: hps.h:11912
Definition: hps.h:8552
Definition: hps.h:26721
Definition: hps.h:19445
HPS::Type ObjectType() const
Definition: hps.h:34605
Action
Definition: hps.h:40819
Event * Clone() const
Definition: hps.h:40635
HPS::Type ObjectType() const
Definition: hps.h:14128
Definition: hps.h:4635
HPS::Type ObjectType() const
Definition: hps.h:42448
HPS::Type ObjectType() const
Definition: hps.h:27450
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6424
Definition: hps.h:21151
Definition: hps.h:4517
HPS::Type ObjectType() const
Definition: hps.h:37790
HPS::Type ObjectType() const
Definition: hps.h:34122
Definition: hps.h:1377
Definition: hps.h:17763
Definition: hps.h:872
Definition: hps.h:5549
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41216
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3930
Border
Definition: hps.h:257
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41042
Definition: hps.h:37757
Definition: hps.h:35938
Definition: hps.h:7370
HPS::Type ObjectType() const
Definition: hps.h:23019
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41693
HPS::Type ObjectType() const
Definition: hps.h:21286
WarningEvent(Event const &in_event)
Definition: hps.h:40688
Definition: hps.h:36850
HPS::Type ObjectType() const
Definition: hps.h:11415
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1924
Definition: hps.h:1705
static ModifierKeys KeyShift()
Definition: hps.h:41099
Definition: hps.h:142
HPS::Type ObjectType() const
Definition: hps.h:28583
Shape
Definition: hps.h:1066
bool IsValid() const
Definition: hps.h:6808
Definition: hps.h:20382
Definition: hps.h:1516
Cuboid_3D()
Definition: hps.h:3722
ErrorEvent(Event const &in_event)
Definition: hps.h:40759
size_t GetWStrLength() const
Definition: hps.h:6837
Event * Clone() const
Definition: hps.h:40588
HPS::Type ObjectType() const
Definition: hps.h:11006
AppendMode
Definition: hps.h:325
Definition: hps.h:8581
Definition: hps.h:25248
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:41387
Definition: hps.h:229
Definition: hps.h:40947
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3915
void Meta(bool in_state)
Definition: hps.h:41064
Definition: hps.h:6576
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6059
Definition: hps.h:26822
HPS::Type ObjectType() const
Definition: hps.h:14558
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3772
HPS::Type ObjectType() const
Definition: hps.h:38373
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40884
Definition: hps.h:20951
Quality
Definition: hps.h:1050
ResolutionUnits
Definition: hps.h:42791
Event * Clone() const
Definition: hps.h:41147
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:41185
Definition: hps.h:4459
TimerTickEvent(Event const &in_event)
Definition: hps.h:40513
Component
Definition: hps.h:345
Definition: hps.h:43193
Definition: hps.h:5658
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6010
HPS::Type ObjectType() const
Definition: hps.h:12176
Definition: hps.h:12302
Default
Definition: hps.h:1878
HPS::Type ObjectType() const
Definition: hps.h:10636
Definition: hps.h:16859
Definition: hps.h:2125
Definition: hps.h:24706
InformationEvent()
Definition: hps.h:40604
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5057
Definition: hps.h:37591
Definition: hps.h:11515
Definition: hps.h:13751
Definition: hps.h:10982
Definition: hps.h:43575
bool Shift() const
Definition: hps.h:41024
SizeToleranceUnits
Definition: hps.h:1610
HPS::Type ObjectType() const
Definition: hps.h:38497
Definition: hps.h:1757
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4001
Cap
Definition: hps.h:1829
Point_3D< F > max
Definition: hps.h:3716
HPS::Type ObjectType() const
Definition: hps.h:7408
Definition: hps.h:11248
Definition: hps.h:20728
Definition: hps.h:13857
HPS::Type ObjectType() const
Definition: hps.h:43107
HPS::Type ObjectType() const
Definition: hps.h:43215
MouseEvent()
Definition: hps.h:41510
Definition: hps.h:13928
HPS::Type ObjectType() const
Definition: hps.h:12017
Definition: hps.h:19935
Definition: hps.h:27093
Definition: hps.h:1060
HPS::Type ObjectType() const
Definition: hps.h:16584
Definition: hps.h:12210
Definition: hps.h:32242
HPS::Type ObjectType() const
Definition: hps.h:35064
Definition: hps.h:12536
static const float Infinity
Definition: hps.h:2180
InsetBehavior
Definition: hps.h:1810
HPS::Type ObjectType() const
Definition: hps.h:24926
Definition: hps.h:5632
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2193
HPS::Type ObjectType() const
Definition: hps.h:13582
HPS::Type ObjectType() const
Definition: hps.h:27043
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6423
HPS::Type ObjectType() const
Definition: hps.h:35254
HPS::Type ObjectType() const
Definition: hps.h:37517
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3894
Algorithm
Definition: hps.h:1438
Definition: hps.h:41847
Decimation
Definition: hps.h:1007
StaticModel
Definition: hps.h:1108
Definition: hps.h:38473
Granularity
Definition: hps.h:1359
Parameterization
Definition: hps.h:37904
Definition: hps.h:36748
DisplayLists
Definition: hps.h:1086
Definition: hps.h:10814
Search the current segment only.
Definition: hps.h:42694
Definition: hps.h:2639
Definition: hps.h:42421
Definition: hps.h:549
KeyboardEvent(Event const &in_event)
Definition: hps.h:41665
Definition: hps.h:21002
Definition: hps.h:34991
ClipOperation
Definition: hps.h:1298
HPS::Type ObjectType() const
Definition: hps.h:8853
Definition: hps.h:2552
Definition: hps.h:30079
Method
Definition: hps.h:1428
Definition: hps.h:36794
HPS::Type ObjectType() const
Definition: hps.h:26463
Definition: hps.h:42736
Parameterization
Definition: hps.h:952
Definition: hps.h:4277
Definition: hps.h:37045
Definition: hps.h:36264
FocusLostEvent()
Definition: hps.h:40892
CuttingLevel
Definition: hps.h:1729
Channel
Definition: hps.h:918
Definition: hps.h:9372
Definition: hps.h:43384
HandleResult
Definition: hps.h:40484
Definition: hps.h:38998
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5069
Definition: hps.h:5906
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40807
Value
Definition: hps.h:1409
Definition: hps.h:1080
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2201
Code
Definition: hps.h:99
HPS::Type ObjectType() const
Definition: hps.h:25959
Event * Clone() const
Definition: hps.h:40900
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41564
Definition: hps.h:42114
Definition: hps.h:41493
ErrorEvent()
Definition: hps.h:40746
Definition: hps.h:40813
Justification
Definition: hps.h:1544
The vertex colors applied to faces.
Definition: hps.h:6496
HPS::Type ObjectType() const
Definition: hps.h:13952
Definition: hps.h:35120
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5541
ErrorEvent(char const *in_message)
Definition: hps.h:40750
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:40920
Definition: hps.h:41189
FrameSize
Definition: hps.h:198
Definition: hps.h:2140
Definition: hps.h:9182
Definition: hps.h:23520
Definition: hps.h:11994
Justification
Definition: hps.h:1846
Definition: hps.h:21479
HPS::Type ObjectType() const
Definition: hps.h:11737
Definition: hps.h:40321
Definition: hps.h:37800
HPS::Type ObjectType() const
Definition: hps.h:19687
Definition: hps.h:1683
Definition: hps.h:1464
HPS::Type ObjectType() const
Definition: hps.h:22093
bool None() const
Definition: hps.h:41371
Definition: hps.h:309
Definition: hps.h:1403
HPS::Type ObjectType() const
Definition: hps.h:8648
HPS::Type ObjectType() const
Definition: hps.h:36781
HPS::Type ObjectType() const
Definition: hps.h:34968
Definition: hps.h:17530
GreekingMode
Definition: hps.h:1635
HPS::Type ObjectType() const
Definition: hps.h:20197
Definition: hps.h:36156
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41729
Operation
Definition: hps.h:448
Definition: hps.h:1422
HPS::Type ObjectType() const
Definition: hps.h:37362
Type
Definition: hps.h:1992
WorldPoint(Point const &in_point)
Definition: hps.h:5716
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41323
Definition: hps.h:43355
HPS::Type ObjectType() const
Definition: hps.h:9835
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2472
Definition: hps.h:22492
HPS::Type ObjectType() const
Definition: hps.h:6655
Definition: hps.h:34734
Definition: hps.h:17835
TouchEvent(Event const &in_event)
Definition: hps.h:41231
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41317
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6940
Definition: hps.h:5040
Definition: hps.h:39266
Definition: hps.h:43379
Definition: hps.h:35221
Definition: hps.h:4216
Relation
Definition: hps.h:371
Action
Definition: hps.h:41624
ChannelMapping
Definition: hps.h:1021
HPS::Type ObjectType() const
Definition: hps.h:22611
Definition: hps.h:6753
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5558
HPS::Type ObjectType() const
Definition: hps.h:38839
HPS::Type ObjectType() const
Definition: hps.h:39478
Definition: hps.h:23794
Definition: hps.h:5759
HPS::Type ObjectType() const
Definition: hps.h:42139
bool Alt() const
Definition: hps.h:41032
Definition: hps.h:41339
ToleranceUnits
Definition: hps.h:354
Definition: hps.h:24573
Definition: hps.h:27317
Definition: hps.h:37899
HPS::Type ObjectType() const
Definition: hps.h:12487
SizeUnits
Definition: hps.h:1797
Type
Definition: hps.h:2009
HPS::Type ObjectType() const
Definition: hps.h:17682
The vertex colors applied to faces.
RelationTest
Definition: hps.h:381
Definition: hps.h:39170
Type
Definition: hps.h:316
HPS::Type ObjectType() const
Definition: hps.h:14702
Behavior
Definition: hps.h:563
Definition: hps.h:5709
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6730
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41730
Definition: hps.h:40500
HPS::Type ObjectType() const
Definition: hps.h:18596
Style Append Mode.
ImageFormat
Definition: hps.h:213
Definition: hps.h:38522
Definition: hps.h:25396
Definition: hps.h:41735
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5532
float blue
Definition: hps.h:4282
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:40888
Type
Definition: hps.h:421
HPS::Type ObjectType() const
Definition: hps.h:21025
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6958
PixelPoint(Point const &in_point)
Definition: hps.h:6062
HPS::Type ObjectType() const
Definition: hps.h:6184
HPS::Type ObjectType() const
Definition: hps.h:7047
Definition: hps.h:17658
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41590
Definition: hps.h:20864
Definition: hps.h:42647
HPS::Type ObjectType() const
Definition: hps.h:21622
HPS::Type ObjectType() const
Definition: hps.h:21502
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:35207
HPS::Type ObjectType() const
Definition: hps.h:28726
HPS::Type ObjectType() const
Definition: hps.h:24087
HPS::Type ObjectType() const
Definition: hps.h:39118
HPS::Type ObjectType() const
Definition: hps.h:20887
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41610
Event * Clone() const
Definition: hps.h:40978
Definition: hps.h:14252
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5063
Definition: hps.h:35807
Definition: hps.h:40909
HPS::Type ObjectType() const
Definition: hps.h:34519
HPS::Type ObjectType() const
Definition: hps.h:40453
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:42270
HPS::Type ObjectType() const
Definition: hps.h:15733
Definition: hps.h:1900
Definition: hps.h:31176
Infinite line which extends infinitely in both directions along a vector.
InformationEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40613
intptr_t GetChannel() const
Definition: hps.h:6138
HPS::Type ObjectType() const
Definition: hps.h:9206
Definition: hps.h:1337
Definition: hps.h:13558
Algorithm
Definition: hps.h:1351
HPS::Type ObjectType() const
Definition: hps.h:31198
HPS::Type ObjectType() const
Definition: hps.h:37833
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3839
Definition: hps.h:12464
Definition: hps.h:10612
Driver
Definition: hps.h:42941
Definition: hps.h:6999
Definition: hps.h:42058
SizeUnits
Definition: hps.h:1665
StandAloneWindowEvent()
Definition: hps.h:40828
HPS::Type ObjectType() const
Definition: hps.h:36360
HPS::Type ObjectType() const
Definition: hps.h:34357
ModifierKeys GetModifierKeys() const
Definition: hps.h:41180
Definition: hps.h:40988
Definition: hps.h:39447
Definition: hps.h:40671
HPS::Type ObjectType() const
Definition: hps.h:12325
HPS::Type ObjectType() const
Definition: hps.h:11156
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40715
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41518
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5504
HPS::Type ObjectType() const
Definition: hps.h:17393
Definition: hps.h:38188
Level
Definition: hps.h:1342
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:40644
bool X2() const
Definition: hps.h:41391
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:40997
Definition: hps.h:34335
Definition: hps.h:43308
bool Left() const
Definition: hps.h:41375
void Control(bool in_state)
Definition: hps.h:41056
Definition: hps.h:21590
Definition: hps.h:2889
Definition: hps.h:16942
Definition: hps.h:41132
HPS::Type ObjectType() const
Definition: hps.h:42675
HPS::Type ObjectType() const
Definition: hps.h:18104
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3986
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:40736
The base class of all HPS exceptions.
Definition: hps.h:5496
RegionAlignment
Definition: hps.h:1644
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41225
Event * Clone() const
Definition: hps.h:41555
Definition: hps.h:6105
HPS::Type ObjectType() const
Definition: hps.h:21174
Definition: hps.h:37289
InformationEvent(Event const &in_event)
Definition: hps.h:40617
Definition: hps.h:12739
void Invalidate()
Definition: hps.h:3784
Definition: hps.h:22987
Definition: hps.h:38816
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4778
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5555
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40916
HPS::Type ObjectType() const
Definition: hps.h:33845
Definition: hps.h:6055
HPS::Type ObjectType() const
Definition: hps.h:39715
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6131
Definition: hps.h:396
char const * GetBytes() const
Definition: hps.h:6844
Definition: hps.h:38063
virtual intptr_t Freshen() const
Definition: hps.h:41602
Definition: hps.h:34216
HPS::Type ObjectType() const
Definition: hps.h:35316
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:41141
float green
Definition: hps.h:4281
Action
Definition: hps.h:41499
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1689
HPS::Type ObjectType() const
Definition: hps.h:10240
HPS::Type ObjectType() const
Definition: hps.h:27115
HPS::Type ObjectType() const
Definition: hps.h:24605
HPS::Type ObjectType() const
Definition: hps.h:24361
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10439
HPS::Type ObjectType() const
Definition: hps.h:37885
HPS::Type ObjectType() const
Definition: hps.h:24728
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5963
ImportStatusEvent(Event const &in_event)
Definition: hps.h:40963
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5813
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6403
static const float NegativeInfinity
Definition: hps.h:2182
HighlightEvent(Event const &in_event)
Definition: hps.h:40571
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6949
SizeUnits
Definition: hps.h:1470
HPS::Type ObjectType() const
Definition: hps.h:12763
HPS::Type ObjectType() const
Definition: hps.h:20583
Definition: hps.h:21263
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41612
HPS::Type ObjectType() const
Definition: hps.h:10461
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5914
GatheringLevel
Definition: hps.h:1745
HPS::Type ObjectType() const
Definition: hps.h:28936
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:40666
Definition: hps.h:40426
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3751
Definition: hps.h:12359
FrameOptions
Definition: hps.h:207
HPS::Type ObjectType() const
Definition: hps.h:35157
Space
Definition: hps.h:8559
void Alt(bool in_state)
Definition: hps.h:41060
Definition: hps.h:7008
Buttons
Definition: hps.h:41479
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41637
HPS::Type ObjectType() const
Definition: hps.h:37089
Type
Definition: hps.h:251
bool operator!=(Touch const &in_that) const
Definition: hps.h:6417
Definition: hps.h:40042
Definition: hps.h:23982
Definition: hps.h:94
Type
Definition: hps.h:439
HPS::Type ObjectType() const
Definition: hps.h:42172
HPS::Type ObjectType() const
Definition: hps.h:43517
HPS::Type ObjectType() const
Definition: hps.h:38085
HPS::Type ObjectType() const
Definition: hps.h:43406
HPS::Type ObjectType() const
Definition: hps.h:33576
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5713
HPS::Type ObjectType() const
Definition: hps.h:9396
HPS::Type ObjectType() const
Definition: hps.h:43603
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6931
Definition: hps.h:23247
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41310
Definition: hps.h:35042
Definition: hps.h:1264
Event * Clone() const
Definition: hps.h:41250
void Middle(bool in_state)
Definition: hps.h:41414
Definition: hps.h:28914
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40786
Definition: hps.h:4786
Event * Clone() const
Definition: hps.h:40854
size_t GetLength() const
Definition: hps.h:6829
HPS::Type ObjectType() const
Definition: hps.h:20974
HPS::Type ObjectType() const
Definition: hps.h:26673
Type
Definition: hps.h:1127
Definition: hps.h:416
HPS::Type ObjectType() const
Definition: hps.h:9314
bool None() const
Definition: hps.h:41020
size_t ClickCount
The number of clicks received.
Definition: hps.h:41614
virtual intptr_t Freshen() const
Definition: hps.h:6135
void Reset()
Definition: hps.h:6824
HPS::Type ObjectType() const
Definition: hps.h:37619
HPS::Type ObjectType() const
Definition: hps.h:23742
Definition: hps.h:34089
HPS::Type ObjectType() const
Definition: hps.h:39819
Definition: hps.h:39095
SizeUnits
Definition: hps.h:1598
Event * Clone() const
Definition: hps.h:40777
MouseEvent(Event const &in_event)
Definition: hps.h:41533
bool Right() const
Definition: hps.h:41379
Definition: hps.h:2004
virtual bool Empty() const
Definition: hps.h:5596
Join
Definition: hps.h:1820
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3908
Modifier
Definition: hps.h:1857
static MouseButtons ButtonLeft()
Definition: hps.h:41457
static MouseButtons ButtonMiddle()
Definition: hps.h:41465
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41208
HighlightEvent()
Definition: hps.h:40555
virtual HPS::Type ObjectType() const
Definition: hps.h:5592
Definition: hps.h:18806
HPS::Type ObjectType() const
Definition: hps.h:13775
Definition: hps.h:28566
Definition: hps.h:16653
Definition: hps.h:5808
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41322
Definition: hps.h:8619
Type
Definition: hps.h:574
virtual intptr_t Freshen() const
Definition: hps.h:40538
Background
Definition: hps.h:232
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3828
Definition: hps.h:42800
static ModifierKeys KeyControl()
Definition: hps.h:41103
HPS::Type ObjectType() const
Definition: hps.h:18316
Definition: hps.h:5514
HPS::Type ObjectType() const
Definition: hps.h:35570
Definition: hps.h:7302
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5861
HPS::Type ObjectType() const
Definition: hps.h:39611
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40833
Mode
Definition: hps.h:1710
Definition: hps.h:33215
Definition: hps.h:11133
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:40665
Event * Clone() const
Definition: hps.h:40937
Definition: hps.h:33951
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4045
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3863
Definition: hps.h:33813
Type
Definition: hps.h:877
Definition: hps.h:339
Definition: hps.h:14679
Definition: hps.h:21338
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3816
Definition: hps.h:912
HPS::Type ObjectType() const
Definition: hps.h:12234
Definition: hps.h:35752
HPS::Type ObjectType() const
Definition: hps.h:32275
HPS::Type ObjectType() const
Definition: hps.h:17786
Definition: hps.h:42110
HPS::Type ObjectType() const
Definition: hps.h:37717
Definition: hps.h:35426
HPS::Type ObjectType() const
Definition: hps.h:42292
Definition: hps.h:5857
Definition: hps.h:37931
HPS::Type ObjectType() const
Definition: hps.h:41970
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3802
HPS::Type ObjectType() const
Definition: hps.h:36872
Definition: hps.h:35691
HPS::Type ObjectType() const
Definition: hps.h:12383
HPS::Type ObjectType() const
Definition: hps.h:17859
Definition: hps.h:24065
Mode
Definition: hps.h:1763
Definition: hps.h:8821
Event * Clone() const
Definition: hps.h:41684
Definition: hps.h:10216
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3874
Tiling
Definition: hps.h:980
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4030
WindowPoint(Point const &in_point)
Definition: hps.h:6013
Transform
Definition: hps.h:1553
HPS::Type ObjectType() const
Definition: hps.h:37187
Definition: hps.h:11392
Definition: hps.h:40600
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:21945
Definition: hps.h:35175
Definition: hps.h:27428
Definition: hps.h:22230
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:38544
Definition: hps.h:25937
Definition: hps.h:932
ModifierKeys()
Definition: hps.h:40992
Definition: hps.h:24978
Definition: hps.h:1792
Definition: hps.h:22589
Definition: hps.h:28040
Preference
Definition: hps.h:1578
HPS::Type ObjectType() const
Definition: hps.h:25280
Capping
Definition: hps.h:519
Definition: hps.h:40742
HPS::Type ObjectType() const
Definition: hps.h:35388
TouchEvent()
Definition: hps.h:41202
Interpolation
Definition: hps.h:996
HPS::Type ObjectType() const
Definition: hps.h:19958
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:41156
WarningEvent(char const *in_message)
Definition: hps.h:40679
HPS::Type ObjectType() const
Definition: hps.h:20751
Modifiers
Definition: hps.h:41117
Component
Definition: hps.h:511
Definition: hps.h:506
Definition: hps.h:9812
Definition: hps.h:37493
HPS::Type ObjectType() const
Definition: hps.h:35878
HPS::Type ObjectType() const
Definition: hps.h:6520
HPS::Type ObjectType() const
Definition: hps.h:22524
Definition: hps.h:17369
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4015
HPS::Type ObjectType() const
Definition: hps.h:42827
HPS::Type ObjectType() const
Definition: hps.h:22314
Definition: hps.h:3175
Format
Definition: hps.h:37050
WarningEvent()
Definition: hps.h:40675
Definition: hps.h:24894
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40532
Touch()
Definition: hps.h:6397
Definition: hps.h:12153
Definition: hps.h:35845
Component
Definition: hps.h:401
Definition: hps.h:33560
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:39588
Definition: hps.h:1122
float red
Definition: hps.h:4280
ClipSpace
Definition: hps.h:1306
Definition: hps.h:12065
Definition: hps.h:37684
Definition: hps.h:15710
Control & operator=(Control &&in_that)
Definition: hps.h:5649
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40684
HPS::Type ObjectType() const
Definition: hps.h:13880
Definition: hps.h:28835
SizeUnits
Definition: hps.h:42784
void Right(bool in_state)
Definition: hps.h:41410
virtual void Reset()
Definition: hps.h:40476
Definition: hps.h:11714
HPS::Type ObjectType() const
Definition: hps.h:11271
bool Meta() const
Definition: hps.h:41036
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4057
Definition: hps.h:35355
TimerTickEvent()
Definition: hps.h:40504
Definition: hps.h:38351
Definition: hps.h:37067
HPS::Type ObjectType() const
Definition: hps.h:21977
RenderingAlgorithm
Definition: hps.h:268
EmergencyHandler()
Definition: hps.h:40019
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5763
TouchID ID
TouchID for this Touch.
Definition: hps.h:6422
Definition: hps.h:36327
HPS::Type ObjectType() const
Definition: hps.h:10837
HPS::Type ObjectType() const
Definition: hps.h:33237
HPS::Type ObjectType() const
Definition: hps.h:8422
Definition: hps.h:42779
Definition: hps.h:6161
Definition: hps.h:24339
HandednessOptimization
Definition: hps.h:362
Definition: hps.h:6703
Projection
Definition: hps.h:1388
Control(Control &&in_that)
Definition: hps.h:5644
bool Control() const
Definition: hps.h:41028
Definition: hps.h:5422
HPS::Type ObjectType() const
Definition: hps.h:34756
Overlay
Definition: hps.h:1278
Definition: hps.h:28704
Definition: hps.h:5955
Definition: hps.h:37165
Definition: hps.h:43085
HPS::Type ObjectType() const
Definition: hps.h:37953
size_t GetHash() const
Status
Definition: hps.h:6111
Definition: hps.h:22071
HPS::Type ObjectType() const
Definition: hps.h:34886
HPS::Type ObjectType() const
Definition: hps.h:6602
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:41613
Definition: hps.h:37334
Definition: hps.h:42150
Definition: hps.h:27011
Definition: hps.h:2020
HPS::Type ObjectType() const
Definition: hps.h:42080