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 # if !defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
77 # define OLD_GCC
78 # define OVERRIDE
79 # else
80 # define OVERRIDE override
81 # endif
82 
83 namespace HPSI
84 {
85  class Impl;
86  class KeyImpl;
87  class TicketImpl;
88  class EventDispatcherImpl;
89  class AbstractImage;
90 };
91 
92 namespace HPS
93 {
94 
95  // unimplemented
96 
97 
98 //Begin Info
100 class HPS_API Info
101 {
102 public:
105  enum class Code {
106  Unknown,
107  Exchange,
108  Publish,
109  Data,
110  Key,
111  Geometry,
112  Database,
113  Driver,
114  Internal,
115  Memory,
116  System,
117  Unsupported,
118  DX9DeviceReset
119  };
120 
121 private:
123  Info();
124 };
125 
126 
127 //Begin Info
129 class HPS_API Emergency
130 {
131 public:
134  enum class Code {
135  Unknown,
136  Fatal,
137  SoftMemoryLimit,
138  HardMemoryLimit,
139  };
140 
141 private:
143  Emergency();
144 };
145 
146 
147 //Begin Window
149 class HPS_API Window
150 {
151 public:
154  enum class Driver {
155  Default3D,
156  OpenGL,
157  OpenGL2,
158  DirectX9,
159  DirectX11,
160  };
161 
164  enum class UpdateStatus {
165  InProgress,
166  Completed,
167  TimedOut,
168  Interrupted,
169  Failed
170  };
171 
175  enum class UpdateControl {
176  DefaultUpdate,
177 
180  CompleteUpdate,
181 
182  RefreshUpdate,
183 
184  CompileOnlyUpdate,
185 
189  ExhaustiveUpdate,
190  };
191 
194  enum class Mobility
195  {
196  Locked,
197  Floating,
198  FixedRatio,
199  Free
200  };
201 
205  enum class FrameSize
206  {
207  Single,
208  Double
209  };
210 
214  enum class FrameOptions
215  {
216  Inset,
217  Overlay
218  };
219 
220  enum class ImageFormat
221  {
222  Default,
223  RGBA,
224  RGB,
225  Jpeg,
226  Png
227  };
228 
229 private:
231  Window();
232 };
233 
234 //Begin Subwindow
236 class HPS_API Subwindow
237 {
238 public:
239  enum class Background
240  {
241  SolidColor,
242  Image,
243  Cubemap,
244  Blend,
245  Transparent,
246  Interactive,
247 
248  GradientTopToBottom,
249  GradientBottomToTop,
250  GradientLeftToRight,
251  GradientRightToLeft,
252  GradientTopLeftToBottomRight,
253  GradientTopRightToBottomLeft,
254  GradientBottomLeftToTopRight,
255  GradientBottomRightToTopLeft,
256  };
257 
258  enum class Type
259  {
260  Standard,
261  Lightweight
262  };
263 
264  enum class Border
265  {
266  None,
267  Inset,
268  InsetBold,
269  Overlay,
270  OverlayBold
271  };
272 
273 
276  {
279  ZBuffer,
280 
286  HiddenLine,
287 
293  FastHiddenLine,
294 
307  Priority
308  };
309 
310 private:
311  Subwindow();
312 };
313 //End Subwindow
314 
316 class HPS_API Style
317 {
318 public:
319 
323  enum class Type
324  {
325  Segment,
326  Named
327  };
328 
332  enum class AppendMode
333  {
334  None,
335  And,
336  Or
337  };
338 
339 private:
340  Style();
341 };
342 
343 
344 //Begin Shell Attributes
346 class HPS_API Shell
347 {
348 public:
349 
352  enum class Component
353  {
354  Faces,
355  Edges,
356  Vertices
357  };
358 
359  /* \enum ToleranceUnits
360  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
361  enum class ToleranceUnits
362  {
363  ObjectSpace,
364  FeatureSizePercentage
365  };
366 
367  /* \enum HandednessOptimization
368  * Enumerates the shell optimization options with regards to handedness. */
370  {
371  None,
372  FixHandedness,
373  ReverseHandedness
374  };
375 
376  /* \enum RelationResults
377  * Enumerates the results of a shell relation computation. */
378  enum class Relation
379  {
380  On,
381  Off,
382  In,
383  Out
384  };
385 
386  /* \enum RelationTest
387  * Enumerates the test options for a shell relation computation. */
388  enum class RelationTest
389  {
390  Simple,
391  Enclosure,
392  Distance
393  };
394 
395 private:
397  Shell();
398 };
399 //End Shell Attributes
400 
401 //Begin Mesh Attributes
403 class HPS_API Mesh
404 {
405 public:
408  enum class Component
409  {
410  Faces,
411  Edges,
412  Vertices
413  };
414 
415 private:
417  Mesh();
418 };
419 //End Mesh Attributes
420 
421 //Begin InfiniteLine Attributes
423 class HPS_API InfiniteLine
424 {
425 public:
428  enum class Type
429  {
430  Line,
431  Ray
432  };
433 
434 private:
436  InfiniteLine();
437 };
438 //End InfiniteLine Attributes
439 
441 class HPS_API Trim
442 {
443 public:
446  enum class Type
447  {
448  Line,
449  Curve
450  };
451 
455  enum class Operation
456  {
457  Keep,
458  Remove
459  };
460 private:
462  Trim();
463 };
464 
465 //Begin Spotlight Attributes
467 class HPS_API Spotlight
468 {
469 public:
472  enum class OuterConeUnits
473  {
477  Degrees,
481  FieldRadius
482  };
483 
486  enum class InnerConeUnits
487  {
491  Degrees,
495  FieldRadius,
498  Percent
499  };
500 
501 
502 private:
504  Spotlight();
505 };
506 //End Spotlight Attributes
507 
508 
509 
510 
511 //Begin Cylinder Attributes
513 class HPS_API Cylinder
514 {
515 public:
518  enum class Component
519  {
520  Faces,
521  Edges,
522  };
523 
526  enum class Capping
527  {
528  None,
529  First,
530  Last,
531  Both
532  };
533 
537  enum class Orientation
538  {
539  Default,
540  DefaultRadii,
541  InvertRadii,
542  InvertRadiiOnly,
543  DefaultColors,
544  InvertColors,
545  InvertColorsOnly,
546  InvertAll
547  };
548 
549 private:
551  Cylinder();
552 };
553 
554 
556 class HPS_API Search
557 {
558 public:
561  enum class Space
562  {
563  SegmentOnly,
564  Subsegments,
565  SubsegmentsAndIncludes
566  };
567 
570  enum class Behavior
571  {
572  Exhaustive,
573  FirstMatch
574  };
575 
576 
577  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to 3DF HK types (if they map to HK types)
581  enum class Type : uint32_t {
582 
583  /* This enum classeration is divided into three parts.
584 
585  0xAABBBCCC
586 
587  The bits in A encode the most general category of the type (Geometry, Attribute).
588  The bits in B encode the subtype (Culling, TextAttribute). Attributes alone have these so far.
589  The bits in C encode the specific type (Shell, CullingVectorTolerance, TextAttributeSpacing).
590 
591  General category designators should have no bits in B or C.
592  Subtype category designators should have bits in A and B but not C.
593  Specific category designators should have bits in A and C and optionally B.
594 
595  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.
596  These types are kept in sync with the 3DF HK types by using Compile-time assets in hpsi.cpp.
597 
598  Geometry have no subtype. Most, 'Ordinary Geometry' map to a 3DF HK type.
599  The mutants or 'Special Geometry' (some lights and infinite ray) have no HK type to map to.
600 
601  Attributes come in a few forms.
602  The 'Simple Attributes' map to an HK type and have no subtypes -- they are what they are. ModellingMatrix, Camera, etc.
603  The 'Complex Attributes' have subtypes. A handful map to an HK type, but the majority are not.
604  */
605  None = 0x00000000,
606  Everything = 0x00ffffff,
607 
608  // Segment Stuff (Include & Segment map to HK types)
609  Include = 0x00000042,
610  Segment = 0x00000043,
611 
612  Includer = 0x00000100,
613 
614  // Geometry
615  Geometry = 0x10000000,
616 
617  // Ordinary Geometry (map to HK types) - (HK_* | Geometry)
618  CuttingSection = 0x10000026,
619  Shell = 0x10000028,
620  Mesh = 0x10000029,
621  Grid = 0x1000002a,
622  NURBSSurface = 0x1000002b,
623  Cylinder = 0x1000002d,
624  Sphere = 0x1000002e,
625  Polygon = 0x1000002f,
626  Circle = 0x10000030,
627  //unused = 0x10000031,
628  CircularWedge = 0x10000032,
629  Ellipse = 0x10000033,
630  Line = 0x10000034,
631  NURBSCurve = 0x10000037,
632  CircularArc = 0x10000038,
633  EllipticalArc = 0x10000039,
634  InfiniteLine = 0x1000003a,
635 // Image = 0x1000003b, N/A since images live in portfolios
636  Marker = 0x1000003c,
637  Text = 0x1000003e,
638  Reference = 0x10000040,
639 
640  // Special Geometry
641  DistantLight = 0x10000100,
642  Spotlight = 0x10000101,
643  InfiniteRay = 0x10000102,
644 
645  // Attributes
646  Attribute = 0x20000000,
647 
648  Priority = 0x20000001,
649 
650  // Simple Attributes (map to HK types)
651  Material = 0x2000000a,
652  Camera = 0x2000000e,
653  ModellingMatrix = 0x20000010,
654  UserData = 0x20000021,
655  TextureMatrix = 0x20000023,
656 
657  // Complex Attributes
658  Culling = 0x20001000,
659  CullingBackFace = 0x20001001,
660  CullingExtent = 0x20001002,
661  CullingVector = 0x20001003,
662  CullingVectorTolerance = 0x20001004,
663  CullingFrustum = 0x20001005,
664  CullingDeferralExtent = 0x20001006,
665 
666  CurveAttribute = 0x20002000,
667  CurveAttributeBudget = 0x20002001,
668  CurveAttributeContinuedBudget = 0x20002002,
669  CurveAttributeViewDependent = 0x20002003,
670  CurveAttributeMaximumDeviation = 0x20002004,
671  CurveAttributeMaximumAngle = 0x20002005,
672  CurveAttributeMaximumLength = 0x20002006,
673 
674  CylinderAttribute = 0x20003000,
675  CylinderAttributeTessellation = 0x20003001,
676  CylinderAttributeOrientation = 0x20003002,
677 
678  // EdgeAttributes map to HK types
679  EdgeAttribute = 0x20004000,
680  EdgeAttributePattern = 0x20004015,
681  EdgeAttributeWeight = 0x20004016,
682 
683  LightingAttribute = 0x20005000,
684  LightingAttributeInterpolation = 0x20005001,
685 
686  // LineAttributes map to HK types
687  LineAttribute = 0x20006000,
688  LineAttributePattern = 0x20006019,
689  LineAttributeWeight = 0x2000601a,
690 
691  // MarkerAttributes map to HK types
692  MarkerAttribute = 0x20007000,
693  MarkerAttributeSize = 0x2000701b,
694  MarkerAttributeSymbol = 0x2000701c,
695 
696  SurfaceAttribute = 0x20008000,
697  SurfaceAttributeBudget = 0x20008001,
698  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
699  SurfaceAttributeMaximumFacetAngle = 0x20008003,
700  SurfaceAttributeMaximumFacetWidth = 0x20008004,
701  SurfaceAttributeTrimCurveBudget = 0x20008005,
702  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
703 
704  Selectability = 0x20009000,
705  SelectabilityWindows = 0x20009001,
706  SelectabilityEdges = 0x20009002,
707  SelectabilityFaces = 0x20009003,
708  SelectabilityLights = 0x20009004,
709  SelectabilityLines = 0x20009005,
710  SelectabilityMarkers = 0x20009006,
711  SelectabilityVertices = 0x20009007,
712  SelectabilityText = 0x20009008,
713 
714  SphereAttribute = 0x2000a000,
715  SphereAttributeTessellation = 0x2000a001,
716 
717  Subwindow = 0x2000b000,
718  SubwindowEitherType = 0x2000b001,
719  SubwindowStandard = 0x2000b00d,
720  SubwindowLightweight = 0x2000b002,
721  SubwindowBackground = 0x2000b003,
722  SubwindowBorder = 0x2000b004,
723  SubwindowRenderingAlgorithm = 0x2000b005,
724 
725  // TextAttributeAlignment, Path, & Spacing map to HK types
726  TextAttribute = 0x2000c000,
727  TextAttributeAlignment = 0x2000c01d,
728  TextAttributeBold = 0x2000c002,
729  TextAttributeItalic = 0x2000c003,
730  TextAttributeOverline = 0x2000c004,
731  TextAttributeStrikethrough = 0x2000c005,
732  TextAttributeUnderline = 0x2000c006,
733  TextAttributeSlant = 0x2000c007,
734  TextAttributeLineSpacing = 0x2000c008,
735  TextAttributeRotation = 0x2000c00a,
736  TextAttributeExtraSpace = 0x2000c00b,
737  TextAttributeGreeking = 0x2000c00c,
738  TextAttributeSizeTolerance = 0x2000c00d,
739  TextAttributeSize = 0x2000c00e,
740  TextAttributeFont = 0x2000c00f,
741  TextAttributeTransform = 0x2000c010,
742  TextAttributeRenderer = 0x2000c011,
743  TextAttributePreference = 0x2000c012,
744  TextAttributePath = 0x2000c01f,
745  TextAttributeSpacing = 0x2000c020,
746 
747  Transparency = 0x2000d000,
748  TransparencyMethod = 0x2000d001,
749  TransparencyAlgorithm = 0x2000d002,
750  TransparencyDepthPeelingLayers = 0x2000d004,
751  TransparencyDepthPeelingMinimumArea = 0x2000d005,
752  TransparencyDepthWriting = 0x2000d006,
753 
754  Visibility = 0x2000e000,
755  VisibilityCuttingSections = 0x2000e001,
756  VisibilityCutEdges = 0x2000e002,
757  VisibilityCutFaces = 0x2000e003,
758  VisibilityWindows = 0x2000e004,
759  VisibilityText = 0x2000e005,
760  VisibilityLines = 0x2000e006,
761  VisibilityEdgeLights = 0x2000e007,
762  VisibilityMarkerLights = 0x2000e008,
763  VisibilityFaceLights = 0x2000e009,
764  VisibilityGenericEdges = 0x2000e00a,
765  VisibilityHardEdges = 0x2000e00b,
766  VisibilityAdjacentEdges = 0x2000e00c,
767  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
768  VisibilityShadowEmitting = 0x2000e00e,
769  VisibilityShadowReceiving = 0x2000e00f,
770  VisibilityShadowCasting = 0x2000e010,
771  VisibilityMarkers = 0x2000e011,
772  VisibilityVertices = 0x2000e012,
773  VisibilityFaces = 0x2000e013,
774  VisibilityPerimeterEdges = 0x2000e014,
775  VisibilityNonCulledEdges = 0x2000e015,
776  VisibilityMeshQuadEdges = 0x2000e016,
777 
778  VisualEffects = 0x2000f000,
779  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
780  VisualEffectsAntiAliasing = 0x2000f002,
781  VisualEffectsShadowMaps = 0x2000f003,
782  VisualEffectsSimpleShadow = 0x2000f004,
783  VisualEffectsSimpleShadowPlane = 0x2000f005,
784  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
785  VisualEffectsSimpleShadowColor = 0x2000f007,
786  VisualEffectsSimpleReflection = 0x2000f008,
787  VisualEffectsSimpleReflectionPlane = 0x2000f009,
788  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
789 
790  Performance = 0x20010000,
791  PerformanceDisplayLists = 0x20010001,
792  PerformanceStaticModel = 0x20010002,
793  StaticModelSegment = 0x40000043,
794 
795  // DrawingAttributeWorldHandedness map to HK types
796  DrawingAttribute = 0x20011000,
797  DrawingAttributePolygonHandedness = 0x20011001,
798  DrawingAttributeDepthRange = 0x20011002,
799  DrawingAttributeFaceDisplacement = 0x20011003,
800  DrawingAttributeGeneralDisplacement = 0x20011004,
801  DrawingAttributeVertexDisplacement = 0x20011005,
802  DrawingAttributeOverlay = 0x20011006,
803  DrawingAttributeDeferral = 0x20011007,
804  DrawingAttributeClipRegion = 0x20011012,
805  DrawingAttributeWorldHandedness = 0x20011018,
806 
807  HiddenLineAttribute = 0x20012000,
808  HiddenLineAttributeColor = 0x20012001,
809  HiddenLineAttributeDimFactor = 0x20012002,
810  HiddenLineAttributeFaceDisplacement = 0x20012003,
811  HiddenLineAttributeLinePattern = 0x20012005,
812  HiddenLineAttributeRenderFaces = 0x20012006,
813  HiddenLineAttributeRenderText = 0x20012007,
814  HiddenLineAttributeAlgorithm = 0x20012008,
815  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
816  HiddenLineAttributeVisibility = 0x2001200a,
817  HiddenLineAttributeWeight = 0x2001200b,
818  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
819 
820  SegmentStyle = 0x20013001,
821  NamedStyle = 0x20013002,
822  MaterialPalette = 0x20013003,
823  Portfolio = 0x20013004,
824 
825  ContourLine = 0x20014000,
826  ContourLineVisibility = 0x20014001,
827  ContourLinePosition = 0x20014002,
828  ContourLineColor = 0x20014003,
829  ContourLinePattern = 0x20014004,
830  ContourLineWeight = 0x20014005,
831  ContourLineLighting = 0x20014006,
832 
833  Condition = 0x20015000,
834 
835  Bounding = 0x20016000,
836  BoundingVolume = 0x20016001,
837  BoundingExclusion = 0x20016002,
838 
839  AttributeLock = 0x20017000,
840  AttributeLockSetting = 0x20017001,
841  AttributeLockSubsegmentOverride = 0x20017002,
842 
843  TransformMask = 0x20018000,
844  TransformMaskCamera = 0x20018001,
845  TransformMaskCameraTranslation = 0x20018002,
846  TransformMaskCameraScale = 0x20018003,
847  TransformMaskCameraOffset = 0x20018004,
848  TransformMaskCameraRotation = 0x20018005,
849  TransformMaskCameraPerspectiveScale = 0x20018006,
850  TransformMaskCameraProjection = 0x20018007,
851  TransformMaskModellingMatrix = 0x20018008,
852  TransformMaskModellingMatrixTranslation = 0x20018009,
853  TransformMaskModellingMatrixScale = 0x20018010,
854  TransformMaskModellingMatrixOffset = 0x20018011,
855  TransformMaskModellingMatrixRotation = 0x20018012,
856 
857  ColorInterpolation = 0x20019000,
858  ColorInterpolationFaceColor = 0x20019001,
859  ColorInterpolationEdgeColor = 0x20019002,
860  ColorInterpolationMarkerColor = 0x20019003,
861  ColorInterpolationFaceIndex = 0x20019004,
862  ColorInterpolationEdgeIndex = 0x20019005,
863  ColorInterpolationMarkerIndex = 0x20019006,
864 
865  CuttingSectionAttribute = 0x2001a000,
866  CuttingSectionAttributeCuttingLevel = 0x2001a001,
867  CuttingSectionAttributeCappingLevel = 0x2001a002,
868  CuttingSectionAttributeMaterialPreference = 0x2001a003,
869 
870  };
871  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to HK types (if they are map to HK types)
872 
873 private:
875  Search();
876 };
877 
879 class HPS_API Material
880 {
881 public:
884  enum class Type
885  {
886  InvalidMaterialIndex = -1,
887  Nothing = 0,
888  FullMaterial,
889  ExplicitRGBColor,
890  ExplicitRGBAColor,
891  MaterialIndex,
892  TextureName,
893  ModulatedTexture,
894  CubeMapName,
895  ModulatedCubeMap,
896  GlossValue,
897  DiffuseChannelAlpha
898 
899  };
900 
904  enum class Channel
905  {
906  DiffuseColor = 1,
907  DiffuseTexture = 2,
908  Specular = 3,
909  Emission = 4,
910  Transmission = 5,
911  Mirror = 6,
912  Bump = 7,
913  EnvironmentTexture = 8,
914  EnvironmentCubeMap = 9,
915  Gloss = 10
916  };
917 
919  class HPS_API Color
920  {
921  public:
925  enum class Channel
926  {
927  DiffuseColor = 1,
928  Specular = 3,
929  Emission = 4,
930  Mirror = 6
931  };
932 
933  private:
935  Color();
936  };
937 
939  class HPS_API Texture
940  {
941  public:
945  enum class Channel
946  {
947  DiffuseTexture = 2,
948  Specular = 3,
949  Emission = 4,
950  Transmission = 5,
951  Mirror = 6,
952  Bump = 7,
953  EnvironmentTexture = 8,
954  EnvironmentCubeMap = 9
955  };
956 
959  enum class Parameterization
960  {
962  Cylinder,
964  PhysicalReflection,
966  Object,
972  NaturalUV,
974  ReflectionVector,
976  SurfaceNormal,
978  Sphere,
980  UV,
982  World
983  };
984 
987  enum class Tiling
988  {
991  Clamp,
993  Repeat,
995  Reflect,
998  Trim
999  };
1000 
1003  enum class Interpolation
1004  {
1006  Bilinear,
1007 
1009  InterpolationOff
1010  };
1011 
1014  enum class Decimation
1015  {
1018  Anisotropic,
1020  Mipmap,
1022  DecimationOff
1023  };
1024 
1028  enum class ChannelMapping
1029  {
1030  Red,
1031  Green,
1032  Blue,
1033  Alpha,
1034  Zero,
1035  One,
1036  Luminance
1037  };
1038 
1039  private:
1041  Texture();
1042  };
1043 private:
1045  Material();
1046 };
1047 
1048 class HPS_API PostProcessEffects
1049 {
1050 public:
1051  class HPS_API AmbientOcclusion
1052  {
1053  public:
1057  enum class Quality
1058  {
1059  Fastest,
1060  Nicest
1061  };
1062 
1063  private:
1064  AmbientOcclusion();
1065  };
1066 
1067  class HPS_API Bloom
1068  {
1069  public:
1073  enum class Shape
1074  {
1075  Star,
1076  Radial
1077  };
1078 
1079  private:
1080  Bloom();
1081  };
1082 
1083 private:
1084  PostProcessEffects() {}
1085 };
1086 
1087 class HPS_API Performance
1088 {
1089 public:
1093  enum class DisplayLists
1094  {
1096  NoDisplayLists,
1097 
1100  GeometryDisplayLists,
1101 
1104  SegmentDisplayLists
1105  };
1106 
1115  enum class StaticModel
1116  {
1117 
1118  NoStaticModel,
1119  AttributeStaticModel,
1120  AttributeSpatialStaticModel
1121  };
1122 
1123 
1124 private:
1125  Performance() {}
1126 };
1127 
1128 
1129 class HPS_API AttributeLock
1130 {
1131 public:
1132 
1134  enum class Type : uint32_t
1135  {
1136  Everything = 0x01000000,
1137 
1138  Visibility = 0x02000000,
1139 
1140  VisibilityCuttingSections,
1141  VisibilityCutEdges,
1142  VisibilityCutFaces,
1143  VisibilityWindows,
1144  VisibilityText,
1145  VisibilityLines,
1146  VisibilityEdgeLights,
1147  VisibilityMarkerLights,
1148  VisibilityFaceLights,
1149  VisibilityGenericEdges,
1150  VisibilityHardEdges,
1151  VisibilityAdjacentEdges,
1152  VisibilityInteriorSilhouetteEdges,
1153  VisibilityShadowEmitting,
1154  VisibilityShadowReceiving,
1155  VisibilityShadowCasting,
1156  VisibilityMarkers,
1157  VisibilityVertices,
1158  VisibilityFaces,
1159  VisibilityPerimeterEdges,
1160  VisibilityNonCulledEdges,
1161  VisibilityMeshQuadEdges,
1162  VisibilityCutGeometry,
1163  VisibilityEdges,
1164  VisibilityGeometry,
1165  VisibilityLights,
1166  VisibilityShadows,
1167 
1168  Material = 0x03000000,
1169 
1170  MaterialGeometry,
1171  MaterialCutGeometry,
1172 
1173  MaterialAmbientLightUpColor,
1174  MaterialAmbientLightDownColor,
1175  MaterialAmbientLightColor,
1176 
1177  MaterialWindowColor,
1178  MaterialWindowContrastColor,
1179 
1180  MaterialLightColor,
1181  MaterialLineColor,
1182  MaterialMarkerColor,
1183  MaterialTextColor,
1184  MaterialCutEdgeColor,
1185 
1186  MaterialVertex,
1187  MaterialVertexDiffuse,
1188  MaterialVertexDiffuseColor,
1189  MaterialVertexDiffuseAlpha,
1190  MaterialVertexDiffuseTexture,
1191  MaterialVertexSpecular,
1192  MaterialVertexMirror,
1193  MaterialVertexTransmission,
1194  MaterialVertexEmission,
1195  MaterialVertexEnvironment,
1196  MaterialVertexBump,
1197  MaterialVertexGloss,
1198 
1199  MaterialEdge,
1200  MaterialEdgeDiffuse,
1201  MaterialEdgeDiffuseColor,
1202  MaterialEdgeDiffuseAlpha,
1203  MaterialEdgeDiffuseTexture,
1204  MaterialEdgeSpecular,
1205  MaterialEdgeMirror,
1206  MaterialEdgeTransmission,
1207  MaterialEdgeEmission,
1208  MaterialEdgeEnvironment,
1209  MaterialEdgeBump,
1210  MaterialEdgeGloss,
1211 
1212  MaterialFace,
1213  MaterialFaceDiffuse,
1214  MaterialFaceDiffuseColor,
1215  MaterialFaceDiffuseAlpha,
1216  MaterialFaceDiffuseTexture,
1217  MaterialFaceSpecular,
1218  MaterialFaceMirror,
1219  MaterialFaceTransmission,
1220  MaterialFaceEmission,
1221  MaterialFaceEnvironment,
1222  MaterialFaceBump,
1223  MaterialFaceGloss,
1224 
1225  MaterialBackFace,
1226  MaterialBackFaceDiffuse,
1227  MaterialBackFaceDiffuseColor,
1228  MaterialBackFaceDiffuseAlpha,
1229  MaterialBackFaceDiffuseTexture,
1230  MaterialBackFaceSpecular,
1231  MaterialBackFaceMirror,
1232  MaterialBackFaceTransmission,
1233  MaterialBackFaceEmission,
1234  MaterialBackFaceEnvironment,
1235  MaterialBackFaceBump,
1236  MaterialBackFaceGloss,
1237 
1238  MaterialFrontFace,
1239  MaterialFrontFaceDiffuse,
1240  MaterialFrontFaceDiffuseColor,
1241  MaterialFrontFaceDiffuseAlpha,
1242  MaterialFrontFaceDiffuseTexture,
1243  MaterialFrontFaceSpecular,
1244  MaterialFrontFaceMirror,
1245  MaterialFrontFaceTransmission,
1246  MaterialFrontFaceEmission,
1247  MaterialFrontFaceEnvironment,
1248  MaterialFrontFaceBump,
1249  MaterialFrontFaceGloss,
1250 
1251  MaterialCutFace,
1252  MaterialCutFaceDiffuse,
1253  MaterialCutFaceDiffuseColor,
1254  MaterialCutFaceDiffuseAlpha,
1255  MaterialCutFaceDiffuseTexture,
1256  MaterialCutFaceSpecular,
1257  MaterialCutFaceMirror,
1258  MaterialCutFaceTransmission,
1259  MaterialCutFaceEmission,
1260  MaterialCutFaceEnvironment,
1261  MaterialCutFaceBump,
1262  MaterialCutFaceGloss,
1263 
1264  Camera = 0x04000000,
1265  };
1266 
1267 private:
1268  AttributeLock() {}
1269 };
1270 
1271 class HPS_API Drawing
1272 {
1273 public:
1276  enum class Handedness
1277  {
1278  NoHandedness,
1279  Left,
1280  Right
1281  };
1282 
1285  enum class Overlay
1286  {
1288  NoOverlay,
1291  NormalOverlay,
1294  OverlayWithZValues,
1295 
1300  InPlace,
1301  };
1302 
1305  enum class ClipOperation
1306  {
1307  Keep,
1308  Remove,
1309  };
1310 
1313  enum class ClipSpace
1314  {
1315  Window,
1316  World,
1317  Object,
1318  };
1319 
1320 private:
1321  Drawing() {}
1322 };
1323 
1324 
1325 class HPS_API HiddenLine
1326 {
1327 public:
1331  enum class Algorithm
1332  {
1333  None,
1334  ZBuffer,
1335  ZSort,
1336  };
1337 
1338 private:
1339  HiddenLine() {}
1340 };
1341 
1342 
1344 class HPS_API Selection
1345 {
1346 public:
1349  enum class Level
1350  {
1351  Segment,
1352  Entity,
1353  Subentity,
1354  };
1355 
1358  enum class Algorithm
1359  {
1360  Visual,
1361  Analytic
1362  };
1363 
1366  enum class Granularity
1367  {
1368  General,
1369  Detailed
1370  };
1371 
1372 private:
1374  Selection();
1375 };
1376 
1377 
1381 
1382 //Begin Camera
1384 class HPS_API Camera
1385 {
1386 public:
1395  enum class Projection {
1396  Default=1,
1397  Perspective,
1398  Orthographic,
1399  Stretched,
1400  };
1403 private:
1404  Camera();
1405 };
1406 
1407 
1408 //Begin Selectability
1410 class HPS_API Selectability
1411 {
1412 public:
1416  enum class Value
1417  {
1418  Off=0,
1419  On,
1420  ForcedOn
1421  };
1422 
1423 private:
1424  Selectability();
1425 };
1426 
1427 // Begin Transparency
1429 class HPS_API Transparency
1430 {
1431 public:
1435  enum class Method
1436  {
1437  Off,
1438  Blended,
1439  ScreenDoor
1440  };
1441 
1445  enum class Algorithm
1446  {
1447  NoSorting,
1448  Painters,
1449  ZSortNicest,
1450  ZSortFastest,
1451  DepthPeeling
1452  };
1453 
1457  enum class AreaUnits
1458  {
1459  Percent,
1460  Pixels
1461  };
1462 
1463 private:
1464  Transparency() {}
1465 };
1466 
1467 
1468 
1469 //Begin Marker Attributes
1471 class HPS_API Marker
1472 {
1473 public:
1477  enum class SizeUnits
1478  {
1479  ScaleFactor,
1480  ObjectSpace,
1481  SubscreenRelative,
1482  WindowRelative,
1483  WorldSpace,
1484  Points,
1485  Pixels
1486 
1487  };
1488 private:
1489  Marker();
1490 };
1491 
1492 //Begin Sphere Attributes
1494 class HPS_API Sphere
1495 {
1496 public:
1497 
1498 private:
1499  Sphere();
1500 };
1501 
1502 
1503 //Begin Lighting Attributes
1505 class HPS_API Lighting
1506 {
1507 public:
1512  {
1513  Phong,
1514  Gouraud,
1515  Flat
1516  };
1517 
1518 private:
1519  Lighting();
1520 };
1521 
1523 class HPS_API Text
1524 {
1525 public:
1528  enum class Alignment
1529  {
1530  TopLeft,
1531  CenterLeft,
1532  BottomLeft,
1533  TopCenter,
1534  Center,
1535  BottomCenter,
1536  TopRight,
1537  CenterRight,
1538  BottomRight
1539  };
1540 
1543  enum class ReferenceFrame
1544  {
1545  WorldAligned,
1546  PathAligned
1547  };
1548 
1551  enum class Justification
1552  {
1553  LeftJustified,
1554  RightJustified,
1555  CenterJustified
1556  };
1557 
1560  enum class Transform
1561  {
1563  Transformable,
1566  NonTransformable,
1568  CharacterPositionOnly,
1571  CharacterPositionAdjusted
1572  };
1573 
1576  enum class Renderer
1577  {
1578  DefaultRenderer,
1579  DriverRenderer,
1580  TruetypeRenderer,
1581  };
1582 
1585  enum class Preference
1586  {
1587  Default,
1588  Vector,
1589  Raster,
1590  Exterior
1591  };
1592 
1595  enum class Rotation
1596  {
1597  NoRotation,
1598  Rotate,
1599  FollowPath
1600  };
1601 
1602 
1605  enum class SizeUnits
1606  {
1607  ObjectSpace,
1608  SubscreenRelative,
1609  WindowRelative,
1610  WorldSpace,
1611  Points,
1612  Pixels
1613  };
1614 
1618  {
1619  ObjectSpace,
1620  SubscreenRelative,
1621  WindowRelative,
1622  WorldSpace,
1623  Points,
1624  Pixels,
1625  Percent
1626  };
1627 
1630  enum class GreekingUnits
1631  {
1632  ObjectSpace,
1633  SubscreenRelative,
1634  WindowRelative,
1635  WorldSpace,
1636  Points,
1637  Pixels
1638  };
1639 
1642  enum class GreekingMode
1643  {
1644  Nothing,
1645  Lines,
1646  Box
1647  };
1648 
1651  enum class RegionAlignment
1652  {
1653  RegionTop,
1654  RegionCenter,
1655  RegionBottom
1656  };
1657 
1658 private:
1660  Text();
1661 };
1662 
1663 // Begin Line Attributes
1664 
1666 class HPS_API Line
1667 {
1668 public:
1672  enum class SizeUnits
1673  {
1674  ScaleFactor,
1675  ObjectSpace,
1676  SubscreenRelative,
1677  WindowRelative,
1678  WorldSpace,
1679  Points,
1680  Pixels
1681  };
1682 private:
1683  Line();
1684 };
1685 
1686 
1687 // Begin Edge Attributes
1688 
1690 class HPS_API Edge
1691 {
1692 public:
1696  enum class SizeUnits
1697  {
1698  ScaleFactor,
1699  ObjectSpace,
1700  SubscreenRelative,
1701  WindowRelative,
1702  WorldSpace,
1703  Points,
1704  Pixels
1705  };
1706 private:
1707  Edge();
1708 };
1709 
1710 
1712 class HPS_API CuttingSection
1713 {
1714 public:
1717  enum class Mode
1718  {
1719  None,
1720  Round,
1721  Square,
1722  Plane
1723  };
1724 
1727  enum class CappingLevel
1728  {
1729  Entity,
1730  Segment,
1731  SegmentTree
1732  };
1733 
1736  enum class CuttingLevel
1737  {
1738  Global,
1739  Local,
1740  };
1741 
1745  {
1746  Explicit,
1747  Implicit,
1748  };
1749 
1752  enum class GatheringLevel
1753  {
1754  Segment,
1755  SegmentTree
1756  };
1757 
1758 private:
1760  CuttingSection();
1761 };
1762 
1764 class HPS_API ContourLine
1765 {
1766 public:
1770  enum class Mode
1771  {
1772  Repeating,
1773  Explicit,
1774  };
1775 
1776 private:
1777  ContourLine();
1778 };
1779 
1782 enum class IOResult
1783 {
1784  Success,
1785  Failure,
1786  FileNotFound,
1787  UnableToOpenFile,
1788  InvalidOptions,
1789  InvalidSegment,
1790  InProgress,
1791  Canceled,
1792  UnableToLoadLibraries,
1793  VersionIncompatibility,
1794  InitializationFailed,
1795  UnsupportedFormat,
1796 };
1797 
1799 class HPS_API LinePattern
1800 {
1801 public:
1804  enum class SizeUnits
1805  {
1806  ObjectSpace,
1807  SubscreenRelative,
1808  WindowRelative,
1809  WorldSpace,
1810  Points,
1811  Pixels,
1812  ScaleFactor
1813  };
1814 
1817  enum class InsetBehavior
1818  {
1819  Overlap,
1820  Trim,
1821  Inline
1822  };
1823 
1827  enum class Join
1828  {
1829  MitreJoin,
1830  RoundJoin,
1831  BevelJoin
1832  };
1833 
1836  enum class Cap
1837  {
1840  ButtCap,
1843  SquareCap,
1846  RoundCap,
1848  MitreCap
1849  };
1850 
1853  enum class Justification
1854  {
1857  Center,
1859  Stretch
1860  };
1861 
1864  enum class Modifier
1865  {
1866  GlyphName,
1867  Enumerated
1868  };
1869 
1870 
1885  enum class Default
1886  {
1887  Solid,
1888  DashDot,
1889  Dashed,
1890  Dotted,
1891  Dash2Dot,
1892  Dash3Dot,
1893  LongDash,
1894  LongDashShortDash,
1895  LongDash2ShortDash,
1896  FineDot,
1897  };
1898 
1899 private:
1901  LinePattern();
1902 };
1903 
1904 
1905 //Begin Glyphs
1907 class HPS_API Glyph
1908 {
1909 public:
1912  enum class Fill
1913  {
1914  Unfilled,
1915  ContinuousFill,
1916  NewFill
1917  };
1918 
1921  enum class ColorSource
1922  {
1923  Normal,
1924  Explicit,
1925  Indexed
1926  };
1927 
1931  enum class Default
1932  {
1933  Circle,
1934  CircleWithDot,
1935  CircleWithPlus,
1936  CircleWithTimes,
1937  CircleWithCircle,
1938  SolidCircle,
1939  Dot,
1940  Plus,
1941  Times,
1942  Splat,
1943  Box,
1944  BoxWithDot,
1945  BoxWithTimes,
1946  SolidBox,
1947  Diamond,
1948  DiamondWithDot,
1949  DiamondWithPlus,
1950  SolidDiamond,
1951  TriangleUp,
1952  TriangleUpWithDot,
1953  SolidTriangleUp,
1954  TriangleDown,
1955  TriangleDownWithDot,
1956  SolidTriangleDown,
1957  TriangleRight,
1958  TriangleRightWithDot,
1959  SolidTriangleRight,
1960  TriangleLeft,
1961  TriangleLeftWithDot,
1962  SolidTriangleLeft,
1963  TriangleUpV,
1964  SolidTriangleUpV,
1965  TriangleDownV,
1966  SolidTriangleDownV,
1967  TriangleRightV,
1968  SolidTriangleRightV,
1969  TriangleLeftV,
1970  SolidTriangleLeftV,
1971  LetterY,
1972  LetterZ,
1973  CircleLetterY,
1974  CircleLetterZ,
1975  VerticalBar,
1976  HorizontalBar,
1977  SlantLeft,
1978  SlantRight,
1979  WidePlus,
1980  SolidWidePlus,
1981  WideTimes,
1982  SolidWideTimes,
1983  Pound,
1984  };
1985 
1986 private:
1988  Glyph();
1989 };
1990 
1991 
1993 class HPS_API Bounding
1994 {
1995 public:
1999  enum class Type
2000  {
2001  None,
2002  Sphere,
2003  Cuboid
2004  };
2005 
2006 private:
2007  Bounding() {}
2008 };
2009 
2011 class HPS_API Grid
2012 {
2013 public:
2016  enum class Type
2017  {
2018  Quadrilateral,
2019  Radial
2020  };
2021 
2022 private:
2023  Grid();
2024 };
2025 
2026 
2028 {
2029 public:
2030  enum class UserData
2031  {
2032  Nothing,
2033  Discard,
2034  Preserve,
2035  Merge,
2036  Localize,
2037  };
2038 
2039  enum class Scope
2040  {
2041  SubSegments,
2042  SubsegmentsAndIncludes,
2043  };
2044 
2045  enum class Expansion
2046  {
2047  None,
2048  Includes,
2049  References,
2050  IncludesAndReferences,
2051  };
2052 
2053  enum class Matrix
2054  {
2055  Nothing,
2056  Localize,
2057  Collapse,
2058  };
2059 
2060  enum class Reorganization
2061  {
2062  None,
2063  Attribute,
2064  Spatial,
2065  AttributeSpatial,
2066  };
2067 };
2068 
2069  typedef double Time;
2070 
2071 #ifdef _MSC_VER
2072 # ifndef HPS_INLINE
2073 # define HPS_INLINE __forceinline
2074 # endif
2075 #else
2076 # define HPS_INLINE inline
2077 #endif
2078 
2079 #ifndef HPS_UNREFERENCED
2080 #define HPS_UNREFERENCED(param) ((void)(param))
2081 #endif
2082 
2083 
2084 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2085 
2086 template<typename T>
2087 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2088 {
2089  return degrees * (T)(PI / 180.0);
2090 }
2091 
2092 template<typename T>
2093 HPS_INLINE T Radians_To_Degrees(T const & radians)
2094 {
2095  return radians * (T)(180.0 / PI);
2096 }
2097 
2098 template<typename T>
2099 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2100  T a = Degrees_To_Radians(angle);
2101  cosine = cos(a);
2102  sine = sin(a);
2103 }
2104 
2105 template<typename T>
2106 HPS_INLINE T Cos(T const & angle) {
2107  return cos (Degrees_To_Radians(angle));
2108 }
2109 
2110 template<typename T>
2111 HPS_INLINE T Sin(T const & angle) {
2112  return sin (Degrees_To_Radians(angle));
2113 }
2114 
2115 template<typename T>
2116 HPS_INLINE T ACos(T const & x) {
2117  if (x > 1)
2118  return 0;
2119  if (x < -1)
2120  return 180;
2121  return Radians_To_Degrees(acos(x));
2122 }
2123 
2124 template<typename T>
2125 HPS_INLINE T ATan2(T const & y, T const & x) {
2126  if (x == 0 && y == 0)
2127  return 0;
2128  return Radians_To_Degrees(atan2(y, x));
2129 }
2130 
2131 
2132 template <typename F> struct Float_Traits {};
2133 template <> struct Float_Traits<float> {
2134  typedef double Alternative;
2135  static const int Type = 1;
2136  static float Epsilon () { return 1.0e-30f; }
2137 };
2138 template <> struct Float_Traits<double> {
2139  typedef float Alternative;
2140  static const int Type = 2;
2141  static double Epsilon () { return 1.0e-300; }
2142 };
2143 
2144 
2145 
2147 class HPS_API Float {
2148 private:
2149  enum Parts {
2150 # if HOOPS_BIGENDIAN
2151  High, Low
2152 # else
2153  Low, High
2154 # endif
2155  };
2156 
2157  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2158  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2159  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2160  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2161  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2162 
2163  static HPS_INLINE bool is_nan(int32_t const & v) {
2164  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2165  return exp == 0x7F800000 && mantissa != 0;
2166  }
2167  static HPS_INLINE bool is_nan(uint32_t const & v) {
2168  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2169  return exp == 0x7F800000 && mantissa != 0;
2170  }
2171  static HPS_INLINE bool is_nan(int32_t const * v) {
2172  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2173  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2174  }
2175  static HPS_INLINE bool is_nan(uint32_t const * v) {
2176  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2177  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2178  }
2179 
2180  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2181  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2182  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2183  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2184 public:
2185 
2187  static const float Infinity;
2189  static const float NegativeInfinity;
2190 
2192  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2193  static HPS_INLINE bool IsInfinite(double const & a) {
2194  uint32_t v[2];
2195  memcpy (v, &a, sizeof(double));
2196  return is_infinite (v);
2197  }
2198 
2200  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2201  static HPS_INLINE bool IsNAN(double const & a) {
2202  uint32_t v[2];
2203  memcpy (v, &a, sizeof(double));
2204  return is_nan (v);
2205  }
2206 
2208  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2209  static HPS_INLINE bool IsAbnormal(double const & a) {
2210  uint32_t v[2];
2211  memcpy (v, &a, sizeof(double));
2212  return is_special (v);
2213  }
2214 
2217  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2218  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2219 
2220 #ifndef HOOPS_DEFINED
2221  template <typename Alloc>
2222  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2223  {
2224  if (a.size() != b.size())
2225  return false;
2226 
2227  auto it1 = a.begin();
2228  auto it2 = b.begin();
2229  auto const end = a.end();
2230  for ( ; it1 != end; ++it1, ++it2)
2231  {
2232  if (!Equals(*it1, *it2, tolerance))
2233  return false;
2234  }
2235  return true;
2236  }
2237 #endif
2238 
2239  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2240  return extract_uint32_t(a) & 0x80000000;
2241  }
2242  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2243  uint32_t v[2];
2244  memcpy (v, &a, sizeof(double));
2245  return v[High] & 0x80000000;
2246  }
2247 
2248  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2249  uint32_t v = extract_uint32_t(a);
2250  v &= 0x7FFFFFFF;
2251  v |= sign_bit;
2252  inject_uint32_t(a, v);
2253  }
2254  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2255  uint32_t v[2];
2256  memcpy (v, &a, sizeof(double));
2257  v[High] &= 0x7FFFFFFF;
2258  v[High] |= sign_bit;
2259  memcpy (&a, v, sizeof(double));
2260  }
2261 
2262 
2263  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2264  uint32_t v = extract_uint32_t(a);
2265 
2266  v &= 0x7FFFFFFF;
2267  if (v < 0x3B800000)
2268  return 0;
2269 
2270  v--;
2271 
2272  uint32_t exp = v >> 23;
2273  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2274 
2275  return (unsigned char) (man >> (16 + 126 - exp));
2276  }
2277 
2278  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2279  uint32_t v = extract_uint32_t(a);
2280 
2281  v &= 0x7FFFFFFF;
2282  if (v < 0x3B800000)
2283  return 0;
2284 
2285  v--;
2286 
2287  uint32_t exp = v >> 23;
2288  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2289 
2290  uint32_t x = (man >> (16 + 126 - exp));
2291 
2292  return (unsigned char) ((x * (mix+1)) >> 8);
2293  }
2294 
2295 
2296  static HPS_INLINE bool match(float const & a, float const & b) {
2297  uint32_t va = extract_uint32_t(a);
2298  uint32_t vb = extract_uint32_t(b);
2299 
2300  if (((va | vb) & 0x7FFFFFFF) == 0)
2301  return true;
2302 
2303  return va == vb;
2304  }
2305  static HPS_INLINE bool match(double const & a, double const & b) {
2306  return a == b;
2307  }
2308 
2309 
2310  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2311  uint32_t va = extract_uint32_t(a);
2312  uint32_t vb = extract_uint32_t(b);
2313 
2314  uint32_t a_sign = va & 0x80000000;
2315  uint32_t b_sign = vb & 0x80000000;
2316 
2317  (int32_t&)a_sign >>= 31;
2318  (int32_t&)b_sign >>= 31;
2319 
2320  uint32_t mash = (a_sign&b_sign);
2321 
2322  va ^= mash;
2323  vb ^= mash;
2324 
2325  if ((int32_t&)vb < (int32_t&)va)
2326  memcpy(&a, &b, sizeof(float));
2327  }
2328  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2329  if (b < a)
2330  a = b;
2331  }
2332 
2333  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2334  uint32_t va = extract_uint32_t(a);
2335  uint32_t vb = extract_uint32_t(b);
2336 
2337  uint32_t a_sign = va & 0x80000000;
2338  uint32_t b_sign = vb & 0x80000000;
2339 
2340  (int32_t&)a_sign >>= 31;
2341  (int32_t&)b_sign >>= 31;
2342 
2343  uint32_t mash = (a_sign&b_sign);
2344 
2345  va ^= mash;
2346  vb ^= mash;
2347 
2348  if ((int32_t&)vb > (int32_t&)va)
2349  memcpy(&a, &b, sizeof(float));
2350  }
2351  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2352  if (b > a)
2353  a = b;
2354  }
2355 
2356 
2357  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2358  uint32_t i;
2359  memcpy(&i, &a, sizeof(float));
2360  return i;
2361  }
2362 
2363  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2364  memcpy(&a, &i, sizeof(float));
2365  }
2366 
2367  static HPS_INLINE float C2F(unsigned char x) {
2368  //return (float)x * (1.0f/255.0f);
2369  return char_to_float[x];
2370  }
2371 
2372 
2373  // SSE convenience functions
2374  static HPS_INLINE void pack_4(float const & f, float * m) {
2375  memcpy(&m[0], &f, sizeof(float));
2376  memcpy(&m[1], &f, sizeof(float));
2377  memcpy(&m[2], &f, sizeof(float));
2378  memcpy(&m[3], &f, sizeof(float));
2379  }
2380 
2381  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2382  memcpy(&m[0], &f0, sizeof(float));
2383  memcpy(&m[1], &f1, sizeof(float));
2384  memcpy(&m[2], &f2, sizeof(float));
2385  memcpy(&m[3], &f3, sizeof(float));
2386  }
2387 
2388  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2389  memcpy(f0, m, sizeof(float)*4);
2390  }
2391 
2392  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2393  memcpy(&f0, &m[0], sizeof(float));
2394  memcpy(&f1, &m[1], sizeof(float));
2395  memcpy(&f2, &m[2], sizeof(float));
2396  memcpy(&f3, &m[3], sizeof(float));
2397  }
2398 
2399 private:
2400  static const float char_to_float[256];
2401 
2402  Float();
2403 };
2404 
2405 
2407 
2408 
2409 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2410 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2411 
2412 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2413 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2414 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2415 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2416 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2417 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2418 
2419 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2420 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2421 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); }
2422 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); }
2423 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); }
2424 
2425 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2426 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2427 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); }
2428 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); }
2429 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); }
2430 
2431 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; }
2432 
2433 
2434 template <> HPS_INLINE float Abs<float> (float const & a) {
2435  uint32_t v = Float::extract_uint32_t(a);
2436  v &= 0x7FFFFFFF;
2437  float f;
2438  Float::inject_uint32_t(f,v);
2439  return f;
2440 }
2441 
2442 template <> HPS_INLINE int Sign<float> (float const & a) {
2443  uint32_t v = Float::extract_uint32_t(a);
2444 
2445  if ((v & 0x7FFFFFFF) == 0)
2446  return 0;
2447 
2448  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2449 }
2450 
2451 template <> HPS_INLINE int Compare<float> (float const & a, float const & b) {
2452  int a_sign = Sign(a);
2453  int b_sign = Sign(b);
2454 
2455  if (a_sign != b_sign)
2456  return Compare(a_sign, b_sign);
2457 
2458  uint32_t v = Float::extract_uint32_t(a);
2459  uint32_t u = Float::extract_uint32_t(b);
2460 
2461  return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2462 }
2463 
2464 template <> HPS_INLINE float const & Min<float> (float const & a, float const & b) {
2465  if (Compare(a,b)>0)
2466  return b;
2467  return a;
2468 }
2469 
2470 template <> HPS_INLINE float const & Max<float> (float const & a, float const & b) {
2471  if (Compare(a,b)>0)
2472  return a;
2473  return b;
2474 }
2475 
2476 
2478 
2479 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2480  int32_t va = Float::extract_uint32_t(a);
2481  int32_t vb = Float::extract_uint32_t(b);
2482 
2483  if (is_special(va) || is_special(vb)) {
2484  if (is_infinite(va) || is_infinite(vb))
2485  return va == vb; // final check is for sign bits same
2486  if (is_nan(va) || is_nan(vb))
2487  return false;
2488  }
2489 
2490  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2491  if ((va & 0x7FFFFFFF) == 0)
2492  return (vb & 0x7FFFFFFF) < close_to_zero;
2493  else if ((vb & 0x7FFFFFFF) == 0)
2494  return (va & 0x7FFFFFFF) < close_to_zero;
2495 
2496  uint32_t sign_mask = va ^ vb;
2497  (int32_t &)sign_mask >>= 31;
2498 
2499  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2500  int32_t v1 = tolerance + diff;
2501  int32_t v2 = tolerance - diff;
2502  return (v1|v2) >= 0;
2503 }
2504 
2505 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2506  int32_t va[2], vb[2];
2507  memcpy (va, &a, sizeof(double));
2508  memcpy (vb, &b, sizeof(double));
2509 
2510  if (is_special(va) || is_special(vb)) {
2511  if (is_infinite(va) || is_infinite(vb))
2512  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2513  if (is_nan(va) || is_nan(vb))
2514  return false;
2515  }
2516 
2517  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2518  return Abs(a - b) < 0.000000000000005;
2519 
2520  if (extract_sign_bit(a) != extract_sign_bit(b))
2521  return a == b;
2522 
2523  if (va[High] != vb[High])
2524  return false;
2525 
2526  return Abs(va[Low] - vb[Low]) <= tolerance;
2527 }
2528 
2530 
2531 
2532 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2533 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2534 
2535 template <typename T>
2536 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2537  while (count-- > 0)
2538  if (Is_Abnormal (*t++))
2539  return true;
2540  return false;
2541 }
2542 
2543 template <typename T>
2544 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2545  return count >= 0 && Is_Abnormal((size_t)count, t);
2546 }
2547 
2548 
2550 
2551 
2552 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2553 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2554 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2555 template <typename F> class HPS_TEMPLATE_API Point_2D;
2556 
2557 
2558 template <typename F>
2559 class HPS_TEMPLATE_API Point_3D {
2560  public:
2561  F x;
2562  F y;
2563  F z;
2564 
2565  Point_3D () {}
2566  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2567 
2568  template <typename D>
2569  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2570 
2571  explicit Point_3D (Vector_3D<F> const & v);
2572  explicit Point_3D (Vector_2D<F> const & v);
2573  explicit Point_3D (Point_2D<F> const & that);
2574 
2575  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2576 
2577  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2578  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2579 
2580  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2581  return Float::Equals(x, p.x, in_tolerance) &&
2582  Float::Equals(y, p.y, in_tolerance) &&
2583  Float::Equals(z, p.z, in_tolerance);
2584  }
2585 
2586 
2587  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2588  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2589  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2590  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2591 
2592  F & operator[] (size_t i) { return (&x)[i]; }
2593  F const & operator[] (size_t i) const { return (&x)[i]; }
2594 
2595  Point_3D & operator+= (Vector_3D<F> const & v);
2596  Point_3D & operator-= (Vector_3D<F> const & v);
2597  Point_3D & operator*= (Vector_3D<F> const & v);
2598  Point_3D & operator/= (Vector_3D<F> const & v);
2599  Point_3D const operator* (Vector_3D<F> const & v) const;
2600  Point_3D const operator/ (Vector_3D<F> const & v) const;
2601 
2602  Point_3D & operator+= (Vector_2D<F> const & v);
2603  Point_3D & operator-= (Vector_2D<F> const & v);
2604  Point_3D & operator*= (Vector_2D<F> const & v);
2605  Point_3D & operator/= (Vector_2D<F> const & v);
2606  Point_3D const operator* (Vector_2D<F> const & v) const;
2607  Point_3D const operator/ (Vector_2D<F> const & v) const;
2608 
2609  Vector_3D<F> const operator- (Point_3D const & p) const;
2610 
2611  Point_3D const operator+ (Vector_3D<F> const & v) const;
2612  Point_3D const operator- (Vector_3D<F> const & v) const;
2613 
2614  Point_3D const operator+ (Vector_2D<F> const & v) const;
2615  Point_3D const operator- (Vector_2D<F> const & v) const;
2616 
2617  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2618  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2619 };
2620 
2621 typedef Point_3D<float> Point;
2622 typedef Point_3D<double> DPoint;
2623 
2624 
2625 
2626 template <typename F, typename S>
2627 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)); }
2628 
2629 template <typename F>
2630 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2631  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2632 }
2633 
2634 template <typename F>
2635 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2636  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);
2637 }
2638 
2639 template <typename F>
2640 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2641  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2642 }
2643 
2644 
2645 template <typename F>
2646 class HPS_TEMPLATE_API Point_2D {
2647 public:
2648  F x;
2649  F y;
2650 
2651  Point_2D () {}
2652  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2653 
2654  template <typename D>
2655  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2656 
2657  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2658  explicit Point_2D (Vector_2D<F> const & v);
2659 
2660  Point_2D const operator- () const { return Point_2D (-x, -y); }
2661 
2662  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2663  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2664 
2665  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2666  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2667  }
2668 
2669 
2670  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2671  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2672  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2673  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2674 
2675  F & operator[] (size_t i) { return (&x)[i]; }
2676  F const & operator[] (size_t i) const { return (&x)[i]; }
2677 
2678  Point_2D & operator+= (Vector_2D<F> const & v);
2679  Point_2D & operator-= (Vector_2D<F> const & v);
2680  Point_2D & operator*= (Vector_2D<F> const & v);
2681  Point_2D & operator/= (Vector_2D<F> const & v);
2682  Point_2D const operator* (Vector_2D<F> const & v) const;
2683  Point_2D const operator/ (Vector_2D<F> const & v) const;
2684 
2685  Vector_2D<F> const operator- (Point_2D const & p) const;
2686 
2687  Point_2D const operator+ (Vector_2D<F> const & v) const;
2688  Point_2D const operator- (Vector_2D<F> const & v) const;
2689 
2690  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2691  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2692 };
2693 
2694 typedef Point_2D<float> Point2D;
2695 typedef Point_2D<double> DPoint2D;
2696 
2697 template <typename F>
2698 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2699 
2700 template <typename F, typename S>
2701 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)); }
2702 
2703 template <typename F>
2704 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2705  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2706 }
2707 
2708 template <typename F>
2709 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2710  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);
2711 }
2712 
2713 template <typename F>
2714 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2715  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2716 }
2717 
2718 
2719 template <typename F>
2720 class HPS_TEMPLATE_API Vector_3D {
2721  public:
2722  F x;
2723  F y;
2724  F z;
2725 
2726  Vector_3D () {}
2727  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2728  template <typename D>
2729  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2730  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2731  explicit Vector_3D(Plane_3D<F> const & p);
2732 
2733  explicit Vector_3D (Vector_2D<F> const & that);
2734 
2735  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2736 
2737  bool operator== (Vector_3D const & v) const {
2738  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2739  }
2740  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2741 
2742  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2743  return Float::Equals(x, v.x, in_tolerance) &&
2744  Float::Equals(y, v.y, in_tolerance) &&
2745  Float::Equals(z, v.z, in_tolerance);
2746  }
2747 
2748  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2749  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2750  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2751  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2752 
2753  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2754  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2755  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2756  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2757 
2758  F & operator[] (size_t i) { return (&x)[i]; }
2759  F const & operator[] (size_t i) const { return (&x)[i]; }
2760 
2761  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2762 
2763  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2764 
2765  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2766 
2767  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2768 
2769  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2770  if (check_range) {
2771  F range = Max (Abs (x), Abs (y), Abs (z));
2772  if (range > F(1.0e10))
2773  operator/= (range);
2774  }
2775 
2776  F len = (F)Length();
2777  if (len > epsilon)
2778  operator/= (len);
2779  else
2780  *this = Zero();
2781  return *this;
2782  }
2783  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2784 
2785  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2786  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2787 
2788  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2789 
2790  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2791  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2792  }
2793 
2794 
2795  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2796  return Vector_3D (x * v.x, y * v.y, z * v.z);
2797  }
2798 
2799  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2800  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2801  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2802  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2803  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2804 };
2805 
2806 typedef Vector_3D<float> Vector;
2807 typedef Vector_3D<double> DVector;
2808 
2809 
2810 template <typename F, typename S>
2811 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)); }
2812 
2813 template <typename F>
2814 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2815  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2816 }
2817 
2818 
2819 template <typename F>
2820 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2821 
2822 template <typename F>
2823 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; }
2824 template <typename F>
2825 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; }
2826 
2827 template <typename F>
2828 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); }
2829 
2830 template <typename F>
2831 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); }
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 
2835 template <typename F>
2836 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; }
2837 template <typename F>
2838 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; }
2839 template <typename F>
2840 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); }
2841 template <typename F>
2842 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); }
2843 
2844 
2845 
2846 template <typename F>
2847 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2848  return a + (b - a) * t;
2849 }
2850 
2851 template <typename F>
2852 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2853  return Vector_3D<F>(a + (b - a) * t).Normalize();
2854 }
2855 
2856 
2857 
2858 template <typename F>
2859 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2860  return (p2 - p1).Length();
2861 }
2862 
2863 template <typename F>
2864 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2865  return (p2 - p1).LengthSquared();
2866 }
2867 
2868 template <typename F>
2869 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2870  F p = static_cast<F>((c - b).LengthSquared());
2871  F q = static_cast<F>((c - a).LengthSquared());
2872  F r = static_cast<F>((b - a).LengthSquared());
2873 
2874  return Point_3D<F>(
2875  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2876  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2877 }
2878 
2879 
2880 
2881 template <typename F>
2882 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2883  bool success = true;
2884  for (size_t i = 0; i < count; ++i) {
2885  if (vectors->Normalize() == Vector_3D<F>::Zero())
2886  success = false;
2887  vectors++;
2888  }
2889  return success;
2890 }
2891 
2892 
2893 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2894 
2895 template <typename F>
2896 class HPS_TEMPLATE_API Vector_2D {
2897 public:
2898  F x;
2899  F y;
2900 
2901  Vector_2D () {}
2902  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2903  template <typename D>
2904  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2905 
2906  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2907  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2908  explicit Vector_2D (Plane_2D<F> const & p);
2909 
2910  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2911 
2912  bool operator== (Vector_2D const & v) const {
2913  return Float::match(x, v.x) && Float::match(y, v.y);
2914  }
2915  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2916 
2917  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2918  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2919  }
2920 
2921  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2922  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2923  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2924  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2925 
2926  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2927  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
2928  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
2929  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
2930 
2931  F & operator[] (size_t i) { return (&x)[i]; }
2932  F const & operator[] (size_t i) const { return (&x)[i]; }
2933 
2934  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2935 
2936  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
2937 
2938  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2939  if (check_range) {
2940  F range = Max (Abs (x), Abs (y));
2941  if (range > F(1.0e10))
2942  operator/= (range);
2943  }
2944 
2945  F len = (F)Length();
2946  if (len > epsilon)
2947  operator/= (len);
2948  else
2949  *this = Zero();
2950  return *this;
2951  }
2952  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2953 
2954  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
2955  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
2956 
2957  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
2958 
2959 
2960  HPS_INLINE float Cross (Vector_2D const & v) const {
2961  return x * v.y - y * v.x;
2962  }
2963 
2964  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
2965  return Vector_2D (x * v.x, y * v.y);
2966  }
2967 
2968  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
2969  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
2970 
2971  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
2972  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
2973 };
2974 
2975 typedef Vector_2D<float> Vector2D;
2977 
2978 template <typename F, typename S>
2979 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)); }
2980 
2981 template <typename F>
2982 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
2983  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2984 }
2985 
2986 
2987 template <typename F>
2988 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
2989 
2990 template <typename F>
2991 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
2992 
2993 template <typename F>
2994 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
2995 template <typename F>
2996 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
2997 
2998 template <typename F>
2999 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); }
3000 template <typename F>
3001 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); }
3002 
3003 template <typename F>
3004 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3005 template <typename F>
3006 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3007 
3008 template <typename F>
3009 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); }
3010 template <typename F>
3011 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); }
3012 
3013 
3014 template <typename F>
3015 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3016 template <typename F>
3017 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3018 
3019 template <typename F>
3020 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); }
3021 
3022 template <typename F>
3023 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); }
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 
3027 template <typename F>
3028 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3029 template <typename F>
3030 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3031 template <typename F>
3032 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); }
3033 template <typename F>
3034 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); }
3035 
3036 
3037 
3038 
3039 
3040 template <typename F>
3041 class HPS_TEMPLATE_API Plane_3D {
3042  public:
3043  F a;
3044  F b;
3045  F c;
3046  F d;
3047 
3048  Plane_3D () {}
3049  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3050  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3051  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)) {}
3052  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)) {}
3053  template <typename D>
3054  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3055 
3056  Plane_3D (size_t count, Point_3D<F> const * points) {
3057  if (count >= 3) {
3058  // The 3 coefficients A, B, and C are proportional to the areas of the
3059  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3060 
3061  // run around the polygon, collecting trapezoidal areas
3062  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3063 
3064  // take care of the swing point first
3065  Point_3D<F> const * p0 = &points[count-1];
3066 
3068  Vector_3D<F> normal = Vector_3D<F>::Zero();
3069 
3070  for (size_t i=0; i<count; ++i) {
3071  Point_3D<F> const * p1 = &points[i];
3072 
3073  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3074  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3075  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3076 
3077  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3078 
3079  p0 = p1;
3080  }
3081 
3082  // ("should" always be != 0)
3083  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3084  /* finish finding the average */
3085  double inv_count = 1.0 / (double)count;
3086  ctr *= inv_count;
3087 
3088  *this = Plane_3D(normal, Point_3D<F>(ctr));
3089  return;
3090  }
3091  }
3092 
3093  *this = Plane_3D::Zero();
3094  }
3095 
3096 
3097  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3098 
3099  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3100  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3101 
3102  F & operator[] (size_t i) { return (&a)[i]; }
3103  F const & operator[] (size_t i) const { return (&a)[i]; }
3104 
3105  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3106  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3107  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3108  }
3109 
3110  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3111  F len = (F)Vector_3D<F>(*this).Length();
3112  if (len > epsilon)
3113  operator/= (len);
3114  else
3115  *this = Zero();
3116  return *this;
3117  }
3118 
3119  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3120  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3121  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3122 
3123  if (val1 >= eps) {
3124  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3125  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3126  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3127  }
3128  else
3129  return p1;
3130  }
3131 
3132  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3133  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3134  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3135 
3136  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));
3137  }
3138 
3139  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3140 
3141 
3142  private:
3143  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3144  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3145  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3146  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3147 };
3148 
3149 typedef Plane_3D<float> Plane;
3150 typedef Plane_3D<double> DPlane;
3151 
3152 
3153 template <typename F>
3154 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3155  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3156 }
3157 
3158 
3159 template <typename F>
3160 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3161  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3162 }
3163 template <typename F>
3164 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3165  return plane * point;
3166 }
3167 
3168 template <typename F>
3169 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3170  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);
3171 }
3172 
3173 template <typename F>
3174 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3175 
3176 
3177 
3178 
3179 
3180 
3181 template <typename F>
3182 class HPS_TEMPLATE_API Plane_2D {
3183 public:
3184  F a;
3185  F b;
3186  F c;
3187 
3188  Plane_2D () {}
3189  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3190  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3191  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)) {}
3192  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)) {}
3193  template <typename D>
3194  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3195 
3196  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3197 
3198  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3199  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3200 
3201  F & operator[] (size_t i) { return (&a)[i]; }
3202  F const & operator[] (size_t i) const { return (&a)[i]; }
3203 
3204  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3205  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3206  }
3207 
3208  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3209  F len = (F)Vector_2D<F>(*this).Length();
3210  if (len > epsilon)
3211  operator/= (len);
3212  else
3213  *this = Zero();
3214  return *this;
3215  }
3216 
3217  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3218 
3219 
3220 private:
3221  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3222  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3223  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3224  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3225 };
3226 
3227 typedef Plane_2D<float> Plane2D;
3228 typedef Plane_2D<double> DPlane2D;
3229 
3230 
3231 template <typename F>
3232 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3233  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3234 }
3235 
3236 
3237 template <typename F>
3238 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3239  return plane.a * point.x + plane.b * point.y + plane.c;
3240 }
3241 template <typename F>
3242 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3243  return plane * point;
3244 }
3245 
3246 template <typename F>
3247 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3248  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);
3249 }
3250 
3251 template <typename F>
3252 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3253 
3254 
3255 
3256 
3257 struct Rectangle;
3258 
3259 struct HPS_API IntRectangle {
3260  int left;
3261  int right;
3262  int bottom;
3263  int top;
3264 
3265  IntRectangle()
3266  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3267  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3268 
3269  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3270  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3271 
3272  IntRectangle(IntRectangle const & that)
3273  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3274 
3275  explicit IntRectangle(Rectangle const & that);
3276 
3277  bool operator==(IntRectangle const & rect) const {
3278  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3279  }
3280 
3281  bool operator!=(IntRectangle const & rect) const {
3282  return !(*this == rect);
3283  }
3284 
3285  HPS_INLINE int PixelWidth() const {
3286  return right - left + 1;
3287  }
3288 
3289  HPS_INLINE int PixelHeight() const {
3290  return top - bottom + 1;
3291  }
3292 
3293  HPS_INLINE int Width() const {
3294  return right - left;
3295  }
3296 
3297  HPS_INLINE int Height() const {
3298  return top - bottom;
3299  }
3300 
3301  HPS_INLINE int Area() const {
3302  return Width() * Height();
3303  }
3304 
3305  HPS_INLINE Point2D Center() const {
3306  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3307  }
3308 
3309  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3310  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3311  }
3312 
3313  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3314  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3315  }
3316 
3317  HPS_INLINE IntRectangle & Expand(int border) {
3318  left -= border;
3319  right += border;
3320  bottom -= border;
3321  top += border;
3322  return *this;
3323  }
3324 
3325  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3326  left -= rect.left;
3327  right += rect.right;
3328  bottom -= rect.bottom;
3329  top += rect.top;
3330  return *this;
3331  }
3332 
3333  HPS_INLINE IntRectangle & Contract(int border) {
3334  left += border;
3335  right -= border;
3336  bottom += border;
3337  top -= border;
3338  return *this;
3339  }
3340 
3341  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3342  left += rect.left;
3343  right -= rect.right;
3344  bottom += rect.bottom;
3345  top -= rect.top;
3346  return *this;
3347  }
3348 
3349  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3350  left = Max(left, rect.left);
3351  right = Min(right, rect.right);
3352  bottom = Max(bottom, rect.bottom);
3353  top = Min(top, rect.top);
3354  return *this;
3355  }
3356 
3357  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3358  left = Min(left, rect.left);
3359  right = Max(right, rect.right);
3360  bottom = Min(bottom, rect.bottom);
3361  top = Max(top, rect.top);
3362  return *this;
3363  }
3364 
3365 
3366  static HPS_INLINE IntRectangle Invalid() {
3367  return IntRectangle();
3368  }
3369 
3370  static HPS_INLINE IntRectangle Zero() {
3371  return IntRectangle(0, 0, 0, 0);
3372  }
3373 
3374 };
3375 
3376 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3377  IntRectangle temp = a;
3378  return temp.Expand(border);
3379 }
3380 
3381 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3382  IntRectangle temp = a;
3383  return temp.Expand(border);
3384 }
3385 
3386 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3387  IntRectangle temp = a;
3388  return temp.Contract(border);
3389 }
3390 
3391 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3392  IntRectangle temp = a;
3393  return temp.Contract(border);
3394 }
3395 
3396 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3397  IntRectangle temp = a;
3398  return temp.Intersect(b);
3399 }
3400 
3401 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3402  IntRectangle temp = a;
3403  return temp.Union(b);
3404 }
3405 
3406 struct HPS_API Rectangle {
3407  float left;
3408  float right;
3409  float bottom;
3410  float top;
3411 
3412  Rectangle()
3413  : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3414  bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3415 
3416  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3417  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3418 
3419  Rectangle(Rectangle const & that)
3420  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3421 
3422  explicit Rectangle(IntRectangle const & that)
3423  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3424 
3425  HPS_INLINE Rectangle(size_t count, Point const * points) {
3426  left = points->x;
3427  right = points->x;
3428  top = points->y;
3429  bottom = points->y;
3430  --count;
3431  if (count > 0) {
3432  ++points;
3433  Merge(count, points);
3434  }
3435  }
3436 
3437  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3438  left = points->x;
3439  right = points->x;
3440  top = points->y;
3441  bottom = points->y;
3442  --count;
3443  if (count > 0) {
3444  ++points;
3445  Merge(count, points);
3446  }
3447  }
3448 
3449  HPS_INLINE float Width() const {
3450  return right - left;
3451  }
3452 
3453  HPS_INLINE float Height() const {
3454  return top - bottom;
3455  }
3456 
3457  HPS_INLINE float Area() const {
3458  return Width() * Height();
3459  }
3460 
3461  HPS_INLINE Point2D Center() const {
3462  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3463  }
3464 
3465  HPS_INLINE void Merge(size_t count, Point const * points) {
3466 
3467  while (count > 1) {
3468  if (Compare(points[0].x, points[1].x)>0) {
3469  Float::replace_if_smaller(left, points[1].x);
3470  Float::replace_if_larger(right, points[0].x);
3471  }
3472  else {
3473  Float::replace_if_smaller(left, points[0].x);
3474  Float::replace_if_larger(right, points[1].x);
3475  }
3476 
3477  if (Compare(points[0].y, points[1].y)>0) {
3478  Float::replace_if_smaller(bottom, points[1].y);
3479  Float::replace_if_larger(top, points[0].y);
3480  }
3481  else {
3482  Float::replace_if_smaller(bottom, points[0].y);
3483  Float::replace_if_larger(top, points[1].y);
3484  }
3485 
3486  points += 2;
3487  count -= 2;
3488  }
3489 
3490  if (count > 0)
3491  Merge(*points);
3492  }
3493 
3494  HPS_INLINE void Merge(Point const & point) {
3495  Float::replace_if_smaller(left, point.x);
3496  Float::replace_if_smaller(bottom, point.y);
3497  Float::replace_if_larger(right, point.x);
3498  Float::replace_if_larger(top, point.y);
3499  }
3500 
3501  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3502 
3503  while (count > 1) {
3504  if (Compare(points[0].x, points[1].x)>0) {
3505  Float::replace_if_smaller(left, points[1].x);
3506  Float::replace_if_larger(right, points[0].x);
3507  }
3508  else {
3509  Float::replace_if_smaller(left, points[0].x);
3510  Float::replace_if_larger(right, points[1].x);
3511  }
3512 
3513  if (Compare(points[0].y, points[1].y)>0) {
3514  Float::replace_if_smaller(bottom, points[1].y);
3515  Float::replace_if_larger(top, points[0].y);
3516  }
3517  else {
3518  Float::replace_if_smaller(bottom, points[0].y);
3519  Float::replace_if_larger(top, points[1].y);
3520  }
3521 
3522  points += 2;
3523  count -= 2;
3524  }
3525 
3526  if (count > 0)
3527  Merge(*points);
3528  }
3529 
3530  HPS_INLINE void Merge(Point2D const & point) {
3531  Float::replace_if_smaller(left, point.x);
3532  Float::replace_if_smaller(bottom, point.y);
3533  Float::replace_if_larger(right, point.x);
3534  Float::replace_if_larger(top, point.y);
3535  }
3536 
3537  bool operator==(Rectangle const & rect) const {
3538  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3539  }
3540 
3541  bool operator!=(Rectangle const & rect) const {
3542  return !(*this == rect);
3543  }
3544 
3545  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3546  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3547  }
3548 
3549  HPS_INLINE bool Contains(Point const & contained) const {
3550  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3551  }
3552 
3553  HPS_INLINE bool Contains(Point2D const & contained) const {
3554  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3555  }
3556 
3557  HPS_INLINE bool Contains(Rectangle const & rect) {
3558  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3559  }
3560 
3561  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3562  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3563  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3564  }
3565 
3566  HPS_INLINE Rectangle & Expand(float border) {
3567  left -= border;
3568  right += border;
3569  bottom -= border;
3570  top += border;
3571  return *this;
3572  }
3573 
3574  HPS_INLINE Rectangle & Expand(int border) {
3575  Expand((float)border);
3576  return *this;
3577  }
3578 
3579  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3580  left -= rect.left;
3581  right += rect.right;
3582  bottom -= rect.bottom;
3583  top += rect.top;
3584  return *this;
3585  }
3586 
3587  HPS_INLINE Rectangle & Contract(int border) {
3588  left += border;
3589  right -= border;
3590  bottom += border;
3591  top -= border;
3592  return *this;
3593  }
3594 
3595  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3596  left += rect.left;
3597  right -= rect.right;
3598  bottom += rect.bottom;
3599  top -= rect.top;
3600  return *this;
3601  }
3602 
3603  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3604  left = Max(left, rect.left);
3605  right = Min(right, rect.right);
3606  bottom = Max(bottom, rect.bottom);
3607  top = Min(top, rect.top);
3608  return *this;
3609  }
3610 
3611  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3612  left = Min(left, rect.left);
3613  right = Max(right, rect.right);
3614  bottom = Min(bottom, rect.bottom);
3615  top = Max(top, rect.top);
3616  return *this;
3617  }
3618 
3619  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3620  float scale = (scope.right - scope.left) * 0.5f;
3621  float trans = (scope.right + scope.left) * 0.5f;
3622 
3623  left = left * scale + trans;
3624  right = right * scale + trans;
3625 
3626  scale = (scope.top - scope.bottom) * 0.5f;
3627  trans = (scope.top + scope.bottom) * 0.5f;
3628 
3629  bottom = bottom * scale + trans;
3630  top = top * scale + trans;
3631  return *this;
3632  }
3633 
3634  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3635  float tmp = 2.0f/(scope.right - scope.left);
3636  right = (right - scope.left) * tmp - 1.0f;
3637  left = (left - scope.left) * tmp - 1.0f;
3638 
3639  tmp = 2.0f/(scope.top - scope.bottom);
3640  top = (top - scope.bottom) * tmp - 1.0f;
3641  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3642  return *this;
3643  }
3644 
3645  static HPS_INLINE Rectangle FullScope() {
3646  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3647  }
3648 
3649  static HPS_INLINE Rectangle InvalidScope() {
3650  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3651  }
3652 
3653  static HPS_INLINE Rectangle Zero() {
3654  return Rectangle(0, 0, 0, 0);
3655  }
3656 
3657 };
3658 
3659 
3660 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3661  IntRectangle temp;
3662  temp.left = Floor (a.left);
3663  temp.right = Floor (a.right);
3664  temp.bottom = Floor (a.bottom);
3665  temp.top = Floor (a.top);
3666  return temp;
3667 }
3668 
3669 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3670  Rectangle temp = a;
3671  return temp.Expand(border);
3672 }
3673 
3674 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3675  Rectangle temp = a;
3676  return temp.Expand(border);
3677 }
3678 
3679 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3680  Rectangle temp = a;
3681  return temp.Contract(border);
3682 }
3683 
3684 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3685  Rectangle temp = a;
3686  return temp.Contract(border);
3687 }
3688 
3689 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3690  Rectangle temp = a;
3691  return temp.Intersect(b);
3692 }
3693 
3694 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3695  Rectangle temp = a;
3696  return temp.Union(b);
3697 }
3698 
3699 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3700  Rectangle temp = a;
3701  return temp.Inscribe_Scope(scope);
3702 }
3703 
3704 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3705  Rectangle temp = a;
3706  return temp.Circumscribe_Scope(scope);
3707 }
3708 
3709 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3710  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3711 
3712 
3713 
3714 
3715 template <typename F>
3716 struct Sphere_3D;
3717 
3718 template <typename F>
3719 struct HPS_TEMPLATE_API Cuboid_3D {
3724 
3725 
3729  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3730 
3731  template <typename D>
3732 
3737  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3738 
3739 
3744  Cuboid_3D (Sphere_3D<F> const & that);
3745 
3751  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3752 
3758  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3759  if (count == 0) {
3760  min = Limit_Point();
3761  max = -Limit_Point();
3762  return;
3763  }
3764  min = max = *points++;
3765  --count;
3766  if (count>0)
3767  Merge(count, points);
3768  }
3769 
3774  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3775 
3779  HPS_INLINE bool IsValid() const {
3780  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3781  }
3782 
3786  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3787 
3791  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3792 
3797  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3798 
3803  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3804 
3809  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3810  points[0] = Point_3D<F> (min.x, min.y, min.z);
3811  points[1] = Point_3D<F> (min.x, min.y, max.z);
3812  points[2] = Point_3D<F> (min.x, max.y, min.z);
3813  points[3] = Point_3D<F> (min.x, max.y, max.z);
3814  points[4] = Point_3D<F> (max.x, min.y, min.z);
3815  points[5] = Point_3D<F> (max.x, min.y, max.z);
3816  points[6] = Point_3D<F> (max.x, max.y, min.z);
3817  points[7] = Point_3D<F> (max.x, max.y, max.z);
3818  }
3819 
3823  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3824 
3828  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3829 
3835  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3836  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3837  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3838  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3839  }
3840 
3846  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3847  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3848  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3849  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3850  }
3851 
3858  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3859  //ASSERT (0 <= dimension && dimension <= 2);
3860  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3861  }
3862 
3870  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3871  //ASSERT (0 <= dimension && dimension <= 2);
3872  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3873  }
3874 
3881  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
3882  return LineIntersecting(start, direction, true);
3883  }
3884 
3891  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
3892  Vector_3D<F> const direction = point2 - point1;
3893  return LineIntersecting(point1, direction, false);
3894  }
3895 
3901  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3902  Float::replace_if_smaller(min.x, cuboid.min.x);
3903  Float::replace_if_smaller(min.y, cuboid.min.y);
3904  Float::replace_if_smaller(min.z, cuboid.min.z);
3905  Float::replace_if_larger(max.x, cuboid.max.x);
3906  Float::replace_if_larger(max.y, cuboid.max.y);
3907  Float::replace_if_larger(max.z, cuboid.max.z);
3908  }
3909 
3915  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
3916 
3922  HPS_INLINE void Merge(Point_3D<F> const & point) {
3923  Float::replace_if_smaller(min.x, point.x);
3924  Float::replace_if_smaller(min.y, point.y);
3925  Float::replace_if_smaller(min.z, point.z);
3926  Float::replace_if_larger(max.x, point.x);
3927  Float::replace_if_larger(max.y, point.y);
3928  Float::replace_if_larger(max.z, point.z);
3929  }
3930 
3937  void Merge(size_t count, Point_3D<F> const * points) {
3938  while (count > 1) {
3939  if (Compare(points[0].x, points[1].x)>0) {
3940  Float::replace_if_smaller(min.x, points[1].x);
3941  Float::replace_if_larger(max.x, points[0].x);
3942  }
3943  else {
3944  Float::replace_if_smaller(min.x, points[0].x);
3945  Float::replace_if_larger(max.x, points[1].x);
3946  }
3947 
3948  if (Compare(points[0].y, points[1].y)>0) {
3949  Float::replace_if_smaller(min.y, points[1].y);
3950  Float::replace_if_larger(max.y, points[0].y);
3951  }
3952  else {
3953  Float::replace_if_smaller(min.y, points[0].y);
3954  Float::replace_if_larger(max.y, points[1].y);
3955  }
3956 
3957  if (Compare(points[0].z, points[1].z)>0) {
3958  Float::replace_if_smaller(min.z, points[1].z);
3959  Float::replace_if_larger(max.z, points[0].z);
3960  }
3961  else {
3962  Float::replace_if_smaller(min.z, points[0].z);
3963  Float::replace_if_larger(max.z, points[1].z);
3964  }
3965 
3966  points += 2;
3967  count -= 2;
3968  }
3969 
3970  if (count > 0)
3971  Merge(*points);
3972  }
3973 
3979  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
3980  return (contained.min.x >= min.x &&
3981  contained.min.y >= min.y &&
3982  contained.min.z >= min.z &&
3983  contained.max.x <= max.x &&
3984  contained.max.y <= max.y &&
3985  contained.max.z <= max.z);
3986  }
3987 
3993  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
3994  return (contained.x >= min.x &&
3995  contained.y >= min.y &&
3996  contained.z >= min.z &&
3997  contained.x <= max.x &&
3998  contained.y <= max.y &&
3999  contained.z <= max.z);
4000  }
4001 
4008  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4009  return (contained.x >= min.x - epsilon &&
4010  contained.y >= min.y - epsilon &&
4011  contained.z >= min.z - epsilon &&
4012  contained.x <= max.x + epsilon &&
4013  contained.y <= max.y + epsilon &&
4014  contained.z <= max.z + epsilon);
4015  }
4016 
4022  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4023  Float::replace_if_larger(min.x, cuboid.min.x);
4024  Float::replace_if_larger(min.y, cuboid.min.y);
4025  Float::replace_if_larger(min.z, cuboid.min.z);
4026  Float::replace_if_smaller(max.x, cuboid.max.x);
4027  Float::replace_if_smaller(max.y, cuboid.max.y);
4028  Float::replace_if_smaller(max.z, cuboid.max.z);
4029  return *this;
4030  }
4031 
4037  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4038  Float::replace_if_smaller(min.x, cuboid.min.x);
4039  Float::replace_if_smaller(min.y, cuboid.min.y);
4040  Float::replace_if_smaller(min.z, cuboid.min.z);
4041  Float::replace_if_larger(max.x, cuboid.max.x);
4042  Float::replace_if_larger(max.y, cuboid.max.y);
4043  Float::replace_if_larger(max.z, cuboid.max.z);
4044  return *this;
4045  }
4046 
4052  HPS_INLINE Cuboid_3D & Expand(F border) {
4053  Vector_3D<F> delta (border, border, border);
4054  min -= delta;
4055  max += delta;
4056  return *this;
4057  }
4058 
4064  HPS_INLINE Cuboid_3D & Contract(F border) {
4065  Vector_3D<F> delta (border, border, border);
4066  min += delta;
4067  max -= delta;
4068  return *this;
4069  }
4070 
4071 private:
4072  HPS_INLINE static Point_3D<F> Limit_Point () {
4073  F const limit = std::numeric_limits<F>::max();
4074  return Point_3D<F> (limit, limit, limit);
4075  }
4076 
4077  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4078 };
4079 
4080 typedef Cuboid_3D<float> SimpleCuboid;
4081 typedef Cuboid_3D<double> DSimpleCuboid;
4082 
4083 
4084 template <typename F>
4085 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4086  Cuboid_3D<F> temp = a;
4087  return temp.Intersect(b);
4088 }
4089 
4090 template <typename F>
4091 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4092  Cuboid_3D<F> temp = a;
4093  return temp.Union(b);
4094 }
4095 
4096 template <typename F>
4097 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4098  Cuboid_3D<F> temp = a;
4099  return temp.Expand(border);
4100 }
4101 
4102 template <typename F>
4103 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4104  Cuboid_3D<F> temp = a;
4105  return temp.Contract(border);
4106 }
4107 
4108 
4109 
4110 template <typename F>
4111 struct HPS_TEMPLATE_API Sphere_3D {
4112  Point_3D<F> center;
4113  F radius;
4114 
4115  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4116 
4117  template <typename D>
4118  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4119 
4120  Sphere_3D (Cuboid_3D<F> const & cuboid) :
4121  center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4122 
4123  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4124 
4125  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4126  Cuboid_3D<F> cuboid(count, points);
4127  center = Midpoint(cuboid.min, cuboid.max);
4128  Engulf (count, points);
4129  }
4130 
4131  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4132  Engulf (count, points);
4133  }
4134 
4135  HPS_INLINE bool IsValid() const {
4136  return radius >= 0;
4137  }
4138 
4139  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4140 
4141  void Invalidate() {radius = -1;}
4142 
4143  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4144  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4145 
4146  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4147 
4148  HPS_INLINE void Merge(Point_3D<F> const & point) {
4149  Vector_3D<F> dir = point - center;
4150  F distance = (F)dir.Length();
4151 
4152  if (distance > radius) {
4153  F t = F(0.5) * (distance - radius);
4154  center += t * dir.Normalize();
4155  radius += t;
4156  }
4157  }
4158 
4159  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4160 
4161  for (size_t i = 0; i < count; ++i) {
4162  Vector_3D<F> dir = *points - center;
4163  F distance = (F)dir.Length();
4164 
4165  if (distance > radius) {
4166  F t = F(0.5) * (distance - radius);
4167  center += t * dir.Normalize();
4168  radius += t;
4169  }
4170 
4171  ++points;
4172  }
4173  }
4174 
4175  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4176  Vector_3D<F> dir = sphere.center - center;
4177  F distance = (F)dir.Length();
4178 
4179  if (distance + sphere.radius > radius) {
4180  if (distance + radius > sphere.radius) {
4181  F t = F(0.5 * (sphere.radius + distance - radius));
4182  center += t * dir.Normalize();
4183  radius += t;
4184  }
4185  else {
4186  center = sphere.center;
4187  radius = sphere.radius;
4188  }
4189  }
4190  }
4191 
4192  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4193 
4194 private:
4195  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4196  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4197  for (size_t i = 0; i < count; ++i) {
4198  double dsq = (*points++ - center).LengthSquared();
4199  if ((F)dsq > radius * radius)
4200  radius = (F)sqrt(dsq);
4201  }
4202  }
4203 };
4204 
4205 typedef Sphere_3D<float> SimpleSphere;
4206 typedef Sphere_3D<double> DSimpleSphere;
4207 
4208 
4209 template <typename F>
4210 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4211  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4212  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4213 }
4214 
4215 
4216 
4217 
4218 class RGB24Color;
4219 class RGBA32Color;
4220 class RGBAS32Color;
4221 class RGBAColor;
4222 
4223 class HPS_API RGBColor {
4224 public:
4225  float red;
4226  float green;
4227  float blue;
4228 
4229  HPS_INLINE RGBColor () {}
4230  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4231  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4232  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4233  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4234  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4235  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4236 
4237  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4238  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4239  float Distance(RGBColor const & other_color) const;
4240  HPS_INLINE bool IsValid() const {
4241  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4242  }
4243 
4244  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4245  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4246 
4247  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4248  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4249 
4250  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4251  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4252  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4253  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4254  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4255  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4256 
4257  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4258  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4259  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4260  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4261  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4262  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4263  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4264  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4265 
4266  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4267  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4268  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4269 
4270  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4271  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4272  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4273 
4274  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4275  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4276  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4277 };
4278 
4279 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4280 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4281 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4282 
4283 
4284 class HPS_API RGBAColor {
4285 public:
4286 
4287  float red;
4288  float green;
4289  float blue;
4290  float alpha;
4292  HPS_INLINE RGBAColor () {}
4293  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4294  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4295 
4296  HPS_INLINE RGBAColor (RGBColor const & c) {
4297  memcpy(this, &c, sizeof(RGBColor)); //-V512
4298  alpha = 1.0f;
4299  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4300  }
4301  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4302  memcpy(this, &c, sizeof(RGBColor));
4303  memcpy(&alpha, &a, sizeof(float));
4304  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4305  }
4306  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4307  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4308 
4309  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4310  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4311  HPS_INLINE bool IsValid() const {
4312  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4313  }
4314 
4321  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4322 
4329  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4330 
4331  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4332  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4333  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4334  }
4335 
4336  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4337  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4338  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4339  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4340  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4341  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4342 
4343  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4344  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4345  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4346  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4347  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4348  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4349  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4350  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4351 
4352  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4353  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4354  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4355  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4356  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4357  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4358 
4359  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4360  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4361  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4362  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4363 };
4364 
4365 
4366 
4368 public:
4369  enum Order {
4370  Order_ABGR,
4371  Order_RGBA,
4372  Order_BGRA
4373  };
4374 
4375 #ifdef _MSC_VER
4376  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4377  unsigned char b, g, r, a;
4378 #endif
4379 
4380 #ifdef __linux__
4381  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4382  unsigned char r, g, b, a;
4383 #endif
4384 
4385 #ifdef __APPLE_CC__
4386  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4387  unsigned char r, g, b, a;
4388 #endif
4389 };
4390 
4391 
4392 
4394 public:
4395 
4396  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4397  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4398  r = gray;
4399  g = gray;
4400  b = gray;
4401  a = aa;
4402  }
4403  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4404  r = rr;
4405  g = gg;
4406  b = bb;
4407  a = aa;
4408  }
4409  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4410 
4411  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4412  {
4413  r = Float::unit_to_byte(c.red);
4414  g = Float::unit_to_byte(c.green);
4415  b = Float::unit_to_byte(c.blue);
4416  a = 255;
4417  }
4418 
4419  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4420 
4421  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4422 
4423  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
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 = Float::unit_to_byte(alpha);
4429  }
4430  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
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 = aa;
4436  }
4437  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
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(c.alpha);
4443  }
4444  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4445  {
4446  r = Float::unit_to_byte(c.red);
4447  g = Float::unit_to_byte(c.green);
4448  b = Float::unit_to_byte(c.blue);
4449  a = Float::unit_to_byte_scaled(c.alpha, mix);
4450  }
4451 
4452  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4453  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4454  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4455 
4456  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4457  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4458 
4459  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4460  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4461  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4462 
4463  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4464 };
4465 
4467 public:
4468  unsigned char r;
4469  unsigned char g;
4470  unsigned char b;
4471  unsigned char a;
4472 
4473  HPS_INLINE RGBA32Color () {}
4474  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4475  : r (gray), g (gray), b (gray), a (aa) {}
4476  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4477  : r (rr), g (gg), b (bb), a (aa) {}
4478  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4479  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4480  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4481  r = Float::unit_to_byte(c.red);
4482  g = Float::unit_to_byte(c.green);
4483  b = Float::unit_to_byte(c.blue);
4484  a = 255;
4485  }
4486  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4487  r = Float::unit_to_byte(c.red);
4488  g = Float::unit_to_byte(c.green);
4489  b = Float::unit_to_byte(c.blue);
4490  a = Float::unit_to_byte(alpha);
4491  }
4492  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4493  r = Float::unit_to_byte(c.red);
4494  g = Float::unit_to_byte(c.green);
4495  b = Float::unit_to_byte(c.blue);
4496  a = aa;
4497  }
4498  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4499  r = Float::unit_to_byte(c.red);
4500  g = Float::unit_to_byte(c.green);
4501  b = Float::unit_to_byte(c.blue);
4502  a = Float::unit_to_byte(c.alpha);
4503  }
4504  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4505  r = Float::unit_to_byte(c.red);
4506  g = Float::unit_to_byte(c.green);
4507  b = Float::unit_to_byte(c.blue);
4508  a = Float::unit_to_byte_scaled(c.alpha, mix);
4509  }
4510 
4511  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4512  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4513 
4514  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4515  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4516 
4517  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4518  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4519 
4520  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4521 };
4522 
4523 
4525 {
4526 public:
4527  unsigned char r;
4528  unsigned char g;
4529  unsigned char b;
4530 
4531  HPS_INLINE RGB24Color () {}
4532  explicit HPS_INLINE RGB24Color (unsigned char gray)
4533  : r (gray), g (gray), b (gray) {}
4534  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4535  : r (rr), g (gg), b (bb) {}
4536  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4537  r = Float::unit_to_byte(c.red);
4538  g = Float::unit_to_byte(c.green);
4539  b = Float::unit_to_byte(c.blue);
4540  }
4541 
4542  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4543  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4544 
4545  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4546  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4547 };
4548 
4549 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4550  red = Float::C2F(c32.r);
4551  green = Float::C2F(c32.g);
4552  blue = Float::C2F(c32.b);
4553 }
4554 
4555 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4556  red = Float::C2F(c32.r);
4557  green = Float::C2F(c32.g);
4558  blue = Float::C2F(c32.b);
4559 }
4560 
4561 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4562  red = c.red;
4563  green = c.green;
4564  blue = c.blue;
4565 }
4566 
4567 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4568  red = Float::C2F(c24.r);
4569  green = Float::C2F(c24.g);
4570  blue = Float::C2F(c24.b);
4571 }
4572 
4573 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4574 {
4575  r = c.r;
4576  g = c.g;
4577  b = c.b;
4578  a = 255;
4579 }
4580 
4581 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4582 {
4583  r = c.r;
4584  g = c.g;
4585  b = c.b;
4586  a = c.a;
4587 }
4588 
4589 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color 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 RGBAColor::RGBAColor (RGBA32Color const & c32) {
4597  red = Float::C2F(c32.r);
4598  green = Float::C2F(c32.g);
4599  blue = Float::C2F(c32.b);
4600  alpha = Float::C2F(c32.a);
4601 }
4602 
4603 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4604  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4605 }
4606 
4607 
4608 
4609 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4610  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4611 }
4612 
4613 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4614  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);
4615 }
4616 
4617 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4618  return RGBAS32Color(
4619  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4620  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4621  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4622  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4623 }
4624 
4625 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4626  return RGBA32Color(
4627  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4628  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4629  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4630  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4631 }
4632 
4633 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4634  return RGB24Color(
4635  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4636  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4637  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4638 }
4639 
4640 
4641 
4642 class HPS_API Quaternion {
4643 public:
4644  float w;
4645  float x;
4646  float y;
4647  float z;
4648 
4649  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4650 
4651  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) { }
4652 
4653  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4654 
4655  Quaternion const & Normalize() {
4656  float mag = Norm();
4657 
4658  if (mag > 0) {
4659  w /= mag;
4660  x /= mag;
4661  y /= mag;
4662  z /= mag;
4663  }
4664  return *this;
4665  }
4666 
4667 
4668  Quaternion operator* (Quaternion const & in_right) const {
4669  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4670  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4671  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4672  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4673  }
4674 
4675  Quaternion operator* (float in_right) const {
4676  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4677  }
4678 
4679  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4680  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4681  }
4682 
4683  Quaternion operator/ (float in_right) const {
4684  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4685  }
4686 
4687  Quaternion operator- (Quaternion const & in_right) const {
4688  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4689  }
4690 
4691  Quaternion operator+ (Quaternion const & in_right) const {
4692  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4693  }
4694 
4695  inline float Norm() const {
4696  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4697  }
4698 
4699 
4700  Quaternion Log() const {
4701  Quaternion ret;
4702  float mag_q = Norm();
4703  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4704 
4705  ret.w = static_cast<float>(log(mag_q));
4706 
4707  if (mag_V > 0) {
4708  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4709 
4710  ret.x = x * scale;
4711  ret.y = y * scale;
4712  ret.z = z * scale;
4713  }
4714  else
4715  ret.x = ret.y = ret.z = 0;
4716 
4717  return ret;
4718  }
4719 
4720  Quaternion Exp() const {
4721  Quaternion ret;
4722  float ea = static_cast<float>(exp(w));
4723  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4724  float scale = ea * sin(mag_V) / mag_V;
4725 
4726  ret.w = ea * cos(mag_V);
4727  ret.x = scale * x;
4728  ret.y = scale * y;
4729  ret.z = scale * z;
4730 
4731  return ret;
4732  }
4733 
4734  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4735  Quaternion ret = *this + in_fraction * (in_right - *this);
4736  return ret.Normalize();
4737  }
4738 
4739 
4740  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4741  Quaternion q3;
4742  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4743 
4744  if (in_shortest_path_only && dot < 0) {
4745  dot = -dot;
4746  q3 = -1 * in_right;
4747  }
4748  else
4749  q3 = in_right;
4750 
4751  if (dot > -0.95f && dot < 0.95f) {
4752  float angle = static_cast<float>(acos(dot));
4753  float sina = static_cast<float>(sin(angle));
4754  float sinat = static_cast<float>(sin(angle*in_fraction));
4755  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4756 
4757  return (*this * sinaomt + q3 * sinat) / sina;
4758  }
4759  else //if the angle is small, we use linear interpolation
4760  return Lerp(q3, in_fraction);
4761  }
4762 
4763 
4764  /*
4765  Spherical cubic interpolation between two Quaternions
4766  \param in_right The Quaternion for interpolation.
4767  \param in_control1 The first control point.
4768  \param in_control2 The second control point.
4769  \param in_fraction Interpolation distance (0 - 1).
4770  \return Result of interpolation.
4771  */
4772  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4773  Quaternion q1 = Slerp(in_right , in_fraction, false);
4774  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4775 
4776  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4777  }
4778 
4785  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4786  Quaternion qni(-x, -y, -z, w);
4787 
4788  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4789  }
4790 
4791 };
4792 
4794 {
4795  size_t dot_dc_count;
4796  size_t dot_3d_count;
4797  size_t line_dc_count;
4798  size_t line_3d_count;
4799  size_t triangle_dc_count;
4800  size_t triangle_3d_count;
4801  size_t polygon_dc_count;
4802  size_t polygon_3d_count;
4803  size_t polyhedron_count;
4804  size_t deleted_display_list_count;
4805  size_t display_list_line_3d_count;
4806  size_t display_list_triangle_3d_count;
4807  size_t display_list_vertex_3d_count;
4808  size_t display_list_tristrip_count;
4809  size_t non_display_list_tristrip_count;
4810  size_t culled_display_list_tristrip_count;
4811  size_t raster_count;
4812  size_t segment_count;
4813  size_t frustum_culled_segment_count;
4814  size_t extent_culled_segment_count;
4815  size_t vector_culled_segment_count;
4816  Time update_time;
4817 };
4818 
4819 typedef unsigned char byte;
4820 typedef signed char sbyte;
4821 typedef intptr_t WindowHandle;
4822 typedef int64_t TouchID;
4823 typedef intptr_t PlatformData;
4824 typedef intptr_t OpaqueHandle;
4825 
4826 /*
4827 HPS Lexicon:
4828 
4829 Concept Class -- A class that contains only enums and possibly static functions. The
4830  constructor is usually private because they are not intended to be instantiated.
4831 
4832 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4833  database objects is subject to locking to prevent threading deadlocks. (2) The class
4834  of the same name, offering static functions to initiate operations that take place
4835  within the database.
4836 
4837 Key -- A reference counted smart pointer to an object in the database. The
4838 
4839 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4840  option group, or other type. Modifying a kit has no effect on the database unless
4841  and until it is applied. Kits should generally be passed by reference because they
4842  are potentially very large and copying them can be arduous.
4843 
4844 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4845  pointers should generally be passed by value to ensure the reference count is
4846  correct.
4847 
4848 User Space -- The external space occupied by all user code. User space objects are not
4849  in the database and are not subject to locking.
4850 
4851 */
4852 
4856 class SegmentKey;
4857 class AttributesControl;
4858 class LineKit;
4859 class LineKey;
4860 class TextKey;
4861 class TextKit;
4862 class Key;
4863 class VisibilityControl;
4864 class CameraControl;
4865 class SelectabilityControl;
4866 class TransparencyKit;
4867 class TransparencyControl;
4868 class CullingKit;
4869 class CullingControl;
4870 class GlyphKit;
4872 class GlyphDefinition;
4873 class GeometryInsertControl;
4874 class GlyphElement;
4875 class TextAttributeControl;
4876 class TextAttributeKit;
4877 class LineAttributeKit;
4878 class LineAttributeControl;
4879 class EdgeAttributeKit;
4880 class EdgeAttributeControl;
4881 class CurveAttributeKit;
4882 class CurveAttributeControl;
4883 class GlyphPoint;
4884 class MatrixKit;
4886 class TextureMatrixControl;
4887 class TextureDefinition;
4888 class MaterialMappingKit;
4890 class MaterialKit;
4891 class MarkerKit;
4892 class MarkerKey;
4893 class DistantLightKit;
4894 class DistantLightKey;
4895 class CuttingSectionKit;
4896 class CuttingSectionKey;
4899 class CylinderAttributeKit;
4901 class Cylinder;
4902 class CylinderKey;
4903 class CylinderKit;
4904 class SphereKey;
4905 class SphereKit;
4906 class SphereAttributeKit;
4908 class PolygonKit;
4909 class PolygonKey;
4910 class CircleKey;
4911 class CircleKit;
4912 class CircularArcKey;
4913 class CircularArcKit;
4914 class CircularWedgeKey;
4915 class CircularWedgeKit;
4916 class IncludeKey;
4917 class InfiniteLineKey;
4918 class InfiniteLineKit;
4919 class SpotlightKey;
4920 class SpotlightKit;
4921 class NURBSCurveKey;
4922 class NURBSCurveKit;
4923 class NURBSSurfaceKey;
4924 class NURBSSurfaceKit;
4925 class TrimKit;
4926 class TrimElement;
4927 class EllipseKey;
4928 class EllipseKit;
4929 class EllipticalArcKey;
4930 class EllipticalArcKit;
4931 class ShellKit;
4932 class ShellKey;
4933 class Shell;
4934 class MeshKit;
4935 class MeshKey;
4936 class WindowKey;
4937 class Database;
4940 class Driver;
4941 class Search;
4942 class PerformanceKit;
4943 class PerformanceControl;
4946 class DrawingAttributeKit;
4948 class PortfolioKey;
4949 class Selection;
4950 class SelectionOptionsKit;
4951 class SelectionResults;
4952 class SelectionItem;
4953 class SelectionControl;
4954 class HighlightControl;
4955 class HighlightOptionsKit;
4956 class ImageDefinition;
4957 class ImageKit;
4958 class TextureDefinition;
4959 class TextureOptionsKit;
4960 class NamedStyleDefinition;
4962 class GlyphDefinition;
4963 class LinePatternOptionsKit;
4964 class LinePatternDefinition;
4965 class LinePatternKit;
4966 class LinePatternElement;
4968 class CubeMapDefinition;
4969 class ShaderKit;
4970 class ShaderDefinition;
4971 class EmergencyHandler;
4972 class EventDispatcher;
4973 class EventHandler;
4974 class Event;
4975 class StandAloneWindowKey;
4977 class ApplicationWindowKey;
4979 class OffScreenWindowKey;
4982 class VisualEffectsControl;
4985 class ObjectPoint;
4986 class WorldPoint;
4987 class CameraPoint;
4988 class NormalizedPoint;
4989 class ScreenRangePoint;
4990 class InnerWindowPoint;
4991 class InnerPixelPoint;
4992 class WindowPoint;
4993 class PixelPoint;
4994 class VisibilityKit;
4995 class CameraKit;
4996 class SelectabilityKit;
4997 class MarkerAttributeKit;
4998 class LightingAttributeKit;
4999 class VisualEffectsKit;
5000 class PostProcessEffectsKit;
5001 class Portfolio;
5002 class SubwindowControl;
5003 class SubwindowKit;
5004 class World;
5005 class DebuggingControl;
5006 class DebuggingKit;
5007 class KeyPath;
5008 class ContourLineKit;
5009 class ContourLineControl;
5010 class UTF8;
5011 class StyleControl;
5012 class PortfolioControl;
5013 class Condition;
5014 class ConditionControl;
5015 class WindowInfoKit;
5016 class WindowInfoControl;
5017 class FontInfoState;
5018 class FontInfoControl;
5019 class SearchOptionsKit;
5020 class AttributeLockControl;
5021 class AttributeLockKit;
5022 class ReferenceKey;
5023 class StyleKey;
5024 class BoundingKit;
5025 class BoundingControl;
5026 class TransformMaskKit;
5027 class TransformMaskControl;
5028 class ColorInterpolationKit;
5030 class UpdateOptionsKit;
5031 class UpdateOptionsControl;
5032 class GeometryKey;
5033 class TreeContext;
5036 class GridKit;
5037 class GridKey;
5040 
5044 
5045 
5048 class HPS_API GlyphPoint
5049 {
5050 public:
5051 
5053  GlyphPoint();
5054 
5059  GlyphPoint(sbyte in_x, sbyte in_y);
5060 
5065  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5066 
5071  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5072 
5077  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5078 
5079  sbyte x;
5080  sbyte y;
5081 };
5082 
5085 enum class Type : uint32_t
5086 {
5087  None = 0x00000000,
5088  GenericMask = 0xffffff00,
5089 
5090  World = 0x00000001,
5091  UTF8 = 0x00000002,
5092  EventDispatcher = 0x00000003,
5093  EventHandler = 0x00000004,
5094  EventNotifier = 0x00000005,
5095  UpdateNotifier = 0x00000006,
5096  SearchResults = 0x00000008,
5097  FontSearchResults = 0x00000009,
5098  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
5099  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5100  SelectionResults = 0x0000000c,
5101  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5102  SelectionItem = 0x0000000e,
5103  TreeContext = 0x0000000f,
5104  StreamToolkit = 0x00000010,
5105  DriverEventHandler = 0x00000011,
5106 
5107  IONotifier = 0x04000100,
5108  StreamImportNotifier = 0x04000101,
5109  STLImportNotifier = 0x04000102,
5110  OBJImportNotifier = 0x04000103,
5111  ExchangeImportNotifier = 0x04000104,
5112  SketchupImportNotifier = 0x04000105,
5113  ParasolidImportNotifier = 0x04000106,
5114  ExchangeTranslationNotifier = 0x04000107,
5115  ExchangeExportNotifier = 0x04000108,
5116  StreamExportNotifier = 0x04000109,
5117  ExchangeReloadNotifier = 0x0400010a,
5118 
5119  Kit = 0x01000000,
5120  MarkerKit = 0x01000010,
5121  SphereAttributeKit = 0x01000011,
5122  TextAttributeKit = 0x01000012,
5123  TransparencyKit = 0x01000013,
5124  VisibilityKit = 0x01000014,
5125  VisualEffectsKit = 0x01000015,
5126  CuttingSectionAttributeKit = 0x01000016,
5127  CircleKit = 0x01000017,
5128  CircularArcKit = 0x01000018,
5129  CircularWedgeKit = 0x01000019,
5130  CuttingSectionKit = 0x0100001a,
5131  CylinderKit = 0x0100001b,
5132  DistantLightKit = 0x0100001c,
5133  EllipseKit = 0x0100001d,
5134  EllipticalArcKit = 0x0100001e,
5135  InfiniteLineKit = 0x0100001f,
5136  LineKit = 0x01000020,
5137  NURBSCurveKit = 0x01000021,
5138  MeshKit = 0x01000022,
5139  NURBSSurfaceKit = 0x01000023,
5140  PolygonKit = 0x01000024,
5141  SphereKit = 0x01000025,
5142  SpotlightKit = 0x01000026,
5143  ShellKit = 0x01000027,
5144  TextKit = 0x01000028,
5145  MaterialKit = 0x01000029,
5146  TrimKit = 0x0100002a,
5147  TextureOptionsKit = 0x0100002c,
5148  LinePatternKit = 0x0100002d,
5149  GlyphKit = 0x0100002e,
5150  ImageKit = 0x0100002f,
5151  LinePatternOptionsKit = 0x01000030,
5152  CameraKit = 0x01000031,
5153  BoundingKit = 0x01000032,
5154  CullingKit = 0x01000033,
5155  CurveAttributeKit = 0x01000034,
5156  CylinderAttributeKit = 0x01000035,
5157  EdgeAttributeKit = 0x01000036,
5158  LightingAttributeKit = 0x01000037,
5159  LineAttributeKit = 0x01000038,
5160  MarkerAttributeKit = 0x01000039,
5161  MaterialMappingKit = 0x0100003a,
5162  MatrixKit = 0x0100003b,
5163  NURBSSurfaceAttributeKit = 0x0100003c,
5164  PostProcessEffectsKit = 0x0100003d,
5165  SelectabilityKit = 0x0100003e,
5166  SelectionOptionsKit = 0x0100003f,
5167  StandAloneWindowOptionsKit = 0x01000040,
5168  OffScreenWindowOptionsKit = 0x01000041,
5169  ApplicationWindowOptionsKit = 0x01000042,
5170  HighlightOptionsKit = 0x01000043,
5171  LinePatternParallelKit = 0x01000044,
5172  SubwindowKit = 0x01000045,
5173  PerformanceKit = 0x01000046,
5174  HiddenLineAttributeKit = 0x01000047,
5175  DrawingAttributeKit = 0x01000048,
5176  ShaderKit = 0x01000049,
5177  DebuggingKit = 0x0100004a,
5178  ContourLineKit = 0x0100004b,
5179  StreamImportOptionsKit = 0x0100004c,
5180  StreamImportResultsKit = 0x0100004d,
5181  StreamExportOptionsKit = 0x0100004e,
5182  StreamExportResultsKit = 0x0100004f,
5183  WindowInfoKit = 0x01000050,
5184  ImageImportOptionsKit = 0x01000051,
5185  SearchOptionsKit = 0x01000052,
5186  ShaderImportOptionsKit = 0x01000053,
5187  HardcopyExportOptionsKit = 0x01000055,
5188  AttributeLockKit = 0x01000056,
5189  TransformMaskKit = 0x01000057,
5190  ColorInterpolationKit = 0x01000058,
5191  UpdateOptionsKit = 0x01000059,
5192  ImageExportOptionsKit = 0x0100005a,
5193  OBJImportOptionsKit = 0x0100005b,
5194  OBJImportResultsKit = 0x0100005c,
5195  STLImportOptionsKit = 0x0100005d,
5196  STLImportResultsKit = 0x0100005e,
5197  ShellOptimizationOptionsKit = 0x0100005f,
5198  ShellRelationOptionsKit = 0x01000060,
5199  ShellRelationResultsKit = 0x01000061,
5200  GridKit = 0x01000062,
5201  CutGeometryGatheringOptionsKit = 0x01000063,
5202  SegmentOptimizationOptionsKit = 0x01000064,
5203 
5204 
5205  LinePatternElement = 0x03000000,
5206  SolidLinePatternElement = 0x03000001,
5207  BlankLinePatternElement = 0x03000002,
5208  GlyphLinePatternElement = 0x03000003,
5209 
5210  GlyphElement = 0x05000000,
5211  DotGlyphElement = 0x05000001,
5212  LineGlyphElement = 0x05000002,
5213  EllipseGlyphElement = 0x05000003,
5214  CircularArcGlyphElement = 0x05000004,
5215  InfiniteLineGlyphElement = 0x05000005,
5216 
5217  TrimElement = 0x07000000,
5218 
5219  Condition = 0x09000000,
5220  NOTCondition = 0x09000001,
5221  ANDCondition = 0x09000002,
5222  ORCondition = 0x09000003,
5223  XORCondition = 0x09000004,
5224  EQCondition = 0x09000005,
5225  NEQCondition = 0x09000006,
5226  GTCondition = 0x09000007,
5227  LTCondition = 0x09000008,
5228  GTEQCondition = 0x09000009,
5229  LTEQCondition = 0x0900000A,
5230 
5231  MouseState = 0x01001001,
5232  TouchState = 0x01001002,
5233  KeyboardState = 0x01001003,
5234  FontInfoState = 0x01001004,
5235 
5236  KeyPath = 0x01000F01,
5237 
5238  Key = 0x10000000,
5239  IncludeKey = 0x10000001,
5240  PortfolioKey = 0x10000002,
5241  StyleKey = 0x10000003,
5242 
5243  SegmentKey = 0x10200000,
5244  WindowKey = 0x10600000,
5245  StandAloneWindowKey = 0x10600001,
5246  OffScreenWindowKey = 0x10600002,
5247  ApplicationWindowKey = 0x10600003,
5248 
5249  GeometryKey = 0x10100000,
5250  ReferenceKey = 0x10100001,
5251  CircleKey = 0x10100002,
5252  CircularArcKey = 0x10100003,
5253  CircularWedgeKey = 0x10100004,
5254  CuttingSectionKey = 0x10100005,
5255  CylinderKey = 0x10100006,
5256  EllipseKey = 0x10100007,
5257  EllipticalArcKey = 0x10100008,
5258  InfiniteLineKey = 0x10100009,
5259  LineKey = 0x1010000a,
5260  DistantLightKey = 0x1010000b,
5261  SpotlightKey = 0x1010000c,
5262  MarkerKey = 0x1010000d,
5263  MeshKey = 0x1010000e,
5264  NURBSCurveKey = 0x1010000f,
5265  NURBSSurfaceKey = 0x10100010,
5266  PolygonKey = 0x10100011,
5267  ShellKey = 0x10100012,
5268  SphereKey = 0x10100013,
5269  TextKey = 0x10100014,
5270  GridKey = 0x10100015,
5271 
5272  Definition = 0x20000000,
5273  NamedStyleDefinition = 0x20000001,
5274  TextureDefinition = 0x20000002,
5275  LinePatternDefinition = 0x20000003,
5276  GlyphDefinition = 0x20000004,
5277  CubeMapDefinition = 0x20000005,
5278  ImageDefinition = 0x20000006,
5279  MaterialPaletteDefinition = 0x20000007,
5280  ShaderDefinition = 0x20000008,
5281 
5282  Control = 0x50000000,
5283  CameraControl = 0x50000001,
5284  SelectabilityControl = 0x50000002,
5285  MarkerAttributeControl = 0x50000003,
5286  SphereAttributeControl = 0x50000004,
5287  LightingAttributeControl = 0x50000005,
5288  CylinderAttributeControl = 0x50000006,
5289  TextAttributeControl = 0x50000007,
5290  LineAttributeControl = 0x50000008,
5291  EdgeAttributeControl = 0x50000009,
5292  CurveAttributeControl = 0x5000000a,
5293  ModellingMatrixControl = 0x5000000b,
5294  TextureMatrixControl = 0x5000000c,
5295  CullingControl = 0x5000000d,
5296  TransparencyControl = 0x5000000e,
5297  MaterialMappingControl = 0x5000000f,
5298  NURBSSurfaceAttributeControl = 0x50000010,
5299  PostProcessEffectsControl = 0x50000011,
5300  BoundingControl = 0x50000012,
5301  VisualEffectsControl = 0x50000013,
5302  SelectionOptionsControl = 0x50000014,
5303  HighlightOptionsControl = 0x50000015,
5304  DefinitionControl = 0x50000016,
5305  SelectionControl = 0x50000017,
5306  HighlightControl = 0x50000018,
5307  StandAloneWindowOptionsControl = 0x50000019,
5308  OffScreenWindowOptionsControl = 0x5000001a,
5309  ApplicationWindowOptionsControl = 0x5000001b,
5310  VisibilityControl = 0x5000001c,
5311  SubwindowControl = 0x5000001d,
5312  PerformanceControl = 0x5000001e,
5313  HiddenLineAttributeControl = 0x5000001f,
5314  DrawingAttributeControl = 0x50000020,
5315  DebuggingControl = 0x50000021,
5316  ContourLineControl = 0x50000022,
5317  StyleControl = 0x50000023,
5318  ConditionControl = 0x50000024,
5319  PortfolioControl = 0x50000025,
5320  WindowInfoControl = 0x50000026,
5321  AttributeLockControl = 0x50000027,
5322  TransformMaskControl = 0x50000028,
5323  ColorInterpolationControl = 0x50000029,
5324  UpdateOptionsControl = 0x50000030,
5325  CuttingSectionAttributeControl = 0x50000031,
5326 
5327  LibraryMask = 0x80FF0000,
5328 
5329  Sprocket = 0x80000000,
5330  Canvas = 0x80000001,
5331  Layout = 0x80000002,
5332  View = 0x80000003,
5333  Model = 0x80000004,
5334  Operator = 0x80000005,
5335  SprocketPath = 0x80000007,
5336 
5337  SprocketControl = 0xD0000000,
5338  OperatorControl = 0xD0000008,
5339  NavigationCubeControl = 0xD0000009,
5340  AxisTriadControl = 0xD000000A,
5341 
5342  Metadata = 0x80001000,
5343  IntegerMetadata = 0x80001001,
5344  UnsignedIntegerMetadata = 0x80001002,
5345  DoubleMetadata = 0x80001003,
5346  StringMetadata = 0x80001004,
5347  TimeMetadata = 0x80001005,
5348  BooleanMetadata = 0x80001006,
5349 
5350  Component = 0x80000200,
5351  Filter = 0x80000600,
5352  Capture = 0x80000a00,
5353  CADModel = 0x80000300,
5354  ComponentPath = 0x81001000,
5355 
5356  ExchangeMask = 0x80020000,
5357  ExchangeComponent = 0x80021200,
5358  ExchangeFilter = 0x80020601,
5359  ExchangeCapture = 0x80020a01,
5360  ExchangeCADModel = 0x80020301,
5361  ExchangeConfiguration = 0x81020001,
5362  ExchangeImportOptionsKit = 0x81020002,
5363  ExchangeExportACISOptionsKit = 0x81020003,
5364  ExchangeExportIGESOptionsKit = 0x81020004,
5365  ExchangeExportJTOptionsKit = 0x81020005,
5366  ExchangeExportParasolidOptionsKit = 0x81020006,
5367  ExchangeExportPRCOptionsKit = 0x81020007,
5368  ExchangeExportSTEPOptionsKit = 0x81020008,
5369  ExchangeExportSTLOptionsKit = 0x81020009,
5370  ExchangeExportU3DOptionsKit = 0x8102000a,
5371  ExchangeExportXMLOptionsKit = 0x8102000b,
5372  ExchangeTessellationOptionsKit = 0x8102000c,
5373  ExchangeSheet = 0x80021201,
5374  ExchangeModelFileImportOptionsKit = 0x8102000d,
5375 
5376  PublishMask = 0x80040000,
5377  PublishDocumentKit = 0x81040001,
5378  PublishPageKit = 0x81040002,
5379  PublishTemplateKit = 0x81040003,
5380  PublishAnnotationKit = 0x81040004,
5381  PublishArtworkKit = 0x81040005,
5382  PublishViewKit = 0x81040006,
5383  PublishTextKit = 0x81040007,
5384  PublishImageKit = 0x81040008,
5385  PublishTableKit = 0x81040009,
5386  PublishExportOptionsKit = 0x8104000a,
5387  PublishLinkKit = 0x8104000b,
5388  PublishButtonKit = 0x8104000c,
5389  PublishTextFieldKit = 0x8104000d,
5390  PublishSlideTableKit = 0x8104000e,
5391  PublishCheckBoxKit = 0x8104000f,
5392  PublishRadioButtonKit = 0x81040010,
5393  PublishListBoxKit = 0x81040011,
5394  PublishDropDownListKit = 0x81040012,
5395  PublishSignatureFieldKit = 0x81040013,
5396 
5397  PublishDocumentKey = 0x80040001,
5398  PublishPageControl = 0x80040002,
5399 
5400  SceneTree = 0x80008001,
5401  SceneTreeItem = 0x80008002,
5402 
5403  ComponentTree = 0x80008003,
5404  ComponentTreeItem = 0x80008004,
5405 
5406  SketchupMask = 0x80100000,
5407  SketchupImportOptionsKit = 0x81100001,
5408  SketchupImportResultsKit = 0x81100002,
5409 
5410  ParasolidMask = 0x80200000,
5411  ParasolidComponent = 0x80201201,
5412  ParasolidCADModel = 0x80200302,
5413  ParasolidImportOptionsKit = 0x81200003,
5414  ParasolidFacetTessellationKit = 0x81200004,
5415  ParasolidLineTessellationKit = 0x81200005,
5416  ParasolidExportOptionsKit = 0x81200006,
5417 
5418  IONotifierData = 0x84000200,
5419  StreamImportNotifierData = 0x84000201,
5420  STLImportNotifierData = 0x84000202,
5421  OBJImportNotifierData = 0x84000203,
5422  ExchangeImportNotifierData = 0x84020204,
5423  SketchupImportNotifierData = 0x84100205,
5424  ParasolidImportNotifierData = 0x84200206,
5425  ExchangeTranslationNotifierData = 0x84020207,
5426  ExchangeExportNotifierData = 0x84020208,
5427  StreamExportNotifierData = 0x84000209,
5428 };
5429 
5431 class HPS_API Memory
5432 {
5433 public:
5439  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5440 
5441 
5446  static void Free(void * in_pointer);
5447 
5448 private:
5450  Memory();
5451 };
5452 
5453 
5455 template <typename T>
5456 class NO_HPS_API Allocator
5457 {
5458 public:
5459  typedef T value_type;
5460  typedef value_type * pointer;
5461  typedef value_type const * const_pointer;
5462  typedef value_type & reference;
5463  typedef value_type const & const_reference;
5464  typedef size_t size_type;
5465  typedef ptrdiff_t difference_type;
5466 
5467 
5468  Allocator() {}
5469  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5470  ~Allocator() {}
5471 
5472  template <typename U> Allocator(Allocator<U> const &) {}
5473 
5474  template <typename U>
5475  struct rebind
5476  {
5477  typedef Allocator<U> other;
5478  };
5479 
5480 
5481  pointer address(reference x) const { return &x; }
5482  const_pointer address(const_reference x) const { return &x; }
5483 
5484  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5485  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5486 
5487 #if defined(_MSC_VER) || defined (__APPLE__)
5488  void construct(pointer p, const_reference x) { new(p) T(x); }
5489 #else
5490  template<typename U, typename... Args>
5491  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5492 #endif
5493  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5494 
5495  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5496 };
5497 
5498 template <typename T, typename U>
5499 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5500 
5501 template <typename T, typename U>
5502 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5503 
5505 class Exception : public std::runtime_error
5506 {
5507 public:
5508  Exception(char const * in_info) : std::runtime_error(in_info) { }
5509 };
5510 
5511 
5514 {
5515 public:
5516  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5517  Exception(in_info) {}
5518 };
5519 
5520 
5524 {
5525 public:
5526  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5527  Exception(in_info) {}
5528 };
5529 
5530 
5533 {
5534 public:
5535  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5536  Exception(in_info) {}
5537 };
5538 
5539 
5542 {
5543 public:
5544  InvalidLicenseException(char const * in_info) :
5545  Exception(in_info) {}
5546 };
5547 
5548 
5551 {
5552 public:
5553  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5554  Exception(in_info) {}
5555 };
5556 
5558 class IOException : public Exception
5559 {
5560 public:
5564  IOException(char const * in_info, IOResult in_result)
5565  : Exception(in_info), result(in_result) {}
5566 
5567  IOResult result;
5568 };
5569 
5570 
5572 class HPS_API Object
5573 {
5574 public:
5575 
5576  Object();
5577 
5578  virtual ~Object();
5579 
5580  Object & operator=(Object const & other_object);
5581 
5585  Object(Object && in_that);
5586 
5587 
5591  Object & operator=(Object && in_that);
5592 
5596  HPS::Type Type() const;
5597 
5601  virtual HPS::Type ObjectType() const { return HPS::Type::None; }
5602 
5605  virtual bool Empty() const {return (impl_ == 0);};
5606 
5608  virtual void Reset();
5609 
5613  bool HasType(HPS::Type in_mask) const;
5614 
5617  intptr_t GetClassID() const;
5618 
5622  intptr_t GetInstanceID() const;
5623 
5624  template <typename T>
5625  static intptr_t ClassID()
5626  {
5627  static const intptr_t ret = T().GetClassID();
5628  return ret;
5629  }
5630 private:
5631 
5632  friend class HPSI::Impl;
5633  friend class HPSI::KeyImpl;
5634  friend class HPSI::TicketImpl;
5635 
5636  HPSI::Impl * impl_;
5637 };
5638 
5639 
5641 class HPS_API Control : public Object
5642 {
5643  HPS::Type ObjectType() const {return HPS::Type::Control;}
5644 
5645 
5646 
5647 protected:
5648  Control() {}
5649 
5653  Control(Control && in_that) : Object(std::move(in_that)) {}
5654 
5658  Control & operator=(Control && in_that)
5659  {
5660  this->Object::operator=(std::move(in_that));
5661  return *this;
5662  }
5663 };
5664 
5665 
5667 class HPS_API ObjectPoint : public Point
5668 {
5669 public:
5670 
5672  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5673 
5675  ObjectPoint(Point const & in_point):Point(in_point){}
5676 
5678  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5679 
5681  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5682 
5684  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5685 
5687  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5688 
5690  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5691 
5693  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5694 
5696  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5697 
5699  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5700 
5702  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5703 
5704 private:
5705 
5706  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5707  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5708  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5709  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5710  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5711  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5712  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5713  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5714 
5715 };
5716 
5718 class HPS_API WorldPoint : public Point
5719 {
5720 public:
5722  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5723 
5725  WorldPoint(Point const & in_point):Point(in_point){}
5726 
5728  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5729 
5731  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5732 
5734  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5735 
5737  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5738 
5740  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5741 
5743  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5744 
5746  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5747 
5749  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5750 
5752  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5753 
5754 private:
5755 
5756  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5757  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5758  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5759  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5760  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5761  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5762  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5763  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5764 
5765 };
5766 
5768 class HPS_API CameraPoint : public Point
5769 {
5770 public:
5772  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5773 
5775  CameraPoint(Point const & in_point):Point(in_point){}
5776 
5778  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5779 
5781  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5782 
5784  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5785 
5787  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5788 
5790  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5791 
5793  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5794 
5796  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5797 
5799  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5800 
5802  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5803 
5804 private:
5805  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5806  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5807  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5808  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5809  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5810  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5811  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5812  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5813 
5814 };
5815 
5817 class HPS_API NormalizedPoint : public Point
5818 {
5819 public:
5820 
5822  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5823 
5825  NormalizedPoint(Point const & in_point):Point(in_point){}
5826 
5828  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5829 
5831  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5832 
5834  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5835 
5837  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5838 
5840  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5841 
5843  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5844 
5846  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5847 
5849  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5850 
5852  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5853 
5854 private:
5855  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5856  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5857  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5858  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5859  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5860  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5861  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5862  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5863 };
5864 
5866 class HPS_API ScreenRangePoint : public Point
5867 {
5868 public:
5870  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5871 
5873  ScreenRangePoint(Point const & in_point):Point(in_point){}
5874 
5876  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5877 
5879  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5880 
5882  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5883 
5885  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5886 
5888  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5889 
5891  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5892 
5894  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5895 
5897  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5898 
5900  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5901 
5902 private:
5903  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5904  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5905  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5906  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5907  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5908  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5909  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5910  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5911 
5912 };
5913 
5915 class HPS_API InnerWindowPoint : public Point
5916 {
5917 public:
5918 
5920  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5921 
5923  InnerWindowPoint(Point const & in_point):Point(in_point){}
5924 
5926  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5927 
5929  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5930 
5932  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5933 
5935  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5936 
5938  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5939 
5941  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5942 
5944  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5945 
5947  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5948 
5950  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5951 
5952 private:
5953  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5954  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5955  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5956  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5957  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5958  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5959  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5960  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5961 };
5962 
5964 class HPS_API InnerPixelPoint : public Point
5965 {
5966 public:
5967 
5969  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5970 
5972  InnerPixelPoint(Point const & in_point):Point(in_point){}
5973 
5975  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5976 
5978  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5979 
5981  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5982 
5984  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5985 
5987  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5988 
5990  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5991 
5993  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5994 
5996  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5997 
5999  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6000 
6001 private:
6002  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6003  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6004  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6005  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6006  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6007  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6008  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6009  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6010 
6011 };
6012 
6014 class HPS_API WindowPoint : public Point
6015 {
6016 public:
6017 
6019  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6020 
6022  WindowPoint(Point const & in_point):Point(in_point){}
6023 
6025  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6026 
6028  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6029 
6031  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6032 
6034  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6035 
6037  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6038 
6040  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6041 
6043  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6044 
6046  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6047 
6049  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6050 
6051 private:
6052  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6053  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6054  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6055  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6056  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6057  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6058  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6059  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6060 };
6061 
6062 
6064 class HPS_API PixelPoint : public Point
6065 {
6066 public:
6068  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6069 
6071  PixelPoint(Point const & in_point):Point(in_point){}
6072 
6074  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6075 
6077  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6078 
6080  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6081 
6083  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6084 
6086  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6087 
6089  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6090 
6092  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6093 
6095  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6096 
6098  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6099 
6100 private:
6101  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6102  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6103  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6104  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6105  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6106  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6107  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6108  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6109 
6110 };
6111 
6114 class HPS_API Event
6115 {
6116 public:
6120  enum class Status
6121  {
6122  InProgress,
6123  Completed,
6124  Failed
6125  };
6126 
6128  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6129 
6130  virtual ~Event();
6131 
6133  intptr_t GetClassID() const;
6134 
6137  virtual Event * Clone() const=0;
6138 
6140  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6141 
6144  virtual intptr_t Freshen() const { return 0; }
6145 
6147  intptr_t GetChannel() const { return channel; }
6148 
6150  Time GetTimeStamp() const { return time_stamp; }
6151 
6153  bool IsConsumable() const { return consumable; }
6154 
6155  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6156  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6157 
6158 protected:
6159  intptr_t channel;
6160  bool consumable;
6161 
6162 private:
6163  friend class HPSI::EventDispatcherImpl;
6164  Time time_stamp;
6165 };
6166 
6167 
6170 class HPS_API EventNotifier : public Object
6171 {
6172 public:
6173 
6175  EventNotifier();
6176 
6179  EventNotifier(EventNotifier const & in_that);
6180 
6184  EventNotifier(EventNotifier && in_that);
6185 
6189  EventNotifier & operator=(EventNotifier && in_that);
6190 
6191  virtual ~EventNotifier();
6192 
6193  HPS::Type ObjectType() const {return HPS::Type::EventNotifier;};
6194 
6198  EventNotifier & operator=(EventNotifier const & in_that);
6199 
6202  virtual void Assign(EventNotifier const & in_that);
6203 
6205  void Wait() const;
6206 
6209  Event::Status Status() const;
6210 };
6211 
6213 enum class KeyboardCode
6214 {
6215  None = 0,
6216 
6217  Backspace = 8,
6218  Tab = 9,
6219  Clear = 11,
6220  Return = 13,
6221  Shift = 16,
6222  Control = 17,
6223  Alt = 18,
6224  Pause = 19,
6225  Escape = 27,
6226 
6227  Space = 32,
6228  ExclamationMark,
6229  DoubleQuote,
6230  Number,
6231  Dollar,
6232  Percent,
6233  Ampersand,
6234  SingleQuote,
6235  OpenParen,
6236  CloseParen,
6237 
6238  Asterisk,
6239  Plus,
6240  Comma,
6241  Hyphen,
6242  Period,
6243  Slash,
6244 
6245  D0,
6246  D1,
6247  D2,
6248  D3,
6249  D4,
6250  D5,
6251  D6,
6252  D7,
6253  D8,
6254  D9,
6255 
6256  Colon,
6257  Semicolon,
6258  LessThan,
6259  Equal,
6260  GreaterThan,
6261  QuestionMark,
6262  AtSymbol,
6263 
6264  A,
6265  B,
6266  C,
6267  D,
6268  E,
6269  F,
6270  G,
6271  H,
6272  I,
6273  J,
6274  K,
6275  L,
6276  M,
6277  N,
6278  O,
6279  P,
6280  Q,
6281  R,
6282  S,
6283  T,
6284  U,
6285  V,
6286  W,
6287  X,
6288  Y,
6289  Z,
6290 
6291  OpenBrackets,
6292  Backslash,
6293  CloseBrackets,
6294  Caret,
6295  Underscore,
6296  Backtick,
6297 
6298  a,
6299  b,
6300  c,
6301  d,
6302  e,
6303  f,
6304  g,
6305  h,
6306  i,
6307  j,
6308  k,
6309  l,
6310  m,
6311  n,
6312  o,
6313  p,
6314  q,
6315  r,
6316  s,
6317  t,
6318  u,
6319  v,
6320  w,
6321  x,
6322  y,
6323  z,
6324 
6325  OpenBrace,
6326  VerticalBar,
6327  ClosingBrace,
6328  Tilde,
6329  Delete,
6330 
6331  Insert=1024,
6332  Home,
6333  End,
6334  PageUp,
6335  PageDown,
6336 
6337  Help,
6338 
6339  Left,
6340  Up,
6341  Right,
6342  Down,
6343 
6344  NumPad0,
6345  NumPad1,
6346  NumPad2,
6347  NumPad3,
6348  NumPad4,
6349  NumPad5,
6350  NumPad6,
6351  NumPad7,
6352  NumPad8,
6353  NumPad9,
6354 
6355  F1,
6356  F2,
6357  F3,
6358  F4,
6359  F5,
6360  F6,
6361  F7,
6362  F8,
6363  F9,
6364  F10,
6365  F11,
6366  F12,
6367  F13,
6368  F14,
6369  F15,
6370  F16,
6371  F17,
6372  F18,
6373  F19,
6374  F20,
6375  F21,
6376  F22,
6377  F23,
6378  F24,
6379 
6380  // these are not implemented
6381 // CapsLock, //!< The Caps Lock key.
6382 //
6383 // NumLock, //!< The Num Lock key.
6384 // ScrollLock, //!< The Scroll Lock key.
6385 // LeftShift, //!< The left Shift key.
6386 // RightShift, //!< The right Shift key.
6387 // LeftCtrl, //!< The left CTRL key.
6388 // RightCtrl, //!< The right CTRL key.
6389 // LeftAlt, //!< The left ALT key.
6390 // RightAlt, //!< The right ALT key.
6391 //
6392 // Select, //!< The Select key.
6393 // Print, //!< The Print key.
6394 // Execute, //!< The Execute key.
6395 // PrintScreen, //!< The Print Screen key.
6396 };
6397 
6398 
6400 class NO_HPS_API Touch
6401 {
6402 public:
6403 
6406  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6407 
6412  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6413  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6414 
6418  inline bool operator==(Touch const & in_that) const
6419  {
6420  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6421  }
6422 
6426  inline bool operator!=(Touch const & in_that) const
6427  {
6428  return !(*this == in_that);
6429  }
6430 
6431  TouchID ID;
6433  size_t TapCount;
6434 };
6435 
6436 
6437 typedef std::vector<Point, Allocator<Point> > PointArray;
6438 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6439 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6440 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6441 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6442 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6443 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6444 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6445 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6446 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6447 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6448 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6449 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6450 typedef std::vector<int, Allocator<int> > IntArray;
6451 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6452 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6453 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6454 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6455 typedef std::vector<float, Allocator<float> > FloatArray;
6456 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6457 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6458 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6459 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6460 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6461 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6462 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6463 typedef std::vector<bool, Allocator<bool> > BoolArray;
6464 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6465 typedef std::vector<Key, Allocator<Key> > KeyArray;
6466 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6467 typedef std::vector<char, Allocator<char> > CharArray;
6468 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6469 typedef std::vector<byte, Allocator<byte> > ByteArray;
6470 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6471 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6472 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6473 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6474 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6475 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6476 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6477 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6478 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6479 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6480 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6481 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6482 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6483 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6484 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6485 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6486 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6487 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6488 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6489 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6490 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6491 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6492 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6493 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6494 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6495 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6496 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6497 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6498 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6499 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6500 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6501 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6502 
6503 
6505 class HPS_API SearchResultsIterator : public Object
6506 {
6507 public:
6508 
6511 
6515  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6516 
6521 
6525  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6526 
6528 
6529  HPS::Type ObjectType() const {return HPS::Type::SearchResultsIterator;}
6530 
6535  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6536 
6541  void Set(SearchResultsIterator const & in_search_results_iterator);
6542 
6544  void Next();
6545 
6548  SearchResultsIterator & operator++();
6549 
6552  SearchResultsIterator operator++(int in_val);
6553 
6556  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6557 
6560  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6561 
6565  bool IsValid() const;
6566 
6568  void Reset();
6569 
6573  Key GetItem() const;
6574 
6577  Key operator*() const;
6578 
6581  SearchTypeArray GetResultTypes() const;
6582 };
6583 
6585 class HPS_API SearchResults : public Object
6586 {
6587 public:
6589  SearchResults();
6590 
6593  SearchResults(SearchResults const & in_search_results);
6594 
6598  SearchResults(SearchResults && in_that);
6599 
6603  SearchResults & operator=(SearchResults && in_that);
6604 
6606  virtual void Reset();
6607 
6609  ~SearchResults();
6610 
6611  HPS::Type ObjectType() const {return HPS::Type::SearchResults;}
6612 
6616  void Assign(SearchResults const & in_search_results);
6617 
6621  SearchResults & operator=(SearchResults const & in_search_results);
6622 
6625  size_t GetCount() const;
6626 
6629  SearchResultsIterator GetIterator() const;
6630 };
6631 
6633 class HPS_API FontSearchResultsIterator : public Object
6634 {
6635 public:
6636 
6639 
6643  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6644 
6649 
6654  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6655 
6656 
6660  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6661 
6663 
6664  HPS::Type ObjectType() const {return HPS::Type::FontSearchResultsIterator;}
6665 
6666 
6671  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6672 
6674  void Next();
6675 
6678  FontSearchResultsIterator & operator++();
6679 
6682  FontSearchResultsIterator operator++(int in_val);
6683 
6686  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6687 
6690  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6691 
6695  bool IsValid() const;
6696 
6698  void Reset();
6699 
6703  FontInfoState GetItem() const;
6704 
6707  FontInfoState operator*() const;
6708 
6709 };
6710 
6712 class HPS_API FontSearchResults : public Object
6713 {
6714 public:
6715 
6718 
6721  FontSearchResults(FontSearchResults const & in_search_results);
6722 
6727 
6731  FontSearchResults & operator=(FontSearchResults && in_that);
6732 
6734  virtual void Reset();
6735 
6737  ~FontSearchResults();
6738 
6739  HPS::Type ObjectType() const {return HPS::Type::FontSearchResults;}
6740 
6744  void Assign(FontSearchResults const & in_search_results);
6745 
6746 
6750  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6751 
6754  size_t GetCount() const;
6755 
6758  FontSearchResultsIterator GetIterator() const;
6759 };
6760 
6762 class HPS_API UTF8
6763 {
6764 public:
6765 
6767  UTF8();
6768 
6770  ~UTF8();
6771 
6778  UTF8(char const * in_string, char const * in_locale = 0);
6779 
6782  UTF8(wchar_t const * in_string);
6783 
6786  UTF8(UTF8 const & in_that);
6787 
6790  UTF8(UTF8 && in_that);
6791 
6795  UTF8 & Assign(UTF8 && in_utf8);
6796 
6799  inline UTF8 & operator= (UTF8 && in_utf8)
6800  {
6801  return Assign(std::move(in_utf8));
6802  }
6803 
6808  size_t ToWStr(wchar_t * out_wide_string) const;
6809 
6813  size_t ToWStr(WCharArray & out_wide_string) const;
6814 
6817  inline bool IsValid() const
6818  {
6819  return (_length > 0);
6820  }
6821 
6824  inline bool Empty() const
6825  {
6826  return (_length == 0);
6827  }
6828 
6830  void Clear();
6831 
6833  void Reset() { Clear(); }
6834 
6838  inline size_t GetLength() const
6839  {
6840  return _length;
6841  }
6842 
6846  inline size_t GetWStrLength() const
6847  {
6848  return ToWStr(0);
6849  }
6850 
6853  inline char const * GetBytes() const
6854  {
6855  return _text;
6856  }
6857 
6860  inline operator char const * () const
6861  {
6862  return _text;
6863  }
6864 
6867  char At(size_t in_index) const
6868  {
6869  if(!IsValid())
6870  throw InvalidObjectException();
6871  else if(in_index >= _length)
6872  throw IndexOutOfRangeException();
6873  else
6874  return _text[in_index];
6875  }
6876 
6880  UTF8 & Assign(UTF8 const & in_utf8);
6881 
6885  inline UTF8 & operator= (UTF8 const & in_utf8)
6886  {
6887  return Assign(in_utf8);
6888  }
6889 
6893  UTF8 & operator+= (UTF8 const & in_utf8);
6894 
6898  UTF8 & operator+= (char const * in_utf8);
6899 
6903  UTF8 operator+ (UTF8 const & in_utf8) const;
6904 
6908  UTF8 operator+ (char const * in_utf8) const;
6909 
6913  bool operator== (UTF8 const & in_utf8) const;
6914 
6918  bool operator!= (UTF8 const & in_utf8) const
6919  {
6920  return !(*this == in_utf8);
6921  }
6922 
6926  bool operator== (char const * in_utf8) const;
6927 
6931  bool operator!= (char const * in_utf8) const
6932  {
6933  return !(*this == in_utf8);
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!=(char const * in_left, UTF8 const & in_right)
6950  {
6951  return in_right != in_left;
6952  }
6953 
6958  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
6959  {
6960  return in_right == UTF8(in_left);
6961  }
6962 
6967  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
6968  {
6969  return in_right != UTF8(in_left);
6970  }
6971 
6976  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
6977  {
6978  return UTF8(in_left) + in_right;
6979  }
6980 
6985  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
6986  {
6987  return UTF8(in_left) + in_right;
6988  }
6989 
6990 
6993  size_t GetHash() const;
6994 
6995 private:
6996 
6997  size_t internal_encode(wchar_t const * in_wide_string);
6998  size_t internal_decode(wchar_t * out_wide_string) const;
6999 
7000  char * _text;
7001  size_t _length;
7002  mutable size_t _hash_key;
7003  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7004  char _buffer[_buffer_size];
7005 };
7006 
7008 struct UTF8Hasher {
7009  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7010  {
7011  return in_utf8.GetHash();
7012  }
7013 };
7014 
7017 class HPS_API Condition : public Object
7018 {
7019 public:
7020 
7021  enum class Intrinsic
7022  {
7023  Extent,
7024  DrawPass
7025  };
7026 
7028  Condition();
7029 
7032  Condition(char const * in_utf8);
7033 
7036  Condition(float in_number);
7037 
7040  Condition(HPS::Condition::Intrinsic in_special);
7041 
7044  Condition(Condition const & in_that);
7045 
7049  Condition(Condition && in_that);
7050 
7054  Condition & operator=(Condition && in_that);
7055 
7056  HPS::Type ObjectType() const { return HPS::Type::Condition; }
7057 
7061  bool ShowCondition(UTF8 & out_condition) const;
7062 
7066  bool ShowNumber(float & out_number) const;
7067 
7071  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7072 
7076  bool ShowOperands(ConditionArray & out_operands) const;
7077 
7081  Condition & operator=(Condition const & in_that);
7082 
7086  bool Equals(Condition const & in_that) const;
7087 
7091  bool operator==(Condition const & in_that) const;
7092 
7096  bool operator!=(Condition const & in_that) const;
7097 
7101  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7102 
7106  bool IsSatisfiedBy(char const * in_condition) const;
7107 
7111  Condition OR(Condition const & in_operand2) const;
7112 
7116  Condition XOR(Condition const & in_operand2) const;
7117 
7121  Condition AND(Condition const & in_operand2) const;
7122 
7126  Condition EQ(Condition const & in_operand2) const;
7127 
7131  Condition NEQ(Condition const & in_operand2) const;
7132 
7136  Condition GT(Condition const & in_operand2) const;
7137 
7141  Condition LT(Condition const & in_operand2) const;
7142 
7146  Condition GTEQ(Condition const & in_operand2) const;
7147 
7151  Condition LTEQ(Condition const & in_operand2) const;
7152 
7155  Condition operator !() const;
7156 
7160  Condition operator ||(Condition const & in_operand2) const;
7161 
7165  Condition operator ^(Condition const & in_operand2) const;
7166 
7170  Condition operator &&(Condition const & in_operand2) const;
7171 
7172 
7176  static Condition NOT(Condition const & in_operand);
7177 
7182  static Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7183 
7184 
7189  static Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7190 
7195  static Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7196 
7201  static Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7202 
7207  static Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7208 
7213  static Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7214 
7219  static Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7220 
7225  static Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7226 
7231  static Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7232 
7233  friend HPS_API Condition NOT(Condition const & in_operand);
7234  friend HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7235  friend HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7236  friend HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7237 
7238  friend HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7239  friend HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7240  friend HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7241  friend HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7242  friend HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7243  friend HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7244 };
7245 
7246 
7250 HPS_API Condition NOT(Condition const & in_operand);
7251 
7256 HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7257 
7262 HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7263 
7268 HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7269 
7274 HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7275 
7280 HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7281 
7286 HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7287 
7292 HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7293 
7298 HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7299 
7304 HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7305 
7306 
7307 
7311 class HPS_API Key : public Object
7312 {
7313 public:
7314 
7316  Key();
7317 
7319  Key(Key const & in_that);
7320 
7322  explicit Key(Control const & in_control);
7323 
7327  Key(Key && in_that);
7328 
7332  Key & operator=(Key && in_that);
7333 
7335  virtual ~Key();
7336 
7337  HPS::Type ObjectType() const {return HPS::Type::Key;};
7338 
7340  bool HasOwner() const;
7341 
7343  SegmentKey Up() const;
7344 
7346  SegmentKey Owner() const;
7347 
7349  void Delete();
7350 
7352  void MoveTo(SegmentKey const & in_new_owner);
7353 
7356  Key CopyTo(SegmentKey const & in_destination) const;
7357 
7359  Key & operator=(Key const & in_that);
7360 
7362  virtual void Assign(Key const & in_that);
7363 
7365  bool Equals(Key const & in_that) const;
7366 
7368  bool operator!= (Key const & in_that) const;
7369 
7371  bool operator== (Key const & in_that) const;
7372 
7375  size_t GetHash() const;
7376 };
7377 
7379 struct KeyHasher {
7380  inline size_t operator()(const HPS::Key & in_key) const
7381  {
7382  return in_key.GetHash();
7383  }
7384 };
7385 
7386 
7389 class HPS_API SegmentKey : public Key
7390 {
7391 public:
7393  SegmentKey();
7394 
7396  SegmentKey(SegmentKey const & in_that);
7397 
7399  SegmentKey & operator=(SegmentKey const & other);
7400 
7404  SegmentKey(SegmentKey && in_that);
7405 
7409  SegmentKey & operator=(SegmentKey && in_that);
7410 
7412  explicit SegmentKey(Key const & in_that);
7413 
7415  ~SegmentKey();
7416 
7417  HPS::Type ObjectType() const {return HPS::Type::SegmentKey;};
7418 
7420  UTF8 Name() const;
7421 
7424  SegmentKey & SetName(char const * in_name);
7425 
7428  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7429 
7432  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7433 
7435  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7436 
7438  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7439 
7441  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7442 
7443 
7444 
7446  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7447 
7449  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7450 
7452  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7453 
7454 
7456  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7457 
7459  size_t Find(SearchOptionsKit const & in_options) const;
7460 
7461 
7464  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7465 
7469  IncludeKey IncludeSegment(SegmentKey const & in_seg, Condition const & in_condition);
7470 
7471 
7477  ReferenceKey ReferenceGeometry(Key const & in_key);
7478 
7486  ReferenceKey ReferenceGeometry(Key const & in_key, Condition const & in_condition);
7487 
7488 
7490  size_t ShowSubsegments() const;
7491 
7493  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7494 
7498  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7499 
7503  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7504 
7508  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7509 
7513  size_t ShowStylers(StyleKeyArray & out_styles) const;
7514 
7518  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7519 
7523  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7524 
7525 
7526 
7528  StyleControl GetStyleControl();
7529 
7531  StyleControl const GetStyleControl() const;
7532 
7533 
7535  PortfolioControl GetPortfolioControl();
7536 
7538  PortfolioControl const GetPortfolioControl() const;
7539 
7540 
7542  SegmentKey & SetCondition(char const * in_condition);
7543 
7545  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7546 
7548  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7549 
7551  SegmentKey & UnsetConditions();
7552 
7554  bool ShowConditions(UTF8Array & out_conditions) const;
7555 
7557  ConditionControl GetConditionControl();
7558 
7560  ConditionControl const GetConditionControl() const;
7561 
7562 
7564  SegmentKey & SetMaterialPalette(char const * in_name);
7565 
7567  SegmentKey & UnsetMaterialPalette();
7568 
7570  bool ShowMaterialPalette(UTF8 & out_name) const;
7571 
7572 
7579  SegmentKey & SetPriority(int in_priority);
7580 
7583  SegmentKey & UnsetPriority();
7584 
7588  bool ShowPriority(int & out_priority) const;
7589 
7594  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7595 
7601  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7602 
7607  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7608 
7612  SegmentKey & UnsetUserData(intptr_t in_index);
7613 
7618  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7619 
7623  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
7624 
7627  SegmentKey & UnsetAllUserData();
7628 
7630  size_t ShowUserDataCount() const;
7631 
7636  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
7637 
7641  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7642 
7647  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7648 
7649 
7651  LineKey InsertLine(LineKit const & in_kit);
7652 
7654  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7655 
7657  LineKey InsertLine(PointArray const & in_pts);
7658 
7660  LineKey InsertLine(Point const & pt1, Point const & pt2);
7661 
7662 
7664  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7665 
7667  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);
7668 
7670  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7671 
7673  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7674 
7675 
7680  SphereKey InsertSphere(SphereKit const & in_kit);
7681 
7689  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));
7690 
7692  CircleKey InsertCircle(CircleKit const & in_kit);
7693 
7695  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7696 
7698  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7699 
7700 
7702  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7703 
7705  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7706 
7707 
7709  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7710 
7712  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7713 
7714 
7716  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7717 
7719  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7720 
7721 
7723  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7724 
7726  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float start, float end);
7727 
7728 
7730  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7731 
7733  PolygonKey InsertPolygon(PointArray const & in_pts);
7734 
7736  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7737 
7738 
7740  ShellKey InsertShell(ShellKit const & in_kit);
7741 
7743  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7744 
7746  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7747 
7749  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
7750 
7752  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
7753 
7755  MeshKey InsertMesh(MeshKit const & in_kit);
7756 
7758  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7759 
7761  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7762 
7763 
7765  MarkerKey InsertMarker(Point const & in_position);
7766 
7768  MarkerKey InsertMarker(MarkerKit const & in_kit);
7769 
7770 
7772  DistantLightKey InsertDistantLight(Vector const & in_direction);
7773 
7775  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7776 
7777 
7779  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7780 
7782  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7783 
7785  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7786 
7788  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7789 
7790 
7792  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7793 
7795  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7796 
7797 
7799  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7800 
7802  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7803 
7804 
7806  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7807 
7809  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);
7810 
7812  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);
7813 
7814 
7816  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7817 
7819  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);
7820 
7822  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[]);
7823 
7825  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);
7826 
7828  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[]);
7829 
7830 
7832  TextKey InsertText(TextKit const & in_kit);
7833 
7839  TextKey InsertText(Point const & in_position, char const * in_text);
7840 
7841 
7842 
7844  GridKey InsertGrid(GridKit const & in_kit);
7845 
7847  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);
7848 
7849 
7850 
7858  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7859 
7867  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7868 
7876  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7877 
7885  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7886 
7894  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7895 
7903  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7904 
7909  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7910 
7915  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7916 
7921  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7922 
7927  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7928 
7933  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7934 
7939  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7940 
7941 
7943  SegmentKey & SetAttributeLocks(AttributeLockKit const & in_kit);
7944 
7946  SegmentKey & UnsetAttributeLocks();
7947 
7951  bool ShowAttributeLocks(AttributeLockKit & out_kit) const;
7952 
7954  AttributeLockControl GetAttributeLockControl();
7955 
7957  AttributeLockControl const GetAttributeLockControl() const;
7958 
7959 
7961  SegmentKey & SetBoundings(BoundingKit const & in_kit);
7962 
7964  SegmentKey & UnsetBoundings();
7965 
7969  bool ShowBoundings(BoundingKit & out_kit) const;
7970 
7972  BoundingControl GetBoundingControl();
7973 
7975  BoundingControl const GetBoundingControl() const;
7976 
7977 
7979  SegmentKey & SetCamera(CameraKit const & in_kit);
7980 
7982  SegmentKey & UnsetCamera();
7983 
7985  bool ShowCamera(CameraKit & out_kit) const;
7986 
7988  CameraControl GetCameraControl();
7989 
7991  CameraControl const GetCameraControl() const;
7992 
7994  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
7995 
7997  SegmentKey & UnsetColorInterpolation();
7998 
8000  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
8001 
8003  ColorInterpolationControl GetColorInterpolationControl();
8004 
8006  ColorInterpolationControl const GetColorInterpolationControl() const;
8007 
8008 
8010  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8011 
8013  SegmentKey & UnsetContourLine();
8014 
8016  bool ShowContourLine(ContourLineKit & out_kit) const;
8017 
8019  ContourLineControl GetContourLineControl();
8020 
8022  ContourLineControl const GetContourLineControl() const;
8023 
8024 
8026  SegmentKey & SetCulling(CullingKit const & in_kit);
8027 
8029  SegmentKey & UnsetCulling();
8030 
8034  bool ShowCulling(CullingKit & out_kit) const;
8035 
8037  CullingControl GetCullingControl();
8038 
8040  CullingControl const GetCullingControl() const;
8041 
8042 
8044  SegmentKey & SetCurveAttributes(CurveAttributeKit const & in_kit);
8045 
8047  SegmentKey & UnsetCurveAttributes();
8048 
8050  bool ShowCurveAttributes(CurveAttributeKit & out_kit) const;
8051 
8053  CurveAttributeControl GetCurveAttributeControl();
8054 
8056  CurveAttributeControl const GetCurveAttributeControl() const;
8057 
8058 
8060  SegmentKey & SetCuttingSectionAttributes(CuttingSectionAttributeKit const & in_kit);
8061 
8063  SegmentKey & UnsetCuttingSectionAttributes();
8064 
8066  bool ShowCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
8067 
8069  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8070 
8072  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8073 
8074 
8076  SegmentKey & SetCylinderAttributes(CylinderAttributeKit const & in_kit);
8077 
8079  SegmentKey & UnsetCylinderAttributes();
8080 
8082  bool ShowCylinderAttributes(CylinderAttributeKit & out_kit) const;
8083 
8085  CylinderAttributeControl GetCylinderAttributeControl();
8086 
8088  CylinderAttributeControl const GetCylinderAttributeControl() const;
8089 
8090 
8092  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8093 
8095  SegmentKey & UnsetDrawingAttribute();
8096 
8098  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8099 
8101  DrawingAttributeControl GetDrawingAttributeControl();
8102 
8104  DrawingAttributeControl const GetDrawingAttributeControl() const;
8105 
8106 
8108  SegmentKey & SetEdgeAttributes(EdgeAttributeKit const & in_kit);
8109 
8111  SegmentKey & UnsetEdgeAttributes();
8112 
8114  bool ShowEdgeAttributes(EdgeAttributeKit & out_kit) const;
8115 
8117  EdgeAttributeControl GetEdgeAttributeControl();
8118 
8120  EdgeAttributeControl const GetEdgeAttributeControl() const;
8121 
8122 
8124  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8125 
8127  SegmentKey & UnsetHiddenLineAttribute();
8128 
8130  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8131 
8133  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8134 
8136  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8137 
8138 
8140  SegmentKey & SetLightingAttributes(LightingAttributeKit const & in_kit);
8141 
8143  SegmentKey & UnsetLightingAttributes();
8144 
8146  bool ShowLightingAttributes(LightingAttributeKit & out_kit) const;
8147 
8149  LightingAttributeControl GetLightingAttributeControl();
8150 
8152  LightingAttributeControl const GetLightingAttributeControl() const;
8153 
8154 
8156  SegmentKey & SetLineAttributes(LineAttributeKit const & in_kit);
8157 
8159  SegmentKey & UnsetLineAttributes();
8160 
8162  bool ShowLineAttributes(LineAttributeKit & out_kit) const;
8163 
8165  LineAttributeControl GetLineAttributeControl();
8166 
8168  LineAttributeControl const GetLineAttributeControl() const;
8169 
8170 
8172  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8173 
8175  SegmentKey & UnsetMaterialMapping();
8176 
8178  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8179 
8181  MaterialMappingControl GetMaterialMappingControl();
8182 
8184  MaterialMappingControl const GetMaterialMappingControl() const;
8185 
8186 
8188  SegmentKey & SetMarkerAttributes(MarkerAttributeKit const & in_kit);
8189 
8191  SegmentKey & UnsetMarkerAttributes();
8192 
8194  bool ShowMarkerAttributes(MarkerAttributeKit & out_kit) const;
8195 
8197  MarkerAttributeControl GetMarkerAttributeControl();
8198 
8200  MarkerAttributeControl const GetMarkerAttributeControl() const;
8201 
8202 
8204  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8205 
8207  SegmentKey & UnsetModellingMatrix();
8208 
8210  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8211 
8213  ModellingMatrixControl GetModellingMatrixControl();
8214 
8216  ModellingMatrixControl const GetModellingMatrixControl() const;
8217 
8218 
8220  SegmentKey & SetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit const & in_kit);
8221 
8223  SegmentKey & UnsetNURBSSurfaceAttributes();
8224 
8226  bool ShowNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
8227 
8229  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8230 
8232  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8233 
8234 
8236  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8237 
8239  SegmentKey & UnsetPerformance();
8240 
8242  bool ShowPerformance(PerformanceKit & out_kit) const;
8243 
8245  PerformanceControl GetPerformanceControl();
8246 
8248  PerformanceControl const GetPerformanceControl() const;
8249 
8250 
8252  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8253 
8255  SegmentKey & UnsetSelectability();
8256 
8260  bool ShowSelectability(SelectabilityKit & out_kit) const;
8261 
8263  SelectabilityControl GetSelectabilityControl();
8264 
8266  SelectabilityControl const GetSelectabilityControl() const;
8267 
8268 
8270  SegmentKey & SetSphereAttributes(SphereAttributeKit const & in_kit);
8271 
8273  SegmentKey & UnsetSphereAttributes();
8274 
8278  bool ShowSphereAttributes(SphereAttributeKit & out_kit) const;
8279 
8281  SphereAttributeControl GetSphereAttributeControl();
8282 
8284  SphereAttributeControl const GetSphereAttributeControl() const;
8285 
8286 
8288  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8289 
8291  SegmentKey & UnsetSubwindow();
8292 
8296  bool ShowSubwindow(SubwindowKit & out_kit) const;
8297 
8299  SubwindowControl GetSubwindowControl();
8300 
8302  SubwindowControl const GetSubwindowControl() const;
8303 
8304 
8306  SegmentKey & SetTextAttributes(TextAttributeKit const & in_kit);
8307 
8309  SegmentKey & UnsetTextAttributes();
8310 
8312  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
8313 
8315  TextAttributeControl GetTextAttributeControl();
8316 
8318  TextAttributeControl const GetTextAttributeControl() const;
8319 
8320 
8322  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8323 
8325  SegmentKey & UnsetTextureMatrix();
8326 
8330  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8331 
8333  TextureMatrixControl GetTextureMatrixControl();
8334 
8336  TextureMatrixControl const GetTextureMatrixControl() const;
8337 
8339  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8340 
8342  SegmentKey & UnsetTransformMask();
8343 
8347  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8348 
8350  TransformMaskControl GetTransformMaskControl();
8351 
8353  TransformMaskControl const GetTransformMaskControl() const;
8354 
8355 
8357  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8358 
8360  SegmentKey & UnsetTransparency();
8361 
8365  bool ShowTransparency(TransparencyKit & out_kit) const;
8366 
8368  TransparencyControl GetTransparencyControl();
8369 
8371  TransparencyControl const GetTransparencyControl() const;
8372 
8373 
8375  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8376 
8378  SegmentKey & UnsetVisibility();
8379 
8383  bool ShowVisibility(VisibilityKit & out_kit) const;
8384 
8386  VisibilityControl GetVisibilityControl();
8387 
8389  VisibilityControl const GetVisibilityControl() const;
8390 
8391 
8393  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8394 
8396  SegmentKey & UnsetVisualEffects();
8397 
8401  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8402 
8404  VisualEffectsControl GetVisualEffectsControl();
8405 
8407  VisualEffectsControl const GetVisualEffectsControl() const;
8408 
8409  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8410 };
8411 
8412 
8415 {
8416 public:
8417 
8420 
8424 
8428 
8429  virtual ~SegmentOptimizationOptionsKit();
8430 
8431  HPS::Type ObjectType() const { return HPS::Type::SegmentOptimizationOptionsKit; }
8432 
8435  void Consume(SegmentOptimizationOptionsKit & in_kit);
8436 
8439  void Set(SegmentOptimizationOptionsKit const & in_kit);
8440 
8443  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8444 
8449 
8454 
8457  bool Empty() const;
8458 
8462  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8463 
8467  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8468 
8472  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8473 
8477  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8478 
8482  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8483 
8487  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8488 
8492  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8493 
8497  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8498 
8502  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8503 
8507  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8508 
8512  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8513 
8515  SegmentOptimizationOptionsKit & UnsetUserData();
8516 
8518  SegmentOptimizationOptionsKit & UnsetMatrix();
8519 
8521  SegmentOptimizationOptionsKit & UnsetExpansion();
8522 
8524  SegmentOptimizationOptionsKit & UnsetScope();
8525 
8527  SegmentOptimizationOptionsKit & UnsetReorganization();
8528 
8530  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8531 
8533  SegmentOptimizationOptionsKit & UnsetShellMerging();
8534 
8536  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8537 
8540  SegmentOptimizationOptionsKit & UnsetEverything();
8541 
8542  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8543 
8544  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8545 
8546  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8547 
8548  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8549 
8550  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8551 
8552  bool ShowShellInstancing(bool & out_shell_instancing) const;
8553 
8554  bool ShowShellMerging(bool & out_shell_merging) const;
8555 
8556  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
8557 };
8558 
8559 
8561 class HPS_API Coordinate
8562 {
8563 public:
8564 
8568  enum class Space
8569  {
8570  Object,
8571  World,
8572  Camera,
8573  Normalized,
8574  ScreenRange,
8575  InnerWindow,
8576  InnerPixel,
8577  Window,
8578  Pixel,
8579  };
8580 
8581 private:
8582  Coordinate();
8583 };
8584 
8585 
8586 
8587 
8590 class HPS_API UpdateNotifier : public Object
8591 {
8592 public:
8593 
8594  UpdateNotifier();
8595 
8596  UpdateNotifier(UpdateNotifier const & in_that);
8597 
8601  UpdateNotifier(UpdateNotifier && in_that);
8602 
8606  UpdateNotifier & operator=(UpdateNotifier && in_that);
8607 
8608  virtual ~UpdateNotifier();
8609 
8610  HPS::Type ObjectType() const {return HPS::Type::UpdateNotifier;};
8611 
8613  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8614 
8616  void Assign(UpdateNotifier const & in_that);
8617 
8618  void Wait() const;
8619 
8620  Window::UpdateStatus Status() const;
8621 
8622 };
8623 
8626 class HPS_API DriverEvent
8627 {
8628 public:
8629 
8630  virtual ~DriverEvent() {}
8631 
8633  intptr_t GetClassID() const;
8634 
8635 protected:
8636 
8637  DriverEvent(OpaqueHandle in_nr) : nr(in_nr)
8638  {
8639 
8640  }
8641 
8642  OpaqueHandle nr;
8643 };
8644 
8647 class HPS_API FinishPictureEvent : public DriverEvent
8648 {
8649 public:
8650 
8651  FinishPictureEvent(OpaqueHandle in_nr = 0);
8652 };
8653 
8655 class HPS_API DrawWindowEvent : public DriverEvent
8656 {
8657 public:
8658 
8659  DrawWindowEvent(OpaqueHandle in_nr = 0);
8660 
8662  Rectangle Extent;
8663 
8668  void DrawTexturedBackground(OpaqueHandle in_texture, MatrixKit const & in_matrix, Rectangle const & in_extent) const;
8669 
8670 private:
8671 
8672  mutable HPS::FloatArray matrix_elements;
8673 };
8674 
8676 class HPS_API DriverEventHandler : public Object
8677 {
8678 public:
8679 
8680  HPS::Type ObjectType() const OVERRIDE { return HPS::Type::DriverEventHandler; };
8681 
8683 
8684  DriverEventHandler(DriverEventHandler const & that);
8685 
8686  virtual ~DriverEventHandler();
8687 
8691  virtual void Handle(DriverEvent const * in_event)
8692  {
8693  HPS_UNREFERENCED(in_event);
8694  }
8695 };
8696 
8697 
8701 class HPS_API WindowKey : public SegmentKey
8702 {
8703 public:
8704 
8706  WindowKey();
8707 
8709  WindowKey(WindowKey const & in_window);
8710 
8712  WindowKey & operator=(WindowKey const & other);
8713 
8717  WindowKey(WindowKey && in_that);
8718 
8722  WindowKey & operator=(WindowKey && in_that);
8723 
8725  WindowKey(Key const & in_key);
8726 
8728  ~WindowKey();
8729 
8730  HPS::Type ObjectType() const {return HPS::Type::WindowKey;};
8731 
8733  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8734 
8739  size_t FindFonts(FontSearchResults & out_results) const;
8740 
8742  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8743 
8745  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8746 
8748  PostProcessEffectsControl GetPostProcessEffectsControl();
8749 
8751  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8752 
8753 
8755  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8756 
8760  WindowKey & SetDriverEventHandler(DriverEventHandler const & in_handler, intptr_t in_type);
8761 
8764  WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8765 
8769  bool ShowDebugging(DebuggingKit & out_kit) const;
8770 
8772  DebuggingControl GetDebuggingControl();
8773 
8775  DebuggingControl const GetDebuggingControl() const;
8776 
8778  WindowInfoControl const GetWindowInfoControl() const;
8779 
8780  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8781 
8783  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8784 
8786  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8787 
8789  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
8790 
8792  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
8793 
8794 
8796  SelectionOptionsControl GetSelectionOptionsControl();
8797 
8799  SelectionOptionsControl const GetSelectionOptionsControl() const;
8800 
8801 
8803  SelectionControl GetSelectionControl();
8804 
8806  SelectionControl const GetSelectionControl() const;
8807 
8809  HighlightControl GetHighlightControl();
8810 
8812  HighlightControl const GetHighlightControl() const;
8813 
8815  UpdateOptionsControl GetUpdateOptionsControl();
8816 
8818  UpdateOptionsControl const GetUpdateOptionsControl() const;
8819 
8821  void Update();
8822 
8827  void Update(UpdateOptionsKit const & in_kit);
8828 
8843  void Update(Window::UpdateControl in_control, Time in_time_limit=-1);
8844 
8848  UpdateNotifier UpdateWithNotifier();
8849 
8853  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
8854 
8860  UpdateNotifier UpdateWithNotifier(Window::UpdateControl in_control, Time in_time_limit=-1);
8861 
8863  EventDispatcher & GetEventDispatcher();
8864 
8866  EventDispatcher const & GetEventDispatcher() const;
8867 
8871  bool ShowSnapshot(ImageKit & out_kit) const;
8872 
8873 private:
8874 
8876  SegmentKey & UnsetAttributeLocks();
8877  SegmentKey & UnsetCamera();
8878  SegmentKey & UnsetColorInterpolation();
8879  SegmentKey & UnsetContourLine();
8880  SegmentKey & UnsetCulling();
8881  SegmentKey & UnsetCurveAttributes();
8882  SegmentKey & UnsetCuttingSectionAttributes();
8883  SegmentKey & UnsetCylinderAttributes();
8884  SegmentKey & UnsetDrawingAttribute();
8885  SegmentKey & UnsetEdgeAttributes();
8886  SegmentKey & UnsetHiddenLineAttribute();
8887  SegmentKey & UnsetLightingAttributes();
8888  SegmentKey & UnsetLineAttributes();
8889  SegmentKey & UnsetMaterialMapping();
8890  SegmentKey & UnsetMarkerAttributes();
8891  SegmentKey & UnsetModellingMatrix();
8892  SegmentKey & UnsetNURBSSurfaceAttributes();
8893  SegmentKey & UnsetPerformance();
8894  SegmentKey & UnsetSelectability();
8895  SegmentKey & UnsetSphereAttributes();
8896  SegmentKey & UnsetSubwindow();
8897  SegmentKey & UnsetTextAttributes();
8898  SegmentKey & UnsetTextureMatrix();
8899  SegmentKey & UnsetTransformMask();
8900  SegmentKey & UnsetTransparency();
8901  SegmentKey & UnsetVisibility();
8902  SegmentKey & UnsetVisualEffects();
8903 
8905  void MoveTo(SegmentKey const & in_new_owner);
8906 
8908  Key CopyTo(SegmentKey const & in_destination) const;
8909 };
8910 
8911 
8912 
8915 class HPS_API KeyPath : public Object
8916 {
8917 public:
8918 
8920  KeyPath();
8921 
8924  KeyPath(KeyArray const & in_path);
8925 
8929  KeyPath(size_t in_path_count, Key const in_path []);
8930 
8932  KeyPath(KeyPath const & in_that);
8933 
8937  KeyPath(KeyPath && in_that);
8938 
8942  KeyPath & operator=(KeyPath && in_that);
8943 
8945  virtual ~KeyPath();
8946 
8947  HPS::Type ObjectType() const { return HPS::Type::KeyPath; }
8948 
8952  KeyPath & operator+=(Key const & in_key);
8953 
8957  KeyPath & operator+=(KeyPath const & in_key_path);
8958 
8962  KeyPath & operator+=(KeyArray const & in_key_array);
8963 
8967  KeyPath & Append(Key const & in_key);
8968 
8972  KeyPath & Append(KeyPath const & in_key_path);
8973 
8977  KeyPath & Append(KeyArray const & in_key_array);
8978 
8982  KeyPath & operator=(KeyPath const & in_that);
8983 
8987  KeyPath & operator=(KeyArray const & in_path);
8988 
8991  void Set(KeyPath const & in_that);
8992 
8996  bool Equals(KeyPath const & in_that) const;
8997 
9001  bool operator!= (KeyPath const & in_that) const;
9002 
9006  bool operator== (KeyPath const & in_that) const;
9007 
9008 
9012  KeyPath & SetKeys(KeyArray const & in_keys);
9013 
9018  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
9019 
9020 
9023  KeyPath & UnsetKeys();
9024 
9025 
9028  bool ShowKeys(KeyArray & out_keys) const;
9029 
9030 
9037  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9038 
9045  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
9046 
9052  bool ComputeTextExtent(const char* in_text, float & out_xfrac, float & out_yfrac) const;
9053 
9054 
9060  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
9061 
9062 
9065  bool ShowNetVisibility(VisibilityKit & out_kit) const;
9066 
9069  bool ShowNetBounding(BoundingKit & out_kit) const;
9070 
9073  bool ShowNetCamera(CameraKit & out_kit) const;
9074 
9077  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
9078 
9081  bool ShowNetContourLine(ContourLineKit & out_kit) const;
9082 
9085  bool ShowNetPerformance(PerformanceKit & out_kit) const;
9086 
9089  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9090 
9093  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9094 
9097  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9098 
9101  bool ShowNetMarkerAttributes(MarkerAttributeKit & out_kit) const;
9102 
9105  bool ShowNetSphereAttributes(SphereAttributeKit & out_kit) const;
9106 
9109  bool ShowNetLightingAttributes(LightingAttributeKit & out_kit) const;
9110 
9113  bool ShowNetCylinderAttributes(CylinderAttributeKit & out_kit) const;
9114 
9117  bool ShowNetCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
9118 
9121  bool ShowNetTextAttributes(TextAttributeKit & out_kit) const;
9122 
9125  bool ShowNetLineAttributes(LineAttributeKit & out_kit) const;
9126 
9129  bool ShowNetEdgeAttributes(EdgeAttributeKit & out_kit) const;
9130 
9133  bool ShowNetCurveAttributes(CurveAttributeKit & out_kit) const;
9134 
9137  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9138 
9141  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9142 
9145  bool ShowNetCulling(CullingKit & out_kit) const;
9146 
9149  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9150 
9153  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9154 
9157  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9158 
9161  bool ShowNetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
9162 
9165  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9166 
9169  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9170 
9173  bool ShowNetAttributeLocks(AttributeLockKit & out_kit) const;
9174 
9177  bool ShowNetConditions(UTF8Array & out_conditions) const;
9178 
9184  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9185 
9186 };
9187 
9188 
9193 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9194 {
9195  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9196 }
9197 
9202 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9203 {
9204  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9205 }
9206 
9211 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9212 {
9213  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9214 }
9215 
9220 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9221 {
9222  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9223 }
9224 
9229 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9230 {
9231  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9232 }
9233 
9238 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9239 {
9240  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9241 }
9242 
9247 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9248 {
9249  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9250 }
9251 
9256 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9257 {
9258  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9259 }
9260 
9265 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9266 {
9267  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9268 }
9269 
9270 
9274 
9276 class HPS_API BoundingKit : public Object
9277 {
9278 public:
9279 
9281  BoundingKit();
9282 
9285  BoundingKit(BoundingKit const & in_kit);
9286 
9290  BoundingKit(BoundingKit && in_that);
9291 
9295  BoundingKit & operator=(BoundingKit && in_that);
9296 
9298  virtual ~BoundingKit();
9299 
9300  HPS::Type ObjectType() const {return HPS::Type::BoundingKit;};
9301 
9305  static BoundingKit GetDefault();
9306 
9309  void Set(BoundingKit const & in_kit);
9310 
9313  void Show(BoundingKit & out_kit) const;
9314 
9318  BoundingKit & operator=(BoundingKit const & in_kit);
9319 
9322  bool Empty() const;
9323 
9327  bool Equals(BoundingKit const & in_kit) const;
9328 
9332  bool operator==(BoundingKit const & in_kit) const;
9333 
9337  bool operator!=(BoundingKit const & in_kit) const;
9338 
9339 
9343  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
9344 
9348  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
9349 
9353  BoundingKit & SetExclusion(bool in_exclude);
9354 
9355 
9358  BoundingKit & UnsetVolume();
9359 
9362  BoundingKit & UnsetExclusion();
9363 
9366  BoundingKit & UnsetEverything();
9367 
9368 
9373  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9374 
9378  bool ShowExclusion(bool & out_exclusion) const;
9379 
9380 };
9381 
9382 
9385 class HPS_API BoundingControl : public Control
9386 {
9387 public:
9388 
9390  explicit BoundingControl(SegmentKey & in_seg);
9391 
9393  BoundingControl(BoundingControl const & in_that);
9394 
9398  BoundingControl(BoundingControl && in_that);
9399 
9403  BoundingControl & operator=(BoundingControl && in_that);
9404 
9406  ~BoundingControl();
9407 
9408  HPS::Type ObjectType() const {return HPS::Type::BoundingControl;};
9409 
9411  BoundingControl & operator=(BoundingControl const & in_that);
9412 
9417  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
9418 
9422  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
9423 
9427  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
9428 
9432  BoundingControl & SetExclusion(bool in_exclusion);
9433 
9434 
9437  BoundingControl & UnsetVolume();
9438 
9441  BoundingControl & UnsetExclusion();
9442 
9445  BoundingControl & UnsetEverything();
9446 
9447 
9452  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9453 
9457  bool ShowExclusion(bool & out_exclusion) const;
9458 
9459 private:
9461  BoundingControl();
9462 };
9463 
9464 
9466 class HPS_API VisibilityKit : public Object
9467 {
9468 public:
9469 
9471  VisibilityKit();
9472 
9475  VisibilityKit(VisibilityKit const & in_kit);
9476 
9480  VisibilityKit(VisibilityKit && in_that);
9481 
9485  VisibilityKit & operator=(VisibilityKit && in_that);
9486 
9488  virtual ~VisibilityKit();
9489 
9490  HPS::Type ObjectType() const {return HPS::Type::VisibilityKit;};
9491 
9495  static VisibilityKit GetDefault();
9496 
9499  void Set(VisibilityKit const & in_kit);
9500 
9503  void Show(VisibilityKit & out_kit) const;
9504 
9508  VisibilityKit & operator=(VisibilityKit const & in_kit);
9509 
9512  bool Empty() const;
9513 
9517  bool Equals(VisibilityKit const & in_kit) const;
9518 
9522  bool operator==(VisibilityKit const & in_kit) const;
9523 
9527  bool operator!=(VisibilityKit const & in_kit) const;
9528 
9529 
9533  VisibilityKit & SetCuttingSections(bool in_state);
9534 
9538  VisibilityKit & SetCutEdges(bool in_state);
9539 
9543  VisibilityKit & SetCutFaces(bool in_state);
9544 
9548  VisibilityKit & SetWindows(bool in_state);
9549 
9553  VisibilityKit & SetText(bool in_state);
9554 
9558  VisibilityKit & SetLines(bool in_state);
9559 
9563  VisibilityKit & SetEdgeLights(bool in_state);
9564 
9568  VisibilityKit & SetMarkerLights(bool in_state);
9569 
9573  VisibilityKit & SetFaceLights(bool in_state);
9574 
9578  VisibilityKit & SetGenericEdges(bool in_state);
9579 
9583  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9584 
9591  VisibilityKit & SetAdjacentEdges(bool in_state);
9592 
9596  VisibilityKit & SetHardEdges(bool in_state);
9597 
9601  VisibilityKit & SetMeshQuadEdges(bool in_state);
9602 
9606  VisibilityKit & SetNonCulledEdges(bool in_state);
9607 
9611  VisibilityKit & SetPerimeterEdges(bool in_state);
9612 
9616  VisibilityKit & SetFaces(bool in_state);
9617 
9621  VisibilityKit & SetVertices(bool in_state);
9622 
9626  VisibilityKit & SetMarkers(bool in_state);
9627 
9631  VisibilityKit & SetShadowCasting(bool in_state);
9632 
9636  VisibilityKit & SetShadowReceiving(bool in_state);
9637 
9641  VisibilityKit & SetShadowEmitting(bool in_state);
9642 
9643 
9647  VisibilityKit & SetCutGeometry(bool in_state);
9648 
9652  VisibilityKit & SetEdges(bool in_state);
9653 
9657  VisibilityKit & SetGeometry(bool in_state);
9658 
9662  VisibilityKit & SetLights(bool in_state);
9663 
9667  VisibilityKit & SetShadows(bool in_state);
9668 
9672  VisibilityKit & SetEverything(bool in_state);
9673 
9674 
9677  VisibilityKit & UnsetCuttingSections();
9678 
9681  VisibilityKit & UnsetCutEdges();
9682 
9685  VisibilityKit & UnsetCutFaces();
9686 
9689  VisibilityKit & UnsetWindows();
9690 
9693  VisibilityKit & UnsetText();
9694 
9697  VisibilityKit & UnsetLines();
9698 
9701  VisibilityKit & UnsetEdgeLights();
9702 
9705  VisibilityKit & UnsetMarkerLights();
9706 
9709  VisibilityKit & UnsetFaceLights();
9710 
9713  VisibilityKit & UnsetGenericEdges();
9714 
9717  VisibilityKit & UnsetInteriorSilhouetteEdges();
9718 
9721  VisibilityKit & UnsetAdjacentEdges();
9722 
9725  VisibilityKit & UnsetHardEdges();
9726 
9729  VisibilityKit & UnsetMeshQuadEdges();
9730 
9733  VisibilityKit & UnsetNonCulledEdges();
9734 
9737  VisibilityKit & UnsetPerimeterEdges();
9738 
9741  VisibilityKit & UnsetFaces();
9742 
9745  VisibilityKit & UnsetVertices();
9746 
9749  VisibilityKit & UnsetMarkers();
9750 
9753  VisibilityKit & UnsetShadowCasting();
9754 
9757  VisibilityKit & UnsetShadowReceiving();
9758 
9761  VisibilityKit & UnsetShadowEmitting();
9762 
9763 
9766  VisibilityKit & UnsetCutGeometry();
9767 
9770  VisibilityKit & UnsetEdges();
9771 
9774  VisibilityKit & UnsetGeometry();
9775 
9778  VisibilityKit & UnsetLights();
9779 
9782  VisibilityKit & UnsetShadows();
9783 
9786  VisibilityKit & UnsetEverything();
9787 
9788 
9792  bool ShowCuttingSections(bool & out_state) const;
9793 
9797  bool ShowCutEdges(bool & out_state) const;
9798 
9802  bool ShowCutFaces(bool & out_state) const;
9803 
9807  bool ShowWindows(bool & out_state) const;
9808 
9812  bool ShowText(bool & out_state) const;
9813 
9817  bool ShowLines(bool & out_state) const;
9818 
9822  bool ShowEdgeLights(bool & out_state) const;
9823 
9827  bool ShowMarkerLights(bool & out_state) const;
9828 
9832  bool ShowFaceLights(bool & out_state) const;
9833 
9837  bool ShowGenericEdges(bool & out_state) const;
9838 
9842  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9843 
9847  bool ShowAdjacentEdges(bool & out_state) const;
9848 
9852  bool ShowHardEdges(bool & out_state) const;
9853 
9857  bool ShowMeshQuadEdges(bool & out_state) const;
9858 
9862  bool ShowNonCulledEdges(bool & out_state) const;
9863 
9867  bool ShowPerimeterEdges(bool & out_state) const;
9868 
9872  bool ShowFaces(bool & out_state) const;
9873 
9877  bool ShowVertices(bool & out_state) const;
9878 
9882  bool ShowMarkers(bool & out_state) const;
9883 
9887  bool ShowShadowCasting(bool & out_state) const;
9888 
9892  bool ShowShadowReceiving(bool & out_state) const;
9893 
9897  bool ShowShadowEmitting(bool & out_state) const;
9898 };
9899 
9900 
9906 class HPS_API VisibilityControl : public Control
9907 {
9908 public:
9909 
9911  explicit VisibilityControl(SegmentKey & in_seg);
9912 
9914  VisibilityControl(VisibilityControl const & in_that);
9915 
9920 
9924  VisibilityControl & operator=(VisibilityControl && in_that);
9925 
9927  ~VisibilityControl();
9928 
9929  HPS::Type ObjectType() const {return HPS::Type::VisibilityControl;};
9930 
9932  VisibilityControl & operator=(VisibilityControl const & in_that);
9933 
9934 
9938  VisibilityControl & SetCuttingSections(bool in_state);
9939 
9943  VisibilityControl & SetCutEdges(bool in_state);
9944 
9948  VisibilityControl & SetCutFaces(bool in_state);
9949 
9953  VisibilityControl & SetWindows(bool in_state);
9954 
9958  VisibilityControl & SetText(bool in_state);
9959 
9963  VisibilityControl & SetLines(bool in_state);
9964 
9968  VisibilityControl & SetEdgeLights(bool in_state);
9969 
9973  VisibilityControl & SetMarkerLights(bool in_state);
9974 
9978  VisibilityControl & SetFaceLights(bool in_state);
9979 
9983  VisibilityControl & SetGenericEdges(bool in_state);
9984 
9988  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
9989 
9993  VisibilityControl & SetAdjacentEdges(bool in_state);
9994 
9998  VisibilityControl & SetHardEdges(bool in_state);
9999 
10003  VisibilityControl & SetMeshQuadEdges(bool in_state);
10004 
10008  VisibilityControl & SetNonCulledEdges(bool in_state);
10009 
10013  VisibilityControl & SetPerimeterEdges(bool in_state);
10014 
10018  VisibilityControl & SetFaces(bool in_state);
10019 
10023  VisibilityControl & SetVertices(bool in_state);
10024 
10028  VisibilityControl & SetMarkers(bool in_state);
10029 
10033  VisibilityControl & SetShadowCasting(bool in_state);
10034 
10038  VisibilityControl & SetShadowReceiving(bool in_state);
10039 
10043  VisibilityControl & SetShadowEmitting(bool in_state);
10044 
10045 
10049  VisibilityControl & SetCutGeometry(bool in_state);
10050 
10054  VisibilityControl & SetEdges(bool in_state);
10055 
10059  VisibilityControl & SetGeometry(bool in_state);
10060 
10064  VisibilityControl & SetLights(bool in_state);
10065 
10069  VisibilityControl & SetShadows(bool in_state);
10070 
10074  VisibilityControl & SetEverything(bool in_state);
10075 
10076 
10079  VisibilityControl & UnsetCuttingSections();
10080 
10083  VisibilityControl & UnsetCutEdges();
10084 
10087  VisibilityControl & UnsetCutFaces();
10088 
10091  VisibilityControl & UnsetWindows();
10092 
10095  VisibilityControl & UnsetText();
10096 
10099  VisibilityControl & UnsetLines();
10100 
10103  VisibilityControl & UnsetEdgeLights();
10104 
10107  VisibilityControl & UnsetMarkerLights();
10108 
10111  VisibilityControl & UnsetFaceLights();
10112 
10115  VisibilityControl & UnsetGenericEdges();
10116 
10119  VisibilityControl & UnsetInteriorSilhouetteEdges();
10120 
10123  VisibilityControl & UnsetAdjacentEdges();
10124 
10127  VisibilityControl & UnsetHardEdges();
10128 
10131  VisibilityControl & UnsetMeshQuadEdges();
10132 
10135  VisibilityControl & UnsetNonCulledEdges();
10136 
10139  VisibilityControl & UnsetPerimeterEdges();
10140 
10143  VisibilityControl & UnsetFaces();
10144 
10147  VisibilityControl & UnsetVertices();
10148 
10151  VisibilityControl & UnsetMarkers();
10152 
10155  VisibilityControl & UnsetShadowCasting();
10156 
10159  VisibilityControl & UnsetShadowReceiving();
10160 
10163  VisibilityControl & UnsetShadowEmitting();
10164 
10165 
10168  VisibilityControl & UnsetCutGeometry();
10169 
10172  VisibilityControl & UnsetEdges();
10173 
10176  VisibilityControl & UnsetGeometry();
10177 
10180  VisibilityControl & UnsetLights();
10181 
10184  VisibilityControl & UnsetShadows();
10185 
10188  VisibilityControl & UnsetEverything();
10189 
10190 
10194  bool ShowCuttingSections(bool & out_state) const;
10195 
10199  bool ShowCutEdges(bool & out_state) const;
10200 
10204  bool ShowCutFaces(bool & out_state) const;
10205 
10209  bool ShowWindows(bool & out_state) const;
10210 
10214  bool ShowText(bool & out_state) const;
10215 
10219  bool ShowLines(bool & out_state) const;
10220 
10224  bool ShowEdgeLights(bool & out_state) const;
10225 
10229  bool ShowMarkerLights(bool & out_state) const;
10230 
10234  bool ShowFaceLights(bool & out_state) const;
10235 
10239  bool ShowGenericEdges(bool & out_state) const;
10240 
10244  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10245 
10249  bool ShowAdjacentEdges(bool & out_state) const;
10250 
10254  bool ShowHardEdges(bool & out_state) const;
10255 
10259  bool ShowMeshQuadEdges(bool & out_state) const;
10260 
10264  bool ShowNonCulledEdges(bool & out_state) const;
10265 
10269  bool ShowPerimeterEdges(bool & out_state) const;
10270 
10274  bool ShowFaces(bool & out_state) const;
10275 
10279  bool ShowVertices(bool & out_state) const;
10280 
10284  bool ShowMarkers(bool & out_state) const;
10285 
10289  bool ShowShadowCasting(bool & out_state) const;
10290 
10294  bool ShowShadowReceiving(bool & out_state) const;
10295 
10299  bool ShowShadowEmitting(bool & out_state) const;
10300 
10301 private:
10304 };
10305 
10306 
10307 
10310 class HPS_API CameraKit : public Object
10311 {
10312 public:
10313 
10315  CameraKit();
10316 
10319  CameraKit(const CameraKit & in_kit);
10320 
10324  CameraKit(CameraKit && in_that);
10325 
10329  CameraKit & operator=(CameraKit && in_that);
10330 
10332  virtual ~CameraKit();
10333 
10334  HPS::Type ObjectType() const {return HPS::Type::CameraKit;};
10335 
10339  static CameraKit GetDefault();
10340 
10343  void Set(CameraKit const & in_kit);
10344 
10347  void Show(CameraKit & out_kit) const;
10348 
10352  CameraKit & operator=(CameraKit const & in_kit);
10353 
10356  bool Empty() const;
10357 
10361  bool Equals(CameraKit const & in_kit) const;
10362 
10366  bool operator==(CameraKit const & in_kit) const;
10367 
10371  bool operator!=(CameraKit const & in_kit) const;
10372 
10376  CameraKit & SetUpVector(Vector const & in_up);
10377 
10381  CameraKit & SetPosition(Point const & in_position);
10382 
10386  CameraKit & SetTarget(Point const & in_target);
10387 
10394  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
10395 
10401  CameraKit & SetField(float in_width, float in_height);
10402 
10412  CameraKit & SetNearLimit(float const in_limit);
10413 
10416  CameraKit & UnsetUpVector();
10417 
10420  CameraKit & UnsetPosition();
10421 
10424  CameraKit & UnsetTarget();
10425 
10428  CameraKit & UnsetProjection();
10429 
10432  CameraKit & UnsetField();
10433 
10436  CameraKit & UnsetNearLimit();
10437 
10440  CameraKit & UnsetEverything();
10441 
10442 
10446  bool ShowUpVector(Vector & out_up_vector) const;
10447 
10451  bool ShowPosition(Point & out_position) const;
10452 
10456  bool ShowTarget(Point & out_target) const;
10457 
10461  bool ShowProjection(Camera::Projection & out_type) const;
10462 
10468  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
10469 
10473  bool ShowWidth(float & out_width) const;
10474 
10478  bool ShowHeight(float & out_height) const;
10479 
10484  bool ShowField(float & out_width, float & out_height) const;
10485 
10489  bool ShowNearLimit(float & out_near_limit) const;
10490 
10497  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
10498 
10505  CameraKit & Orbit(float in_theta, float in_phi);
10506 
10513  CameraKit & Pan(float in_theta, float in_phi);
10514 
10520  CameraKit & Roll(float in_theta);
10521 
10527  CameraKit & Zoom(float in_zoom);
10528 };
10529 
10533 class HPS_API CameraControl : public Control
10534 {
10535 public:
10537  explicit CameraControl(SegmentKey & in_seg);
10538 
10540  CameraControl(CameraControl const & in_that);
10541 
10545  CameraControl(CameraControl && in_that);
10546 
10550  CameraControl & operator=(CameraControl && in_that);
10551 
10553  ~CameraControl();
10554 
10555  HPS::Type ObjectType() const {return HPS::Type::CameraControl;};
10556 
10558  CameraControl & operator=(CameraControl const & in_that);
10559 
10560 
10565  CameraControl & SetUpVector(Vector const & in_up);
10566 
10571  CameraControl & SetPosition(Point const & in_position);
10572 
10577  CameraControl & SetTarget(Point const & in_target);
10578 
10585  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10586 
10592  CameraControl & SetField(float in_width, float in_height);
10593 
10604  CameraControl & SetNearLimit(float in_double);
10605 
10609  CameraControl & UnsetEverything();
10610 
10611 
10615  bool ShowUpVector(Vector & out_up_vector) const;
10616 
10620  bool ShowPosition(Point & out_position) const;
10621 
10625  bool ShowTarget(Point & out_target) const;
10626 
10630  bool ShowProjection(Camera::Projection & out_type) const;
10631 
10637  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10638 
10642  bool ShowWidth(float & out_width) const;
10643 
10647  bool ShowHeight(float & out_height) const;
10648 
10653  bool ShowField(float & out_width, float & out_height) const;
10654 
10658  bool ShowNearLimit(float & out_width) const;
10659 
10666  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10667 
10674  CameraControl & Orbit(float in_theta, float in_phi);
10675 
10682  CameraControl & Pan(float in_theta, float in_phi);
10683 
10689  CameraControl & Roll(float in_theta);
10690 
10696  CameraControl & Zoom(float in_zoom);
10697 
10698 private:
10700  CameraControl();
10701 };
10702 
10703 
10704 
10706 class HPS_API SelectabilityKit : public Object
10707 {
10708 public:
10709 
10711  SelectabilityKit();
10712 
10715  SelectabilityKit(SelectabilityKit const & in_kit);
10716 
10720  SelectabilityKit(SelectabilityKit && in_that);
10721 
10725  SelectabilityKit & operator=(SelectabilityKit && in_that);
10726 
10728  virtual ~SelectabilityKit();
10729 
10730  HPS::Type ObjectType() const {return HPS::Type::SelectabilityKit;};
10731 
10735  static SelectabilityKit GetDefault();
10736 
10739  void Set(SelectabilityKit const & in_kit);
10740 
10743  void Show(SelectabilityKit & out_kit) const;
10744 
10748  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10749 
10752  bool Empty() const;
10753 
10757  bool Equals(SelectabilityKit const & in_kit) const;
10758 
10762  bool operator==(SelectabilityKit const & in_kit) const;
10763 
10767  bool operator!=(SelectabilityKit const & in_kit) const;
10768 
10769 
10773  SelectabilityKit & SetWindows(Selectability::Value in_val);
10774 
10778  SelectabilityKit & SetEdges(Selectability::Value in_val);
10779 
10783  SelectabilityKit & SetFaces(Selectability::Value in_val);
10784 
10788  SelectabilityKit & SetLights(Selectability::Value in_val);
10789 
10793  SelectabilityKit & SetLines(Selectability::Value in_val);
10794 
10798  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10799 
10803  SelectabilityKit & SetVertices(Selectability::Value in_val);
10804 
10808  SelectabilityKit & SetText(Selectability::Value in_val);
10809 
10813  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10814 
10818  SelectabilityKit & SetEverything(Selectability::Value in_val);
10819 
10820 
10823  SelectabilityKit & UnsetWindows();
10824 
10827  SelectabilityKit & UnsetEdges();
10828 
10831  SelectabilityKit & UnsetFaces();
10832 
10835  SelectabilityKit & UnsetLights();
10836 
10839  SelectabilityKit & UnsetLines();
10840 
10843  SelectabilityKit & UnsetMarkers();
10844 
10847  SelectabilityKit & UnsetVertices();
10848 
10851  SelectabilityKit & UnsetText();
10852 
10855  SelectabilityKit & UnsetGeometry();
10856 
10859  SelectabilityKit & UnsetEverything();
10860 
10861 
10865  bool ShowWindows(Selectability::Value & out_val) const;
10866 
10870  bool ShowEdges(Selectability::Value & out_val) const;
10871 
10875  bool ShowFaces(Selectability::Value & out_val) const;
10876 
10880  bool ShowLights(Selectability::Value & out_val) const;
10881 
10885  bool ShowLines(Selectability::Value & out_val) const;
10886 
10890  bool ShowMarkers(Selectability::Value & out_val) const;
10891 
10895  bool ShowVertices(Selectability::Value & out_val) const;
10896 
10900  bool ShowText(Selectability::Value & out_val) const;
10901 };
10902 
10908 class HPS_API SelectabilityControl : public Control
10909 {
10910 public:
10911 
10913  explicit SelectabilityControl(SegmentKey & in_seg);
10914 
10916  SelectabilityControl(SelectabilityControl const & in_that);
10917 
10922 
10926  SelectabilityControl & operator=(SelectabilityControl && in_that);
10927 
10930 
10931  HPS::Type ObjectType() const {return HPS::Type::SelectabilityControl;};
10932 
10934  SelectabilityControl & operator=(SelectabilityControl const & in_that);
10935 
10936 
10940  SelectabilityControl & SetWindows(Selectability::Value in_val);
10941 
10945  SelectabilityControl & SetEdges(Selectability::Value in_val);
10946 
10950  SelectabilityControl & SetFaces(Selectability::Value in_val);
10951 
10955  SelectabilityControl & SetLights(Selectability::Value in_val);
10956 
10960  SelectabilityControl & SetLines(Selectability::Value in_val);
10961 
10965  SelectabilityControl & SetMarkers(Selectability::Value in_val);
10966 
10970  SelectabilityControl & SetVertices(Selectability::Value in_val);
10971 
10975  SelectabilityControl & SetText(Selectability::Value in_val);
10976 
10980  SelectabilityControl & SetGeometry(Selectability::Value in_val);
10981 
10985  SelectabilityControl & SetEverything(Selectability::Value in_val);
10986 
10987 
10990  SelectabilityControl & UnsetWindows();
10991 
10994  SelectabilityControl & UnsetEdges();
10995 
10998  SelectabilityControl & UnsetFaces();
10999 
11002  SelectabilityControl & UnsetLights();
11003 
11006  SelectabilityControl & UnsetLines();
11007 
11010  SelectabilityControl & UnsetMarkers();
11011 
11014  SelectabilityControl & UnsetVertices();
11015 
11018  SelectabilityControl & UnsetText();
11019 
11022  SelectabilityControl & UnsetGeometry();
11023 
11026  SelectabilityControl & UnsetEverything();
11027 
11028 
11032  bool ShowWindows(Selectability::Value & out_val) const;
11033 
11037  bool ShowEdges(Selectability::Value & out_val) const;
11038 
11042  bool ShowFaces(Selectability::Value & out_val) const;
11043 
11047  bool ShowLights(Selectability::Value & out_val) const;
11048 
11052  bool ShowLines(Selectability::Value & out_val) const;
11053 
11057  bool ShowMarkers(Selectability::Value & out_val) const;
11058 
11062  bool ShowVertices(Selectability::Value & out_val) const;
11063 
11067  bool ShowText(Selectability::Value & out_val) const;
11068 
11069 private:
11072 };
11073 
11074 
11076 class HPS_API TransparencyKit : public Object
11077 {
11078 public:
11079 
11081  TransparencyKit();
11082 
11085  TransparencyKit(TransparencyKit const & in_kit);
11086 
11090  TransparencyKit(TransparencyKit && in_that);
11091 
11095  TransparencyKit & operator=(TransparencyKit && in_that);
11096 
11098  virtual ~TransparencyKit();
11099 
11100  HPS::Type ObjectType() const {return HPS::Type::TransparencyKit;};
11101 
11105  static TransparencyKit GetDefault();
11106 
11109  void Set(TransparencyKit const & in_kit);
11110 
11113  void Show(TransparencyKit & out_kit) const;
11114 
11118  TransparencyKit & operator=(TransparencyKit const & in_kit);
11119 
11122  bool Empty() const;
11123 
11127  bool Equals(TransparencyKit const & in_kit) const;
11128 
11132  bool operator==(TransparencyKit const & in_kit) const;
11133 
11137  bool operator!=(TransparencyKit const & in_kit) const;
11138 
11139 
11143  TransparencyKit & SetMethod(Transparency::Method in_style);
11144 
11148  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
11149 
11154  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
11155 
11161  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11162 
11167  TransparencyKit & SetDepthWriting(bool in_state);
11168 
11169 
11172  TransparencyKit & UnsetMethod();
11173 
11176  TransparencyKit & UnsetAlgorithm();
11177 
11180  TransparencyKit & UnsetDepthPeelingLayers();
11181 
11184  TransparencyKit & UnsetDepthPeelingMinimumArea();
11185 
11188  TransparencyKit & UnsetDepthWriting();
11189 
11192  TransparencyKit & UnsetEverything();
11193 
11194 
11198  bool ShowMethod(Transparency::Method & out_style) const;
11199 
11203  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11204 
11208  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11209 
11214  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11215 
11219  bool ShowDepthWriting(bool & out_state) const;
11220 };
11221 
11227 class HPS_API TransparencyControl : public Control
11228 {
11229 public:
11230 
11232  explicit TransparencyControl(SegmentKey & in_seg);
11233 
11235  TransparencyControl(TransparencyControl const & in_that);
11236 
11241 
11245  TransparencyControl & operator=(TransparencyControl && in_that);
11246 
11249 
11250  HPS::Type ObjectType() const {return HPS::Type::TransparencyControl;};
11251 
11253  TransparencyControl & operator=(TransparencyControl const & in_that);
11254 
11258  TransparencyControl & SetMethod(Transparency::Method in_style);
11259 
11263  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
11264 
11269  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
11270 
11276  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11277 
11282  TransparencyControl & SetDepthWriting(bool in_state);
11283 
11284 
11287  TransparencyControl & UnsetMethod();
11288 
11291  TransparencyControl & UnsetAlgorithm();
11292 
11295  TransparencyControl & UnsetDepthPeelingLayers();
11296 
11299  TransparencyControl & UnsetDepthPeelingMinimumArea();
11300 
11303  TransparencyControl & UnsetDepthWriting();
11304 
11307  TransparencyControl & UnsetEverything();
11308 
11309 
11313  bool ShowMethod(Transparency::Method & out_style) const;
11314 
11318  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11319 
11323  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11324 
11329  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11330 
11334  bool ShowDepthWriting(bool & out_state) const;
11335 
11336 private:
11339 };
11340 
11342 class HPS_API ColorInterpolationKit : public Object
11343 {
11344 public:
11345 
11348 
11351 
11356 
11360  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
11361 
11363  virtual ~ColorInterpolationKit();
11364 
11365  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationKit;};
11366 
11367  static ColorInterpolationKit GetDefault();
11368 
11370  void Set(ColorInterpolationKit const & in_kit);
11371 
11373  void Show(ColorInterpolationKit & out_kit) const;
11374 
11376  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
11377 
11379  bool Empty() const;
11380 
11382  bool Equals(ColorInterpolationKit const & in_kit) const;
11383 
11385  bool operator==(ColorInterpolationKit const & in_kit) const;
11386 
11388  bool operator!=(ColorInterpolationKit const & in_kit) const;
11389 
11390 
11394  ColorInterpolationKit & SetFaceColor(bool in_state);
11395 
11399  ColorInterpolationKit & SetEdgeColor(bool in_state);
11400 
11404  ColorInterpolationKit & SetVertexColor(bool in_state);
11405 
11409  ColorInterpolationKit & SetFaceIndex(bool in_state);
11410 
11414  ColorInterpolationKit & SetEdgeIndex(bool in_state);
11415 
11419  ColorInterpolationKit & SetVertexIndex(bool in_state);
11420 
11421 
11424  ColorInterpolationKit & UnsetFaceColor();
11425 
11428  ColorInterpolationKit & UnsetEdgeColor();
11429 
11432  ColorInterpolationKit & UnsetVertexColor();
11433 
11436  ColorInterpolationKit & UnsetFaceIndex();
11437 
11440  ColorInterpolationKit & UnsetEdgeIndex();
11441 
11444  ColorInterpolationKit & UnsetVertexIndex();
11445 
11448  ColorInterpolationKit & UnsetEverything();
11449 
11450 
11454  bool ShowFaceColor(bool & out_state) const;
11455 
11459  bool ShowEdgeColor(bool & out_state) const;
11460 
11464  bool ShowVertexColor(bool & out_state) const;
11465 
11469  bool ShowFaceIndex(bool & out_state) const;
11470 
11474  bool ShowEdgeIndex(bool & out_state) const;
11475 
11479  bool ShowVertexIndex(bool & out_state) const;
11480 };
11481 
11482 
11486 class HPS_API ColorInterpolationControl : public Control
11487 {
11488 public:
11489 
11491  explicit ColorInterpolationControl(SegmentKey & in_seg);
11492 
11495 
11500 
11504  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11505 
11508 
11509  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationControl;};
11510 
11511 
11515  ColorInterpolationControl & SetFaceColor(bool in_state);
11516 
11520  ColorInterpolationControl & SetEdgeColor(bool in_state);
11521 
11525  ColorInterpolationControl & SetVertexColor(bool in_state);
11526 
11530  ColorInterpolationControl & SetFaceIndex(bool in_state);
11531 
11535  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11536 
11540  ColorInterpolationControl & SetVertexIndex(bool in_state);
11541 
11542 
11545  ColorInterpolationControl & UnsetFaceColor();
11546 
11549  ColorInterpolationControl & UnsetEdgeColor();
11550 
11553  ColorInterpolationControl & UnsetVertexColor();
11554 
11557  ColorInterpolationControl & UnsetFaceIndex();
11558 
11561  ColorInterpolationControl & UnsetEdgeIndex();
11562 
11565  ColorInterpolationControl & UnsetVertexIndex();
11566 
11569  ColorInterpolationControl & UnsetEverything();
11570 
11571 
11575  bool ShowFaceColor(bool & out_state) const;
11576 
11580  bool ShowEdgeColor(bool & out_state) const;
11581 
11585  bool ShowVertexColor(bool & out_state) const;
11586 
11590  bool ShowFaceIndex(bool & out_state) const;
11591 
11595  bool ShowEdgeIndex(bool & out_state) const;
11596 
11600  bool ShowVertexIndex(bool & out_state) const;
11601 
11602 private:
11605 };
11606 
11607 
11609 class HPS_API CullingKit : public Object
11610 {
11611 public:
11612 
11614  CullingKit();
11615 
11618  CullingKit(CullingKit const & in_kit);
11619 
11623  CullingKit(CullingKit && in_that);
11624 
11628  CullingKit & operator=(CullingKit && in_that);
11629 
11631  virtual ~CullingKit();
11632 
11633  HPS::Type ObjectType() const {return HPS::Type::CullingKit;};
11634 
11638  static CullingKit GetDefault();
11639 
11642  void Set(CullingKit const & in_kit);
11643 
11646  void Show(CullingKit & out_kit) const;
11647 
11651  CullingKit & operator=(CullingKit const & in_kit);
11652 
11655  bool Empty() const;
11656 
11660  bool Equals(CullingKit const & in_kit) const;
11661 
11665  bool operator==(CullingKit const & in_kit) const;
11666 
11670  bool operator!=(CullingKit const & in_kit) const;
11671 
11676  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11677 
11682  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11683 
11688  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11689 
11694  CullingKit & SetExtent(unsigned int in_pixels);
11695 
11699  CullingKit & SetBackFace(bool in_state);
11700 
11707  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11708 
11715  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11716 
11723  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11724 
11730  CullingKit & SetVector(HPS::Vector const & in_vector);
11731 
11735  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11736 
11740  CullingKit & SetFrustum(bool in_state);
11741 
11744  CullingKit & UnsetDeferralExtent();
11745 
11748  CullingKit & UnsetExtent();
11749 
11752  CullingKit & UnsetBackFace();
11753 
11756  CullingKit & UnsetVector();
11757 
11760  CullingKit & UnsetVectorTolerance();
11761 
11764  CullingKit & UnsetFrustum();
11765 
11768  CullingKit & UnsetEverything();
11769 
11774  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11775 
11780  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11781 
11785  bool ShowBackFace(bool & out_state) const;
11786 
11792  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11793 
11797  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11798 
11802  bool ShowFrustum(bool & out_state) const;
11803 };
11804 
11808 class HPS_API CullingControl : public Control
11809 {
11810 public:
11811 
11813  explicit CullingControl(SegmentKey & in_seg);
11814 
11816  CullingControl(CullingControl const & in_that);
11817 
11819  ~CullingControl();
11820 
11824  CullingControl(CullingControl && in_that);
11825 
11829  CullingControl & operator=(CullingControl && in_that);
11830 
11831  HPS::Type ObjectType() const {return HPS::Type::CullingControl;};
11832 
11834  CullingControl & operator=(CullingControl const & in_that);
11835 
11842  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11843 
11850  CullingControl & SetDeferralExtent(unsigned int in_pixels);
11851 
11856  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
11857 
11862  CullingControl & SetExtent(unsigned int in_pixels);
11863 
11868  CullingControl & SetBackFace(bool in_state);
11869 
11876  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11877 
11884  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11885 
11892  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11893 
11899  CullingControl & SetVector(HPS::Vector const & in_vector);
11900 
11904  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
11905 
11909  CullingControl & SetFrustum(bool in_state);
11910 
11913  CullingControl & UnsetDeferralExtent();
11914 
11917  CullingControl & UnsetExtent();
11918 
11921  CullingControl & UnsetBackFace();
11922 
11925  CullingControl & UnsetVector();
11926 
11929  CullingControl & UnsetVectorTolerance();
11930 
11933  CullingControl & UnsetFrustum();
11934 
11937  CullingControl & UnsetEverything();
11938 
11943  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11944 
11949  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11950 
11954  bool ShowBackFace(bool & out_state) const;
11955 
11961  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11962 
11966  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11967 
11971  bool ShowFrustum(bool & out_state) const;
11972 
11973 private:
11975  CullingControl();
11976 };
11977 
11978 
11979 
11980 
11982 class HPS_API MarkerAttributeKit : public Object
11983 {
11984 public:
11985 
11988 
11991  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
11992 
11997 
12001  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
12002 
12004  virtual ~MarkerAttributeKit();
12005 
12006  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeKit;};
12007 
12011  static MarkerAttributeKit GetDefault();
12012 
12015  void Set(MarkerAttributeKit const & in_kit);
12016 
12019  void Show(MarkerAttributeKit & out_kit) const;
12020 
12024  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
12025 
12028  bool Empty() const;
12029 
12033  bool Equals(MarkerAttributeKit const & in_kit) const;
12034 
12038  bool operator==(MarkerAttributeKit const & in_kit) const;
12039 
12043  bool operator!=(MarkerAttributeKit const & in_kit) const;
12044 
12045 
12049  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
12050 
12055  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12056 
12057 
12060  MarkerAttributeKit & UnsetSymbol();
12061 
12064  MarkerAttributeKit & UnsetSize();
12065 
12068  MarkerAttributeKit & UnsetEverything();
12069 
12070 
12074  bool ShowSymbol(UTF8 & out_glyph_name) const;
12075 
12080  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12081 };
12082 
12088 class HPS_API MarkerAttributeControl : public Control
12089 {
12090 public:
12091 
12093  explicit MarkerAttributeControl(SegmentKey & in_seg);
12094 
12097 
12102 
12106  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
12107 
12110 
12111  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeControl;};
12112 
12114  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
12115 
12119  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
12120 
12125  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12126 
12127 
12130  MarkerAttributeControl & UnsetSymbol();
12131 
12134  MarkerAttributeControl & UnsetSize();
12135 
12138  MarkerAttributeControl & UnsetEverything();
12139 
12140 
12144  bool ShowSymbol(UTF8 & out_glyph_name) const;
12145 
12150  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12151 
12152 private:
12155 };
12156 
12157 
12159 class HPS_API SphereAttributeKit : public Object
12160 {
12161 public:
12162 
12165 
12168  SphereAttributeKit(SphereAttributeKit const & in_kit);
12169 
12174 
12178  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
12179 
12181  virtual ~SphereAttributeKit();
12182 
12183  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeKit;};
12184 
12188  static SphereAttributeKit GetDefault();
12189 
12192  void Set(SphereAttributeKit const & in_kit);
12193 
12196  void Show(SphereAttributeKit & out_kit) const;
12197 
12201  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
12202 
12205  bool Empty() const;
12206 
12210  bool Equals(SphereAttributeKit const & in_kit) const;
12211 
12215  bool operator==(SphereAttributeKit const & in_kit) const;
12216 
12220  bool operator!=(SphereAttributeKit const & in_kit) const;
12221 
12222 
12226  SphereAttributeKit & SetTessellation(size_t in_facets);
12227 
12228 
12231  SphereAttributeKit & UnsetTessellation();
12232 
12235  SphereAttributeKit & UnsetEverything();
12236 
12237 
12241  bool ShowTessellation(size_t & out_facets) const;
12242 };
12243 
12244 
12247 class HPS_API SphereAttributeControl : public Control
12248 {
12249 public:
12250 
12252  explicit SphereAttributeControl(SegmentKey const & in_seg);
12253 
12256 
12261 
12265  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
12266 
12269 
12270  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeControl;};
12271 
12273  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
12274 
12275 
12280  SphereAttributeControl & SetTessellation(size_t in_facets);
12281 
12282 
12285  SphereAttributeControl & UnsetTessellation();
12286 
12289  SphereAttributeControl & UnsetEverything();
12290 
12291 
12295  bool ShowTessellation(size_t & out_facets) const;
12296 
12297 private:
12300 };
12301 
12302 
12304 class HPS_API LightingAttributeKit : public Object
12305 {
12306 public:
12307 
12310 
12314 
12319 
12323  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
12324 
12326  virtual ~LightingAttributeKit();
12327 
12328  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeKit;};
12329 
12333  static LightingAttributeKit GetDefault();
12334 
12337  void Set(LightingAttributeKit const & in_kit);
12338 
12341  void Show(LightingAttributeKit & out_kit) const;
12342 
12346  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
12347 
12350  bool Empty() const;
12351 
12355  bool Equals(LightingAttributeKit const & in_kit) const;
12356 
12360  bool operator==(LightingAttributeKit const & in_kit) const;
12361 
12365  bool operator!=(LightingAttributeKit const & in_kit) const;
12366 
12367 
12371  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12372 
12373 
12376  LightingAttributeKit & UnsetInterpolationAlgorithm();
12377 
12380  LightingAttributeKit & UnsetEverything();
12381 
12382 
12386  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12387 };
12388 
12389 
12390 
12396 class HPS_API LightingAttributeControl : public Control
12397 {
12398 public:
12399 
12401  explicit LightingAttributeControl(SegmentKey & in_seg);
12402 
12405 
12410 
12414  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
12415 
12418 
12419  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeControl;};
12420 
12422  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
12423 
12424 
12428  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12429 
12430 
12433  LightingAttributeControl & UnsetInterpolationAlgorithm();
12434 
12437  LightingAttributeControl & UnsetEverything();
12438 
12439 
12443  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12444 
12445 private:
12448 };
12449 
12450 
12451 
12453 class HPS_API CylinderAttributeKit : public Object
12454 {
12455 public:
12456 
12459 
12463 
12468 
12472  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
12473 
12475  virtual ~CylinderAttributeKit();
12476 
12477  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeKit;};
12478 
12482  static CylinderAttributeKit GetDefault();
12483 
12486  void Set(CylinderAttributeKit const & in_kit);
12487 
12490  void Show(CylinderAttributeKit & out_kit) const;
12491 
12495  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
12496 
12499  bool Empty() const;
12500 
12504  bool Equals(CylinderAttributeKit const & in_kit) const;
12505 
12509  bool operator==(CylinderAttributeKit const & in_kit) const;
12510 
12514  bool operator!=(CylinderAttributeKit const & in_kit) const;
12515 
12516 
12520  CylinderAttributeKit & SetTessellation(size_t in_facets);
12521 
12526  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12527 
12528 
12531  CylinderAttributeKit & UnsetTessellation();
12532 
12535  CylinderAttributeKit & UnsetOrientation();
12536 
12539  CylinderAttributeKit & UnsetEverything();
12540 
12541 
12545  bool ShowTessellation(size_t & out_facets) const;
12546 
12550  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12551 };
12552 
12553 
12554 
12558 class HPS_API CylinderAttributeControl : public Control
12559 {
12560 public:
12561 
12563  explicit CylinderAttributeControl(SegmentKey & in_seg);
12564 
12567 
12572 
12576  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12577 
12580 
12581  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeControl;};
12582 
12584  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12585 
12586 
12590  CylinderAttributeControl & SetTessellation(size_t in_facets);
12591 
12596  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12597 
12598 
12601  CylinderAttributeControl & UnsetTessellation();
12602 
12605  CylinderAttributeControl & UnsetOrientation();
12606 
12609  CylinderAttributeControl & UnsetEverything();
12610 
12611 
12615  bool ShowTessellation(size_t & out_facets) const;
12616 
12620  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12621 
12622 private:
12625 };
12626 
12627 
12628 
12630 class HPS_API CuttingSectionAttributeKit : public Object
12631 {
12632 public:
12633 
12636 
12640 
12645 
12650 
12652  virtual ~CuttingSectionAttributeKit();
12653 
12654  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeKit;};
12655 
12659  static CuttingSectionAttributeKit GetDefault();
12660 
12663  void Set(CuttingSectionAttributeKit const & in_kit);
12664 
12667  void Show(CuttingSectionAttributeKit & out_kit) const;
12668 
12672  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12673 
12676  bool Empty() const;
12677 
12681  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12682 
12686  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12687 
12691  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12692 
12693 
12697  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12698 
12702  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12703 
12707  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12708 
12709 
12712  CuttingSectionAttributeKit & UnsetCuttingLevel();
12713 
12716  CuttingSectionAttributeKit & UnsetCappingLevel();
12717 
12720  CuttingSectionAttributeKit & UnsetMaterialPreference();
12721 
12724  CuttingSectionAttributeKit & UnsetEverything();
12725 
12726 
12730  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12731 
12735  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12736 
12740  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12741 };
12742 
12743 
12744 
12749 {
12750 public:
12751 
12753  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12754 
12757 
12762 
12767 
12770 
12771  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeControl;};
12772 
12775 
12776 
12781 
12786 
12790  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12791 
12792 
12795  CuttingSectionAttributeControl & UnsetCuttingLevel();
12796 
12799  CuttingSectionAttributeControl & UnsetCappingLevel();
12800 
12803  CuttingSectionAttributeControl & UnsetMaterialPreference();
12804 
12807  CuttingSectionAttributeControl & UnsetEverything();
12808 
12809 
12813  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12814 
12818  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12819 
12823  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12824 
12825 private:
12828 };
12829 
12830 
12831 
12833 class HPS_API TextAttributeKit : public Object
12834 {
12835 public:
12836 
12838  TextAttributeKit();
12839 
12842  TextAttributeKit(TextAttributeKit const & in_kit);
12843 
12847  TextAttributeKit(TextAttributeKit && in_that);
12848 
12852  TextAttributeKit & operator=(TextAttributeKit && in_that);
12853 
12855  virtual ~TextAttributeKit();
12856 
12857  HPS::Type ObjectType() const {return HPS::Type::TextAttributeKit;};
12858 
12862  static TextAttributeKit GetDefault();
12863 
12866  void Set(TextAttributeKit const & in_kit);
12867 
12870  void Show(TextAttributeKit & out_kit) const;
12871 
12875  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
12876 
12879  bool Empty() const;
12880 
12884  bool Equals(TextAttributeKit const & in_kit) const;
12885 
12889  bool operator==(TextAttributeKit const & in_kit) const;
12890 
12894  bool operator!=(TextAttributeKit const & in_kit) const;
12895 
12896 
12903 
12908  TextAttributeKit & SetBold(bool in_state);
12909 
12914  TextAttributeKit & SetItalic(bool in_state);
12915 
12919  TextAttributeKit & SetOverline(bool in_state);
12920 
12924  TextAttributeKit & SetStrikethrough(bool in_state);
12925 
12929  TextAttributeKit & SetUnderline(bool in_state);
12930 
12936  TextAttributeKit & SetSlant(float in_angle);
12937 
12942  TextAttributeKit & SetLineSpacing(float in_multiplier);
12943 
12948  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12949 
12954  TextAttributeKit & SetRotation(float in_angle);
12955 
12961  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12962 
12968  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12969 
12976  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12977 
12984 
12994  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12995 
13005  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13006 
13011  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
13012 
13019  TextAttributeKit & SetFont(char const * in_name);
13020 
13024  TextAttributeKit & SetTransform(Text::Transform in_trans);
13025 
13029  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
13030 
13035  TextAttributeKit & SetPreference(Text::Preference in_pref);
13036 
13044  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13045 
13050  TextAttributeKit & SetPath(Vector const & in_path);
13051 
13059  TextAttributeKit & SetSpacing(float in_multiplier);
13060 
13061 
13064  TextAttributeKit & UnsetAlignment();
13065 
13068  TextAttributeKit & UnsetBold();
13069 
13072  TextAttributeKit & UnsetItalic();
13073 
13076  TextAttributeKit & UnsetOverline();
13077 
13080  TextAttributeKit & UnsetStrikethrough();
13081 
13084  TextAttributeKit & UnsetUnderline();
13085 
13088  TextAttributeKit & UnsetSlant();
13089 
13092  TextAttributeKit & UnsetLineSpacing();
13093 
13096  TextAttributeKit & UnsetRotation();
13097 
13100  TextAttributeKit & UnsetExtraSpace();
13101 
13104  TextAttributeKit & UnsetGreeking();
13105 
13108  TextAttributeKit & UnsetSizeTolerance();
13109 
13112  TextAttributeKit & UnsetSize();
13113 
13116  TextAttributeKit & UnsetFont();
13117 
13120  TextAttributeKit & UnsetTransform();
13121 
13124  TextAttributeKit & UnsetRenderer();
13125 
13128  TextAttributeKit & UnsetPreference();
13129 
13132  TextAttributeKit & UnsetPath();
13133 
13136  TextAttributeKit & UnsetSpacing();
13137 
13140  TextAttributeKit & UnsetEverything();
13141 
13142 
13148  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13149 
13153  bool ShowBold(bool & out_state) const;
13154 
13158  bool ShowItalic(bool & out_state) const;
13159 
13163  bool ShowOverline(bool & out_state) const;
13164 
13168  bool ShowStrikethrough(bool & out_state) const;
13169 
13173  bool ShowUnderline(bool & out_state) const;
13174 
13178  bool ShowSlant(float & out_angle) const;
13179 
13183  bool ShowLineSpacing(float & out_multiplier) const;
13184 
13189  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13190 
13196  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13197 
13204  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13205 
13211  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13212 
13217  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13218 
13222  bool ShowFont(UTF8 & out_name) const;
13223 
13227  bool ShowTransform(Text::Transform & out_trans) const;
13228 
13232  bool ShowRenderer(Text::Renderer & out_rend) const;
13233 
13240  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13241 
13245  bool ShowPath(Vector & out_path) const;
13246 
13250  bool ShowSpacing(float & out_multiplier) const;
13251 };
13252 
13258 class HPS_API TextAttributeControl : public Control
13259 {
13260 public:
13261 
13263  explicit TextAttributeControl(SegmentKey & in_seg);
13264 
13266  TextAttributeControl(TextAttributeControl const & in_that);
13267 
13272 
13276  TextAttributeControl & operator=(TextAttributeControl && in_that);
13277 
13280 
13281  HPS::Type ObjectType() const {return HPS::Type::TextAttributeControl;};
13282 
13284  TextAttributeControl & operator=(TextAttributeControl const & in_that);
13285 
13286 
13293 
13298  TextAttributeControl & SetBold(bool in_state);
13299 
13304  TextAttributeControl & SetItalic(bool in_state);
13305 
13309  TextAttributeControl & SetOverline(bool in_state);
13310 
13314  TextAttributeControl & SetStrikethrough(bool in_state);
13315 
13319  TextAttributeControl & SetUnderline(bool in_state);
13320 
13326  TextAttributeControl & SetSlant(float in_angle);
13327 
13332  TextAttributeControl & SetLineSpacing(float in_multiplier);
13333 
13338  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13339 
13344  TextAttributeControl & SetRotation(float in_angle);
13345 
13351  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13352 
13358  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13359 
13366  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13367 
13374 
13384  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13385 
13395  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13396 
13401  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
13402 
13409  TextAttributeControl & SetFont(char const * in_name);
13410 
13414  TextAttributeControl & SetTransform(Text::Transform in_trans);
13415 
13419  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
13420 
13425  TextAttributeControl & SetPreference(Text::Preference in_pref);
13426 
13434  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13435 
13440  TextAttributeControl & SetPath(Vector const & in_path);
13441 
13449  TextAttributeControl & SetSpacing(float in_multiplier);
13450 
13451 
13454  TextAttributeControl & UnsetAlignment();
13455 
13458  TextAttributeControl & UnsetBold();
13459 
13462  TextAttributeControl & UnsetItalic();
13463 
13466  TextAttributeControl & UnsetOverline();
13467 
13470  TextAttributeControl & UnsetStrikethrough();
13471 
13474  TextAttributeControl & UnsetUnderline();
13475 
13478  TextAttributeControl & UnsetSlant();
13479 
13482  TextAttributeControl & UnsetLineSpacing();
13483 
13486  TextAttributeControl & UnsetRotation();
13487 
13490  TextAttributeControl & UnsetExtraSpace();
13491 
13494  TextAttributeControl & UnsetGreeking();
13495 
13498  TextAttributeControl & UnsetSizeTolerance();
13499 
13502  TextAttributeControl & UnsetSize();
13503 
13506  TextAttributeControl & UnsetFont();
13507 
13510  TextAttributeControl & UnsetTransform();
13511 
13514  TextAttributeControl & UnsetRenderer();
13515 
13518  TextAttributeControl & UnsetPreference();
13519 
13522  TextAttributeControl & UnsetPath();
13523 
13526  TextAttributeControl & UnsetSpacing();
13527 
13530  TextAttributeControl & UnsetEverything();
13531 
13532 
13538  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13539 
13543  bool ShowBold(bool & out_state) const;
13544 
13548  bool ShowItalic(bool & out_state) const;
13549 
13553  bool ShowOverline(bool & out_state) const;
13554 
13558  bool ShowStrikethrough(bool & out_state) const;
13559 
13563  bool ShowUnderline(bool & out_state) const;
13564 
13568  bool ShowSlant(float & out_angle) const;
13569 
13573  bool ShowLineSpacing(float & out_multiplier) const;
13574 
13579  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13580 
13586  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13587 
13594  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13595 
13601  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13602 
13607  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13608 
13612  bool ShowFont(UTF8 & out_name) const;
13613 
13617  bool ShowTransform(Text::Transform & out_trans) const;
13618 
13622  bool ShowRenderer(Text::Renderer & out_rend) const;
13623 
13630  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13631 
13635  bool ShowPath(Vector & out_path) const;
13636 
13640  bool ShowSpacing(float & out_multiplier) const;
13641 
13642 private:
13645 };
13646 
13647 
13648 
13649 
13650 
13652 class HPS_API LineAttributeKit : public Object
13653 {
13654 public:
13655 
13657  LineAttributeKit();
13658 
13661  LineAttributeKit(LineAttributeKit const & in_kit);
13662 
13666  LineAttributeKit(LineAttributeKit && in_that);
13667 
13671  LineAttributeKit & operator=(LineAttributeKit && in_that);
13672 
13674  virtual ~LineAttributeKit();
13675 
13676  HPS::Type ObjectType() const {return HPS::Type::LineAttributeKit;};
13677 
13681  static LineAttributeKit GetDefault();
13682 
13685  void Set(LineAttributeKit const & in_kit);
13686 
13689  void Show(LineAttributeKit & out_kit) const;
13690 
13694  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13695 
13698  bool Empty() const;
13699 
13703  bool Equals(LineAttributeKit const & in_kit) const;
13704 
13708  bool operator==(LineAttributeKit const & in_kit) const;
13709 
13713  bool operator!=(LineAttributeKit const & in_kit) const;
13714 
13715 
13719  LineAttributeKit & SetPattern(char const * in_name);
13720 
13725  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13726 
13731  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13732 
13733 
13736  LineAttributeKit & UnsetPattern();
13737 
13740  LineAttributeKit & UnsetWeight();
13741 
13744  LineAttributeKit & UnsetEverything();
13745 
13746 
13751  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13752 
13757  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13758 };
13759 
13765 class HPS_API LineAttributeControl : public Control
13766 {
13767 public:
13768 
13770  explicit LineAttributeControl(SegmentKey & in_seg);
13771 
13773  LineAttributeControl(LineAttributeControl const & in_that);
13774 
13779 
13783  LineAttributeControl & operator=(LineAttributeControl && in_that);
13784 
13787 
13788  HPS::Type ObjectType() const {return HPS::Type::LineAttributeControl;};
13789 
13791  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13792 
13793 
13797  LineAttributeControl & SetPattern(char const * in_pattern);
13798 
13803  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13804 
13809  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13810 
13811 
13814  LineAttributeControl & UnsetPattern();
13815 
13818  LineAttributeControl & UnsetWeight();
13819 
13822  LineAttributeControl & UnsetEverything();
13823 
13824 
13829  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13830 
13835  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13836 
13837 private:
13840 };
13841 
13842 
13843 
13845 class HPS_API EdgeAttributeKit : public Object
13846 {
13847 public:
13848 
13850  EdgeAttributeKit();
13851 
13854  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
13855 
13859  EdgeAttributeKit(EdgeAttributeKit && in_that);
13860 
13864  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
13865 
13867  virtual ~EdgeAttributeKit();
13868 
13869  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeKit;};
13870 
13874  static EdgeAttributeKit GetDefault();
13875 
13878  void Set(EdgeAttributeKit const & in_kit);
13879 
13882  void Show(EdgeAttributeKit & out_kit) const;
13883 
13887  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
13888 
13891  bool Empty() const;
13892 
13896  bool Equals(EdgeAttributeKit const & in_kit) const;
13897 
13901  bool operator==(EdgeAttributeKit const & in_kit) const;
13902 
13906  bool operator!=(EdgeAttributeKit const & in_kit) const;
13907 
13908 
13912  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
13913 
13918  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13919 
13920 
13923  EdgeAttributeKit & UnsetPattern();
13924 
13927  EdgeAttributeKit & UnsetWeight();
13928 
13931  EdgeAttributeKit & UnsetEverything();
13932 
13933 
13937  bool ShowPattern(UTF8 & out_pattern_name) const;
13938 
13943  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13944 };
13945 
13951 class HPS_API EdgeAttributeControl : public Control
13952 {
13953 public:
13954 
13956  explicit EdgeAttributeControl(SegmentKey & in_seg);
13957 
13959  EdgeAttributeControl(EdgeAttributeControl const & in_that);
13960 
13965 
13969  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
13970 
13973 
13974  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeControl;};
13975 
13977  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
13978 
13982  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
13983 
13988  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13989 
13990 
13993  EdgeAttributeControl & UnsetPattern();
13994 
13997  EdgeAttributeControl & UnsetWeight();
13998 
14001  EdgeAttributeControl & UnsetEverything();
14002 
14003 
14007  bool ShowPattern(UTF8 & out_pattern_name) const;
14008 
14013  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14014 
14015 private:
14018 };
14019 
14020 
14022 class HPS_API CurveAttributeKit : public Object
14023 {
14024 public:
14025 
14028 
14031  CurveAttributeKit(CurveAttributeKit const & in_kit);
14032 
14037 
14041  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
14042 
14044  virtual ~CurveAttributeKit();
14045 
14046  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeKit;};
14047 
14051  static CurveAttributeKit GetDefault();
14052 
14055  void Set(CurveAttributeKit const & in_kit);
14056 
14059  void Show(CurveAttributeKit & out_kit) const;
14060 
14064  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
14065 
14068  bool Empty() const;
14069 
14073  bool Equals(CurveAttributeKit const & in_kit) const;
14074 
14078  bool operator==(CurveAttributeKit const & in_kit) const;
14079 
14083  bool operator!=(CurveAttributeKit const & in_kit) const;
14084 
14085  //Set
14086  CurveAttributeKit & SetBudget(size_t in_budget);
14087 
14094  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14095 
14102  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
14103 
14104 
14111  CurveAttributeKit & SetViewDependent(bool in_state);
14112 
14116  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
14117 
14122  CurveAttributeKit & SetMaximumAngle(float in_degrees);
14123 
14128  CurveAttributeKit & SetMaximumLength(float in_length);
14129 
14130 
14133  CurveAttributeKit & UnsetBudget();
14134 
14137  CurveAttributeKit & UnsetContinuedBudget();
14138 
14141  CurveAttributeKit & UnsetViewDependent();
14142 
14145  CurveAttributeKit & UnsetMaximumDeviation();
14146 
14149  CurveAttributeKit & UnsetMaximumAngle();
14150 
14153  CurveAttributeKit & UnsetMaximumLength();
14154 
14157  CurveAttributeKit & UnsetEverything();
14158 
14159 
14163  bool ShowBudget(size_t & out_budget) const;
14164 
14169  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14170 
14174  bool ShowViewDependent(bool & out_state) const;
14175 
14180  bool ShowMaximumDeviation(float & out_deviation) const;
14181 
14186  bool ShowMaximumAngle(float & out_degrees) const;
14187 
14192  bool ShowMaximumLength(float & out_length) const;
14193 };
14194 
14195 
14199 class HPS_API CurveAttributeControl : public Control
14200 {
14201 public:
14202 
14204  explicit CurveAttributeControl(SegmentKey & in_seg);
14205 
14208 
14213 
14217  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
14218 
14221 
14222  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeControl;};
14223 
14225  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
14226 
14230  CurveAttributeControl & SetBudget(size_t in_budget);
14231 
14238  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14239 
14246  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
14247 
14254  CurveAttributeControl & SetViewDependent(bool in_state);
14255 
14259  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
14260 
14265  CurveAttributeControl & SetMaximumAngle(float in_degrees);
14266 
14271  CurveAttributeControl & SetMaximumLength(float in_length);
14272 
14273 
14276  CurveAttributeControl & UnsetBudget();
14277 
14280  CurveAttributeControl & UnsetContinuedBudget();
14281 
14284  CurveAttributeControl & UnsetViewDependent();
14285 
14288  CurveAttributeControl & UnsetMaximumDeviation();
14289 
14292  CurveAttributeControl & UnsetMaximumAngle();
14293 
14296  CurveAttributeControl & UnsetMaximumLength();
14297 
14300  CurveAttributeControl & UnsetEverything();
14301 
14302 
14306  bool ShowBudget(size_t & out_budget) const;
14307 
14312  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14313 
14317  bool ShowViewDependent(bool & out_state) const;
14318 
14323  bool ShowMaximumDeviation(float & out_deviation) const;
14324 
14329  bool ShowMaximumAngle(float & out_degrees) const;
14330 
14335  bool ShowMaximumLength(float & out_length) const;
14336 
14337 private:
14340 };
14341 
14342 
14343 
14344 
14346 class HPS_API MatrixKit : public Object
14347 {
14348 public:
14349 
14351  MatrixKit();
14352 
14355  MatrixKit(MatrixKit const & in_kit);
14356 
14360  MatrixKit(MatrixKit && in_that);
14361 
14365  MatrixKit & operator=(MatrixKit && in_that);
14366 
14370  MatrixKit(FloatArray const & in_matrix_source);
14371 
14375  MatrixKit(float const in_matrix_source []);
14376 
14379  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
14380 
14382  virtual ~MatrixKit();
14383 
14384  HPS::Type ObjectType() const {return HPS::Type::MatrixKit;};
14385 
14388  static MatrixKit GetDefault();
14389 
14392  void Set(MatrixKit const & in_kit);
14393 
14396  void Show(MatrixKit & out_kit) const;
14397 
14401  MatrixKit & operator=(MatrixKit const & in_kit);
14402 
14405  bool Empty() const;
14406 
14410  bool Equals(MatrixKit const & in_kit) const;
14411 
14415  bool operator==(MatrixKit const & in_kit) const;
14416 
14420  bool operator!=(MatrixKit const & in_kit) const;
14421 
14427  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
14428 
14433  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14434 
14438  MatrixKit & SetElements(FloatArray const & in_matrix);
14439 
14444  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
14445 
14446 
14449  MatrixKit & UnsetEverything();
14450 
14451 
14457  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14458 
14463  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14464 
14468  bool ShowElements(FloatArray & out_matrix) const;
14469 
14473  bool ShowDeterminant(float & out_determinant) const;
14474 
14478  bool ShowInverse(MatrixKit & out_matrix) const;
14479 
14484  bool ShowAdjoint(MatrixKit & out_matrix) const;
14485 
14486 
14492  MatrixKit & Rotate(float in_x, float in_y, float in_z);
14493 
14498  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
14499 
14505  MatrixKit & Translate(float in_x, float in_y, float in_z);
14506 
14512  MatrixKit & Scale(float in_x, float in_y, float in_z);
14513 
14517  MatrixKit & Concatenate(MatrixKit const & in_kit);
14518 
14521  MatrixKit & Normalize();
14522 
14525  MatrixKit & Invert();
14526 
14530  MatrixKit & Adjoint();
14531 
14532 
14536  MatrixKit Multiply(MatrixKit const & in_right) const;
14537 
14541  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14542 
14546  MatrixKit Multiply(float in_scalar) const;
14547 
14551  MatrixKit const & MultiplyAndAssign(float in_scalar);
14552 
14556  MatrixKit operator*(MatrixKit const & in_right) const;
14557 
14561  MatrixKit const & operator*=(MatrixKit const & in_right);
14562 
14566  MatrixKit operator*(float in_scalar) const;
14567 
14571  MatrixKit const & operator*=(float in_scalar);
14572 
14573 
14577  Point Transform(Point const & in_source) const;
14578 
14582  PointArray Transform(PointArray const & in_source) const;
14583 
14588  PointArray Transform(size_t in_count, Point const in_source []) const;
14589 
14593  Vector Transform(Vector const & in_source) const;
14594 
14598  VectorArray Transform(VectorArray const & in_source) const;
14599 
14604  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14605 
14609  Plane Transform(Plane const & in_source) const;
14610 
14614  PlaneArray Transform(PlaneArray const & in_source) const;
14615 
14620  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14621 
14625  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
14626 
14630  SimpleSphere Transform(SimpleSphere const & in_source) const;
14631 };
14632 
14636 class HPS_API ModellingMatrixControl : public Control
14637 {
14638 public:
14639 
14641  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14642 
14644  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14645 
14648 
14653 
14657  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14658 
14661 
14662  HPS::Type ObjectType() const {return HPS::Type::ModellingMatrixControl;};
14663 
14665  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14666 
14672  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14673 
14678  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14679 
14683  ModellingMatrixControl & SetElements(FloatArray const & in_matrix);
14684 
14689  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14690 
14691 
14694  ModellingMatrixControl & UnsetEverything();
14695 
14696 
14702  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14703 
14708  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14709 
14713  bool ShowElements(FloatArray & out_matrix) const;
14714 
14718  bool ShowDeterminant(float & out_determinant) const;
14719 
14723  bool ShowInverse(MatrixKit & out_matrix) const;
14724 
14729  bool ShowAdjoint(MatrixKit & out_matrix) const;
14730 
14736  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14737 
14742  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14743 
14749  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14750 
14756  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14757 
14761  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14762 
14765  ModellingMatrixControl & Normalize();
14766 
14769  ModellingMatrixControl & Invert();
14770 
14774  ModellingMatrixControl & Adjoint();
14775 
14776 private:
14779 };
14780 
14783 class HPS_API TextureMatrixControl : public Control
14784 {
14785 public:
14786 
14788  explicit TextureMatrixControl(SegmentKey & in_seg);
14789 
14791  TextureMatrixControl(const TextureMatrixControl & in_that);
14792 
14797 
14801  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
14802 
14805 
14806  HPS::Type ObjectType() const {return HPS::Type::TextureMatrixControl;};
14807 
14809  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
14810 
14811 
14817  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14818 
14823  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14824 
14828  TextureMatrixControl & SetElements(FloatArray const & in_matrix);
14829 
14834  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14835 
14836 
14839  TextureMatrixControl & UnsetEverything();
14840 
14841 
14847  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14848 
14853  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14854 
14858  bool ShowElements(FloatArray & out_matrix) const;
14859 
14863  bool ShowDeterminant(float & out_determinant) const;
14864 
14868  bool ShowInverse(MatrixKit & out_matrix) const;
14869 
14874  bool ShowAdjoint(MatrixKit & out_matrix) const;
14875 
14881  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
14882 
14887  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14888 
14894  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
14895 
14901  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
14902 
14906  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
14907 
14910  TextureMatrixControl & Normalize();
14911 
14914  TextureMatrixControl & Invert();
14915 
14919  TextureMatrixControl & Adjoint();
14920 
14921 private:
14924 };
14925 
14926 
14929 class HPS_API MaterialMappingKit : public Object
14930 {
14931 public:
14932 
14935 
14938  MaterialMappingKit(MaterialMappingKit const & in_kit);
14939 
14944 
14948  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
14949 
14951  ~MaterialMappingKit();
14952 
14953  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingKit;};
14954 
14958  static MaterialMappingKit GetDefault();
14959 
14962  void Set(MaterialMappingKit const & in_kit);
14963 
14966  void Show(MaterialMappingKit & out_kit) const;
14967 
14971  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
14972 
14975  bool Empty() const;
14976 
14980  bool Equals(MaterialMappingKit const & in_kit) const;
14981 
14985  bool operator==(MaterialMappingKit const & in_kit) const;
14986 
14990  bool operator!=(MaterialMappingKit const & in_kit) const;
14991 
14992  //Set
14993 
14997  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
14998 
15004  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
15005 
15006 
15010  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15011 
15017  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
15018 
15024  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15025 
15030  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
15031 
15038  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15039 
15048  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);
15049 
15053  MaterialMappingKit & SetBackFaceGloss(float in_value);
15054 
15058  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
15059 
15064  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
15065 
15071  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15072 
15077  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
15078 
15085  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15086 
15095  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);
15096 
15100  MaterialMappingKit & SetFrontFaceGloss(float in_value);
15101 
15105  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
15106 
15111  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
15112 
15113 
15117  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15118 
15124  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
15125 
15131  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15132 
15137  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
15138 
15145  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15146 
15155  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);
15156 
15160  MaterialMappingKit & SetCutFaceGloss(float in_value);
15161 
15165  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
15166 
15171  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
15172 
15177  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
15178 
15184  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15185 
15192  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15193 
15202  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);
15203 
15207  MaterialMappingKit & SetEdgeGloss(float in_value);
15208 
15212  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
15213 
15218  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
15219 
15224  MaterialMappingKit & SetFaceAlpha(float in_alpha);
15225 
15231  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15232 
15239  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15240 
15249  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);
15250 
15254  MaterialMappingKit & SetFaceGloss(float in_value);
15255 
15259  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
15260 
15265  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
15266 
15270  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
15271 
15272 
15273 
15274 
15275 
15279  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
15280 
15286  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
15287 
15288 
15292  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
15293 
15299  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
15300 
15301 
15305  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
15306 
15312  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
15313 
15314 
15318  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
15319 
15325  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
15326 
15331  MaterialMappingKit & SetVertexAlpha(float in_alpha);
15332 
15338  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15339 
15346  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15347 
15356  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);
15357 
15361  MaterialMappingKit & SetVertexGloss(float in_value);
15362 
15366  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
15367 
15372  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
15373 
15377  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
15378 
15379 
15383  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
15384 
15390  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
15391 
15392 
15396  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15397 
15403  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
15404 
15405  //Aggregate Sets
15406 
15410  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15411 
15416  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
15417 
15418 
15422  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15423 
15429  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
15430 
15431 
15432  //Unset
15433 
15436  MaterialMappingKit & UnsetAmbientLightUpColor();
15437 
15438 
15441  MaterialMappingKit & UnsetAmbientLightDownColor();
15442 
15443 
15446  MaterialMappingKit & UnsetBackFaceMaterial();
15447 
15450  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
15451 
15454  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15455 
15458  MaterialMappingKit & UnsetFrontFaceMaterial();
15459 
15462  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
15463 
15466  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15467 
15468 
15469 
15472  MaterialMappingKit & UnsetCutEdgeColor();
15473 
15474 
15477  MaterialMappingKit & UnsetCutFaceMaterial();
15478 
15481  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
15482 
15485  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15486 
15487 
15490  MaterialMappingKit & UnsetEdgeMaterial();
15491 
15494  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
15495 
15498  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15499 
15500 
15503  MaterialMappingKit & UnsetFaceMaterial();
15504 
15507  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
15508 
15511  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15512 
15513 
15516  MaterialMappingKit & UnsetLightColor();
15517 
15518 
15521  MaterialMappingKit & UnsetLineColor();
15522 
15523 
15526  MaterialMappingKit & UnsetMarkerColor();
15527 
15528 
15531  MaterialMappingKit & UnsetTextColor();
15532 
15533 
15536  MaterialMappingKit & UnsetVertexMaterial();
15537 
15540  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15541 
15544  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15545 
15546 
15549  MaterialMappingKit & UnsetWindowColor();
15550 
15551 
15554  MaterialMappingKit & UnsetWindowContrastColor();
15555 
15556 
15557  //Aggregate Unsets
15558 
15561  MaterialMappingKit & UnsetCutGeometryColor();
15562 
15565  MaterialMappingKit & UnsetAmbientLightColor();
15566 
15569  MaterialMappingKit & UnsetEverything();
15570 
15571 
15572  //Show
15573 
15579  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15580 
15586  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15587 
15588 
15596  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15597 
15606  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;
15607 
15613  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15614 
15615 
15623  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15624 
15633  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;
15634 
15640  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15641 
15642 
15643 
15649  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15650 
15651 
15659  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15660 
15669  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;
15670 
15676  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15677 
15678 
15686  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15687 
15696  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;
15697 
15703  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15704 
15705 
15713  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15714 
15723  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;
15724 
15730  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15731 
15732 
15738  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15739 
15740 
15746  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15747 
15748 
15754  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15755 
15756 
15762  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15763 
15764 
15772  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15773 
15782  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;
15783 
15789  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15790 
15791 
15797  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15798 
15799 
15805  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15806 };
15807 
15808 
15814 class HPS_API MaterialMappingControl : public Control
15815 {
15816 public:
15817 
15819  explicit MaterialMappingControl(SegmentKey & in_seg);
15820 
15823 
15828 
15832  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
15833 
15836 
15837  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingControl;};
15838 
15840  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
15841 
15842  //Set
15843 
15847  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15848 
15854  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
15855 
15856 
15860  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15861 
15867  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
15868 
15873  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
15874 
15880  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15881 
15888  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15889 
15898  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);
15899 
15903  MaterialMappingControl & SetBackFaceGloss(float in_value);
15904 
15908  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
15909 
15914  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
15915 
15916 
15921  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
15922 
15928  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15929 
15936  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15937 
15946  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);
15947 
15951  MaterialMappingControl & SetFrontFaceGloss(float in_value);
15952 
15956  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
15957 
15962  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
15963 
15967  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15968 
15974  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
15975 
15980  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
15981 
15987  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15988 
15995  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15996 
16005  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);
16006 
16010  MaterialMappingControl & SetCutFaceGloss(float in_value);
16011 
16015  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
16016 
16021  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
16022 
16027  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
16028 
16034  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16035 
16042  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16043 
16052  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);
16053 
16057  MaterialMappingControl & SetEdgeGloss(float in_value);
16058 
16062  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
16063 
16068  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
16069 
16075  MaterialMappingControl & SetFaceAlpha(float in_alpha);
16076 
16083  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16084 
16091  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16092 
16101  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);
16102 
16106  MaterialMappingControl & SetFaceGloss(float in_value);
16107 
16111  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
16112 
16117  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
16118 
16122  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
16123 
16124 
16128  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
16129 
16135  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
16136 
16137 
16141  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
16142 
16148  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
16149 
16150 
16154  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
16155 
16161  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
16162 
16163 
16167  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
16168 
16174  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
16175 
16176 
16181  MaterialMappingControl & SetVertexAlpha(float in_alpha);
16182 
16183 
16189  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16190 
16197  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16198 
16207  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);
16208 
16212  MaterialMappingControl & SetVertexGloss(float in_value);
16213 
16217  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
16218 
16223  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
16224 
16228  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
16229 
16230 
16234  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
16235 
16241  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
16242 
16243 
16247  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16248 
16254  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
16255 
16256  //Aggregate Sets
16257 
16261  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16262 
16267  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
16268 
16269 
16273  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16274 
16280  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
16281 
16282 
16283  //Unset
16284 
16287  MaterialMappingControl & UnsetAmbientLightUpColor();
16288 
16289 
16292  MaterialMappingControl & UnsetAmbientLightDownColor();
16293 
16294 
16297  MaterialMappingControl & UnsetFrontFaceMaterial();
16298 
16301  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
16302 
16305  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16306 
16307 
16310  MaterialMappingControl & UnsetBackFaceMaterial();
16311 
16314  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
16315 
16318  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16319 
16320 
16323  MaterialMappingControl & UnsetCutEdgeColor();
16324 
16325 
16328  MaterialMappingControl & UnsetCutFaceMaterial();
16329 
16332  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
16333 
16336  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16337 
16338 
16341  MaterialMappingControl & UnsetEdgeMaterial();
16342 
16345  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
16346 
16349  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
16350 
16351 
16354  MaterialMappingControl & UnsetFaceMaterial();
16355 
16358  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
16359 
16362  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
16363 
16364 
16367  MaterialMappingControl & UnsetLightColor();
16368 
16369 
16372  MaterialMappingControl & UnsetLineColor();
16373 
16374 
16377  MaterialMappingControl & UnsetMarkerColor();
16378 
16379 
16382  MaterialMappingControl & UnsetTextColor();
16383 
16384 
16387  MaterialMappingControl & UnsetVertexMaterial();
16388 
16391  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
16392 
16395  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
16396 
16397 
16400  MaterialMappingControl & UnsetWindowColor();
16401 
16402 
16405  MaterialMappingControl & UnsetWindowContrastColor();
16406 
16407 
16408  //Aggregate Unsets
16409 
16412  MaterialMappingControl & UnsetCutGeometryColor();
16413 
16416  MaterialMappingControl & UnsetAmbientLightColor();
16417 
16420  MaterialMappingControl & UnsetEverything();
16421 
16422 
16423  //Show
16424 
16430  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16431 
16432 
16438  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16439 
16440 
16448  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16449 
16458  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;
16459 
16465  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16466 
16467 
16475  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16476 
16485  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;
16486 
16492  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16493 
16494 
16500  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16501 
16502 
16510  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16511 
16520  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;
16521 
16527  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16528 
16529 
16537  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16538 
16547  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;
16548 
16554  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16555 
16556 
16564  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16565 
16574  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;
16575 
16581  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16582 
16583 
16589  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16590 
16591 
16597  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16598 
16599 
16605  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16606 
16607 
16613  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16614 
16615 
16623  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16624 
16633  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;
16634 
16640  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16641 
16642 
16648  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16649 
16650 
16656  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16657 
16658 private:
16660 };
16661 
16662 
16665 class HPS_API PortfolioControl : public Control
16666 {
16667 public:
16669  explicit PortfolioControl(SegmentKey & in_seg);
16670 
16672  PortfolioControl(PortfolioControl const & in_that);
16673 
16677  PortfolioControl(PortfolioControl && in_that);
16678 
16682  PortfolioControl & operator=(PortfolioControl && in_that);
16683 
16685  ~PortfolioControl();
16686 
16687  HPS::Type ObjectType() const { return HPS::Type::PortfolioControl; };
16688 
16690  PortfolioControl & operator=(PortfolioControl const & in_that);
16691 
16693  size_t GetCount() const;
16694 
16695 
16700  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16701 
16704  bool Pop();
16705 
16709  bool Pop(PortfolioKey & out_portfolio);
16710 
16711 
16715  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16716 
16720  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16721 
16726  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16727 
16728 
16731  PortfolioControl & UnsetTop();
16732 
16735  PortfolioControl & UnsetEverything();
16736 
16737 
16741  bool ShowTop(PortfolioKey & out_portfolio) const;
16742 
16746  bool Show(PortfolioKeyArray & out_portfolios) const;
16747 
16748 private:
16749  PortfolioControl();
16750 };
16751 
16752 
16753 
16756 class HPS_API StyleControl : public Control
16757 {
16758 public:
16760  explicit StyleControl(SegmentKey & in_seg);
16761 
16763  StyleControl(StyleControl const & in_that);
16764 
16768  StyleControl(StyleControl && in_that);
16769 
16773  StyleControl & operator=(StyleControl && in_that);
16774 
16776  ~StyleControl();
16777 
16778  HPS::Type ObjectType() const { return HPS::Type::StyleControl; };
16779 
16781  StyleControl & operator=(StyleControl const & in_that);
16782 
16784  size_t GetCount() const;
16785 
16786 
16788  StyleKey PushNamed(char const * in_style_name);
16789 
16791  StyleKey PushNamed(char const * in_style_name, Condition const & in_condition);
16792 
16794  StyleKey AppendNamed(char const * in_style_name, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16795 
16799  StyleKey PushSegment(SegmentKey const & in_style_source);
16800 
16804  StyleKey PushSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16805 
16808  StyleKey AppendSegment(SegmentKey const & in_style_source, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16809 
16810 
16811 
16814  bool Pop();
16815 
16822  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition);
16823 
16827  void Flush(SegmentKey const & in_style_source);
16828 
16835  void Flush(SegmentKey const & in_style_source, Condition const & in_condition);
16836 
16840  void Flush(char const * in_style_name);
16841 
16848  void Flush(char const * in_style_name, Condition const & in_condition);
16849 
16850 
16853  StyleKey SetNamed(char const * in_style_name);
16854 
16858  StyleKey SetNamed(char const * in_style_name, Condition const & in_condition);
16859 
16860 
16863  StyleKey SetSegment(SegmentKey const & in_style_source);
16864 
16868  StyleKey SetSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16869 
16870 
16876  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionArray const & in_conditions);
16877 
16882  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
16883 
16890  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[]);
16891 
16892 
16893 
16895  void UnsetTop();
16896 
16898  void UnsetAllSegment();
16899 
16901  void UnsetAllNamed();
16902 
16904  void UnsetEverything();
16905 
16906 
16913  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition) const;
16914 
16918  bool ShowTop(StyleKey & out_style) const;
16919 
16926  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions) const;
16927 
16931  bool Show(StyleKeyArray & out_styles) const;
16932 
16937  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions) const;
16938 
16942  bool ShowAllSegment(StyleKeyArray & out_styles) const;
16943 
16948  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions) const;
16949 
16953  bool ShowAllNamed(StyleKeyArray & out_styles) const;
16954 
16955 private:
16956  StyleControl();
16957 };
16958 
16959 
16962 class HPS_API ConditionControl : public Control
16963 {
16964 public:
16966  explicit ConditionControl(SegmentKey & in_seg);
16967 
16969  ConditionControl(ConditionControl const & in_that);
16970 
16974  ConditionControl(ConditionControl && in_that);
16975 
16979  ConditionControl & operator=(ConditionControl && in_that);
16980 
16982  ~ConditionControl();
16983 
16984 
16985  HPS::Type ObjectType() const { return HPS::Type::ConditionControl; };
16986 
16988  ConditionControl & operator=(ConditionControl const & in_that);
16989 
16992  size_t GetCount() const;
16993 
16997  ConditionControl & AddCondition(char const * in_condition);
16998 
16999 
17003  ConditionControl & SetCondition(char const * in_condition);
17004 
17008  ConditionControl & SetConditions(UTF8Array const & in_conditions);
17009 
17014  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
17015 
17016 
17020  ConditionControl & UnsetCondition(char const * in_condition);
17021 
17024  ConditionControl & UnsetEverything();
17025 
17026 
17030  bool ShowCondition(char const * in_condition) const;
17031 
17035  bool ShowConditions(UTF8Array & out_conditions) const;
17036 
17037 private:
17039  ConditionControl();
17040 };
17041 
17042 
17045 class HPS_API MaterialKit : public Object
17046 {
17047 public:
17048 
17050  MaterialKit();
17051 
17054  MaterialKit(MaterialKit const & in_kit);
17055 
17059  MaterialKit(MaterialKit && in_that);
17060 
17064  MaterialKit & operator=(MaterialKit && in_that);
17065 
17067  ~MaterialKit();
17068 
17069  HPS::Type ObjectType() const {return HPS::Type::MaterialKit;};
17070 
17073  void Set(MaterialKit const & in_kit);
17074 
17077  void Show(MaterialKit & out_kit) const;
17078 
17082  MaterialKit & operator=(MaterialKit const & in_kit);
17083 
17086  bool Empty() const;
17087 
17091  bool Equals(MaterialKit const & in_kit) const;
17092 
17096  bool operator==(MaterialKit const & in_kit) const;
17097 
17101  bool operator!=(MaterialKit const & in_kit) const;
17102 
17103 
17104  //Set
17105 
17109  MaterialKit & SetDiffuse(RGBColor const & in_color);
17110 
17114  MaterialKit & SetDiffuse(RGBAColor const & in_color);
17115 
17119  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
17120 
17124  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
17125 
17130  MaterialKit & SetDiffuseAlpha(float in_alpha);
17131 
17138  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
17139 
17147  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
17148 
17153  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
17154 
17160  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
17161 
17168  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
17169 
17177  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
17178 
17179 
17183  MaterialKit & SetShader(char const * in_shader_name);
17184 
17185 
17186 
17190  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
17191 
17195  MaterialKit & SetSpecular(char const * in_texture_name);
17196 
17201  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
17202 
17203 
17204 
17208  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
17209 
17213  MaterialKit & SetMirror(char const * in_texture_name);
17214 
17219  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
17220 
17221 
17222 
17226  MaterialKit & SetTransmission(char const * in_texture_name);
17227 
17232  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17233 
17234 
17235 
17239  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
17240 
17244  MaterialKit & SetEmission(char const * in_texture_name);
17245 
17250  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17251 
17252 
17253 
17257  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
17258 
17263  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
17264 
17268  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
17269 
17274  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
17275 
17278  MaterialKit & SetEnvironmentTexture();
17279 
17280 
17284  MaterialKit & SetBump(char const * in_texture_name);
17285 
17286 
17287 
17294  MaterialKit & SetGloss(float in_gloss);
17295 
17298  MaterialKit & UnsetDiffuseColorRGB();
17299 
17302  MaterialKit & UnsetDiffuseColor();
17303 
17306  MaterialKit & UnsetDiffuseAlpha();
17307 
17310  MaterialKit & UnsetDiffuseTexture();
17311 
17315  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
17316 
17319  MaterialKit & UnsetShader();
17320 
17323  MaterialKit & UnsetSpecular();
17324 
17327  MaterialKit & UnsetMirror();
17328 
17331  MaterialKit & UnsetTransmission();
17332 
17335  MaterialKit & UnsetEmission();
17336 
17339  MaterialKit & UnsetEnvironment();
17340 
17343  MaterialKit & UnsetBump();
17344 
17347  MaterialKit & UnsetGloss();
17348 
17351  MaterialKit & UnsetEverything();
17352 
17353 
17356  bool ShowDiffuse() const;
17357 
17361  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
17362 
17366  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
17367 
17371  bool ShowDiffuseAlpha(float & out_alpha) const;
17372 
17379  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17380 
17388  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17389 
17396  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
17397 
17401  bool ShowShader(UTF8 & out_shader_name) const;
17402 
17411  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17412 
17421  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17422 
17423 
17424 
17433  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17434 
17435 
17444  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17445 
17446 
17455  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17456 
17457 
17461  bool ShowBump(UTF8 & out_texture_name) const;
17462 
17467  bool ShowGloss(float & out_gloss) const;
17468 };
17469 
17470 
17472 class HPS_API NURBSSurfaceAttributeKit : public Object
17473 {
17474 public:
17475 
17478 
17482 
17487 
17491  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
17492 
17494  virtual ~NURBSSurfaceAttributeKit();
17495 
17496  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeKit;};
17497 
17501  static NURBSSurfaceAttributeKit GetDefault();
17502 
17505  void Set(NURBSSurfaceAttributeKit const & in_kit);
17506 
17509  void Show(NURBSSurfaceAttributeKit & out_kit) const;
17510 
17514  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17515 
17518  bool Empty() const;
17519 
17523  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17524 
17528  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17529 
17533  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17534 
17535 
17539  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17540 
17545  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17546 
17550  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17551 
17555  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17556 
17560  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17561 
17566  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17567 
17568 
17571  NURBSSurfaceAttributeKit & UnsetBudget();
17572 
17575  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17576 
17579  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17580 
17583  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17584 
17587  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17588 
17591  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17592 
17595  NURBSSurfaceAttributeKit & UnsetEverything();
17596 
17600  bool ShowBudget(size_t & out_budget) const;
17601 
17605  bool ShowMaximumDeviation(float & out_deviation) const;
17606 
17610  bool ShowMaximumAngle(float & out_degrees) const;
17611 
17615  bool ShowMaximumWidth(float & out_width) const;
17616 
17620  bool ShowTrimBudget(size_t & out_budget) const;
17621 
17625  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17626 };
17627 
17634 {
17635 public:
17636 
17638  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17639 
17642 
17647 
17652 
17655 
17656  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeControl;};
17657 
17659  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17660 
17664  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17665 
17670  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17671 
17675  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17676 
17680  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17681 
17685  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17686 
17691  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17692 
17693 
17696  NURBSSurfaceAttributeControl & UnsetBudget();
17697 
17700  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17701 
17704  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17705 
17708  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17709 
17712  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17713 
17716  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17717 
17720  NURBSSurfaceAttributeControl & UnsetEverything();
17721 
17722 
17726  bool ShowBudget(size_t & out_budget) const;
17727 
17731  bool ShowMaximumDeviation(float & out_deviation) const;
17732 
17736  bool ShowMaximumAngle(float & out_degrees) const;
17737 
17741  bool ShowMaximumWidth(float & out_width) const;
17742 
17746  bool ShowTrimBudget(size_t & out_budget) const;
17747 
17751  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17752 
17753 private:
17756 };
17757 
17758 
17759 
17761 class HPS_API PerformanceKit : public Object
17762 {
17763 public:
17764 
17766  PerformanceKit();
17767 
17770  PerformanceKit(PerformanceKit const & in_kit);
17771 
17775  PerformanceKit(PerformanceKit && in_that);
17776 
17780  PerformanceKit & operator=(PerformanceKit && in_that);
17781 
17783  virtual ~PerformanceKit();
17784 
17785  HPS::Type ObjectType() const {return HPS::Type::PerformanceKit;};
17786 
17790  static PerformanceKit GetDefault();
17791 
17794  void Set(PerformanceKit const & in_kit);
17795 
17798  void Show(PerformanceKit & out_kit) const;
17799 
17803  PerformanceKit & operator=(PerformanceKit const & in_kit);
17804 
17807  bool Empty() const;
17808 
17812  bool Equals(PerformanceKit const & in_kit) const;
17813 
17817  bool operator==(PerformanceKit const & in_kit) const;
17818 
17822  bool operator!=(PerformanceKit const & in_kit) const;
17823 
17824 
17829 
17834  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
17835 
17836 
17839  PerformanceKit & UnsetDisplayLists();
17840 
17843  PerformanceKit & UnsetStaticModel();
17844 
17847  PerformanceKit & UnsetEverything();
17848 
17852  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17853 
17857  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17858 };
17859 
17860 
17866 class HPS_API PerformanceControl : public Control
17867 {
17868 public:
17869 
17871  explicit PerformanceControl(SegmentKey & in_seg);
17872 
17874  PerformanceControl(PerformanceControl const & in_that);
17875 
17880 
17884  PerformanceControl & operator=(PerformanceControl && in_that);
17885 
17887  ~PerformanceControl();
17888 
17889  HPS::Type ObjectType() const {return HPS::Type::PerformanceControl;};
17890 
17892  PerformanceControl & operator=(PerformanceControl const & in_that);
17893 
17894 
17899 
17904  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
17905 
17906 
17909  PerformanceControl & UnsetDisplayLists();
17910 
17913  PerformanceControl & UnsetStaticModel();
17914 
17917  PerformanceControl & UnsetEverything();
17918 
17919 
17923  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17924 
17928  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17929 
17930 private:
17933 };
17934 
17935 
17936 
17938 class HPS_API HiddenLineAttributeKit : public Object
17939 {
17940 public:
17941 
17944 
17948 
17953 
17957  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
17958 
17960  virtual ~HiddenLineAttributeKit();
17961 
17962  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeKit;};
17963 
17967  static HiddenLineAttributeKit GetDefault();
17968 
17971  void Set(HiddenLineAttributeKit const & in_kit);
17972 
17975  void Show(HiddenLineAttributeKit & out_kit) const;
17976 
17980  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
17981 
17984  bool Empty() const;
17985 
17989  bool Equals(HiddenLineAttributeKit const & in_kit) const;
17990 
17994  bool operator==(HiddenLineAttributeKit const & in_kit) const;
17995 
17999  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
18000 
18001 
18005  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
18006 
18012  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
18013 
18023  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
18024 
18028  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
18029 
18033  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
18034 
18038  HiddenLineAttributeKit & SetRenderText(bool in_state);
18039 
18044  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18045 
18051  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
18052 
18056  HiddenLineAttributeKit & SetVisibility(bool in_state);
18057 
18062  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18063 
18069  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
18070 
18071 
18074  HiddenLineAttributeKit & UnsetColor();
18075 
18078  HiddenLineAttributeKit & UnsetDimFactor();
18079 
18082  HiddenLineAttributeKit & UnsetFaceDisplacement();
18083 
18086  HiddenLineAttributeKit & UnsetLinePattern();
18087 
18090  HiddenLineAttributeKit & UnsetRenderFaces();
18091 
18094  HiddenLineAttributeKit & UnsetRenderText();
18095 
18098  HiddenLineAttributeKit & UnsetAlgorithm();
18099 
18102  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
18103 
18106  HiddenLineAttributeKit & UnsetVisibility();
18107 
18110  HiddenLineAttributeKit & UnsetWeight();
18111 
18114  HiddenLineAttributeKit & UnsetTransparencyCutoff();
18115 
18118  HiddenLineAttributeKit & UnsetEverything();
18119 
18120 
18124  bool ShowColor(RGBAColor & out_color) const;
18125 
18129  bool ShowDimFactor(float & out_zero_to_one) const;
18130 
18134  bool ShowFaceDisplacement(float & out_buckets) const;
18135 
18139  bool ShowLinePattern(UTF8 & out_pattern) const;
18140 
18144  bool ShowRenderFaces(bool & out_state) const;
18145 
18149  bool ShowRenderText(bool & out_state) const;
18150 
18154  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18155 
18159  bool ShowSilhouetteCleanup(bool & out_state) const;
18160 
18164  bool ShowVisibility(bool & out_state) const;
18165 
18170  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18171 
18175  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18176 };
18177 
18178 
18184 class HPS_API HiddenLineAttributeControl : public Control
18185 {
18186 public:
18187 
18189  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
18190 
18193 
18198 
18203 
18206 
18207  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeControl;};
18208 
18210  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
18211 
18215  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
18216 
18222  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
18223 
18233  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
18234 
18238  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
18239 
18243  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
18244 
18248  HiddenLineAttributeControl & SetRenderText(bool in_state);
18249 
18254  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18255 
18261  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
18262 
18266  HiddenLineAttributeControl & SetVisibility(bool in_state);
18267 
18272  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18273 
18279  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
18280 
18281 
18284  HiddenLineAttributeControl & UnsetColor();
18285 
18288  HiddenLineAttributeControl & UnsetDimFactor();
18289 
18292  HiddenLineAttributeControl & UnsetFaceDisplacement();
18293 
18296  HiddenLineAttributeControl & UnsetLinePattern();
18297 
18300  HiddenLineAttributeControl & UnsetRenderFaces();
18301 
18304  HiddenLineAttributeControl & UnsetRenderText();
18305 
18308  HiddenLineAttributeControl & UnsetAlgorithm();
18309 
18312  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
18313 
18316  HiddenLineAttributeControl & UnsetVisibility();
18317 
18320  HiddenLineAttributeControl & UnsetWeight();
18321 
18324  HiddenLineAttributeControl & UnsetTransparencyCutoff();
18325 
18328  HiddenLineAttributeControl & UnsetEverything();
18329 
18330 
18334  bool ShowColor(RGBAColor & out_color) const;
18335 
18339  bool ShowDimFactor(float & out_zero_to_one) const;
18340 
18344  bool ShowFaceDisplacement(float & out_buckets) const;
18345 
18349  bool ShowLinePattern(UTF8 & out_pattern) const;
18350 
18354  bool ShowRenderFaces(bool & out_state) const;
18355 
18359  bool ShowRenderText(bool & out_state) const;
18360 
18364  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18365 
18369  bool ShowSilhouetteCleanup(bool & out_state) const;
18370 
18374  bool ShowVisibility(bool & out_state) const;
18375 
18380  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18381 
18385  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18386 
18387 private:
18390 };
18391 
18392 
18393 
18395 class HPS_API DrawingAttributeKit : public Object
18396 {
18397 public:
18398 
18401 
18404  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
18405 
18410 
18414  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
18415 
18417  virtual ~DrawingAttributeKit();
18418 
18419  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeKit;};
18420 
18424  static DrawingAttributeKit GetDefault();
18425 
18428  void Set(DrawingAttributeKit const & in_kit);
18429 
18432  void Show(DrawingAttributeKit & out_kit) const;
18433 
18437  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
18438 
18441  bool Empty() const;
18442 
18446  bool Equals(DrawingAttributeKit const & in_kit) const;
18447 
18451  bool operator==(DrawingAttributeKit const & in_kit) const;
18452 
18456  bool operator!=(DrawingAttributeKit const & in_kit) const;
18457 
18473  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
18474 
18480  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
18481 
18494  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
18495 
18502  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
18503 
18508  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
18509 
18516  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18517 
18522  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18523 
18530  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18531 
18536  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18537 
18541  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18542 
18547  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18548 
18554  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18555 
18562  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);
18563 
18569  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18570 
18573  DrawingAttributeKit & UnsetPolygonHandedness();
18574 
18577  DrawingAttributeKit & UnsetWorldHandedness();
18578 
18581  DrawingAttributeKit & UnsetDepthRange();
18582 
18585  DrawingAttributeKit & UnsetFaceDisplacement();
18586 
18589  DrawingAttributeKit & UnsetGeneralDisplacement();
18590 
18593  DrawingAttributeKit & UnsetVertexDisplacement();
18594 
18597  DrawingAttributeKit & UnsetOverlay();
18598 
18601  DrawingAttributeKit & UnsetDeferral();
18602 
18605  DrawingAttributeKit & UnsetClipRegion();
18606 
18609  DrawingAttributeKit & UnsetEverything();
18610 
18614  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18615 
18619  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18620 
18625  bool ShowDepthRange(float & out_near, float & out_far) const;
18626 
18631  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18632 
18637  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18638 
18643  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18644 
18648  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18649 
18653  bool ShowDeferral(int & out_defer_batch) const;
18654 
18660  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18661 
18662 };
18663 
18664 
18676 class HPS_API DrawingAttributeControl : public Control
18677 {
18678 public:
18679 
18681  explicit DrawingAttributeControl(SegmentKey & in_seg);
18682 
18685 
18690 
18694  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18695 
18698 
18699  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeControl;};
18700 
18702  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18703 
18713  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18714 
18720  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18721 
18734  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18735 
18742  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18743 
18748  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18749 
18756  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18757 
18762  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
18763 
18770  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
18771 
18776  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
18777 
18781  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
18782 
18788  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18789 
18796  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);
18797 
18803  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18804 
18809  DrawingAttributeControl & SetDeferral(int in_deferral);
18812  DrawingAttributeControl & UnsetPolygonHandedness();
18813 
18816  DrawingAttributeControl & UnsetWorldHandedness();
18817 
18820  DrawingAttributeControl & UnsetDepthRange();
18821 
18824  DrawingAttributeControl & UnsetFaceDisplacement();
18825 
18828  DrawingAttributeControl & UnsetGeneralDisplacement();
18829 
18832  DrawingAttributeControl & UnsetVertexDisplacement();
18833 
18836  DrawingAttributeControl & UnsetOverlay();
18837 
18840  DrawingAttributeControl & UnsetDeferral();
18841 
18844  DrawingAttributeControl & UnsetClipRegion();
18845 
18848  DrawingAttributeControl & UnsetEverything();
18849 
18850 
18854  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18855 
18859  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18860 
18865  bool ShowDepthRange(float & out_x, float & out_y) const;
18866 
18871  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18872 
18877  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18878 
18883  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18884 
18888  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18889 
18893  bool ShowDeferral(int & out_defer_batch) const;
18894 
18900  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation);
18901 
18902 private:
18905 };
18906 
18907 
18909 class HPS_API PostProcessEffectsKit : public Object
18910 {
18911 public:
18912 
18915 
18919 
18924 
18928  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
18929 
18931  virtual ~PostProcessEffectsKit();
18932 
18933  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsKit;};
18934 
18938  static PostProcessEffectsKit GetDefault();
18939 
18942  void Set(PostProcessEffectsKit const & in_kit);
18943 
18946  void Show(PostProcessEffectsKit & out_kit) const;
18947 
18951  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
18952 
18955  bool Empty() const;
18956 
18960  bool Equals(PostProcessEffectsKit const & in_kit) const;
18961 
18965  bool operator==(PostProcessEffectsKit const & in_kit) const;
18966 
18970  bool operator!=(PostProcessEffectsKit const & in_kit) const;
18971 
18972 
18980  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18981 
18988  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18989 
18996  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18997 
19003  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19004 
19011  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19012 
19018  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19019 
19027  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19028 
19035  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19036 
19044  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19045 
19052  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
19053 
19056  PostProcessEffectsKit & UnsetAmbientOcclusion();
19057 
19060  PostProcessEffectsKit & UnsetBloom();
19061 
19064  PostProcessEffectsKit & UnsetDepthOfField();
19065 
19068  PostProcessEffectsKit & UnsetSilhouetteEdges();
19069 
19072  PostProcessEffectsKit & UnsetEyeDomeLighting();
19073 
19076  PostProcessEffectsKit & UnsetEverything();
19077 
19078 
19085  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19086 
19093  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19094 
19101  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19102 
19110  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19111 
19119  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19120 };
19121 
19122 
19126 class HPS_API PostProcessEffectsControl : public Control
19127 {
19128 public:
19129 
19131  explicit PostProcessEffectsControl(WindowKey & in_seg);
19132 
19135 
19140 
19144  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
19145 
19148 
19149  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsControl;};
19150 
19152  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
19153 
19154 
19162  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19163 
19170  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19171 
19178  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19179 
19185  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19186 
19193  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19194 
19200  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19201 
19209  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19210 
19217  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19218 
19225  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19226 
19233  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
19234 
19235 
19238  PostProcessEffectsControl & UnsetAmbientOcclusion();
19239 
19242  PostProcessEffectsControl & UnsetBloom();
19243 
19246  PostProcessEffectsControl & UnsetDepthOfField();
19247 
19250  PostProcessEffectsControl & UnsetSilhouetteEdges();
19251 
19254  PostProcessEffectsControl & UnsetEyeDomeLighting();
19255 
19258  PostProcessEffectsControl & UnsetEverything();
19259 
19260 
19267  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19268 
19275  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19276 
19283  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19284 
19292  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19293 
19301  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19302 
19303 private:
19306 };
19307 
19309 class HPS_API TransformMaskKit : public Object
19310 {
19311 public:
19312 
19314  TransformMaskKit();
19315 
19317  TransformMaskKit(TransformMaskKit const & in_kit);
19318 
19322  TransformMaskKit(TransformMaskKit && in_that);
19323 
19327  TransformMaskKit & operator=(TransformMaskKit && in_that);
19328 
19330  virtual ~TransformMaskKit();
19331 
19332  HPS::Type ObjectType() const {return HPS::Type::TransformMaskKit;};
19333 
19334  static TransformMaskKit GetDefault();
19335 
19337  void Set(TransformMaskKit const & in_kit);
19338 
19340  void Show(TransformMaskKit & out_kit) const;
19341 
19343  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
19344 
19346  bool Empty() const;
19347 
19349  bool Equals(TransformMaskKit const & in_kit) const;
19350 
19352  bool operator==(TransformMaskKit const & in_kit) const;
19353 
19355  bool operator!=(TransformMaskKit const & in_kit) const;
19356 
19357 
19361  TransformMaskKit & SetCameraRotation(bool in_state);
19362 
19366  TransformMaskKit & SetCameraScale(bool in_state);
19367 
19371  TransformMaskKit & SetCameraTranslation(bool in_state);
19372 
19376  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
19377 
19381  TransformMaskKit & SetCameraProjection(bool in_state);
19382 
19386  TransformMaskKit & SetCameraOffset(bool in_state);
19387 
19391  TransformMaskKit & SetCameraNearLimit(bool in_state);
19392 
19396  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
19397 
19401  TransformMaskKit & SetModellingMatrixScale(bool in_state);
19402 
19406  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
19407 
19411  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
19412 
19413 
19417  TransformMaskKit & SetCameraEverything(bool in_state);
19418 
19422  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
19423 
19427  TransformMaskKit & SetEverything(bool in_state);
19428 
19429 
19432  TransformMaskKit & UnsetCameraRotation();
19433 
19436  TransformMaskKit & UnsetCameraScale();
19437 
19440  TransformMaskKit & UnsetCameraTranslation();
19441 
19444  TransformMaskKit & UnsetCameraPerspectiveScale();
19445 
19448  TransformMaskKit & UnsetCameraProjection();
19449 
19452  TransformMaskKit & UnsetCameraOffset();
19453 
19456  TransformMaskKit & UnsetCameraNearLimit();
19457 
19460  TransformMaskKit & UnsetCameraEverything();
19461 
19464  TransformMaskKit & UnsetModellingMatrixRotation();
19465 
19468  TransformMaskKit & UnsetModellingMatrixScale();
19469 
19472  TransformMaskKit & UnsetModellingMatrixTranslation();
19473 
19476  TransformMaskKit & UnsetModellingMatrixOffset();
19477 
19480  TransformMaskKit & UnsetModellingMatrixEverything();
19481 
19484  TransformMaskKit & UnsetEverything();
19485 
19486 
19490  bool ShowCameraRotation(bool & out_state) const;
19491 
19495  bool ShowCameraScale(bool & out_state) const;
19496 
19500  bool ShowCameraTranslation(bool & out_state) const;
19501 
19505  bool ShowCameraPerspectiveScale(bool & out_state) const;
19506 
19510  bool ShowCameraProjection(bool & out_state) const;
19511 
19515  bool ShowCameraOffset(bool & out_state) const;
19516 
19520  bool ShowCameraNearLimit(bool & out_state) const;
19521 
19525  bool ShowModellingMatrixRotation(bool & out_state) const;
19526 
19530  bool ShowModellingMatrixScale(bool & out_state) const;
19531 
19535  bool ShowModellingMatrixTranslation(bool & out_state) const;
19536 
19540  bool ShowModellingMatrixOffset(bool & out_state) const;
19541 };
19542 
19543 
19548 class HPS_API TransformMaskControl : public Control
19549 {
19550 public:
19551 
19553  explicit TransformMaskControl(SegmentKey & in_seg);
19554 
19556  TransformMaskControl(TransformMaskControl const & in_that);
19557 
19562 
19566  TransformMaskControl & operator=(TransformMaskControl && in_that);
19567 
19570 
19571  HPS::Type ObjectType() const {return HPS::Type::TransformMaskControl;};
19572 
19573 
19577  TransformMaskControl & SetCameraRotation(bool in_state);
19578 
19582  TransformMaskControl & SetCameraScale(bool in_state);
19583 
19587  TransformMaskControl & SetCameraTranslation(bool in_state);
19588 
19592  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19593 
19597  TransformMaskControl & SetCameraProjection(bool in_state);
19598 
19602  TransformMaskControl & SetCameraOffset(bool in_state);
19603 
19607  TransformMaskControl & SetCameraNearLimit(bool in_state);
19608 
19612  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19613 
19617  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19618 
19622  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19623 
19627  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19628 
19629 
19633  TransformMaskControl & SetCameraEverything(bool in_state);
19634 
19638  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19639 
19643  TransformMaskControl & SetEverything(bool in_state);
19644 
19645 
19648  TransformMaskControl & UnsetCameraRotation();
19649 
19652  TransformMaskControl & UnsetCameraScale();
19653 
19656  TransformMaskControl & UnsetCameraTranslation();
19657 
19660  TransformMaskControl & UnsetCameraPerspectiveScale();
19661 
19664  TransformMaskControl & UnsetCameraProjection();
19665 
19668  TransformMaskControl & UnsetCameraOffset();
19669 
19672  TransformMaskControl & UnsetCameraNearLimit();
19673 
19676  TransformMaskControl & UnsetCameraEverything();
19677 
19680  TransformMaskControl & UnsetModellingMatrixRotation();
19681 
19684  TransformMaskControl & UnsetModellingMatrixScale();
19685 
19688  TransformMaskControl & UnsetModellingMatrixTranslation();
19689 
19692  TransformMaskControl & UnsetModellingMatrixOffset();
19693 
19696  TransformMaskControl & UnsetModellingMatrixEverything();
19697 
19700  TransformMaskControl & UnsetEverything();
19701 
19702 
19706  bool ShowCameraRotation(bool & out_state) const;
19707 
19711  bool ShowCameraScale(bool & out_state) const;
19712 
19716  bool ShowCameraTranslation(bool & out_state) const;
19717 
19721  bool ShowCameraPerspectiveScale(bool & out_state) const;
19722 
19726  bool ShowCameraProjection(bool & out_state) const;
19727 
19731  bool ShowCameraOffset(bool & out_state) const;
19732 
19736  bool ShowCameraNearLimit(bool & out_state) const;
19737 
19741  bool ShowModellingMatrixRotation(bool & out_state) const;
19742 
19746  bool ShowModellingMatrixScale(bool & out_state) const;
19747 
19751  bool ShowModellingMatrixTranslation(bool & out_state) const;
19752 
19756  bool ShowModellingMatrixOffset(bool & out_state) const;
19757 
19758 private:
19761 };
19762 
19763 
19764 
19766 class HPS_API VisualEffectsKit : public Object
19767 {
19768 public:
19769 
19771  VisualEffectsKit();
19772 
19775  VisualEffectsKit(VisualEffectsKit const & in_kit);
19776 
19780  VisualEffectsKit(VisualEffectsKit && in_that);
19781 
19785  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
19786 
19788  virtual ~VisualEffectsKit();
19789 
19790  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsKit;};
19791 
19795  static VisualEffectsKit GetDefault();
19796 
19799  void Set(VisualEffectsKit const & in_kit);
19800 
19803  void Show(VisualEffectsKit & out_kit) const;
19804 
19808  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
19809 
19812  bool Empty() const;
19813 
19817  bool Equals(VisualEffectsKit const & in_kit) const;
19818 
19822  bool operator==(VisualEffectsKit const & in_kit) const;
19823 
19827  bool operator!=(VisualEffectsKit const & in_kit) const;
19828 
19832  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
19833 
19837  VisualEffectsKit & SetAntiAliasing(bool in_state);
19838 
19848  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19849 
19858  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19859 
19866  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19867 
19873  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19874 
19878  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19879 
19883  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19884 
19888  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19889 
19900  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);
19901 
19911  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19912 
19916  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19917 
19921  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19922 
19923 
19926  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
19927 
19930  VisualEffectsKit & UnsetAntiAliasing();
19931 
19934  VisualEffectsKit & UnsetShadowMaps();
19935 
19938  VisualEffectsKit & UnsetSimpleShadow();
19939 
19942  VisualEffectsKit & UnsetSimpleShadowPlane();
19943 
19946  VisualEffectsKit & UnsetSimpleShadowLightDirection();
19947 
19950  VisualEffectsKit & UnsetSimpleShadowColor();
19951 
19954  VisualEffectsKit & UnsetSimpleReflection();
19955 
19958  VisualEffectsKit & UnsetSimpleReflectionPlane();
19959 
19962  VisualEffectsKit & UnsetSimpleReflectionVisibility();
19963 
19966  VisualEffectsKit & UnsetEverything();
19967 
19971  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19972 
19976  bool ShowAntiAliasing(bool & out_state) const;
19977 
19985  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19986 
19993  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19994 
19998  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
19999 
20003  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20004 
20008  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20009 
20018  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;
20019 
20020 
20024  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20025 
20029  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20030 };
20031 
20032 
20038 class HPS_API VisualEffectsControl : public Control
20039 {
20040 public:
20041 
20043  explicit VisualEffectsControl(SegmentKey & in_seg);
20044 
20046  VisualEffectsControl(VisualEffectsControl const & in_that);
20047 
20052 
20056  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
20057 
20060 
20061  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsControl;};
20062 
20064  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
20065 
20069  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
20070 
20074  VisualEffectsControl & SetAntiAliasing(bool in_state);
20075 
20085  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
20086 
20095  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
20096 
20103  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
20104 
20110  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20111 
20115  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20116 
20120  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20121 
20125  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20126 
20137  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);
20138 
20148  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20149 
20153  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20154 
20158  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20159 
20160 
20163  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
20164 
20167  VisualEffectsControl & UnsetAntiAliasing();
20168 
20171  VisualEffectsControl & UnsetShadowMaps();
20172 
20175  VisualEffectsControl & UnsetSimpleShadow();
20176 
20179  VisualEffectsControl & UnsetSimpleShadowPlane();
20180 
20183  VisualEffectsControl & UnsetSimpleShadowLightDirection();
20184 
20187  VisualEffectsControl & UnsetSimpleShadowColor();
20188 
20191  VisualEffectsControl & UnsetSimpleReflection();
20192 
20195  VisualEffectsControl & UnsetSimpleReflectionPlane();
20196 
20199  VisualEffectsControl & UnsetSimpleReflectionVisibility();
20200 
20203  VisualEffectsControl & UnsetEverything();
20204 
20205 
20209  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20210 
20214  bool ShowAntiAliasing(bool & out_state) const;
20215 
20223  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20224 
20231  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20232 
20236  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20237 
20241  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20242 
20246  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20247 
20256  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;
20257 
20261  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20262 
20266  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20267 
20268 private:
20271 };
20272 
20273 
20274 
20276 class HPS_API ContourLineKit : public Object
20277 {
20278 public:
20279 
20281  ContourLineKit();
20282 
20285  ContourLineKit(ContourLineKit const & in_kit);
20286 
20290  ContourLineKit(ContourLineKit && in_that);
20291 
20295  ContourLineKit & operator=(ContourLineKit && in_that);
20296 
20298  virtual ~ContourLineKit();
20299 
20300  HPS::Type ObjectType() const { return HPS::Type::ContourLineKit; };
20301 
20305  static ContourLineKit GetDefault();
20306 
20309  void Set(ContourLineKit const & in_kit);
20310 
20313  void Show(ContourLineKit & out_kit) const;
20314 
20318  ContourLineKit & operator=(ContourLineKit const & in_kit);
20319 
20322  bool Empty() const;
20323 
20327  bool Equals(ContourLineKit const & in_kit) const;
20328 
20332  bool operator==(ContourLineKit const & in_kit) const;
20333 
20337  bool operator!=(ContourLineKit const & in_kit) const;
20338 
20339 
20343  ContourLineKit & SetVisibility(bool in_state);
20344 
20349  ContourLineKit & SetPositions(float in_interval, float in_offset);
20350 
20354  ContourLineKit & SetPositions(FloatArray const & in_positions);
20355 
20360  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
20361 
20365  ContourLineKit & SetColors(RGBColorArray const & in_colors);
20366 
20371  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
20372 
20376  ContourLineKit & SetColors(RGBColor const & in_color);
20377 
20381  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
20382 
20387  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20388 
20392  ContourLineKit & SetPatterns(char const * in_pattern);
20393 
20398  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20399 
20405  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20406 
20411  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20412 
20416  ContourLineKit & SetLighting(bool in_state);
20417 
20418 
20421  ContourLineKit & UnsetVisibility();
20422 
20425  ContourLineKit & UnsetPositions();
20426 
20429  ContourLineKit & UnsetColors();
20430 
20433  ContourLineKit & UnsetPatterns();
20434 
20437  ContourLineKit & UnsetWeights();
20438 
20441  ContourLineKit & UnsetLighting();
20442 
20445  ContourLineKit & UnsetEverything();
20446 
20447 
20451  bool ShowVisibility(bool & out_state) const;
20452 
20458  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20459 
20463  bool ShowColors(RGBColorArray & out_colors) const;
20464 
20468  bool ShowPatterns(UTF8Array & out_patterns) const;
20469 
20474  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20475 
20479  bool ShowLighting(bool & out_state) const;
20480 };
20481 
20485 class HPS_API ContourLineControl : public Control
20486 {
20487 public:
20488 
20490  explicit ContourLineControl(SegmentKey & in_seg);
20491 
20493  ContourLineControl(ContourLineControl const & in_that);
20494 
20499 
20503  ContourLineControl & operator=(ContourLineControl && in_that);
20504 
20506  ~ContourLineControl();
20507 
20508  HPS::Type ObjectType() const { return HPS::Type::ContourLineControl; };
20509 
20511  ContourLineControl & operator=(ContourLineControl const & in_that);
20512 
20513 
20517  ContourLineControl & SetVisibility(bool in_state);
20518 
20523  ContourLineControl & SetPositions(float in_interval, float in_offset);
20524 
20528  ContourLineControl & SetPositions(FloatArray const & in_positions);
20529 
20534  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20535 
20539  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20540 
20545  ContourLineControl & SetColors(size_t in_count, RGBColor const in_rgb_colors[]);
20546 
20550  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20551 
20555  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20556 
20561  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20562 
20566  ContourLineControl & SetPatterns(char const * in_pattern);
20567 
20572  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20573 
20579  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20580 
20585  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20586 
20590  ContourLineControl & SetLighting(bool in_state);
20591 
20592 
20595  ContourLineControl & UnsetVisibility();
20596 
20599  ContourLineControl & UnsetPositions();
20600 
20603  ContourLineControl & UnsetColors();
20604 
20607  ContourLineControl & UnsetPatterns();
20608 
20611  ContourLineControl & UnsetWeights();
20612 
20615  ContourLineControl & UnsetLighting();
20616 
20619  ContourLineControl & UnsetEverything();
20620 
20621 
20625  bool ShowVisibility(bool & out_state) const;
20626 
20632  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20633 
20637  bool ShowColors(RGBColorArray & out_colors) const;
20638 
20642  bool ShowPatterns(UTF8Array & out_patterns) const;
20643 
20648  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20649 
20653  bool ShowLighting(bool & out_state) const;
20654 
20655 private:
20658 };
20659 
20660 
20661 
20663 class HPS_API SubwindowKit : public Object
20664 {
20665 public:
20666 
20668  SubwindowKit();
20669 
20671  SubwindowKit(SubwindowKit const & in_kit);
20672 
20676  SubwindowKit(SubwindowKit && in_that);
20677 
20681  SubwindowKit & operator=(SubwindowKit && in_that);
20682 
20684  virtual ~SubwindowKit();
20685 
20686  HPS::Type ObjectType() const {return HPS::Type::SubwindowKit;}
20687 
20691  static SubwindowKit GetDefault();
20692 
20695  void Set(SubwindowKit const & in_kit);
20696 
20699  void Show(SubwindowKit & out_kit) const;
20700 
20704  SubwindowKit & operator=(SubwindowKit const & in_kit);
20705 
20708  bool Empty() const;
20709 
20713  bool Equals(SubwindowKit const & in_kit) const;
20714 
20718  bool operator==(SubwindowKit const & in_kit) const;
20719 
20723  bool operator!=(SubwindowKit const & in_kit) const;
20724 
20725 
20735  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20736 
20743  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20744 
20749  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
20750 
20755  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20756 
20762  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20763 
20768  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20769 
20772  SubwindowKit & UnsetSubwindow();
20773 
20776  SubwindowKit & UnsetBackground();
20777 
20780  SubwindowKit & UnsetBorder();
20781 
20784  SubwindowKit & UnsetRenderingAlgorithm();
20785 
20788  SubwindowKit & UnsetModelCompareMode();
20789 
20792  SubwindowKit & UnsetEverything();
20793 
20798  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
20799 
20804  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20805 
20809  bool ShowBorder(Subwindow::Border & out_border_type) const;
20810 
20814  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20815 
20821  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20822 };
20823 
20824 
20825 
20831 class HPS_API SubwindowControl : public Control
20832 {
20833 public:
20834 
20836  explicit SubwindowControl(SegmentKey & in_seg);
20837 
20839  SubwindowControl(SubwindowControl const & in_that);
20840 
20844  SubwindowControl(SubwindowControl && in_that);
20845 
20849  SubwindowControl & operator=(SubwindowControl && in_that);
20850 
20852  ~SubwindowControl();
20853 
20854  HPS::Type ObjectType() const {return HPS::Type::SubwindowControl;}
20855 
20857  SubwindowControl & operator=(SubwindowControl const & in_that);
20858 
20869  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
20870 
20877  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20878 
20883  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
20884 
20890  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20891 
20897  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20898 
20903  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20904 
20907  SubwindowControl & UnsetSubwindow();
20908 
20911  SubwindowControl & UnsetBackground();
20912 
20915  SubwindowControl & UnsetBorder();
20916 
20919  SubwindowControl & UnsetRenderingAlgorithm();
20920 
20923  SubwindowControl & UnsetModelCompareMode();
20924 
20927  SubwindowControl & UnsetEverything();
20928 
20929 
20934  bool ShowSubwindow(Rectangle & out_window_position, Subwindow::Type & out_subwindow_type) const;
20935 
20940  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20941 
20945  bool ShowBorder(Subwindow::Border & out_border_type) const;
20946 
20950  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20951 
20957  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20958 
20959 private:
20961  SubwindowControl();
20962 };
20963 
20964 
20965 
20967 class HPS_API DebuggingKit : public Object
20968 {
20969 public:
20970 
20972  DebuggingKit();
20973 
20975  DebuggingKit(DebuggingKit const & in_kit);
20976 
20980  DebuggingKit(DebuggingKit && in_that);
20981 
20985  DebuggingKit & operator=(DebuggingKit && in_that);
20986 
20988  virtual ~DebuggingKit();
20989 
20990  HPS::Type ObjectType() const {return HPS::Type::DebuggingKit;}
20991 
20995  static DebuggingKit GetDefault();
20996 
20999  void Set(DebuggingKit const & in_kit);
21000 
21003  void Show(DebuggingKit & out_kit) const;
21004 
21008  DebuggingKit & operator=(DebuggingKit const & in_kit);
21009 
21012  bool Empty() const;
21013 
21017  bool Equals(DebuggingKit const & in_kit) const;
21018 
21022  bool operator==(DebuggingKit const & in_kit) const;
21023 
21027  bool operator!=(DebuggingKit const & in_kit) const;
21028 
21029 
21033  DebuggingKit & SetResourceMonitor(bool in_display);
21034 
21035 
21038  DebuggingKit & UnsetResourceMonitor();
21039 
21042  DebuggingKit & UnsetEverything();
21043 
21044 
21048  bool ShowResourceMonitor(bool & out_display) const;
21049 };
21050 
21051 
21054 class HPS_API DebuggingControl : public Control
21055 {
21056 public:
21057 
21059  explicit DebuggingControl(WindowKey & in_window);
21060 
21062  DebuggingControl(DebuggingControl const & in_that);
21063 
21067  DebuggingControl(DebuggingControl && in_that);
21068 
21072  DebuggingControl & operator=(DebuggingControl && in_that);
21073 
21075  ~DebuggingControl();
21076 
21077  HPS::Type ObjectType() const {return HPS::Type::DebuggingControl;}
21078 
21080  DebuggingControl & operator=(DebuggingControl const & in_that);
21081 
21086  DebuggingControl & SetResourceMonitor(bool in_display);
21087 
21091  bool ShowResourceMonitor(bool & out_display) const;
21092 
21096  bool ShowLastUpdateInfo(UpdateInfo & out_info);
21097 
21098 private:
21100  DebuggingControl();
21101 };
21102 
21103 
21105 class HPS_API WindowInfoKit : public Object
21106 {
21107 public:
21108 
21110  WindowInfoKit();
21111 
21113  WindowInfoKit(WindowInfoKit const & in_kit);
21114 
21118  WindowInfoKit(WindowInfoKit && in_that);
21119 
21123  WindowInfoKit & operator=(WindowInfoKit && in_that);
21124 
21126  virtual ~WindowInfoKit();
21127 
21128  HPS::Type ObjectType() const {return HPS::Type::WindowInfoKit;}
21129 
21132  void Set(WindowInfoKit const & in_kit);
21133 
21136  void Show(WindowInfoKit & out_kit) const;
21137 
21141  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
21142 
21145  bool Empty() const;
21146 
21150  bool Equals(WindowInfoKit const & in_kit) const;
21151 
21155  bool operator==(WindowInfoKit const & in_kit) const;
21156 
21160  bool operator!=(WindowInfoKit const & in_kit) const;
21161 
21162 
21167  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
21168 
21173  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
21174 
21179  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
21180 
21185  WindowInfoKit & SetWindowSize(float in_width, float in_height);
21186 
21187 
21190  WindowInfoKit & UnsetPhysicalPixels();
21191 
21194  WindowInfoKit & UnsetPhysicalSize();
21195 
21198  WindowInfoKit & UnsetWindowPixels();
21199 
21202  WindowInfoKit & UnsetWindowSize();
21203 
21206  WindowInfoKit & UnsetEverything();
21207 
21208 
21213  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21214 
21219  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21220 
21225  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21226 
21231  bool ShowWindowSize(float & out_width, float & out_height) const;
21232 
21238  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21239 
21243  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21244 
21248  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21249 };
21250 
21251 
21254 class HPS_API WindowInfoControl : public Control
21255 {
21256 public:
21257 
21259  explicit WindowInfoControl(WindowKey & in_window);
21260 
21262  WindowInfoControl(WindowInfoControl const & in_that);
21263 
21268 
21272  WindowInfoControl & operator=(WindowInfoControl && in_that);
21273 
21275  ~WindowInfoControl();
21276 
21277  HPS::Type ObjectType() const {return HPS::Type::WindowInfoControl;}
21278 
21280  WindowInfoControl & operator=(WindowInfoControl const & in_that);
21281 
21286  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21287 
21292  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21293 
21298  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21299 
21304  bool ShowWindowSize(float & out_width, float & out_height) const;
21305 
21311  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21312 
21316  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21317 
21321  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21322 
21327  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
21328 
21333  bool ShowLastUpdateTime(Time & out_time) const;
21334 
21338  bool ShowDepthPeelingLayers(size_t & out_layers) const;
21339 
21343  bool ShowVideoMemory(size_t & out_video_memory) const;
21344 
21348  bool ShowDepthBufferSize(size_t & out_bits) const;
21349 
21353  bool ShowMaxLights(size_t & out_lights) const;
21354 
21358  bool ShowColorBitPlanes(size_t & out_planes) const;
21359 
21360 private:
21363 };
21364 
21366 class HPS_API FontInfoState : public Object
21367 {
21368 public:
21369 
21371  FontInfoState();
21372 
21374  FontInfoState(FontInfoState const & in_kit);
21375 
21379  FontInfoState(FontInfoState && in_that);
21380 
21384  FontInfoState & operator=(FontInfoState && in_that);
21385 
21387  virtual ~FontInfoState();
21388 
21389  HPS::Type ObjectType() const {return HPS::Type::FontInfoState;}
21390 
21393  void Assign(FontInfoState const & in_that);
21394 
21397  void Set(FontInfoState const & in_kit);
21398 
21401  void Show(FontInfoState & out_kit) const;
21402 
21406  FontInfoState & operator=(FontInfoState const & in_kit);
21407 
21410  bool Empty() const;
21411 
21415  bool Equals(FontInfoState const & in_kit) const;
21416 
21420  bool operator==(FontInfoState const & in_kit) const;
21421 
21425  bool operator!=(FontInfoState const & in_kit) const;
21426 
21429  UTF8 GetName() const;
21430 
21433  bool GetShellConvertibility() const;
21434 };
21435 
21436 
21441 class HPS_API AttributeLockKit : public Object
21442 {
21443 public:
21444 
21446  AttributeLockKit();
21447 
21449  AttributeLockKit(AttributeLockKit const & in_kit);
21450 
21454  AttributeLockKit(AttributeLockKit && in_that);
21455 
21459  AttributeLockKit & operator=(AttributeLockKit && in_that);
21460 
21462  virtual ~AttributeLockKit();
21463 
21464  HPS::Type ObjectType() const {return HPS::Type::AttributeLockKit;}
21465 
21469  static AttributeLockKit GetDefault();
21470 
21473  void Set(AttributeLockKit const & in_kit);
21474 
21477  void Show(AttributeLockKit & out_kit) const;
21478 
21482  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
21483 
21486  bool Empty() const;
21487 
21491  bool Equals(AttributeLockKit const & in_kit) const;
21492 
21496  bool operator==(AttributeLockKit const & in_kit) const;
21497 
21501  bool operator!=(AttributeLockKit const & in_kit) const;
21502 
21508  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
21509 
21514  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21515 
21521  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21522 
21528  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21529 
21530 
21533  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21534 
21537  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
21538 
21541  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21542 
21545  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21546 
21549  AttributeLockKit & UnsetEverything();
21550 
21551 
21556  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21557 
21562  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21563 
21568  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21569 
21574  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21575 };
21576 
21577 
21582 class HPS_API AttributeLockControl : public Control
21583 {
21584 public:
21585 
21587  explicit AttributeLockControl(SegmentKey & in_seg);
21588 
21593 
21597  AttributeLockControl & operator=(AttributeLockControl && in_that);
21598 
21600  AttributeLockControl(AttributeLockControl const & in_that);
21601 
21604 
21605  HPS::Type ObjectType() const {return HPS::Type::AttributeLockControl;}
21606 
21608  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21609 
21610 
21616  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21617 
21622  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21623 
21629  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21630 
21636  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21637 
21638 
21641  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21642 
21645  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21646 
21649  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21650 
21653  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21654 
21657  AttributeLockControl & UnsetEverything();
21658 
21659 
21664  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21665 
21670  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21671 
21676  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21677 
21682  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21683 
21684 private:
21687 };
21688 
21692 
21693 class HPS_API GeometryKey : public Key
21694 {
21695 public:
21697  GeometryKey();
21698 
21702  explicit GeometryKey(Key const & in_that);
21703 
21706  GeometryKey(GeometryKey const & in_that);
21707 
21711  GeometryKey & operator=(GeometryKey const & in_that);
21712 
21716  GeometryKey(GeometryKey && in_that);
21717 
21721  GeometryKey & operator=(GeometryKey && in_that);
21722 
21723  ~GeometryKey();
21724 
21725  HPS::Type ObjectType() const { return HPS::Type::GeometryKey; };
21726 
21727 
21731  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21732 
21736  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
21737 
21738 
21739 
21746  GeometryKey & SetPriority(int in_priority);
21747 
21750  GeometryKey & UnsetPriority();
21751 
21755  bool ShowPriority(int & out_priority) const;
21756 
21757 
21763  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21764 
21769  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
21770 
21775  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21776 
21780  GeometryKey & UnsetUserData(intptr_t in_index);
21781 
21786  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21787 
21791  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
21792 
21795  GeometryKey & UnsetAllUserData();
21796 
21798  size_t ShowUserDataCount() const;
21799 
21803  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21804 
21809  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21810 
21815  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21816 
21821  bool ShowBoundings(BoundingKit & out_kit) const;
21822 };
21823 
21824 
21826 class HPS_API LineKit : public Object
21827 {
21828 public:
21830  LineKit();
21831 
21834  LineKit(LineKit const & in_kit);
21835 
21839  LineKit(LineKit && in_that);
21840 
21844  LineKit & operator=(LineKit && in_that);
21845 
21846  virtual ~LineKit();
21847 
21848  HPS::Type ObjectType() const { return HPS::Type::LineKit; };
21849 
21852  void Consume(LineKit & in_kit);
21853 
21856  void Set(LineKit const & in_kit);
21857 
21860  void Show(LineKit & out_kit) const;
21861 
21865  LineKit & operator=(LineKit const & in_kit);
21866 
21869  bool Empty() const;
21870 
21874  bool Equals(LineKit const & in_kit) const;
21875 
21879  bool operator==(LineKit const & in_kit) const;
21880 
21884  bool operator!=(LineKit const & in_kit) const;
21885 
21888  size_t GetPointCount() const;
21889 
21896  LineKit & SetPriority(int in_priority);
21897 
21900  LineKit & UnsetPriority();
21901 
21905  bool ShowPriority(int & out_priority) const;
21906 
21907 
21911  LineKit & SetPoints(PointArray const & in_points);
21912 
21917  LineKit & SetPoints(size_t in_count, Point const in_points []);
21918 
21919 
21922  LineKit & UnsetPoints();
21923 
21926  LineKit & UnsetEverything();
21927 
21928 
21932  bool ShowPoints(PointArray & out_points) const;
21933 
21939  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
21940 
21945  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
21946 
21952  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
21953 
21954 
21960  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21961 
21966  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21967 
21972  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
21973 
21979  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21980 
21986  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21987 
21993  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21994 
21999  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22000 
22005  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22006 
22010  LineKit & UnsetUserData(intptr_t in_index);
22011 
22016  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22017 
22021  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
22022 
22025  LineKit & UnsetAllUserData();
22026 
22028  size_t ShowUserDataCount() const;
22029 
22033  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22034 
22039  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22040 
22045  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22046 };
22047 
22049 class HPS_API LineKey : public GeometryKey
22050 {
22051 public:
22053  LineKey();
22054 
22058  explicit LineKey(Key const & in_that);
22059 
22062  LineKey(LineKey const & in_that);
22063 
22067  LineKey & operator=(LineKey const & in_that);
22068 
22072  LineKey(LineKey && in_that);
22073 
22077  LineKey & operator=(LineKey && in_that);
22078 
22079  ~LineKey();
22080 
22081  HPS::Type ObjectType() const { return HPS::Type::LineKey; };
22082 
22083 
22086  void Consume(LineKit & in_kit);
22087 
22090  void Set(LineKit const & in_kit);
22091 
22094  void Show(LineKit & out_kit) const;
22095 
22098  size_t GetPointCount() const;
22099 
22103  LineKey & SetPoints(PointArray const & in_points);
22104 
22109  LineKey & SetPoints(size_t in_count, Point const in_points []);
22110 
22111 
22115  bool ShowPoints(PointArray & out_points) const;
22116 
22122  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22123 
22128  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22129 
22135  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22136 
22137 
22143  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22144 
22149  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22150 
22155  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22156 
22162  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22163 
22169  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22170 };
22171 
22172 
22173 
22175 class HPS_API MarkerKit : public Object
22176 {
22177 public:
22179  MarkerKit();
22180 
22183  MarkerKit(MarkerKit const & in_kit);
22184 
22188  MarkerKit(MarkerKit && in_that);
22189 
22193  MarkerKit & operator=(MarkerKit && in_that);
22194 
22195  virtual ~MarkerKit();
22196 
22197  HPS::Type ObjectType() const { return HPS::Type::MarkerKit; };
22198 
22201  void Consume(MarkerKit & in_kit);
22202 
22205  void Set(MarkerKit const & in_kit);
22206 
22209  void Show(MarkerKit & out_kit) const;
22210 
22214  MarkerKit & operator=(MarkerKit const & in_kit);
22215 
22218  bool Empty() const;
22219 
22223  bool Equals(MarkerKit const & in_kit) const;
22224 
22228  bool operator==(MarkerKit const & in_kit) const;
22229 
22233  bool operator!=(MarkerKit const & in_kit) const;
22234 
22235 
22242  MarkerKit & SetPriority(int in_priority);
22243 
22246  MarkerKit & UnsetPriority();
22247 
22251  bool ShowPriority(int & out_priority) const;
22252 
22256  MarkerKit & SetPoint(Point const & in_point);
22257 
22258 
22261  MarkerKit & UnsetPoint();
22262 
22265  MarkerKit & UnsetEverything();
22266 
22267 
22271  bool ShowPoint(HPS::Point & out_point) const;
22272 
22278  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22279 
22284  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22285 
22290  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22291 
22295  MarkerKit & UnsetUserData(intptr_t in_index);
22296 
22301  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22302 
22306  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
22307 
22310  MarkerKit & UnsetAllUserData();
22311 
22313  size_t ShowUserDataCount() const;
22314 
22318  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22319 
22324  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22325 
22330  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22331 };
22332 
22334 class HPS_API MarkerKey : public GeometryKey
22335 {
22336 public:
22338  MarkerKey();
22339 
22343  explicit MarkerKey(Key const & in_that);
22344 
22347  MarkerKey(MarkerKey const & in_that);
22348 
22352  MarkerKey & operator=(MarkerKey const & in_that);
22353 
22357  MarkerKey(MarkerKey && in_that);
22358 
22362  MarkerKey & operator=(MarkerKey && in_that);
22363 
22364  ~MarkerKey();
22365 
22366  HPS::Type ObjectType() const { return HPS::Type::MarkerKey; };
22367 
22368 
22371  void Consume(MarkerKit & in_kit);
22372 
22375  void Set(MarkerKit const & in_kit);
22376 
22379  void Show(MarkerKit & out_kit) const;
22380 
22381 
22385  MarkerKey & SetPoint(Point const & in_point);
22386 
22390  bool ShowPoint(Point & out_point) const;
22391 };
22392 
22393 
22394 
22396 class HPS_API DistantLightKit : public Object
22397 {
22398 public:
22400  DistantLightKit();
22401 
22404  DistantLightKit(DistantLightKit const & in_kit);
22405 
22409  DistantLightKit(DistantLightKit && in_that);
22410 
22414  DistantLightKit & operator=(DistantLightKit && in_that);
22415 
22416  virtual ~DistantLightKit();
22417 
22418  HPS::Type ObjectType() const { return HPS::Type::DistantLightKit; };
22419 
22422  void Consume(DistantLightKit & in_kit);
22423 
22426  void Set(DistantLightKit const & in_kit);
22427 
22430  void Show(DistantLightKit & out_kit) const;
22431 
22435  DistantLightKit & operator=(DistantLightKit const & in_kit);
22436 
22439  bool Empty() const;
22440 
22444  bool Equals(DistantLightKit const & in_kit) const;
22445 
22449  bool operator==(DistantLightKit const & in_kit) const;
22450 
22454  bool operator!=(DistantLightKit const & in_kit) const;
22455 
22456 
22463  DistantLightKit & SetPriority(int in_priority);
22464 
22470  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
22471 
22475  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
22476 
22480  DistantLightKit & SetColorByIndex(float in_index);
22481 
22487  DistantLightKit & SetCameraRelative(bool in_state);
22488 
22489 
22492  DistantLightKit & UnsetPriority();
22493 
22496  DistantLightKit & UnsetDirection();
22497 
22500  DistantLightKit & UnsetColor();
22501 
22504  DistantLightKit & UnsetCameraRelative();
22505 
22508  DistantLightKit & UnsetEverything();
22509 
22510 
22514  bool ShowPriority(int & out_priority) const;
22515 
22519  bool ShowDirection(HPS::Vector & out_vector) const;
22520 
22526  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22527 
22531  bool ShowCameraRelative(bool & out_state) const;
22532 
22538  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22539 
22544  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22545 
22550  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22551 
22555  DistantLightKit & UnsetUserData(intptr_t in_index);
22556 
22561  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22562 
22566  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
22567 
22570  DistantLightKit & UnsetAllUserData();
22571 
22573  size_t ShowUserDataCount() const;
22574 
22578  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22579 
22584  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22585 
22590  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22591 };
22592 
22593 
22594 
22596 class HPS_API DistantLightKey : public GeometryKey
22597 {
22598 public:
22600  DistantLightKey();
22601 
22605  explicit DistantLightKey(Key const & in_that);
22606 
22609  DistantLightKey(DistantLightKey const & in_that);
22610 
22614  DistantLightKey & operator=(DistantLightKey const & in_that);
22615 
22619  DistantLightKey(DistantLightKey && in_that);
22620 
22624  DistantLightKey & operator=(DistantLightKey && in_that);
22625 
22626  ~DistantLightKey();
22627 
22628  HPS::Type ObjectType() const { return HPS::Type::DistantLightKey; };
22629 
22632  void Consume(DistantLightKit & in_kit);
22633 
22636  void Set(DistantLightKit const & in_kit);
22637 
22640  void Show(DistantLightKit & out_kit) const;
22641 
22642 
22647  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
22648 
22652  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22653 
22657  DistantLightKey & SetColorByIndex(float in_index);
22658 
22663  DistantLightKey & SetCameraRelative(bool in_state);
22664 
22665 
22668  DistantLightKey & UnsetColor();
22669 
22670 
22674  bool ShowDirection(HPS::Vector & out_vector) const;
22675 
22681  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22682 
22686  bool ShowCameraRelative(bool & out_state) const;
22687 };
22688 
22689 
22690 
22691 
22693 class HPS_API CylinderKit : public Object
22694 {
22695 public:
22697  CylinderKit();
22698 
22701  CylinderKit(CylinderKit const & in_kit);
22702 
22706  CylinderKit(CylinderKit && in_that);
22707 
22711  CylinderKit & operator=(CylinderKit && in_that);
22712 
22713  virtual ~CylinderKit();
22714 
22715  HPS::Type ObjectType() const { return HPS::Type::CylinderKit; };
22716 
22719  void Consume(CylinderKit & in_kit);
22720 
22723  void Set(CylinderKit const & in_kit);
22724 
22727  void Show(CylinderKit & out_kit) const;
22728 
22732  CylinderKit & operator=(CylinderKit const & in_kit);
22733 
22736  bool Empty() const;
22737 
22741  bool Equals(CylinderKit const & in_kit) const;
22742 
22746  bool operator==(CylinderKit const & in_kit) const;
22747 
22751  bool operator!=(CylinderKit const & in_kit) const;
22752 
22755  size_t GetPointCount() const;
22756 
22763  CylinderKit & SetPriority(int in_priority);
22764 
22767  CylinderKit & UnsetPriority();
22768 
22772  bool ShowPriority(int & out_priority) const;
22773 
22774 
22778  CylinderKit & SetPoints(PointArray const & in_points);
22779 
22784  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
22785 
22789  CylinderKit & SetRadii(FloatArray const & in_radii);
22790 
22795  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
22796 
22800  CylinderKit & SetCaps(Cylinder::Capping in_capping);
22801 
22802 
22805  CylinderKit & UnsetPoints();
22806 
22809  CylinderKit & UnsetRadii();
22810 
22813  CylinderKit & UnsetCaps();
22814 
22817  CylinderKit & UnsetEverything();
22818 
22819 
22823  bool ShowPoints(PointArray & out_points) const;
22824 
22830  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22831 
22836  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22837 
22843  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22844 
22848  bool ShowRadii(FloatArray & out_radii) const;
22849 
22853  bool ShowCaps(Cylinder::Capping & out_caps) const;
22854 
22855 
22862  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22863 
22869  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22870 
22877  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22878 
22885  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22886 
22893  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22894 
22901  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22902 
22908  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22909 
22910 
22917  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22918 
22924  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22925 
22932  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22933 
22940  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22941 
22948  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22949 
22956  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22957 
22963  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22964 
22965 
22968  CylinderKit & UnsetVertexColors();
22969 
22974  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22975 
22979  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
22980 
22981 
22985  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
22986 
22992  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22993 
22998  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
22999 
23000 
23012  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;
23013 
23026  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23027 
23033  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23034 
23039  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23040 
23045  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23046 
23050  CylinderKit & UnsetUserData(intptr_t in_index);
23051 
23056  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23057 
23061  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
23062 
23065  CylinderKit & UnsetAllUserData();
23066 
23068  size_t ShowUserDataCount() const;
23069 
23073  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23074 
23079  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23080 
23085  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23086 };
23087 
23088 
23089 
23091 class HPS_API CylinderKey : public GeometryKey
23092 {
23093 public:
23095  CylinderKey();
23096 
23100  explicit CylinderKey(Key const & in_that);
23101 
23104  CylinderKey(CylinderKey const & in_that);
23105 
23109  CylinderKey & operator=(CylinderKey const & in_that);
23110 
23114  CylinderKey(CylinderKey && in_that);
23115 
23119  CylinderKey & operator=(CylinderKey && in_that);
23120 
23121  ~CylinderKey();
23122 
23123  HPS::Type ObjectType() const { return HPS::Type::CylinderKey; };
23124 
23127  void Consume(CylinderKit & in_kit);
23128 
23131  void Set(CylinderKit const & in_kit);
23132 
23133 
23139  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23140 
23145  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23146 
23151  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
23152 
23158  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23159 
23165  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23166 
23167 
23173  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
23174 
23179  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
23180 
23185  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
23186 
23192  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
23193 
23199  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
23200 
23201 
23204  void Show(CylinderKit & out_kit) const;
23205 
23208  size_t GetPointCount() const;
23209 
23213  bool ShowPoints(PointArray & out_points) const;
23214 
23220  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23221 
23226  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23227 
23233  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23234 
23238  bool ShowRadii(FloatArray & out_radii) const;
23239 
23243  bool ShowCaps(Cylinder::Capping & out_caps) const;
23244 
23245 
23252  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23253 
23260  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23261 
23268  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23269 
23270 
23277  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23278 
23285  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23286 
23293  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23294 
23295 
23298  CylinderKey & UnsetVertexColors();
23299 
23304  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23305 
23309  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
23310 
23316  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23317 
23318 
23330  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;
23331 
23344  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23345 };
23346 
23347 
23348 
23349 
23351 class HPS_API SphereKit : public Object
23352 {
23353 public:
23355  SphereKit();
23356 
23359  SphereKit(SphereKit const & in_kit);
23360 
23364  SphereKit(SphereKit && in_that);
23365 
23369  SphereKit & operator=(SphereKit && in_that);
23370 
23371  virtual ~SphereKit();
23372 
23373  HPS::Type ObjectType() const { return HPS::Type::SphereKit; };
23374 
23377  void Consume(SphereKit & in_kit);
23378 
23381  void Set(SphereKit const & in_kit);
23382 
23385  void Show(SphereKit & out_kit) const;
23386 
23390  SphereKit & operator=(SphereKit const & in_kit);
23391 
23394  bool Empty() const;
23395 
23399  bool Equals(SphereKit const & in_kit) const;
23400 
23404  bool operator==(SphereKit const & in_kit) const;
23405 
23409  bool operator!=(SphereKit const & in_kit) const;
23410 
23417  SphereKit & SetPriority(int in_priority);
23418 
23421  SphereKit & UnsetPriority();
23422 
23426  bool ShowPriority(int & out_priority) const;
23427 
23431  SphereKit & SetCenter(Point const & in_center);
23432 
23436  SphereKit & SetRadius(float in_radius);
23437 
23442  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23443 
23444 
23447  SphereKit & UnsetCenter();
23448 
23451  SphereKit & UnsetRadius();
23452 
23455  SphereKit & UnsetBasis();
23456 
23459  SphereKit & UnsetEverything();
23460 
23461 
23465  bool ShowCenter(Point & out_center) const;
23466 
23470  bool ShowRadius(float & out_radius) const;
23471 
23476  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23477 
23483  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23484 
23489  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23490 
23495  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23496 
23500  SphereKit & UnsetUserData(intptr_t in_index);
23501 
23506  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23507 
23511  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
23512 
23515  SphereKit & UnsetAllUserData();
23516 
23518  size_t ShowUserDataCount() const;
23519 
23523  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23524 
23529  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23530 
23535  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23536 };
23537 
23539 class HPS_API SphereKey : public GeometryKey
23540 {
23541 public:
23543  SphereKey();
23544 
23548  explicit SphereKey(Key const & in_that);
23549 
23552  SphereKey(SphereKey const & in_that);
23553 
23557  SphereKey & operator=(SphereKey const & in_that);
23558 
23562  SphereKey(SphereKey && in_that);
23563 
23567  SphereKey & operator=(SphereKey && in_that);
23568 
23569  ~SphereKey();
23570 
23571  HPS::Type ObjectType() const {return HPS::Type::SphereKey;};
23572 
23575  void Consume(SphereKit & in_kit);
23576 
23579  void Set(SphereKit const & in_kit);
23580 
23583  void Show(SphereKit & out_kit) const;
23584 
23585 
23589  SphereKey & SetCenter(Point const & in_center);
23590 
23594  SphereKey & SetRadius(float in_radius);
23595 
23600  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23601 
23602 
23606  bool ShowCenter(Point & out_center) const;
23607 
23611  bool ShowRadius(float & out_radius) const;
23612 
23617  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23618 };
23619 
23620 
23621 
23622 
23624 class HPS_API CircleKit : public Object
23625 {
23626 public:
23628  CircleKit();
23629 
23632  CircleKit(CircleKit const & in_kit);
23633 
23637  CircleKit(CircleKit && in_that);
23638 
23642  CircleKit & operator=(CircleKit && in_that);
23643 
23644  virtual ~CircleKit();
23645 
23646  HPS::Type ObjectType() const { return HPS::Type::CircleKit; };
23647 
23650  void Consume(CircleKit & in_kit);
23651 
23654  void Set(CircleKit const & in_kit);
23655 
23658  void Show(CircleKit & out_kit) const;
23659 
23663  CircleKit & operator=(CircleKit const & in_kit);
23664 
23667  bool Empty() const;
23668 
23672  bool Equals(CircleKit const & in_kit) const;
23673 
23677  bool operator==(CircleKit const & in_kit) const;
23678 
23682  bool operator!=(CircleKit const & in_kit) const;
23683 
23690  CircleKit & SetPriority(int const in_priority);
23691 
23694  CircleKit & UnsetPriority();
23695 
23699  bool ShowPriority(int & out_priority) const;
23700 
23701 
23702 
23706  CircleKit & SetCenter(Point const & in_center);
23707 
23711  CircleKit & SetRadius(float in_radius);
23712 
23716  CircleKit & SetNormal(Vector const & in_normal);
23717 
23718 
23721  CircleKit & UnsetCenter();
23722 
23725  CircleKit & UnsetRadius();
23726 
23729  CircleKit & UnsetNormal();
23730 
23733  CircleKit & UnsetEverything();
23734 
23735 
23739  bool ShowCenter(Point & out_center) const;
23740 
23744  bool ShowRadius(float & out_radius) const;
23745 
23749  bool ShowNormal(Vector & out_normal) const;
23750 
23756  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23757 
23762  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23763 
23768  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23769 
23773  CircleKit & UnsetUserData(intptr_t in_index);
23774 
23779  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23780 
23784  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
23785 
23788  CircleKit & UnsetAllUserData();
23789 
23791  size_t ShowUserDataCount() const;
23792 
23796  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23797 
23802  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23803 
23808  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23809 };
23810 
23811 
23814 class HPS_API CircleKey : public GeometryKey
23815 {
23816 public:
23818  CircleKey();
23819 
23823  explicit CircleKey(Key const & in_that);
23824 
23827  CircleKey(CircleKey const & in_that);
23828 
23832  CircleKey & operator=(CircleKey const & in_that);
23833 
23837  CircleKey(CircleKey && in_that);
23838 
23842  CircleKey & operator=(CircleKey && in_that);
23843 
23844  ~CircleKey();
23845 
23846  HPS::Type ObjectType() const { return HPS::Type::CircleKey; };
23847 
23848 
23851  void Consume(CircleKit & in_kit);
23852 
23855  void Set(CircleKit const & in_kit);
23856 
23859  void Show(CircleKit & out_kit) const;
23860 
23861 
23865  CircleKey & SetCenter(Point const & in_center);
23866 
23870  CircleKey & SetRadius(float in_radius);
23871 
23875  CircleKey & SetNormal(Vector const & in_normal);
23876 
23877 
23881  bool ShowCenter(Point & out_center) const;
23882 
23886  bool ShowRadius(float & out_radius) const;
23887 
23891  bool ShowNormal(Vector & out_normal) const;
23892 };
23893 
23894 
23895 
23896 
23898 class HPS_API CircularArcKit : public Object
23899 {
23900 public:
23902  CircularArcKit();
23903 
23906  CircularArcKit(CircularArcKit const & in_kit);
23907 
23911  CircularArcKit(CircularArcKit && in_that);
23912 
23916  CircularArcKit & operator=(CircularArcKit && in_that);
23917 
23918  virtual ~CircularArcKit();
23919 
23920  HPS::Type ObjectType() const { return HPS::Type::CircularArcKit; };
23921 
23924  void Consume(CircularArcKit & in_kit);
23925 
23928  void Set(CircularArcKit const & in_kit);
23929 
23932  void Show(CircularArcKit & out_kit) const;
23933 
23937  CircularArcKit & operator=(CircularArcKit const & in_kit);
23938 
23941  bool Empty() const;
23942 
23946  bool Equals(CircularArcKit const & in_kit) const;
23947 
23951  bool operator==(CircularArcKit const & in_kit) const;
23952 
23956  bool operator!=(CircularArcKit const & in_kit) const;
23957 
23964  CircularArcKit & SetPriority(int in_priority);
23965 
23968  CircularArcKit & UnsetPriority();
23969 
23973  bool ShowPriority(int & out_priority) const;
23974 
23975 
23979  CircularArcKit & SetStart(Point const & in_start);
23980 
23984  CircularArcKit & SetMiddle(Point const & in_middle);
23985 
23989  CircularArcKit & SetEnd(Point const & in_end);
23990 
23991 
23994  CircularArcKit & UnsetStart();
23995 
23998  CircularArcKit & UnsetMiddle();
23999 
24002  CircularArcKit & UnsetEnd();
24003 
24006  CircularArcKit & UnsetEverything();
24007 
24008 
24012  bool ShowStart(Point & out_start) const;
24013 
24017  bool ShowMiddle(Point & out_middle) const;
24018 
24022  bool ShowEnd(Point & out_end) const;
24023 
24029  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24030 
24035  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24036 
24041  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24042 
24046  CircularArcKit & UnsetUserData(intptr_t in_index);
24047 
24052  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24053 
24057  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
24058 
24061  CircularArcKit & UnsetAllUserData();
24062 
24064  size_t ShowUserDataCount() const;
24065 
24069  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24070 
24075  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24076 
24081  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24082 };
24083 
24086 class HPS_API CircularArcKey : public GeometryKey
24087 {
24088 public:
24090  CircularArcKey();
24091 
24095  explicit CircularArcKey(Key const & in_that);
24096 
24099  CircularArcKey(CircularArcKey const & in_that);
24100 
24104  CircularArcKey & operator=(CircularArcKey const & in_that);
24105 
24109  CircularArcKey(CircularArcKey && in_that);
24110 
24114  CircularArcKey & operator=(CircularArcKey && in_that);
24115 
24116  ~CircularArcKey();
24117 
24118  HPS::Type ObjectType() const { return HPS::Type::CircularArcKey; };
24119 
24120 
24123  void Consume(CircularArcKit & in_kit);
24124 
24127  void Set(CircularArcKit const & in_kit);
24128 
24131  void Show(CircularArcKit & out_kit) const;
24132 
24133 
24137  CircularArcKey & SetStart(Point const & in_start);
24138 
24142  CircularArcKey & SetMiddle(Point const & in_middle);
24143 
24147  CircularArcKey & SetEnd(Point const & in_end);
24148 
24149 
24153  bool ShowStart(Point & out_start) const;
24154 
24158  bool ShowMiddle(Point & out_middle) const;
24159 
24163  bool ShowEnd(Point & out_end) const;
24164 };
24165 
24166 
24167 
24169 class HPS_API CircularWedgeKit : public Object
24170 {
24171 public:
24173  CircularWedgeKit();
24174 
24177  CircularWedgeKit(CircularWedgeKit const & in_kit);
24178 
24182  CircularWedgeKit(CircularWedgeKit && in_that);
24183 
24187  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
24188 
24189  virtual ~CircularWedgeKit();
24190 
24191  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKit; };
24192 
24195  void Consume(CircularWedgeKit & in_kit);
24196 
24199  void Set(CircularWedgeKit const & in_kit);
24200 
24203  void Show(CircularWedgeKit & out_kit) const;
24204 
24208  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
24209 
24212  bool Empty() const;
24213 
24217  bool Equals(CircularWedgeKit const & in_kit) const;
24218 
24222  bool operator==(CircularWedgeKit const & in_kit) const;
24223 
24227  bool operator!=(CircularWedgeKit const & in_kit) const;
24228 
24229 
24236  CircularWedgeKit & SetPriority(int in_priority);
24237 
24240  CircularWedgeKit & UnsetPriority();
24241 
24245  bool ShowPriority(int & out_priority) const;
24246 
24247 
24251  CircularWedgeKit & SetStart(Point const & in_start);
24252 
24256  CircularWedgeKit & SetMiddle(Point const & in_middle);
24257 
24261  CircularWedgeKit & SetEnd(Point const & in_end);
24262 
24263 
24266  CircularWedgeKit & UnsetStart();
24267 
24270  CircularWedgeKit & UnsetMiddle();
24271 
24274  CircularWedgeKit & UnsetEnd();
24275 
24278  CircularWedgeKit & UnsetEverything();
24279 
24280 
24284  bool ShowStart(Point & out_start) const;
24285 
24289  bool ShowMiddle(Point & out_middle) const;
24290 
24294  bool ShowEnd(Point & out_end) const;
24295 
24301  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24302 
24307  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24308 
24313  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24314 
24318  CircularWedgeKit & UnsetUserData(intptr_t in_index);
24319 
24324  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24325 
24329  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
24330 
24333  CircularWedgeKit & UnsetAllUserData();
24334 
24336  size_t ShowUserDataCount() const;
24337 
24341  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24342 
24347  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24348 
24353  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24354 };
24355 
24356 
24360 class HPS_API CircularWedgeKey : public GeometryKey
24361 {
24362 public:
24364  CircularWedgeKey();
24365 
24369  explicit CircularWedgeKey(Key const & in_that);
24370 
24373  CircularWedgeKey(CircularWedgeKey const & in_that);
24374 
24378  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
24379 
24383  CircularWedgeKey(CircularWedgeKey && in_that);
24384 
24388  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
24389 
24390  ~CircularWedgeKey();
24391 
24392  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKey; };
24393 
24394 
24397  void Consume(CircularWedgeKit & in_kit);
24398 
24401  void Set(CircularWedgeKit const & in_kit);
24402 
24405  void Show(CircularWedgeKit & out_kit) const;
24406 
24407 
24411  CircularWedgeKey & SetStart(Point const & in_start);
24412 
24416  CircularWedgeKey & SetMiddle(Point const & in_middle);
24417 
24421  CircularWedgeKey & SetEnd(Point const & in_end);
24422 
24423 
24427  bool ShowStart(Point & out_start) const;
24428 
24432  bool ShowMiddle(Point & out_middle) const;
24433 
24437  bool ShowEnd(Point & out_end) const;
24438 };
24439 
24440 
24441 
24443 class HPS_API CuttingSectionKit : public Object
24444 {
24445 public:
24448 
24451  CuttingSectionKit(CuttingSectionKit const & in_kit);
24452 
24457 
24461  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
24462 
24463  virtual ~CuttingSectionKit();
24464 
24465  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKit; };
24466 
24469  void Consume(CuttingSectionKit & in_kit);
24470 
24473  void Set(CuttingSectionKit const & in_kit);
24474 
24477  void Show(CuttingSectionKit & out_kit) const;
24478 
24482  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
24483 
24486  bool Empty() const;
24487 
24491  bool Equals(CuttingSectionKit const & in_kit) const;
24492 
24496  bool operator==(CuttingSectionKit const & in_kit) const;
24497 
24501  bool operator!=(CuttingSectionKit const & in_kit) const;
24502 
24509  CuttingSectionKit & SetPriority(int in_priority);
24510 
24513  CuttingSectionKit & UnsetPriority();
24514 
24518  bool ShowPriority(int & out_priority) const;
24519 
24520 
24524  CuttingSectionKit & SetPlanes(Plane const & in_plane);
24525 
24529  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
24530 
24535  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
24536 
24542  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24543 
24544 
24547  CuttingSectionKit & UnsetPlanes();
24548 
24551  CuttingSectionKit & UnsetVisualization();
24552 
24555  CuttingSectionKit & UnsetEverything();
24556 
24557 
24560  size_t GetPlaneCount() const;
24561 
24565  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24566 
24572  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24573 
24574 
24581  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24582 
24588  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24589 
24596  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24597 
24604  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24605 
24613  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24614 
24620  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24621 
24626  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24627 
24632  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24633 
24637  CuttingSectionKit & UnsetUserData(intptr_t in_index);
24638 
24643  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24644 
24648  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
24649 
24652  CuttingSectionKit & UnsetAllUserData();
24653 
24655  size_t ShowUserDataCount() const;
24656 
24660  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24661 
24666  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24667 
24672  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24673 };
24674 
24675 
24677 class HPS_API CuttingSectionKey : public GeometryKey
24678 {
24679 public:
24682 
24686  explicit CuttingSectionKey(Key const & in_that);
24687 
24690  CuttingSectionKey(CuttingSectionKey const & in_that);
24691 
24695  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24696 
24701 
24705  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24706 
24707  ~CuttingSectionKey();
24708 
24709  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKey; };
24710 
24711 
24714  void Consume(CuttingSectionKit & in_kit);
24715 
24718  void Set(CuttingSectionKit const & in_kit);
24719 
24722  void Show(CuttingSectionKit & out_kit) const;
24723 
24724 
24728  CuttingSectionKey & SetPlanes(Plane const & in_plane);
24729 
24733  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
24734 
24739  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
24740 
24746  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24747 
24748 
24751  size_t GetPlaneCount() const;
24752 
24756  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24757 
24763  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24764 
24765 
24772  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24773 
24779  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24780 
24787  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24788 
24795  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24796 
24802  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24803 };
24804 
24805 
24806 
24808 class HPS_API InfiniteLineKit : public Object
24809 {
24810 public:
24812  InfiniteLineKit();
24813 
24816  InfiniteLineKit(InfiniteLineKit const & in_kit);
24817 
24821  InfiniteLineKit(InfiniteLineKit && in_that);
24822 
24826  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
24827 
24828  virtual ~InfiniteLineKit();
24829 
24830  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKit; };
24831 
24834  void Consume(InfiniteLineKit & in_kit);
24835 
24838  void Set(InfiniteLineKit const & in_kit);
24839 
24842  void Show(InfiniteLineKit & out_kit) const;
24843 
24847  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
24848 
24851  bool Empty() const;
24852 
24856  bool Equals(InfiniteLineKit const & in_kit) const;
24857 
24861  bool operator==(InfiniteLineKit const & in_kit) const;
24862 
24866  bool operator!=(InfiniteLineKit const & in_kit) const;
24867 
24874  InfiniteLineKit & SetPriority(int in_priority);
24875 
24878  InfiniteLineKit & UnsetPriority();
24879 
24883  bool ShowPriority(int & out_priority) const;
24884 
24885 
24889  InfiniteLineKit & SetFirst(Point const & in_first);
24890 
24894  InfiniteLineKit & SetSecond(Point const & in_second);
24895 
24899  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
24900 
24901 
24904  InfiniteLineKit & UnsetFirst();
24905 
24908  InfiniteLineKit & UnsetSecond();
24909 
24912  InfiniteLineKit & UnsetType();
24913 
24916  InfiniteLineKit & UnsetEverything();
24917 
24918 
24922  bool ShowFirst(Point & out_first) const;
24923 
24927  bool ShowSecond(Point & out_second) const;
24928 
24932  bool ShowType(InfiniteLine::Type & out_type) const;
24933 
24939  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24940 
24945  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24946 
24951  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24952 
24956  InfiniteLineKit & UnsetUserData(intptr_t in_index);
24957 
24962  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24963 
24967  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
24968 
24971  InfiniteLineKit & UnsetAllUserData();
24972 
24974  size_t ShowUserDataCount() const;
24975 
24979  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24980 
24985  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24986 
24991  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24992 };
24993 
24994 
24996 class HPS_API InfiniteLineKey : public GeometryKey
24997 {
24998 public:
25000  InfiniteLineKey();
25001 
25005  explicit InfiniteLineKey(Key const & in_that);
25006 
25009  InfiniteLineKey(InfiniteLineKey const & in_that);
25010 
25014  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
25015 
25019  InfiniteLineKey(InfiniteLineKey && in_that);
25020 
25024  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
25025 
25026  ~InfiniteLineKey();
25027 
25028  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKey; };
25029 
25032  void Consume(InfiniteLineKit & in_kit);
25033 
25036  void Set(InfiniteLineKit const & in_kit);
25037 
25040  void Show(InfiniteLineKit & out_kit) const;
25041 
25042 
25046  InfiniteLineKey & SetFirst(Point const & in_first);
25047 
25051  InfiniteLineKey & SetSecond(Point const & in_second);
25052 
25056  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
25057 
25058 
25062  bool ShowFirst(Point & out_first) const;
25063 
25067  bool ShowSecond(Point & out_second) const;
25068 
25072  bool ShowType(InfiniteLine::Type & out_type) const;
25073 };
25074 
25075 
25076 
25080 class HPS_API SpotlightKit : public Object
25081 {
25082 public:
25084  SpotlightKit();
25085 
25088  SpotlightKit(SpotlightKit const & in_kit);
25089 
25093  SpotlightKit(SpotlightKit && in_that);
25094 
25098  SpotlightKit & operator=(SpotlightKit && in_that);
25099 
25100  virtual ~SpotlightKit();
25101 
25102  HPS::Type ObjectType() const { return HPS::Type::SpotlightKit; };
25103 
25107  static SpotlightKit GetDefault();
25108 
25111  void Consume(SpotlightKit & in_kit);
25112 
25115  void Set(SpotlightKit const & in_kit);
25116 
25119  void Show(SpotlightKit & out_kit) const;
25120 
25124  SpotlightKit & operator=(SpotlightKit const & in_kit);
25125 
25128  bool Empty() const;
25129 
25133  bool Equals(SpotlightKit const & in_kit) const;
25134 
25138  bool operator==(SpotlightKit const & in_kit) const;
25139 
25143  bool operator!=(SpotlightKit const & in_kit) const;
25144 
25145 
25152  SpotlightKit & SetPriority(int in_priority);
25153 
25159  SpotlightKit & SetPosition(HPS::Point const & in_position);
25160 
25166  SpotlightKit & SetTarget(HPS::Point const & in_target);
25167 
25171  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
25172 
25176  SpotlightKit & SetColorByIndex(float in_index);
25177 
25184 
25191 
25197  SpotlightKit & SetConcentration(float in_concentration);
25198 
25204  SpotlightKit & SetCameraRelative(bool in_state);
25205 
25206 
25209  SpotlightKit & UnsetPriority();
25210 
25213  SpotlightKit & UnsetPosition();
25214 
25217  SpotlightKit & UnsetTarget();
25218 
25221  SpotlightKit & UnsetColor();
25222 
25225  SpotlightKit & UnsetOuterCone();
25226 
25229  SpotlightKit & UnsetInnerCone();
25230 
25233  SpotlightKit & UnsetConcentration();
25234 
25237  SpotlightKit & UnsetCameraRelative();
25238 
25241  SpotlightKit & UnsetEverything();
25242 
25243 
25247  bool ShowPriority(int & out_priority) const;
25248 
25252  bool ShowPosition(HPS::Point & out_position) const;
25253 
25257  bool ShowTarget(HPS::Point & out_target) const;
25258 
25264  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25265 
25270  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25271 
25276  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25277 
25281  bool ShowConcentration(float & out_concentration) const;
25282 
25286  bool ShowCameraRelative(bool & out_state) const;
25287 
25293  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25294 
25299  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25300 
25305  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25306 
25310  SpotlightKit & UnsetUserData(intptr_t in_index);
25311 
25316  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25317 
25321  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
25322 
25325  SpotlightKit & UnsetAllUserData();
25326 
25328  size_t ShowUserDataCount() const;
25329 
25333  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25334 
25339  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25340 
25345  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25346 };
25347 
25348 
25350 class HPS_API SpotlightKey : public GeometryKey
25351 {
25352 public:
25354  SpotlightKey();
25355 
25359  explicit SpotlightKey(Key const & in_that);
25360 
25363  SpotlightKey(SpotlightKey const & in_that);
25364 
25368  SpotlightKey & operator=(SpotlightKey const & in_that);
25369 
25373  SpotlightKey(SpotlightKey && in_that);
25374 
25378  SpotlightKey & operator=(SpotlightKey && in_that);
25379 
25380  ~SpotlightKey();
25381 
25382  HPS::Type ObjectType() const { return HPS::Type::SpotlightKey; };
25383 
25386  void Consume(SpotlightKit & in_kit);
25387 
25390  void Set(SpotlightKit const & in_kit);
25391 
25394  void Show(SpotlightKit & out_kit) const;
25395 
25396 
25402  SpotlightKey & SetPosition(HPS::Point const & in_position);
25403 
25409  SpotlightKey & SetTarget(HPS::Point const & in_target);
25410 
25414  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
25415 
25419  SpotlightKey & SetColorByIndex(float in_index);
25420 
25427 
25434 
25440  SpotlightKey & SetConcentration(float in_concentration);
25441 
25447  SpotlightKey & SetCameraRelative(bool in_state);
25448 
25449 
25452  SpotlightKey & UnsetColor();
25453 
25454 
25458  bool ShowPosition(HPS::Point & out_position) const;
25459 
25463  bool ShowTarget(HPS::Point & out_target) const;
25464 
25470  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25471 
25476  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25477 
25482  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25483 
25487  bool ShowConcentration(float & out_concentration) const;
25488 
25492  bool ShowCameraRelative(bool & out_state) const;
25493 };
25494 
25495 
25496 
25498 class HPS_API NURBSCurveKit : public Object
25499 {
25500 public:
25502  NURBSCurveKit();
25503 
25506  NURBSCurveKit(NURBSCurveKit const & in_kit);
25507 
25511  NURBSCurveKit(NURBSCurveKit && in_that);
25512 
25516  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
25517 
25518  virtual ~NURBSCurveKit();
25519 
25520  HPS::Type ObjectType() const { return HPS::Type::NURBSCurveKit; };
25521 
25524  void Consume(NURBSCurveKit & in_kit);
25525 
25528  void Set(NURBSCurveKit const & in_kit);
25529 
25532  void Show(NURBSCurveKit & out_kit) const;
25533 
25537  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
25538 
25541  bool Empty() const;
25542 
25546  bool Equals(NURBSCurveKit const & in_kit) const;
25547 
25551  bool operator==(NURBSCurveKit const & in_kit) const;
25552 
25556  bool operator!=(NURBSCurveKit const & in_kit) const;
25557 
25560  size_t GetPointCount() const;
25561 
25568  NURBSCurveKit & SetPriority(int in_priority);
25569 
25572  NURBSCurveKit & UnsetPriority();
25573 
25577  bool ShowPriority(int & out_priority) const;
25578 
25582  NURBSCurveKit & SetDegree(size_t in_degree);
25583 
25587  NURBSCurveKit & SetPoints(PointArray const & in_points);
25588 
25593  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
25594 
25598  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
25599 
25604  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
25605 
25609  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
25610 
25615  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
25616 
25621  NURBSCurveKit & SetParameters(float in_start, float in_end);
25622 
25623 
25626  NURBSCurveKit & UnsetDegree();
25627 
25630  NURBSCurveKit & UnsetPoints();
25631 
25634  NURBSCurveKit & UnsetWeights();
25635 
25638  NURBSCurveKit & UnsetKnots();
25639 
25642  NURBSCurveKit & UnsetParameters();
25643 
25646  NURBSCurveKit & UnsetEverything();
25647 
25648 
25652  bool ShowDegree(size_t & out_degree) const;
25653 
25657  bool ShowPoints(PointArray & out_points) const;
25658 
25664  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25665 
25670  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25671 
25677  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25678 
25682  bool ShowWeights(FloatArray & out_weights) const;
25683 
25687  bool ShowKnots(FloatArray & out_knots) const;
25688 
25693  bool ShowParameters(float & out_start, float & out_end) const;
25694 
25695 
25702  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25703 
25709  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25710 
25717  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25718 
25725  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25726 
25733  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25734 
25735 
25743  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25744 
25751  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25752 
25760  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25761 
25768  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25769 
25776  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25777 
25778 
25784  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25785 
25790  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25791 
25797  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
25798 
25805  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25806 
25813  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25814 
25820  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25821 
25826  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25827 
25832  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25833 
25837  NURBSCurveKit & UnsetUserData(intptr_t in_index);
25838 
25843  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25844 
25848  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
25849 
25852  NURBSCurveKit & UnsetAllUserData();
25853 
25855  size_t ShowUserDataCount() const;
25856 
25860  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25861 
25866  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25867 
25872  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25873 };
25874 
25875 
25877 class HPS_API NURBSCurveKey : public GeometryKey
25878 {
25879 public:
25881  NURBSCurveKey();
25882 
25886  explicit NURBSCurveKey(Key const & in_that);
25887 
25890  NURBSCurveKey(NURBSCurveKey const & in_that);
25891 
25895  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
25896 
25900  NURBSCurveKey(NURBSCurveKey && in_that);
25901 
25905  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
25906 
25907  ~NURBSCurveKey();
25908 
25909  HPS::Type ObjectType() const {return HPS::Type::NURBSCurveKey;};
25910 
25913  void Consume(NURBSCurveKit & in_kit);
25914 
25917  void Set(NURBSCurveKit const & in_kit);
25918 
25921  void Show(NURBSCurveKit & out_kit) const;
25922 
25925  size_t GetPointCount() const;
25926 
25931  NURBSCurveKey & SetParameters(float in_start, float in_end);
25932 
25936  bool ShowDegree(size_t & out_degree) const;
25937 
25941  bool ShowPoints(PointArray & out_points) const;
25942 
25948  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25949 
25954  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25955 
25961  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25962 
25966  bool ShowWeights(FloatArray & out_weights) const;
25967 
25971  bool ShowKnots(FloatArray & out_knots) const;
25972 
25977  bool ShowParameters(float & out_start, float & out_end) const;
25978 
25979 
25987  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25988 
25995  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25996 
25997 
26006  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26007 
26015  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26016 
26017 
26025  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26026 
26033  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26034 };
26035 
26036 
26037 
26039 class HPS_API NURBSSurfaceKit : public Object
26040 {
26041 public:
26043  NURBSSurfaceKit();
26044 
26047  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
26048 
26052  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
26053 
26057  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
26058 
26059  virtual ~NURBSSurfaceKit();
26060 
26061  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKit; };
26062 
26065  void Consume(NURBSSurfaceKit & in_kit);
26066 
26069  void Set(NURBSSurfaceKit const & in_kit);
26070 
26073  void Show(NURBSSurfaceKit & out_kit) const;
26074 
26078  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
26079 
26082  bool Empty() const;
26083 
26087  bool Equals(NURBSSurfaceKit const & in_kit) const;
26088 
26092  bool operator==(NURBSSurfaceKit const & in_kit) const;
26093 
26097  bool operator!=(NURBSSurfaceKit const & in_kit) const;
26098 
26101  size_t GetPointCount() const;
26102 
26109  NURBSSurfaceKit & SetPriority(int in_priority);
26110 
26113  NURBSSurfaceKit & UnsetPriority();
26114 
26118  bool ShowPriority(int & out_priority) const;
26119 
26123  NURBSSurfaceKit & SetUDegree(size_t in_degree);
26124 
26128  NURBSSurfaceKit & SetVDegree(size_t in_degree);
26129 
26133  NURBSSurfaceKit & SetUCount(size_t in_count);
26134 
26138  NURBSSurfaceKit & SetVCount(size_t in_count);
26139 
26143  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
26144 
26149  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
26150 
26155  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
26156 
26162  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
26163 
26168  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
26169 
26175  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
26176 
26181  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
26182 
26188  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
26189 
26193  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
26194 
26199  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
26200 
26201 
26204  NURBSSurfaceKit & UnsetUDegree();
26205 
26208  NURBSSurfaceKit & UnsetVDegree();
26209 
26212  NURBSSurfaceKit & UnsetUCount();
26213 
26216  NURBSSurfaceKit & UnsetVCount();
26217 
26220  NURBSSurfaceKit & UnsetPoints();
26221 
26224  NURBSSurfaceKit & UnsetWeights();
26225 
26228  NURBSSurfaceKit & UnsetUKnots();
26229 
26232  NURBSSurfaceKit & UnsetVKnots();
26233 
26236  NURBSSurfaceKit & UnsetTrims();
26237 
26240  NURBSSurfaceKit & UnsetEverything();
26241 
26242 
26246  bool ShowUDegree(size_t & out_degree) const;
26247 
26251  bool ShowVDegree(size_t & out_degree) const;
26252 
26256  bool ShowUCount(size_t & out_count) const;
26257 
26261  bool ShowVCount(size_t & out_count) const;
26262 
26266  bool ShowPoints(PointArray & out_points) const;
26267 
26273  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26274 
26279  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26280 
26286  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26287 
26291  bool ShowWeights(FloatArray & out_weights) const;
26292 
26296  bool ShowUKnots(FloatArray & out_knots) const;
26297 
26301  bool ShowVKnots(FloatArray & out_knots) const;
26302 
26306  bool ShowTrims(TrimKitArray & out_trims) const;
26307 
26308 
26315  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
26316 
26322  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
26323 
26330  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
26331 
26338  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26339 
26346  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26347 
26348 
26356  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
26357 
26364  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
26365 
26373  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
26374 
26381  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26382 
26389  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26390 
26391 
26398  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26399 
26405  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26406 
26413  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
26414 
26421  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26422 
26429  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26430 
26431 
26438  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26439 
26445  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26446 
26453  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
26454 
26461  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26462 
26469  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26470 
26476  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26477 
26482  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26483 
26488  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26489 
26493  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
26494 
26499  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26500 
26504  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
26505 
26508  NURBSSurfaceKit & UnsetAllUserData();
26509 
26511  size_t ShowUserDataCount() const;
26512 
26516  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26517 
26522  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26523 
26528  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26529 };
26530 
26531 
26533 class HPS_API NURBSSurfaceKey : public GeometryKey
26534 {
26535 public:
26537  NURBSSurfaceKey();
26538 
26542  explicit NURBSSurfaceKey(Key const & in_that);
26543 
26546  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
26547 
26551  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
26552 
26556  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
26557 
26561  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
26562 
26563  ~NURBSSurfaceKey();
26564 
26565  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKey; };
26566 
26569  void Consume(NURBSSurfaceKit & in_kit);
26570 
26573  void Set(NURBSSurfaceKit const & in_kit);
26574 
26577  void Show(NURBSSurfaceKit & out_kit) const;
26578 
26581  size_t GetPointCount() const;
26582 
26587  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
26588 
26592  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
26593 
26594 
26597  NURBSSurfaceKey & UnsetTrims();
26598 
26599 
26603  bool ShowUDegree(size_t & out_degree) const;
26604 
26608  bool ShowVDegree(size_t & out_degree) const;
26609 
26613  bool ShowUCount(size_t & out_count) const;
26614 
26618  bool ShowVCount(size_t & out_count) const;
26619 
26623  bool ShowPoints(PointArray & out_points) const;
26624 
26630  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26631 
26636  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26637 
26643  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26644 
26648  bool ShowWeights(FloatArray & out_weights) const;
26649 
26653  bool ShowUKnots(FloatArray & out_knots) const;
26654 
26658  bool ShowVKnots(FloatArray & out_knots) const;
26659 
26663  bool ShowTrims(TrimKitArray & out_trims) const;
26664 
26665 
26673  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26674 
26681  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26682 
26683 
26692  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26693 
26701  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26702 
26703 
26711  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26712 
26719  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26720 
26721 
26729  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26730 
26737  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26738 };
26739 
26740 
26741 
26743 class HPS_API TrimElement : public Object
26744 {
26745 public:
26747  TrimElement();
26748 
26751  TrimElement(TrimElement const & in_that);
26752 
26756  TrimElement(LineKit const & in_line);
26757 
26761  TrimElement(NURBSCurveKit const & in_curve);
26762 
26766  TrimElement(TrimElement && in_that);
26767 
26771  TrimElement & operator=(TrimElement && in_that);
26772 
26773  ~TrimElement();
26774 
26775  HPS::Type ObjectType() const { return HPS::Type::TrimElement; };
26776 
26779  void Set(TrimElement const & in_that);
26780 
26784  TrimElement & operator=(TrimElement const & in_that);
26785 
26789  bool Equals(TrimElement const & in_that) const;
26790 
26794  bool operator==(TrimElement const & in_that) const;
26795 
26799  bool operator!=(TrimElement const & in_that) const;
26800 
26801 
26805  void SetCurve(LineKit const & in_line);
26806 
26810  void SetCurve(NURBSCurveKit const & in_curve);
26811 
26817  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
26818 };
26819 
26820 
26821 
26823 class HPS_API TrimKit : public Object
26824 {
26825 public:
26827  TrimKit();
26828 
26831  TrimKit(TrimKit const & in_kit);
26832 
26836  TrimKit(TrimKit && in_that);
26837 
26841  TrimKit & operator=(TrimKit && in_that);
26842 
26843  virtual ~TrimKit();
26844 
26845  HPS::Type ObjectType() const { return HPS::Type::TrimKit; };
26846 
26849  void Set(TrimKit const & in_kit);
26850 
26853  void Show(TrimKit & out_kit) const;
26854 
26858  TrimKit & operator=(TrimKit const & in_kit);
26859 
26862  bool Empty() const;
26863 
26867  bool Equals(TrimKit const & in_kit) const;
26868 
26872  bool operator==(TrimKit const & in_kit) const;
26873 
26877  bool operator!=(TrimKit const & in_kit) const;
26878 
26879 
26884  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
26885 
26889  TrimKit & SetShape(TrimElementArray const & in_shape);
26890 
26894  TrimKit & SetOperation(Trim::Operation in_operation);
26895 
26896 
26899  TrimKit & UnsetShape();
26900 
26903  TrimKit & UnsetOperation();
26904 
26907  TrimKit & UnsetEverything();
26908 
26909 
26913  bool ShowShape(TrimElementArray & out_shape) const;
26914 
26918  bool ShowOperation(Trim::Operation & out_operation) const;
26919 };
26920 
26921 
26922 
26924 class HPS_API EllipseKit : public Object
26925 {
26926 public:
26928  EllipseKit();
26929 
26932  EllipseKit(EllipseKit const & in_kit);
26933 
26937  EllipseKit(EllipseKit && in_that);
26938 
26942  EllipseKit & operator=(EllipseKit && in_that);
26943 
26944  virtual ~EllipseKit();
26945 
26946  HPS::Type ObjectType() const { return HPS::Type::EllipseKit; };
26947 
26950  void Consume(EllipseKit & in_kit);
26951 
26954  void Set(EllipseKit const & in_kit);
26955 
26958  void Show(EllipseKit & out_kit) const;
26959 
26963  EllipseKit & operator=(EllipseKit const & in_kit);
26964 
26967  bool Empty() const;
26968 
26972  bool Equals(EllipseKit const & in_kit) const;
26973 
26977  bool operator==(EllipseKit const & in_kit) const;
26978 
26982  bool operator!=(EllipseKit const & in_kit) const;
26983 
26990  EllipseKit & SetPriority(int in_priority);
26991 
26994  EllipseKit & UnsetPriority();
26995 
26999  bool ShowPriority(int & out_priority) const;
27000 
27001 
27005  EllipseKit & SetCenter(Point const & in_center);
27006 
27010  EllipseKit & SetMajor(Point const & in_major);
27011 
27015  EllipseKit & SetMinor(Point const & in_minor);
27016 
27017 
27020  EllipseKit & UnsetCenter();
27021 
27024  EllipseKit & UnsetMajor();
27025 
27028  EllipseKit & UnsetMinor();
27029 
27032  EllipseKit & UnsetEverything();
27033 
27034 
27038  bool ShowCenter(Point & out_center) const;
27039 
27043  bool ShowMajor(Point & out_major) const;
27044 
27048  bool ShowMinor(Point & out_minor) const;
27049 
27055  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27056 
27061  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27062 
27067  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27068 
27072  EllipseKit & UnsetUserData(intptr_t in_index);
27073 
27078  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27079 
27083  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
27084 
27087  EllipseKit & UnsetAllUserData();
27088 
27090  size_t ShowUserDataCount() const;
27091 
27095  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27096 
27101  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27102 
27107  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27108 };
27109 
27110 
27111 
27113 class HPS_API EllipseKey : public GeometryKey
27114 {
27115 public:
27117  EllipseKey();
27118 
27122  explicit EllipseKey(Key const & in_that);
27123 
27126  EllipseKey(EllipseKey const & in_that);
27127 
27131  EllipseKey & operator=(EllipseKey const & other);
27132 
27136  EllipseKey(EllipseKey && in_that);
27137 
27141  EllipseKey & operator=(EllipseKey && in_that);
27142 
27143  ~EllipseKey();
27144 
27145  HPS::Type ObjectType() const { return HPS::Type::EllipseKey; };
27146 
27149  void Consume(EllipseKit & in_kit);
27150 
27153  void Set(EllipseKit const & in_kit);
27154 
27157  void Show(EllipseKit & out_kit) const;
27158 
27159 
27163  EllipseKey & SetCenter(Point const & in_center);
27164 
27168  EllipseKey & SetMajor(Point const & in_major);
27169 
27173  EllipseKey & SetMinor(Point const & in_minor);
27174 
27175 
27179  bool ShowCenter(Point & out_center) const;
27180 
27184  bool ShowMajor(Point & out_major) const;
27185 
27189  bool ShowMinor(Point & out_minor) const;
27190 };
27191 
27192 
27193 
27195 class HPS_API EllipticalArcKit : public Object
27196 {
27197 public:
27199  EllipticalArcKit();
27200 
27203  EllipticalArcKit(EllipticalArcKit const & in_kit);
27204 
27208  EllipticalArcKit(EllipticalArcKit && in_that);
27209 
27213  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
27214 
27215  virtual ~EllipticalArcKit();
27216 
27217  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKit; };
27218 
27221  void Consume(EllipticalArcKit & in_kit);
27222 
27225  void Set(EllipticalArcKit const & in_kit);
27226 
27229  void Show(EllipticalArcKit & out_kit) const;
27230 
27234  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
27235 
27238  bool Empty() const;
27239 
27243  bool Equals(EllipticalArcKit const & in_kit) const;
27244 
27248  bool operator==(EllipticalArcKit const & in_kit) const;
27249 
27253  bool operator!=(EllipticalArcKit const & in_kit) const;
27254 
27261  EllipticalArcKit & SetPriority(int in_priority);
27262 
27265  EllipticalArcKit & UnsetPriority();
27266 
27270  bool ShowPriority(int & out_priority) const;
27271 
27272 
27276  EllipticalArcKit & SetCenter(Point const & in_center);
27277 
27281  EllipticalArcKit & SetMajor(Point const & in_major);
27282 
27286  EllipticalArcKit & SetMinor(Point const & in_minor);
27287 
27295  EllipticalArcKit & SetStart(float in_start);
27296 
27304  EllipticalArcKit & SetEnd(float in_end);
27305 
27306 
27309  EllipticalArcKit & UnsetCenter();
27310 
27313  EllipticalArcKit & UnsetMajor();
27314 
27317  EllipticalArcKit & UnsetMinor();
27318 
27321  EllipticalArcKit & UnsetStart();
27322 
27325  EllipticalArcKit & UnsetEnd();
27326 
27329  EllipticalArcKit & UnsetEverything();
27330 
27331 
27335  bool ShowCenter(Point & out_center) const;
27336 
27340  bool ShowMajor(Point & out_major) const;
27341 
27345  bool ShowMinor(Point & out_minor) const;
27346 
27350  bool ShowStart(float & out_start) const;
27351 
27355  bool ShowEnd(float & out_end) const;
27356 
27362  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27363 
27368  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27369 
27374  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27375 
27379  EllipticalArcKit & UnsetUserData(intptr_t in_index);
27380 
27385  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27386 
27390  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
27391 
27394  EllipticalArcKit & UnsetAllUserData();
27395 
27397  size_t ShowUserDataCount() const;
27398 
27402  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27403 
27408  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27409 
27414  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27415 };
27416 
27417 
27419 class HPS_API EllipticalArcKey : public GeometryKey
27420 {
27421 public:
27423  EllipticalArcKey();
27424 
27428  explicit EllipticalArcKey(Key const & in_that);
27429 
27432  EllipticalArcKey(EllipticalArcKey const & in_that);
27433 
27437  EllipticalArcKey & operator=(EllipticalArcKey const & other);
27438 
27442  EllipticalArcKey(EllipticalArcKey && in_that);
27443 
27447  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
27448 
27449  ~EllipticalArcKey();
27450 
27451  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKey; };
27452 
27453 
27456  void Consume(EllipticalArcKit & in_kit);
27457 
27460  void Set(EllipticalArcKit const & in_kit);
27461 
27464  void Show(EllipticalArcKit & out_kit) const;
27465 
27466 
27470  EllipticalArcKey & SetCenter(Point const & in_center);
27471 
27475  EllipticalArcKey & SetMajor(Point const & in_major);
27476 
27480  EllipticalArcKey & SetMinor(Point const & in_minor);
27481 
27489  EllipticalArcKey & SetStart(float in_start);
27490 
27498  EllipticalArcKey & SetEnd(float in_end);
27499 
27500 
27504  bool ShowCenter(Point & out_center) const;
27505 
27509  bool ShowMajor(Point & out_major) const;
27510 
27514  bool ShowMinor(Point & out_minor) const;
27515 
27519  bool ShowStart(float & out_start) const;
27520 
27524  bool ShowEnd(float & out_end) const;
27525 };
27526 
27527 
27528 
27530 class HPS_API TextKit : public Object
27531 {
27532 public:
27534  TextKit();
27535 
27538  TextKit(TextKit const & in_kit);
27539 
27543  TextKit(TextKit && in_that);
27544 
27548  TextKit & operator=(TextKit && in_that);
27549 
27550  virtual ~TextKit();
27551 
27552  HPS::Type ObjectType() const { return HPS::Type::TextKit; };
27553 
27556  void Consume(TextKit & in_kit);
27557 
27560  void Set(TextKit const & in_kit);
27561 
27564  void Show(TextKit & out_kit) const;
27565 
27569  TextKit & operator=(TextKit const & in_kit);
27570 
27573  bool Empty() const;
27574 
27578  bool Equals(TextKit const & in_kit) const;
27579 
27583  bool operator==(TextKit const & in_kit) const;
27584 
27588  bool operator!=(TextKit const & in_kit) const;
27589 
27596  TextKit & SetPriority(int in_priority);
27597 
27600  TextKit & UnsetPriority();
27601 
27605  bool ShowPriority(int & out_priority) const;
27606 
27610  TextKit & SetPosition(Point const & in_position);
27611 
27615  TextKit & SetText(char const * in_string);
27616 
27620  TextKit & SetColor(RGBAColor const & in_rgba_color);
27621 
27625  TextKit & SetColorByIndex(float in_index);
27626 
27630  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
27631 
27638 
27642  TextKit & SetBold(bool in_state);
27643 
27647  TextKit & SetItalic(bool in_state);
27648 
27652  TextKit & SetOverline(bool in_state);
27653 
27657  TextKit & SetStrikethrough(bool in_state);
27658 
27662  TextKit & SetUnderline(bool in_state);
27663 
27668  TextKit & SetSlant(float in_angle);
27669 
27673  TextKit & SetLineSpacing(float in_multiplier);
27674 
27680  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27681 
27685  TextKit & SetRotation(float in_angle);
27686 
27692  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27693 
27698  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
27699 
27706  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27707 
27713  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27714 
27723  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
27724 
27732  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
27733 
27738  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
27739 
27745  TextKit & SetFont(char const * in_name);
27746 
27750  TextKit & SetTransform(Text::Transform in_trans);
27751 
27755  TextKit & SetRenderer(Text::Renderer in_rend);
27756 
27760  TextKit & SetPreference(Text::Preference in_pref);
27761 
27768  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27769 
27773  TextKit & SetPath(Vector const & in_path);
27774 
27780  TextKit & SetSpacing(float in_multiplier);
27781 
27782 
27785  TextKit & UnsetPosition();
27786 
27789  TextKit & UnsetText();
27790 
27793  TextKit & UnsetColor();
27794 
27797  TextKit & UnsetModellingMatrix();
27798 
27801  TextKit & UnsetAlignment();
27802 
27805  TextKit & UnsetBold();
27806 
27809  TextKit & UnsetItalic();
27810 
27813  TextKit & UnsetOverline();
27814 
27817  TextKit & UnsetStrikethrough();
27818 
27821  TextKit & UnsetUnderline();
27822 
27825  TextKit & UnsetSlant();
27826 
27829  TextKit & UnsetLineSpacing();
27830 
27833  TextKit & UnsetRotation();
27834 
27837  TextKit & UnsetExtraSpace();
27838 
27841  TextKit & UnsetGreeking();
27842 
27845  TextKit & UnsetSizeTolerance();
27846 
27849  TextKit & UnsetSize();
27850 
27853  TextKit & UnsetFont();
27854 
27857  TextKit & UnsetTransform();
27858 
27861  TextKit & UnsetRenderer();
27862 
27865  TextKit & UnsetPreference();
27866 
27869  TextKit & UnsetPath();
27870 
27873  TextKit & UnsetSpacing();
27874 
27877  TextKit & UnsetEverything();
27878 
27879 
27883  bool ShowPosition(Point & out_position) const;
27884 
27888  bool ShowText(UTF8 & out_string) const;
27889 
27895  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27896 
27900  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27901 
27907  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27908 
27912  bool ShowBold(bool & out_state) const;
27913 
27917  bool ShowItalic(bool & out_state) const;
27918 
27922  bool ShowOverline(bool & out_state) const;
27923 
27927  bool ShowStrikethrough(bool & out_state) const;
27928 
27932  bool ShowUnderline(bool & out_state) const;
27933 
27937  bool ShowSlant(float & out_angle) const;
27938 
27942  bool ShowLineSpacing(float & out_multiplier) const;
27943 
27948  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27949 
27955  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27956 
27963  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27964 
27970  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27971 
27976  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27977 
27981  bool ShowFont(UTF8 & out_name) const;
27982 
27986  bool ShowTransform(Text::Transform & out_trans) const;
27987 
27991  bool ShowRenderer(Text::Renderer & out_renderer) const;
27992 
27999  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28000 
28004  bool ShowPath(Vector & out_path) const;
28005 
28009  bool ShowSpacing(float & out_multiplier) const;
28010 
28011 
28019  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28020 
28027  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28028 
28035  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28036 
28045  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;
28046 
28059  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);
28060 
28074  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);
28075 
28081  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28082 
28085  TextKit & UnsetRegion();
28086 
28091  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28092 
28097  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28098 
28102  TextKit & UnsetUserData(intptr_t in_index);
28103 
28108  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28109 
28113  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
28114 
28117  TextKit & UnsetAllUserData();
28118 
28120  size_t ShowUserDataCount() const;
28121 
28125  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28126 
28131  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28132 
28137  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28138 };
28139 
28140 
28142 class HPS_API TextKey : public GeometryKey
28143 {
28144 public:
28146  TextKey();
28147 
28151  explicit TextKey(Key const & in_that);
28152 
28155  TextKey(TextKey const & in_that);
28156 
28160  TextKey & operator=(TextKey const & other);
28161 
28165  TextKey(TextKey && in_that);
28166 
28170  TextKey & operator=(TextKey && in_that);
28171 
28172  ~TextKey();
28173 
28174  HPS::Type ObjectType() const {return HPS::Type::TextKey;};
28175 
28178  void Consume(TextKit & in_kit);
28179 
28182  void Set(TextKit const & in_kit);
28183 
28186  void Show(TextKit & out_kit) const;
28187 
28190  TextKey & SetTextAttributes(TextAttributeKit const & in_kit);
28191 
28195  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
28196 
28200  TextKey & SetPosition(Point const & in_position);
28201 
28205  TextKey & SetText(char const * in_string);
28206 
28210  TextKey & SetColor(RGBAColor const & in_rgba_color);
28211 
28215  TextKey & SetColorByIndex(float in_index);
28216 
28220  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
28221 
28228 
28232  TextKey & SetBold(bool in_state);
28233 
28237  TextKey & SetItalic(bool in_state);
28238 
28242  TextKey & SetOverline(bool in_state);
28243 
28247  TextKey & SetStrikethrough(bool in_state);
28248 
28252  TextKey & SetUnderline(bool in_state);
28253 
28258  TextKey & SetSlant(float in_angle);
28259 
28264  TextKey & SetLineSpacing(float in_multiplier);
28265 
28271  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
28272 
28276  TextKey & SetRotation(float in_angle);
28277 
28283  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
28284 
28289  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
28290 
28297  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28298 
28304  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28305 
28314  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
28315 
28323  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
28324 
28329  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
28330 
28336  TextKey & SetFont(char const * in_name);
28337 
28341  TextKey & SetTransform(Text::Transform in_transform);
28342 
28346  TextKey & SetRenderer(Text::Renderer in_renderer);
28347 
28351  TextKey & SetPreference(Text::Preference in_preference);
28352 
28360  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
28361 
28366  TextKey & SetPath(Vector const & in_path);
28367 
28373  TextKey & SetSpacing(float in_multiplier);
28374 
28387  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);
28388 
28402  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);
28403 
28404 
28407  TextKey & UnsetColor();
28408 
28411  TextKey & UnsetModellingMatrix();
28412 
28415  TextKey & UnsetAlignment();
28416 
28419  TextKey & UnsetBold();
28420 
28423  TextKey & UnsetItalic();
28424 
28427  TextKey & UnsetOverline();
28428 
28431  TextKey & UnsetStrikethrough();
28432 
28435  TextKey & UnsetUnderline();
28436 
28439  TextKey & UnsetSlant();
28440 
28443  TextKey & UnsetLineSpacing();
28444 
28447  TextKey & UnsetRotation();
28448 
28451  TextKey & UnsetExtraSpace();
28452 
28455  TextKey & UnsetGreeking();
28456 
28459  TextKey & UnsetSizeTolerance();
28460 
28463  TextKey & UnsetSize();
28464 
28467  TextKey & UnsetFont();
28468 
28471  TextKey & UnsetTransform();
28472 
28475  TextKey & UnsetRenderer();
28476 
28479  TextKey & UnsetPreference();
28480 
28483  TextKey & UnsetPath();
28484 
28487  TextKey & UnsetSpacing();
28488 
28491  TextKey & UnsetRegion();
28492 
28495  TextKey & UnsetEverything();
28496 
28497 
28501  bool ShowPosition(Point & out_position) const;
28502 
28506  bool ShowText(UTF8 & out_string) const;
28507 
28513  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28514 
28518  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28519 
28525  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28526 
28530  bool ShowBold(bool & out_state) const;
28531 
28535  bool ShowItalic(bool & out_state) const;
28536 
28540  bool ShowOverline(bool & out_state) const;
28541 
28545  bool ShowStrikethrough(bool & out_state) const;
28546 
28550  bool ShowUnderline(bool & out_state) const;
28551 
28555  bool ShowSlant(float & out_angle) const;
28556 
28560  bool ShowLineSpacing(float & out_multiplier) const;
28561 
28566  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28567 
28573  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28574 
28581  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28582 
28588  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28589 
28594  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28595 
28599  bool ShowFont(UTF8 & out_name) const;
28600 
28604  bool ShowTransform(Text::Transform & out_trans) const;
28605 
28609  bool ShowRenderer(Text::Renderer & out_renderer) const;
28610 
28617  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28618 
28622  bool ShowPath(Vector & out_path) const;
28623 
28627  bool ShowSpacing(float & out_multiplier) const;
28628 
28637  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;
28638 
28639 
28647  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28648 
28655  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28656 
28663  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28664 };
28665 
28666 
28668 class HPS_API ShellOptimizationOptionsKit : public Object
28669 {
28670 public:
28673 
28677 
28682 
28683  virtual ~ShellOptimizationOptionsKit();
28684 
28685  HPS::Type ObjectType() const { return HPS::Type::ShellOptimizationOptionsKit; };
28686 
28689  void Consume(ShellOptimizationOptionsKit & in_kit);
28690 
28693  void Set(ShellOptimizationOptionsKit const & in_kit);
28694 
28697  void Show(ShellOptimizationOptionsKit & out_kit) const;
28698 
28702  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
28703 
28708 
28711  bool Empty() const;
28712 
28716  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
28717 
28721  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
28722 
28726  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
28727 
28731  static ShellOptimizationOptionsKit GetDefault();
28732 
28733 
28737  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
28738 
28743  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
28744 
28749  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
28750 
28755  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
28756 
28757 
28760  ShellOptimizationOptionsKit & UnsetNormalTolerance();
28761 
28764  ShellOptimizationOptionsKit & UnsetTolerance();
28765 
28768  ShellOptimizationOptionsKit & UnsetOrphanElimination();
28769 
28772  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
28773 
28776  ShellOptimizationOptionsKit & UnsetEverything();
28777 
28778 
28782  bool ShowNormalTolerance(float & out_normal_tolerance) const;
28783 
28788  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
28789 
28793  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
28794 
28799  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
28800 };
28801 
28802 
28806 class HPS_API ShellRelationOptionsKit : public Object
28807 {
28808 public:
28811 
28815 
28820 
28824  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
28825 
28826  virtual ~ShellRelationOptionsKit();
28827 
28828  HPS::Type ObjectType() const { return HPS::Type::ShellRelationOptionsKit; };
28829 
28833  static ShellRelationOptionsKit GetDefault();
28834 
28837  void Consume(ShellRelationOptionsKit & in_kit);
28838 
28841  void Set(ShellRelationOptionsKit const & in_kit);
28842 
28845  void Show(ShellRelationOptionsKit & out_kit) const;
28846 
28850  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
28851 
28854  bool Empty() const;
28855 
28859  bool Equals(ShellRelationOptionsKit const & in_kit) const;
28860 
28864  bool operator==(ShellRelationOptionsKit const & in_kit) const;
28865 
28869  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
28870 
28871 
28875  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
28876 
28880  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
28881 
28886  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
28887 
28891  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
28892 
28893 
28896  ShellRelationOptionsKit & UnsetTolerance();
28897 
28900  ShellRelationOptionsKit & UnsetTest();
28901 
28904  ShellRelationOptionsKit & UnsetTreeContext();
28905 
28908  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
28909 
28912  ShellRelationOptionsKit & UnsetEverything();
28913 
28914 
28918  bool ShowTolerance(float & out_tolerance) const;
28919 
28923  bool ShowTest(Shell::RelationTest & out_test) const;
28924 
28928  bool ShowTreeContext(TreeContext & out_tree_context) const;
28929 
28933  bool ShowNearestFaceCalculation(bool & out_state) const;
28934 };
28935 
28937 class HPS_API ShellRelationResultsKit : public Object
28938 {
28939 public:
28942 
28946 
28951 
28955  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
28956 
28957  virtual ~ShellRelationResultsKit();
28958 
28959  HPS::Type ObjectType() const { return HPS::Type::ShellRelationResultsKit; };
28960 
28963  void Consume(ShellRelationResultsKit & in_kit);
28964 
28967  void Set(ShellRelationResultsKit const & in_kit);
28968 
28971  void Show(ShellRelationResultsKit & out_kit) const;
28972 
28976  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
28977 
28980  bool Empty() const;
28981 
28985  bool Equals(ShellRelationResultsKit const & in_kit) const;
28986 
28990  bool operator==(ShellRelationResultsKit const & in_kit) const;
28991 
28995  bool operator!=(ShellRelationResultsKit const & in_kit) const;
28996 
28997 
29001  bool ShowRelations(ShellRelationArray & out_results) const;
29002 
29006  bool ShowNearestFaces(SizeTArray & out_faces) const;
29007 
29011  bool ShowDistances(FloatArray & out_distances) const;
29012 };
29013 
29014 
29016 class HPS_API ShellKit : public Object
29017 {
29018 public:
29020  ShellKit();
29021 
29024  ShellKit(ShellKit const & in_kit);
29025 
29029  ShellKit(ShellKit && in_that);
29030 
29034  ShellKit & operator=(ShellKit && in_that);
29035 
29036  virtual ~ShellKit();
29037 
29038  HPS::Type ObjectType() const { return HPS::Type::ShellKit; };
29039 
29042  void Consume(ShellKit & in_kit);
29043 
29046  void Set(ShellKit const & in_kit);
29047 
29050  void Show(ShellKit & out_kit) const;
29051 
29054  size_t GetPointCount() const;
29055 
29058  size_t GetFaceCount() const;
29059 
29063  ShellKit & operator=(ShellKit const & in_kit);
29064 
29067  bool Empty() const;
29068 
29072  bool Equals(ShellKit const & in_kit) const;
29073 
29077  bool operator==(ShellKit const & in_kit) const;
29078 
29082  bool operator!=(ShellKit const & in_kit) const;
29083 
29090  ShellKit & SetPriority(int in_priority);
29091 
29094  ShellKit & UnsetPriority();
29095 
29099  bool ShowPriority(int & out_priority) const;
29100 
29101 
29102 
29106  ShellKit & SetPoints(PointArray const & in_points);
29107 
29112  ShellKit & SetPoints(size_t in_count, Point const in_points []);
29113 
29117  ShellKit & SetFacelist(IntArray const & in_facelist);
29118 
29123  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
29124 
29128  ShellKit & SetTristrips(IntArray const & in_tristrips);
29129 
29134  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
29135 
29138  ShellKit & UnsetPoints();
29139 
29142  ShellKit & UnsetFacelist();
29143 
29146  ShellKit & UnsetTristrips();
29147 
29150  ShellKit & UnsetEverything();
29151 
29155  bool ShowPoints(PointArray & out_points) const;
29156 
29162  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29163 
29168  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29169 
29175  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29176 
29180  bool ShowFacelist(IntArray & out_facelist) const;
29181 
29185  bool ShowTristrips(IntArray & out_tristrips) const;
29186 
29192  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
29193 
29194 
29201  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29202 
29208  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29209 
29216  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29217 
29224  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29225 
29232  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29233 
29240  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29241 
29247  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29248 
29249 
29256  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29257 
29263  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29264 
29271  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29272 
29279  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29280 
29287  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29288 
29295  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29296 
29302  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29303 
29304 
29311  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29312 
29318  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29319 
29326  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29327 
29334  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29335 
29342  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29343 
29350  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29351 
29357  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29358 
29359 
29365  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29366 
29371  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29372 
29378  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29379 
29385  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29386 
29391  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29392 
29398  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29399 
29404  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29405 
29406 
29413  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29414 
29421  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29422 
29431  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);
29432 
29440  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29441 
29442 
29448  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29449 
29454  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29455 
29461  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29462 
29468  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29469 
29474  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29475 
29481  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29482 
29487  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29488 
29489 
29492  ShellKit & UnsetMaterialMapping();
29493 
29494 
29497  ShellKit & UnsetVertexColors();
29498 
29503  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29504 
29508  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29509 
29510 
29514  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
29515 
29521  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29522 
29527  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29528 
29529 
29532  ShellKit & UnsetVertexNormals();
29533 
29538  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29539 
29543  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29544 
29545 
29548  ShellKit & UnsetVertexParameters();
29549 
29554  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29555 
29559  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29560 
29561 
29564  ShellKit & UnsetVertexVisibilities();
29565 
29570  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29571 
29575  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29576 
29577 
29580  ShellKit & UnsetVertexEverything();
29581 
29582 
29586  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29587 
29588 
29602  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29603  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29604 
29619  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29620  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29621 
29622 
29631  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29632 
29641  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29642 
29643 
29653  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29654 
29664  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29665 
29675  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
29676 
29686  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29687 
29688 
29697  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29698 
29707  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
29708 
29709 
29710 
29716  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
29717 
29722  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
29723 
29729  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
29730 
29736  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
29737 
29742  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
29743 
29749  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
29750 
29755  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
29756 
29757 
29763  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
29764 
29769  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
29770 
29776  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
29777 
29783  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
29784 
29789  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
29790 
29796  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
29797 
29802  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
29803 
29804 
29810  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29811 
29816  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
29817 
29823  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29824 
29830  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
29831 
29836  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
29837 
29843  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
29844 
29849  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
29850 
29851 
29857  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29858 
29863  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29864 
29870  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29871 
29877  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
29878 
29883  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
29884 
29890  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
29891 
29896  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
29897 
29898 
29901  ShellKit & UnsetFaceColors();
29902 
29907  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
29908 
29912  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
29913 
29914 
29917  ShellKit & UnsetFaceNormals();
29918 
29923  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
29924 
29928  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
29929 
29930 
29933  ShellKit & UnsetFaceVisibilities();
29934 
29939  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
29940 
29944  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
29945 
29946 
29949  ShellKit & UnsetFaceEverything();
29950 
29951 
29961  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29962 
29973  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29974 
29975 
29984  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29985 
29994  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
29995 
29996 
30005  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30006 
30015  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
30016 
30017 
30024  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
30025 
30031  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
30032 
30038  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
30039 
30045  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
30046 
30052  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
30053 
30054 
30061  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
30062 
30068  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
30069 
30075  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
30076 
30085  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
30086 
30094  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
30095 
30098  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
30099 
30104  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30105 
30110  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30111 
30116  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30117 
30123  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30124 
30129  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30130 
30135  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30136 
30140  ShellKit & UnsetUserData(intptr_t in_index);
30141 
30146  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30147 
30151  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
30152 
30155  ShellKit & UnsetAllUserData();
30156 
30158  size_t ShowUserDataCount() const;
30159 
30163  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30164 
30169  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30170 
30175  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30176 };
30177 
30178 
30179 
30181 class HPS_API ShellKey : public GeometryKey
30182 {
30183 public:
30185  ShellKey();
30186 
30191  explicit ShellKey(Key const & in_that);
30192 
30195  ShellKey(ShellKey const & in_that);
30196 
30200  ShellKey & operator=(ShellKey const & other);
30201 
30205  ShellKey(ShellKey && in_that);
30206 
30210  ShellKey & operator=(ShellKey && in_that);
30211 
30212  ~ShellKey();
30213 
30214  HPS::Type ObjectType() const { return HPS::Type::ShellKey; };
30215 
30218  void Consume(ShellKit & in_kit);
30219 
30222  void Set(ShellKit const & in_kit);
30223 
30226  void Show(ShellKit & out_kit) const;
30227 
30230  size_t GetPointCount() const;
30231 
30234  size_t GetFaceCount() const;
30235 
30236 
30240  ShellKey & SetPoints(PointArray const & in_points);
30241 
30246  ShellKey & SetPoints(size_t in_count, Point const in_points []);
30247 
30251  ShellKey & SetFacelist(IntArray const & in_facelist);
30252 
30257  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
30258 
30262  ShellKey & SetTristrips(IntArray const & in_tristrips);
30263 
30268  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
30269 
30274  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
30275 
30278  ShellKey & UnsetPoints();
30279 
30282  ShellKey & UnsetFacelist();
30283 
30286  ShellKey & UnsetTristrips();
30287 
30290  ShellKey & UnsetMaterialMapping();
30291 
30294  ShellKey & UnsetEverything();
30295 
30299  bool ShowPoints(PointArray & out_points) const;
30300 
30306  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
30307 
30312  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
30313 
30319  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
30320 
30324  bool ShowFacelist(IntArray & out_facelist) const;
30325 
30329  bool ShowTristrips(IntArray & out_tristrips) const;
30330 
30334  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30335 
30336 
30343  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30344 
30351  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30352 
30359  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30360 
30367  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30368 
30375  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30376 
30383  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30384 
30390  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30391 
30392 
30399  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30400 
30407  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30408 
30415  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30416 
30423  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30424 
30431  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30432 
30439  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30440 
30446  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30447 
30448 
30455  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30456 
30463  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30464 
30471  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30472 
30479  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30480 
30487  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30488 
30495  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30496 
30502  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30503 
30504 
30510  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30511 
30517  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30518 
30524  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30525 
30531  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30532 
30537  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30538 
30544  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30545 
30550  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30551 
30552 
30560  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30561 
30568  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30569 
30578  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);
30579 
30587  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30588 
30589 
30595  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30596 
30602  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30603 
30609  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30610 
30616  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30617 
30622  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
30623 
30629  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
30630 
30635  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
30636 
30637 
30640  ShellKey & UnsetVertexColors();
30641 
30646  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
30647 
30651  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
30652 
30653 
30657  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
30658 
30664  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
30665 
30670  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
30671 
30672 
30675  ShellKey & UnsetVertexNormals();
30676 
30681  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
30682 
30686  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
30687 
30688 
30691  ShellKey & UnsetVertexParameters();
30692 
30697  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
30698 
30702  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
30703 
30704 
30707  ShellKey & UnsetVertexVisibilities();
30708 
30713  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
30714 
30718  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
30719 
30720 
30723  ShellKey & UnsetVertexEverything();
30724 
30725 
30739  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30740  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30741 
30756  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30757  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30758 
30759 
30768  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30769 
30778  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
30779 
30780 
30790  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
30791 
30801  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30802 
30812  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
30813 
30823  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30824 
30825 
30834  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30835 
30844  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30845 
30846 
30852  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30853 
30859  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
30860 
30866  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
30867 
30873  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
30874 
30879  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
30880 
30886  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
30887 
30892  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
30893 
30894 
30900  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
30901 
30907  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
30908 
30914  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
30915 
30921  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
30922 
30927  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
30928 
30934  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
30935 
30940  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
30941 
30942 
30948  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30949 
30955  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
30956 
30962  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30963 
30969  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
30970 
30975  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
30976 
30982  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
30983 
30988  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
30989 
30990 
30996  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30997 
31003  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31004 
31010  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31011 
31017  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
31018 
31023  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
31024 
31030  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
31031 
31036  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
31037 
31038 
31041  ShellKey & UnsetFaceColors();
31042 
31047  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
31048 
31052  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
31053 
31054 
31057  ShellKey & UnsetFaceNormals();
31058 
31063  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
31064 
31068  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
31069 
31070 
31073  ShellKey & UnsetFaceVisibilities();
31074 
31079  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
31080 
31084  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
31085 
31086 
31089  ShellKey & UnsetFaceEverything();
31090 
31091 
31101  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31102 
31113  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31114 
31115 
31124  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31125 
31134  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31135 
31136 
31142  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
31143 
31150  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
31151 
31152 
31161  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31162 
31171  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31172 
31173 
31180  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
31181 
31187  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
31188 
31194  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
31195 
31201  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
31202 
31208  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
31209 
31210 
31217  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
31218 
31224  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
31225 
31231  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
31232 
31241  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
31242 
31250  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
31251 
31254  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
31255 
31260  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31261 
31266  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31267 
31272  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31273 };
31274 
31275 
31276 
31278 class HPS_API MeshKit : public Object
31279 {
31280 public:
31282  MeshKit();
31283 
31286  MeshKit(MeshKit const & in_kit);
31287 
31291  MeshKit(MeshKit && in_that);
31292 
31296  MeshKit & operator=(MeshKit && in_that);
31297 
31298  virtual ~MeshKit();
31299 
31300  HPS::Type ObjectType() const { return HPS::Type::MeshKit; };
31301 
31304  void Consume(MeshKit & in_kit);
31305 
31308  void Set(MeshKit const & in_kit);
31309 
31312  void Show(MeshKit & out_kit) const;
31313 
31317  MeshKit & operator=(MeshKit const & in_kit);
31318 
31321  bool Empty() const;
31322 
31326  bool Equals(MeshKit const & in_kit) const;
31327 
31331  bool operator==(MeshKit const & in_kit) const;
31332 
31336  bool operator!=(MeshKit const & in_kit) const;
31337 
31340  size_t GetPointCount() const;
31341 
31348  MeshKit & SetPriority(int in_priority);
31349 
31352  MeshKit & UnsetPriority();
31353 
31357  bool ShowPriority(int & out_priority) const;
31358 
31362  MeshKit & SetPoints(PointArray const & in_points);
31363 
31368  MeshKit & SetPoints(size_t in_count, Point const in_points []);
31369 
31375  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
31376 
31383  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31384 
31388  MeshKit & SetRows(size_t in_rows);
31389 
31393  MeshKit & SetColumns(size_t in_columns);
31394 
31397  MeshKit & UnsetPoints();
31398 
31401  MeshKit & UnsetRows();
31402 
31405  MeshKit & UnsetColumns();
31406 
31409  MeshKit & UnsetEverything();
31410 
31414  bool ShowPoints(PointArray & out_points) const;
31415 
31421  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
31422 
31427  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
31428 
31434  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
31435 
31441  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31442 
31446  bool ShowRows(size_t & out_rows) const;
31447 
31451  bool ShowColumns(size_t & out_columns) const;
31452 
31453 
31459  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
31460 
31467  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31468 
31474  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31475 
31482  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31483 
31490  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31491 
31498  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31499 
31506  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31507 
31513  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31514 
31515 
31522  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31523 
31529  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31530 
31537  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31538 
31545  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31546 
31553  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31554 
31561  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31562 
31568  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31569 
31570 
31577  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31578 
31584  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31585 
31592  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31593 
31600  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31601 
31608  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31609 
31616  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31617 
31623  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31624 
31625 
31631  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31632 
31637  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31638 
31644  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31645 
31651  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31652 
31657  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31658 
31664  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31665 
31670  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31671 
31672 
31679  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31680 
31687  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31688 
31697  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);
31698 
31706  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31707 
31708 
31714  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31715 
31720  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31721 
31727  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31728 
31734  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31735 
31740  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31741 
31747  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31748 
31753  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31754 
31755 
31758  MeshKit & UnsetMaterialMapping();
31759 
31762  MeshKit & UnsetVertexColors();
31763 
31768  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31769 
31773  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31774 
31775 
31779  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
31780 
31786  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
31787 
31792  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
31793 
31794 
31797  MeshKit & UnsetVertexNormals();
31798 
31803  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31804 
31808  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31809 
31810 
31813  MeshKit & UnsetVertexParameters();
31814 
31819  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31820 
31824  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31825 
31826 
31829  MeshKit & UnsetVertexVisibilities();
31830 
31835  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31836 
31840  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31841 
31842 
31845  MeshKit & UnsetVertexEverything();
31846 
31847 
31851  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31852 
31866  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31867  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31868 
31883  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31884  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31885 
31886 
31895  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31896 
31905  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31906 
31907 
31917  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31918 
31928  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31929 
31939  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31940 
31950  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31951 
31952 
31961  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31962 
31971  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31972 
31973 
31979  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31980 
31985  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31986 
31992  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31993 
31999  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32000 
32005  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32006 
32012  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32013 
32018  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32019 
32020 
32026  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32027 
32032  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32033 
32039  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32040 
32046  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32047 
32052  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32053 
32059  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32060 
32065  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32066 
32067 
32073  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32074 
32079  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
32080 
32086  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32087 
32093  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
32094 
32099  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
32100 
32106  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32107 
32112  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32113 
32114 
32120  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32121 
32126  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32127 
32133  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32134 
32140  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32141 
32146  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32147 
32153  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32154 
32159  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32160 
32161 
32164  MeshKit & UnsetFaceColors();
32165 
32170  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32171 
32175  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
32176 
32177 
32180  MeshKit & UnsetFaceNormals();
32181 
32186  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32187 
32191  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
32192 
32193 
32196  MeshKit & UnsetFaceVisibilities();
32197 
32202  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32203 
32207  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
32208 
32209 
32212  MeshKit & UnsetFaceEverything();
32213 
32214 
32224  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32225 
32236  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32237 
32238 
32247  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32248 
32257  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32258 
32259 
32268  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32269 
32278  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32279 
32285  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32286 
32291  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32292 
32297  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32298 
32302  MeshKit & UnsetUserData(intptr_t in_index);
32303 
32308  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32309 
32313  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
32314 
32317  MeshKit & UnsetAllUserData();
32318 
32320  size_t ShowUserDataCount() const;
32321 
32325  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32326 
32331  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32332 
32337  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32338 
32339 };
32340 
32341 
32342 
32344 class HPS_API MeshKey : public GeometryKey
32345 {
32346 public:
32348  MeshKey();
32349 
32354  explicit MeshKey(Key const & in_that);
32355 
32358  MeshKey(MeshKey const & in_that);
32359 
32363  MeshKey & operator=(MeshKey const & in_that);
32364 
32368  MeshKey(MeshKey && in_that);
32369 
32373  MeshKey & operator=(MeshKey && in_that);
32374 
32375  ~MeshKey();
32376 
32377  HPS::Type ObjectType() const { return HPS::Type::MeshKey; };
32378 
32381  void Consume(MeshKit & in_kit);
32382 
32385  void Set(MeshKit const & in_kit);
32386 
32389  void Show(MeshKit & out_kit) const;
32390 
32393  size_t GetPointCount() const;
32394 
32400  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
32401 
32408  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
32409 
32413  bool ShowPoints(PointArray & out_points) const;
32414 
32420  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32421 
32426  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32427 
32433  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32434 
32440  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
32441 
32445  bool ShowRows(size_t & out_rows) const;
32446 
32450  bool ShowColumns(size_t & out_columns) const;
32451 
32452 
32457  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
32458 
32461  MeshKey & UnsetMaterialMapping();
32462 
32466  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32467 
32468 
32475  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32476 
32483  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32484 
32491  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32492 
32499  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32500 
32507  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32508 
32515  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32516 
32522  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32523 
32524 
32531  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32532 
32539  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32540 
32547  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32548 
32555  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32556 
32563  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32564 
32571  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32572 
32578  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32579 
32580 
32587  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32588 
32595  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32596 
32603  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32604 
32611  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32612 
32619  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32620 
32627  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32628 
32634  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32635 
32636 
32642  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32643 
32649  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32650 
32656  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32657 
32663  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32664 
32669  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32670 
32676  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32677 
32682  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32683 
32684 
32692  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32693 
32700  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32701 
32710  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);
32711 
32719  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32720 
32721 
32727  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32728 
32734  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32735 
32741  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32742 
32748  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32749 
32754  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32755 
32761  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32762 
32767  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32768 
32769 
32772  MeshKey & UnsetVertexColors();
32773 
32778  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32779 
32783  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32784 
32785 
32789  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
32790 
32796  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
32797 
32802  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
32803 
32804 
32807  MeshKey & UnsetVertexNormals();
32808 
32813  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
32814 
32818  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
32819 
32820 
32823  MeshKey & UnsetVertexParameters();
32824 
32829  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
32830 
32834  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
32835 
32836 
32839  MeshKey & UnsetVertexVisibilities();
32840 
32845  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
32846 
32850  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
32851 
32852 
32855  MeshKey & UnsetVertexEverything();
32856 
32859  MeshKey & UnsetEverything();
32860 
32861 
32875  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32876  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32877 
32892  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32893  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32894 
32895 
32904  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32905 
32914  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32915 
32916 
32926  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32927 
32937  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32938 
32948  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32949 
32959  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32960 
32961 
32970  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32971 
32980  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32981 
32982 
32988  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32989 
32995  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32996 
33002  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
33003 
33009  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
33010 
33015  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
33016 
33022  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
33023 
33028  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
33029 
33030 
33036  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
33037 
33043  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
33044 
33050  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
33051 
33057  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
33058 
33063  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
33064 
33070  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
33071 
33076  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
33077 
33078 
33084  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33085 
33091  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33092 
33098  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33099 
33105  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33106 
33111  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33112 
33118  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33119 
33124  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33125 
33126 
33132  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33133 
33139  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33140 
33146  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33147 
33153  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33154 
33159  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33160 
33166  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33167 
33172  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33173 
33174 
33177  MeshKey & UnsetFaceColors();
33178 
33183  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33184 
33188  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
33189 
33190 
33193  MeshKey & UnsetFaceNormals();
33194 
33199  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33200 
33204  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
33205 
33206 
33209  MeshKey & UnsetFaceVisibilities();
33210 
33215  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33216 
33220  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
33221 
33222 
33225  MeshKey & UnsetFaceEverything();
33226 
33227 
33237  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33238 
33249  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33250 
33251 
33260  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33261 
33270  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33271 
33272 
33281  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33282 
33291  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33292 
33301  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[]);
33302 
33310  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);
33311 };
33312 
33313 
33314 
33315 
33317 class HPS_API PolygonKit : public Object
33318 {
33319 public:
33321  PolygonKit();
33322 
33325  PolygonKit(PolygonKit const & in_kit);
33326 
33330  PolygonKit(PolygonKit && in_that);
33331 
33335  PolygonKit & operator=(PolygonKit && in_that);
33336 
33337  virtual ~PolygonKit();
33338 
33339  HPS::Type ObjectType() const { return HPS::Type::PolygonKit; };
33340 
33343  void Consume(PolygonKit & in_kit);
33344 
33347  void Set(PolygonKit const & in_kit);
33348 
33351  void Show(PolygonKit & out_kit) const;
33352 
33356  PolygonKit & operator=(PolygonKit const & in_kit);
33357 
33360  bool Empty() const;
33361 
33365  bool Equals(PolygonKit const & in_kit) const;
33366 
33370  bool operator==(PolygonKit const & in_kit) const;
33371 
33375  bool operator!=(PolygonKit const & in_kit) const;
33376 
33379  size_t GetPointCount() const;
33380 
33387  PolygonKit & SetPriority(int in_priority);
33388 
33391  PolygonKit & UnsetPriority();
33392 
33396  bool ShowPriority(int & out_priority) const;
33397 
33398 
33402  PolygonKit & SetPoints(PointArray const & in_points);
33403 
33408  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
33409 
33412  PolygonKit & UnsetPoints();
33413 
33416  PolygonKit & UnsetEverything();
33417 
33421  bool ShowPoints(PointArray & out_points) const;
33422 
33428  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33429 
33434  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33435 
33441  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33442 
33448  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33449 
33454  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33455 
33460  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
33461 
33467  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33468 
33473  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33474 
33480  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33481 
33486  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33487 
33492  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33493 
33497  PolygonKit & UnsetUserData(intptr_t in_index);
33498 
33503  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33504 
33508  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
33509 
33512  PolygonKit & UnsetAllUserData();
33513 
33515  size_t ShowUserDataCount() const;
33516 
33520  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33521 
33526  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33527 
33532  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33533 };
33534 
33535 
33537 class HPS_API PolygonKey : public GeometryKey
33538 {
33539 public:
33541  PolygonKey();
33542 
33547  explicit PolygonKey(Key const & in_that);
33548 
33551  PolygonKey(PolygonKey const & in_that);
33552 
33556  PolygonKey & operator=(PolygonKey const & in_that);
33557 
33561  PolygonKey(PolygonKey && in_that);
33562 
33566  PolygonKey & operator=(PolygonKey && in_that);
33567 
33568  ~PolygonKey();
33569 
33570  HPS::Type ObjectType() const { return HPS::Type::PolygonKey; };
33571 
33572 
33575  void Consume(PolygonKit & in_kit);
33576 
33579  void Set(PolygonKit const & in_kit);
33580 
33583  void Show(PolygonKit & out_kit) const;
33584 
33587  size_t GetPointCount() const;
33588 
33592  PolygonKey & SetPoints(PointArray const & in_points);
33593 
33598  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
33599 
33603  bool ShowPoints(PointArray & out_points) const;
33604 
33610  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33611 
33616  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33617 
33623  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33624 
33630  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33631 
33636  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33637 
33642  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
33643 
33649  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33650 
33655  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33656 };
33657 
33658 
33659 
33660 
33662 class HPS_API GridKit : public Object
33663 {
33664 public:
33666  GridKit();
33667 
33670  GridKit(GridKit const & in_kit);
33671 
33674  GridKit(GridKit && in_that);
33675 
33676  virtual ~GridKit();
33677 
33678  HPS::Type ObjectType() const { return HPS::Type::GridKit; };
33679 
33682  void Consume(GridKit & in_kit);
33683 
33686  void Set(GridKit const & in_kit);
33687 
33690  void Show(GridKit & out_kit) const;
33691 
33695  GridKit & operator=(GridKit const & in_kit);
33696 
33700  GridKit & operator=(GridKit && in_that);
33701 
33704  bool Empty() const;
33705 
33709  bool Equals(GridKit const & in_kit) const;
33710 
33714  bool operator==(GridKit const & in_kit) const;
33715 
33719  bool operator!=(GridKit const & in_kit) const;
33720 
33721 
33728  GridKit & SetPriority(int in_priority);
33729 
33733  GridKit & SetType(Grid::Type in_type);
33734 
33738  GridKit & SetOrigin(Point const & in_origin);
33739 
33746  GridKit & SetFirstPoint(Point const & in_first_point);
33747 
33755  GridKit & SetSecondPoint(Point const & in_second_point);
33756 
33770  GridKit & SetFirstCount(int in_first_count);
33771 
33782  GridKit & SetSecondCount(int in_second_count);
33783 
33784 
33787  GridKit & UnsetPriority();
33788 
33791  GridKit & UnsetType();
33792 
33795  GridKit & UnsetOrigin();
33796 
33799  GridKit & UnsetFirstPoint();
33800 
33803  GridKit & UnsetSecondPoint();
33804 
33807  GridKit & UnsetFirstCount();
33808 
33811  GridKit & UnsetSecondCount();
33812 
33815  GridKit & UnsetEverything();
33816 
33817 
33821  bool ShowPriority(int & out_priority) const;
33822 
33826  bool ShowType(Grid::Type & out_type) const;
33827 
33831  bool ShowOrigin(Point & out_origin) const;
33832 
33836  bool ShowFirstPoint(Point & out_first_point) const;
33837 
33841  bool ShowSecondPoint(Point & out_second_point) const;
33842 
33846  bool ShowFirstCount(int & out_first_count) const;
33847 
33851  bool ShowSecondCount(int & out_second_count) const;
33852 
33858  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33859 
33864  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33865 
33870  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33871 
33875  GridKit & UnsetUserData(intptr_t in_index);
33876 
33881  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33882 
33886  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
33887 
33890  GridKit & UnsetAllUserData();
33891 
33893  size_t ShowUserDataCount() const;
33894 
33898  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33899 
33904  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33905 
33910  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33911 };
33912 
33913 
33915 class HPS_API GridKey : public GeometryKey
33916 {
33917 public:
33919  GridKey();
33920 
33925  explicit GridKey(Key const & in_that);
33926 
33929  GridKey(GridKey const & in_that);
33930 
33933  GridKey(GridKey && in_that);
33934 
33938  GridKey & operator=(GridKey const & in_that);
33939 
33943  GridKey & operator=(GridKey && in_that);
33944 
33945  ~GridKey();
33946 
33947  HPS::Type ObjectType() const { return HPS::Type::GridKey; };
33948 
33951  void Consume(GridKit & in_kit);
33952 
33955  void Set(GridKit const & in_kit);
33956 
33959  void Show(GridKit & out_kit) const;
33960 
33961 
33965  GridKey & SetType(Grid::Type in_type);
33966 
33970  GridKey & SetOrigin(Point const & in_origin);
33971 
33978  GridKey & SetFirstPoint(Point const & in_first_point);
33979 
33987  GridKey & SetSecondPoint(Point const & in_second_point);
33988 
34002  GridKey & SetFirstCount(int in_first_count);
34003 
34014  GridKey & SetSecondCount(int in_second_count);
34015 
34016 
34017 
34021  bool ShowType(Grid::Type & out_type) const;
34022 
34026  bool ShowOrigin(Point & out_origin) const;
34027 
34031  bool ShowFirstPoint(Point & out_first_point) const;
34032 
34036  bool ShowSecondPoint(Point & out_second_point) const;
34037 
34041  bool ShowFirstCount(int & out_first_count) const;
34042 
34046  bool ShowSecondCount(int & out_second_count) const;
34047 };
34048 
34049 
34050 
34051 
34053 class HPS_API IncludeKey : public Key
34054 {
34055 public:
34057  IncludeKey();
34058 
34063  explicit IncludeKey(Key const & in_that);
34064 
34067  IncludeKey(IncludeKey const & in_that);
34068 
34072  IncludeKey & operator=(IncludeKey const & in_that);
34073 
34077  IncludeKey(IncludeKey && in_that);
34078 
34082  IncludeKey & operator=(IncludeKey && in_that);
34083 
34084  ~IncludeKey();
34085 
34086 
34087  HPS::Type ObjectType() const { return HPS::Type::IncludeKey; };
34088 
34091  SegmentKey GetTarget() const;
34092 
34093 
34098  IncludeKey & SetPriority(int in_priority);
34099 
34107  IncludeKey & SetCondition(Condition const & in_condition);
34108 
34109 
34112  IncludeKey & UnsetPriority();
34113 
34116  IncludeKey & UnsetCondition();
34117 
34118 
34122  bool ShowPriority(int & out_priority) const;
34123 
34127  bool ShowCondition(Condition & out_condition) const;
34128 
34134  IncludeKey & SetFilter(AttributeLock::Type in_type);
34135 
34142  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34143 
34149  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
34150 
34156  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
34157 
34164  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34165 
34171  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34172 
34178  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34179 
34185  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34186 };
34187 
34188 
34189 
34191 class HPS_API StyleKey : public Key
34192 {
34193 public:
34195  StyleKey();
34196 
34201  explicit StyleKey(Key const & in_that);
34202 
34205  StyleKey(StyleKey const & in_that);
34206 
34210  StyleKey & operator=(StyleKey const & other);
34211 
34215  StyleKey(StyleKey && in_that);
34216 
34220  StyleKey & operator=(StyleKey && in_that);
34221 
34222  ~StyleKey();
34223 
34224  HPS::Type ObjectType() const { return HPS::Type::StyleKey; };
34225 
34226 
34232  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
34233 
34234 
34242  StyleKey & SetCondition(Condition const & in_condition);
34243 
34244 
34247  StyleKey & UnsetCondition();
34248 
34249 
34253  bool ShowCondition(Condition & out_condition) const;
34254 
34255 
34261  StyleKey & SetFilter(AttributeLock::Type in_type);
34262 
34269  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34270 
34276  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
34277 
34283  StyleKey & UnsetFilter(AttributeLock::Type in_type);
34284 
34291  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34292 
34298  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34299 
34305  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34306 
34312  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34313 };
34314 
34315 
34316 
34318 class HPS_API ReferenceKey : public GeometryKey
34319 {
34320 public:
34322  ReferenceKey();
34323 
34328  explicit ReferenceKey(Key const & in_that);
34329 
34332  ReferenceKey(ReferenceKey const & in_that);
34333 
34337  ReferenceKey & operator=(ReferenceKey const & in_that);
34338 
34342  ReferenceKey(ReferenceKey && in_that);
34343 
34347  ReferenceKey & operator=(ReferenceKey && in_that);
34348 
34349  ~ReferenceKey();
34350 
34351  HPS::Type ObjectType() const { return HPS::Type::ReferenceKey; };
34352 
34356  Key GetTarget() const;
34357 
34361  size_t ShowTargets(bool masked=true) const;
34362 
34367  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
34368 
34372  size_t ShowGeometryMask() const;
34373 
34378  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
34379 
34383  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
34384 
34387  ReferenceKey & UnsetGeometryMask();
34388 
34391  void SetModellingMatrix(MatrixKit const & in_kit);
34392 
34401  ReferenceKey & SetCondition(Condition const & in_condition);
34402 
34403 
34405  void UnsetModellingMatrix();
34406 
34409  ReferenceKey & UnsetCondition();
34410 
34411 
34415  bool ShowModellingMatrix(MatrixKit & out_kit) const;
34416 
34420  bool ShowCondition(Condition & out_condition) const;
34421 
34422 
34425  ModellingMatrixControl GetModellingMatrixControl();
34426 
34429  ModellingMatrixControl const GetModellingMatrixControl() const;
34430 };
34431 
34432 
34433 
34437 class HPS_API StandAloneWindowOptionsKit : public Object
34438 {
34439 public:
34442 
34446 
34451 
34456 
34457  virtual ~StandAloneWindowOptionsKit();
34458 
34459  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsKit; };
34460 
34464  static StandAloneWindowOptionsKit GetDefault();
34465 
34468  void Set(StandAloneWindowOptionsKit const & in_kit);
34469 
34472  void Show(StandAloneWindowOptionsKit & out_kit) const;
34473 
34477  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
34478 
34481  bool Empty() const;
34482 
34486  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
34487 
34491  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
34492 
34496  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
34497 
34501  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
34502 
34507  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34508 
34512  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
34513 
34518  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
34519 
34523  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
34524 
34528  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
34529 
34532  StandAloneWindowOptionsKit & UnsetDriver();
34533 
34536  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
34537 
34540  StandAloneWindowOptionsKit & UnsetTitle();
34541 
34544  StandAloneWindowOptionsKit & UnsetSubscreen();
34545 
34548  StandAloneWindowOptionsKit & UnsetMobility();
34549 
34552  StandAloneWindowOptionsKit & UnsetFullScreen();
34553 
34556  StandAloneWindowOptionsKit & UnsetEverything();
34557 
34561  bool ShowDriver(Window::Driver & out_driver) const;
34562 
34567  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34568 
34572  bool ShowTitle(UTF8 & out_window_name) const;
34573 
34577  bool ShowSubscreen(Rectangle & out_subscreen) const;
34578 
34582  bool ShowMobility(Window::Mobility & out_mobility) const;
34583 
34587  bool ShowFullScreen(bool & out_state) const;
34588 };
34589 
34590 
34591 
34598 {
34599 public:
34603 
34607 
34612 
34617 
34620 
34621  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsControl; };
34622 
34627 
34632  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
34633 
34637  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
34638 
34642  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
34643 
34647  bool ShowDriver(Window::Driver & out_driver) const;
34648 
34653  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34654 
34658  bool ShowTitle(UTF8 & out_window_name) const;
34659 
34663  bool ShowSubscreen(Rectangle & out_subscreen) const;
34664 
34668  bool ShowMobility(Window::Mobility & out_mobility) const;
34669 
34673  bool ShowFullScreen(bool & out_state) const;
34674 
34675 private:
34678 };
34679 
34680 
34681 
34685 class HPS_API OffScreenWindowOptionsKit : public Object
34686 {
34687 public:
34690 
34694 
34699 
34703  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
34704 
34705  virtual ~OffScreenWindowOptionsKit();
34706 
34707  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsKit; };
34708 
34712  static OffScreenWindowOptionsKit GetDefault();
34713 
34716  void Set(OffScreenWindowOptionsKit const & in_kit);
34717 
34720  void Show(OffScreenWindowOptionsKit & out_kit) const;
34721 
34725  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
34726 
34729  bool Empty() const;
34730 
34734  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
34735 
34739  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
34740 
34744  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
34745 
34749  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
34750 
34755  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34756 
34761  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
34762 
34767  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
34768 
34773  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
34774 
34778  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
34779 
34782  OffScreenWindowOptionsKit & UnsetDriver();
34783 
34786  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
34787 
34790  OffScreenWindowOptionsKit & UnsetHardwareResident();
34791 
34794  OffScreenWindowOptionsKit & UnsetNativeFormat();
34795 
34798  OffScreenWindowOptionsKit & UnsetOpacity();
34799 
34802  OffScreenWindowOptionsKit & UnsetEverything();
34803 
34807  bool ShowDriver(Window::Driver & out_driver) const;
34808 
34813  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34814 
34818  bool ShowHardwareResident(bool & out_state) const;
34819 
34824  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
34825 
34830  bool ShowOpacity(bool & out_state, float & out_opacity) const;
34831 };
34832 
34836 class HPS_API ApplicationWindowOptionsKit : public Object
34837 {
34838 public:
34841 
34845 
34850 
34855 
34856  virtual ~ApplicationWindowOptionsKit();
34857 
34858  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsKit; };
34859 
34863  static ApplicationWindowOptionsKit GetDefault();
34864 
34867  void Set(ApplicationWindowOptionsKit const & in_kit);
34868 
34871  void Show(ApplicationWindowOptionsKit & out_kit) const;
34872 
34876  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
34877 
34880  bool Empty() const;
34881 
34885  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
34886 
34890  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
34891 
34895  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
34896 
34900  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
34901 
34906  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34907 
34911  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
34912 
34916  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
34917 
34920  ApplicationWindowOptionsKit & UnsetDriver();
34921 
34924  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
34925 
34928  ApplicationWindowOptionsKit & UnsetPlatformData();
34929 
34932  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
34933 
34936  ApplicationWindowOptionsKit & UnsetEverything();
34937 
34941  bool ShowDriver(Window::Driver & out_driver) const;
34942 
34947  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34948 
34952  bool ShowPlatformData(PlatformData & out_platform_data) const;
34953 
34957  bool ShowFramebufferRetention(bool & out_retain) const;
34958 
34959 };
34960 
34961 
34962 
34965 {
34966 public:
34970 
34974 
34979 
34984 
34987 
34988  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsControl; };
34989 
34994 
34999  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35000 
35004  bool ShowDriver(Window::Driver & out_driver) const;
35005 
35009  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
35010 
35014  bool ShowPlatformData(PlatformData & out_platform_data) const;
35015 
35019  bool ShowFramebufferRetention(bool & out_retain) const;
35020 
35024  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
35025 
35029  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
35030 
35031 private:
35034 };
35035 
35036 
35037 
35042 class HPS_API StandAloneWindowKey : public WindowKey
35043 {
35044 public:
35047 
35052  StandAloneWindowKey(Key const & in_key);
35053 
35056  StandAloneWindowKey(StandAloneWindowKey const & in_that);
35057 
35062 
35066  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
35067 
35069 
35070  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowKey; };
35071 
35074  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
35075 
35078  StandAloneWindowOptionsControl GetWindowOptionsControl();
35079 
35083  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
35084 
35087  Window::UpdateStatus Pause();
35088 };
35089 
35090 
35091 
35093 class HPS_API ApplicationWindowKey : public WindowKey
35094 {
35095 public:
35098 
35103  ApplicationWindowKey(Key const & in_key);
35104 
35107  ApplicationWindowKey(ApplicationWindowKey const & in_that);
35108 
35113 
35117  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
35118 
35120 
35121  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowKey; };
35122 
35125  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
35126 
35129  ApplicationWindowOptionsControl GetWindowOptionsControl();
35130 
35134  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
35135 };
35136 
35140 
35141 
35142 
35144 class HPS_API GlyphElement : public Object
35145 {
35146 public:
35148  GlyphElement();
35149 
35152  GlyphElement(GlyphElement const & in_that);
35153 
35157  GlyphElement(GlyphElement && in_that);
35158 
35162  GlyphElement & operator=(GlyphElement && in_that);
35163 
35164  virtual ~GlyphElement();
35165 
35166  HPS::Type ObjectType() const { return HPS::Type::GlyphElement; };
35167 
35170  void Set(GlyphElement const & in_that);
35171 
35175  GlyphElement & operator=(GlyphElement const & in_that);
35176 
35180  bool Equals(GlyphElement const & in_that) const;
35181 
35185  bool operator==(GlyphElement const & in_that) const;
35186 
35190  bool operator!=(GlyphElement const & in_that) const;
35191 
35194  void SetFill(Glyph::Fill in_fill);
35195 
35198  void SetIndexedColor(byte in_index);
35199 
35201  void SetNormalColor();
35202 
35205  void SetExplicitColor(RGBAColor const & in_color);
35206 
35210  bool ShowFill(Glyph::Fill & out_fill) const;
35211 
35217  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
35218 };
35219 
35220 
35222 class HPS_API LineGlyphElement : public GlyphElement
35223 {
35224 public:
35226  LineGlyphElement();
35227 
35232  LineGlyphElement(GlyphElement const & in_that);
35233 
35236  LineGlyphElement(LineGlyphElement const & in_that);
35237 
35240  explicit LineGlyphElement(GlyphPointArray const & in_points);
35241 
35245  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
35246 
35250  LineGlyphElement(LineGlyphElement && in_that);
35251 
35255  LineGlyphElement & operator=(LineGlyphElement && in_that);
35256 
35257  ~LineGlyphElement();
35258 
35259  HPS::Type ObjectType() const { return HPS::Type::LineGlyphElement; };
35260 
35263  void SetPoints(GlyphPointArray const & in_points);
35264 
35268  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
35269 
35273  bool ShowPoints(GlyphPointArray & out_points) const;
35274 };
35275 
35277 class HPS_API DotGlyphElement : public GlyphElement
35278 {
35279 public:
35281  DotGlyphElement();
35282 
35287  DotGlyphElement(GlyphElement const & in_that);
35288 
35291  DotGlyphElement(DotGlyphElement const & in_that);
35292 
35295  explicit DotGlyphElement(GlyphPoint const & in_point);
35296 
35300  DotGlyphElement(DotGlyphElement && in_that);
35301 
35305  DotGlyphElement & operator=(DotGlyphElement && in_that);
35306 
35307  ~DotGlyphElement();
35308 
35309  HPS::Type ObjectType() const { return HPS::Type::DotGlyphElement; };
35310 
35313  void SetPoint(GlyphPoint const & in_point);
35314 
35318  bool ShowPoint(GlyphPoint & out_point) const;
35319 };
35320 
35321 
35323 class HPS_API EllipseGlyphElement : public GlyphElement
35324 {
35325 public:
35328 
35333  EllipseGlyphElement(GlyphElement const & in_that);
35334 
35337  EllipseGlyphElement(EllipseGlyphElement const & in_that);
35338 
35342  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35343 
35348 
35352  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
35353 
35355 
35356  HPS::Type ObjectType() const { return HPS::Type::EllipseGlyphElement; };
35357 
35360  void SetLowerLeft(GlyphPoint const & in_point);
35361 
35364  void SetUpperRight(GlyphPoint const & in_point);
35365 
35369  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35370 
35374  bool ShowLowerLeft(GlyphPoint & out_point) const;
35375 
35379  bool ShowUpperRight(GlyphPoint & out_point) const;
35380 };
35381 
35382 
35385 {
35386 public:
35389 
35394  CircularArcGlyphElement(GlyphElement const & in_that);
35395 
35399 
35404  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35405 
35410 
35414  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
35415 
35417 
35418  HPS::Type ObjectType() const { return HPS::Type::CircularArcGlyphElement; };
35419 
35422  void SetStartPoint(GlyphPoint const & in_point);
35423 
35426  void SetIntermediatePoint(GlyphPoint const & in_point);
35427 
35430  void SetEndPoint(GlyphPoint const & in_point);
35431 
35436  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35437 
35441  bool ShowStartPoint(GlyphPoint & out_point) const;
35442 
35446  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
35447 
35451  bool ShowEndPoint(GlyphPoint & out_point) const;
35452 };
35453 
35454 
35455 
35458 {
35459 public:
35462 
35467  InfiniteLineGlyphElement(GlyphElement const & in_that);
35468 
35472 
35477  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
35478 
35483 
35487  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
35488 
35490 
35491  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineGlyphElement; };
35492 
35495  void SetFirstPoint(GlyphPoint const & in_point);
35496 
35499  void SetSecondPoint(GlyphPoint const & in_point);
35500 
35504  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
35505 
35508  void SetInfiniteType(InfiniteLine::Type in_type);
35509 
35513  bool ShowFirstPoint(GlyphPoint & out_point) const;
35514 
35518  bool ShowSecondPoint(GlyphPoint & out_point) const;
35519 
35523  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
35524 };
35525 
35526 
35527 
35529 class HPS_API GlyphKit : public Object
35530 {
35531 public:
35533  GlyphKit();
35534 
35537  GlyphKit(GlyphKit const & in_kit);
35538 
35542  GlyphKit(GlyphKit && in_that);
35543 
35547  GlyphKit & operator=(GlyphKit && in_that);
35548 
35549  virtual ~GlyphKit();
35550 
35551  HPS::Type ObjectType() const { return HPS::Type::GlyphKit; };
35552 
35556  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
35557 
35560  void Set(GlyphKit const & in_kit);
35561 
35564  void Show(GlyphKit & out_kit) const;
35565 
35569  GlyphKit & operator=(GlyphKit const & in_kit);
35570 
35573  bool Empty() const;
35574 
35578  bool Equals(GlyphKit const & in_kit) const;
35579 
35583  bool operator==(GlyphKit const & in_kit) const;
35584 
35588  bool operator!=(GlyphKit const & in_kit) const;
35589 
35593  GlyphKit & SetRadius(sbyte in_radius);
35594 
35599  GlyphKit & SetOffset(GlyphPoint const & in_point);
35600 
35604  GlyphKit & SetElements(GlyphElementArray const & in_def);
35605 
35610  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
35611 
35614  GlyphKit & UnsetRadius();
35615 
35618  GlyphKit & UnsetOffset();
35619 
35622  GlyphKit & UnsetElements();
35623 
35626  GlyphKit & UnsetEverything();
35627 
35631  bool ShowRadius(sbyte & out_radius) const;
35632 
35636  bool ShowOffset(GlyphPoint & out_point) const;
35637 
35641  bool ShowElements(GlyphElementArray & out_def) const;
35642 };
35643 
35647 
35648 
35651 class HPS_API LinePatternOptionsKit : public Object
35652 {
35653 public:
35656 
35660 
35665 
35669  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
35670 
35671  virtual ~LinePatternOptionsKit();
35672 
35673  HPS::Type ObjectType() const { return HPS::Type::LinePatternOptionsKit; };
35674 
35677  void Set(LinePatternOptionsKit const & in_kit);
35678 
35681  void Show(LinePatternOptionsKit & out_kit) const;
35682 
35686  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
35687 
35690  bool Empty() const;
35691 
35695  bool Equals(LinePatternOptionsKit const & in_kit) const;
35696 
35700  bool operator==(LinePatternOptionsKit const & in_kit) const;
35701 
35705  bool operator!=(LinePatternOptionsKit const & in_kit) const;
35706 
35710  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
35711 
35715  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
35716 
35720  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
35721 
35725  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
35726 
35730  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
35731 
35735  LinePatternOptionsKit & SetJoin(char const * in_glyph);
35736 
35740  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
35741 
35745  LinePatternOptionsKit & UnsetStartCap();
35746 
35750  LinePatternOptionsKit & UnsetEndCap();
35751 
35754  LinePatternOptionsKit & UnsetInnerCap();
35755 
35759  LinePatternOptionsKit & UnsetJoin();
35760 
35763  LinePatternOptionsKit & UnsetEverything();
35764 
35770  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35771 
35777  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35778 
35782  bool ShowInnerCap(LinePattern::Cap & out_type) const;
35783 
35789  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
35790 };
35791 
35794 class HPS_API LinePatternElement : public Object
35795 {
35796 public:
35799 
35802  LinePatternElement(LinePatternElement const & in_that);
35803 
35808 
35812  LinePatternElement & operator=(LinePatternElement && in_that);
35813 
35814  ~LinePatternElement();
35815 
35816  HPS::Type ObjectType() const { return HPS::Type::LinePatternElement; };
35817 
35820  void Set(LinePatternElement const & in_that);
35821 
35825  LinePatternElement & operator=(LinePatternElement const & in_that);
35826 
35830  bool Equals(LinePatternElement const & in_that) const;
35831 
35835  bool operator==(LinePatternElement const & in_that) const;
35836 
35840  bool operator!=(LinePatternElement const & in_that) const;
35841 
35845  void SetSize(float in_size, LinePattern::SizeUnits in_units);
35846 
35851  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
35852 };
35853 
35856 {
35857 public:
35860 
35866 
35870 
35874  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35875 
35880 
35884  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
35885 
35887 
35888  HPS::Type ObjectType() const { return HPS::Type::SolidLinePatternElement; };
35889 
35893  void SetColor(RGBAColor const & in_color);
35894 
35898  void SetMaterialByIndex(float in_material_index);
35899 
35905  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
35906 };
35907 
35908 
35911 {
35912 public:
35915 
35921 
35925 
35929  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35930 
35935 
35939  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
35940 
35942 
35943  HPS::Type ObjectType() const { return HPS::Type::BlankLinePatternElement; };
35944 };
35945 
35946 
35949 {
35950 public:
35953 
35959 
35963 
35967  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
35968 
35973 
35977  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
35978 
35980 
35981  HPS::Type ObjectType() const { return HPS::Type::GlyphLinePatternElement; };
35982 
35985  void SetSource(char const * in_source);
35986 
35990  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
35991 
35994  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
35995 
35998  void SetMirror(bool in_state);
35999 
36002  void SetFixed(bool in_state);
36003 
36006  void SetRotation(float in_degrees);
36007 
36011  bool ShowSource(UTF8 & out_source) const;
36012 
36017  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
36018 
36022  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
36023 
36027  bool ShowMirror(bool & out_state) const;
36028 
36032  bool ShowFixed(bool & out_state) const;
36033 
36037  bool ShowRotation(float & out_degrees) const;
36038 };
36039 
36041 class HPS_API LinePatternParallelKit : public Object
36042 {
36043 public:
36046 
36050 
36055 
36059  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
36060 
36061  virtual ~LinePatternParallelKit();
36062 
36063  HPS::Type ObjectType() const { return HPS::Type::LinePatternParallelKit; };
36064 
36067  void Set(LinePatternParallelKit const & in_kit);
36068 
36071  void Show(LinePatternParallelKit & out_kit) const;
36072 
36076  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
36077 
36080  bool Empty() const;
36081 
36085  bool Equals(LinePatternParallelKit const & in_kit) const;
36086 
36090  bool operator==(LinePatternParallelKit const & in_kit) const;
36091 
36095  bool operator!=(LinePatternParallelKit const & in_kit) const;
36096 
36100  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
36101 
36105  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
36106 
36110  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
36111 
36115  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
36116 
36121  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
36122 
36126  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
36127 
36131  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
36132 
36136  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
36137 
36144  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
36145 
36151  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
36152 
36156  LinePatternParallelKit & SetContinuous(bool in_state);
36157 
36160  LinePatternParallelKit & UnsetStartCap();
36161 
36164  LinePatternParallelKit & UnsetEndCap();
36165 
36168  LinePatternParallelKit & UnsetJoin();
36169 
36172  LinePatternParallelKit & UnsetBody();
36173 
36176  LinePatternParallelKit & UnsetAbsoluteLength();
36177 
36180  LinePatternParallelKit & UnsetAbsoluteWeight();
36181 
36184  LinePatternParallelKit & UnsetJustification();
36185 
36188  LinePatternParallelKit & UnsetOffset();
36189 
36192  LinePatternParallelKit & UnsetWeight();
36193 
36196  LinePatternParallelKit & UnsetContinuous();
36197 
36200  LinePatternParallelKit & UnsetEverything();
36201 
36205  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
36206 
36210  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
36211 
36215  bool ShowJoin(GlyphLinePatternElement & out_join) const;
36216 
36220  bool ShowBody(LinePatternElementArray & out_elements) const;
36221 
36225  bool ShowAbsoluteLength(bool & out_state) const;
36226 
36230  bool ShowAbsoluteWeight(bool & out_state) const;
36231 
36235  bool ShowJustification(LinePattern::Justification & out_type) const;
36236 
36242  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36243 
36249  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36250 
36254  bool ShowContinuous(bool & out_state) const;
36255 };
36256 
36257 
36259 class HPS_API LinePatternKit : public Object
36260 {
36261 public:
36263  LinePatternKit();
36264 
36267  LinePatternKit(LinePatternKit const & in_kit);
36268 
36272  LinePatternKit(LinePatternKit && in_that);
36273 
36277  LinePatternKit & operator=(LinePatternKit && in_that);
36278 
36279  virtual ~LinePatternKit();
36280 
36281  HPS::Type ObjectType() const { return HPS::Type::LinePatternKit; };
36282 
36286  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
36287 
36290  void Set(LinePatternKit const & in_kit);
36291 
36294  void Show(LinePatternKit & out_kit) const;
36295 
36299  LinePatternKit & operator=(LinePatternKit const & in_kit);
36300 
36303  bool Empty() const;
36304 
36308  bool Equals(LinePatternKit const & in_kit) const;
36309 
36313  bool operator==(LinePatternKit const & in_kit) const;
36314 
36318  bool operator!=(LinePatternKit const & in_kit) const;
36319 
36323  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
36324 
36329  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
36330 
36334  LinePatternKit & SetJoin(LinePattern::Join in_type);
36335 
36338  LinePatternKit & UnsetParallels();
36339 
36342  LinePatternKit & UnsetJoin();
36343 
36346  LinePatternKit & UnsetEverything();
36347 
36351  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
36352 
36356  bool ShowJoin(LinePattern::Join & out_type) const;
36357 };
36358 
36359 
36360 
36364 
36365 
36367 class HPS_API Definition : public Object
36368 {
36369 public:
36371  Definition();
36372 
36375  Definition(Definition const & in_that);
36376 
36380  Definition & operator=(Definition const & in_that);
36381 
36385  Definition(Definition && in_that);
36386 
36390  Definition & operator=(Definition && in_that);
36391 
36392  virtual ~Definition();
36393 
36394  HPS::Type ObjectType() const { return HPS::Type::Definition; };
36395 
36397  void Undefine();
36398 
36401  PortfolioKey Owner() const;
36402 
36405  UTF8 Name() const;
36406 
36409  virtual void Assign(Definition const & in_that);
36410 
36414  bool Equals(Definition const & in_that) const;
36415 
36419  bool operator==(Definition const & in_that) const;
36420 
36424  bool operator!=(Definition const & in_that) const;
36425 };
36426 
36427 
36430 class HPS_API PortfolioKey : public Key
36431 {
36432 public:
36434  PortfolioKey();
36435 
36440  explicit PortfolioKey(Key const & in_that);
36441 
36444  PortfolioKey(PortfolioKey const & in_that);
36445 
36449  PortfolioKey & operator=(PortfolioKey const & in_that);
36450 
36454  PortfolioKey(PortfolioKey && in_that);
36455 
36459  PortfolioKey & operator=(PortfolioKey && in_that);
36460 
36461  ~PortfolioKey();
36462 
36463  HPS::Type ObjectType() const { return HPS::Type::PortfolioKey; };
36464 
36465  // Define
36466 
36473  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
36474 
36482  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
36483 
36484 
36496  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36497  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36498  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
36499 
36512  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36513  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36514  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
36515 
36516 
36522  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
36523 
36524 
36530  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
36531 
36532 
36538  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
36539 
36546  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
36547 
36548 
36554  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
36555 
36556 
36562  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
36563 
36564 
36570  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
36571 
36572 
36573  // UnDefine
36574 
36578  PortfolioKey & UndefineTexture(char const * in_name);
36579 
36583  PortfolioKey & UndefineCubeMap(char const * in_name);
36584 
36588  PortfolioKey & UndefineImage(char const * in_name);
36589 
36593  PortfolioKey & UndefineNamedStyle(char const * in_name);
36594 
36598  PortfolioKey & UndefineMaterialPalette(char const * in_name);
36599 
36603  PortfolioKey & UndefineGlyph(char const * in_name);
36604 
36608  PortfolioKey & UndefineLinePattern(char const * in_name);
36609 
36613  PortfolioKey & UndefineShader(char const * in_name);
36614 
36615 
36616  // Import collections
36622  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36623 
36624 
36630  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36631 
36637  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36638 
36644  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36645 
36651  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36652 
36658  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36659 
36665  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36666 
36672  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36673 
36679  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36680 
36681 
36682  // Import individual definitions
36686  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
36687 
36691  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
36692 
36696  ImageDefinition ImportImage(ImageDefinition const & in_definition);
36697 
36701  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
36702 
36706  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
36707 
36711  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
36712 
36716  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
36717 
36721  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
36722 
36723 
36724  // Show
36726  size_t GetDefinitionCount() const;
36727 
36729  size_t GetTextureDefinitionCount() const;
36730 
36732  size_t GetCubeMapDefinitionCount() const;
36733 
36735  size_t GetImageDefinitionCount() const;
36736 
36738  size_t GetNamedStyleDefinitionCount() const;
36739 
36741  size_t GetMaterialPaletteDefinitionCount() const;
36742 
36744  size_t GetGlyphDefinitionCount() const;
36745 
36747  size_t GetLinePatternDefinitionCount() const;
36748 
36750  size_t GetShaderDefinitionCount() const;
36751 
36756  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
36757 
36761  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
36762 
36767  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
36768 
36772  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
36773 
36778  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
36779 
36783  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
36784 
36789  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
36790 
36794  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
36795 
36800  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
36801 
36805  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
36806 
36811  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
36812 
36816  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
36817 
36822  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
36823 
36827  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
36828 
36833  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
36834 
36838  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
36839 
36840 private:
36842  void MoveTo(SegmentKey const & in_new_owner);
36843 
36845  Key CopyTo(SegmentKey const & in_destination) const;
36846 };
36847 
36848 
36849 
36851 class HPS_API GlyphDefinition : public Definition
36852 {
36853 public:
36855  GlyphDefinition();
36856 
36861  GlyphDefinition(Definition const & in_that);
36862 
36865  GlyphDefinition(GlyphDefinition const & in_that);
36866 
36870  GlyphDefinition & operator=(GlyphDefinition const & in_that);
36871 
36875  GlyphDefinition(GlyphDefinition && in_that);
36876 
36880  GlyphDefinition & operator=(GlyphDefinition && in_that);
36881 
36882  ~GlyphDefinition();
36883 
36884  HPS::Type ObjectType() const { return HPS::Type::GlyphDefinition; };
36885 
36888  void Set(GlyphKit const & in_kit);
36889 
36892  void Show(GlyphKit & out_kit) const;
36893 };
36894 
36895 
36897 class HPS_API TextureDefinition : public Definition
36898 {
36899 public:
36902 
36907  TextureDefinition(Definition const & in_that);
36908 
36911  TextureDefinition(TextureDefinition const & in_that);
36912 
36916  TextureDefinition & operator=(TextureDefinition const & in_that);
36917 
36922 
36926  TextureDefinition & operator=(TextureDefinition && in_that);
36927 
36928  ~TextureDefinition();
36929 
36930  HPS::Type ObjectType() const { return HPS::Type::TextureDefinition; };
36931 
36934  void SetSource(ImageDefinition const & in_source);
36935 
36938  void ShowSource(ImageDefinition & out_source) const;
36939 
36942  void SetOptions(TextureOptionsKit const & in_options);
36943 
36946  void ShowOptions(TextureOptionsKit & out_options) const;
36947 
36948 };
36949 
36953 class HPS_API TextureOptionsKit : public Object
36954 {
36955 public:
36958 
36961  TextureOptionsKit(TextureOptionsKit const & in_kit);
36962 
36967 
36971  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
36972 
36973  virtual ~TextureOptionsKit();
36974 
36975  HPS::Type ObjectType() const { return HPS::Type::TextureOptionsKit; };
36976 
36980  static TextureOptionsKit GetDefault();
36981 
36984  void Set(TextureOptionsKit const & in_kit);
36985 
36988  void Show(TextureOptionsKit & out_kit) const;
36989 
36993  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
36994 
36997  bool Empty() const;
36998 
37002  bool Equals(TextureOptionsKit const & in_kit) const;
37003 
37007  bool operator==(TextureOptionsKit const & in_kit) const;
37008 
37012  bool operator!=(TextureOptionsKit const & in_kit) const;
37013 
37018  TextureOptionsKit & SetDecal(bool in_state);
37019 
37023  TextureOptionsKit & SetDownSampling(bool in_state);
37024 
37028  TextureOptionsKit & SetModulation(bool in_state);
37029 
37033  TextureOptionsKit & SetParameterOffset(size_t in_offset);
37034 
37038  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
37039 
37043  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
37044 
37048  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
37049 
37053  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
37054 
37058  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
37059 
37062  TextureOptionsKit & UnsetDecal();
37063 
37066  TextureOptionsKit & UnsetDownSampling();
37067 
37070  TextureOptionsKit & UnsetModulation();
37071 
37074  TextureOptionsKit & UnsetParameterOffset();
37075 
37078  TextureOptionsKit & UnsetParameterizationSource();
37079 
37082  TextureOptionsKit & UnsetTiling();
37083 
37086  TextureOptionsKit & UnsetInterpolationFilter();
37087 
37090  TextureOptionsKit & UnsetDecimationFilter();
37091 
37094  TextureOptionsKit & UnsetTransformMatrix();
37095 
37098  TextureOptionsKit & UnsetEverything();
37099 
37103  bool ShowDecal(bool & out_state) const;
37104 
37108  bool ShowDownSampling(bool & out_state) const;
37109 
37113  bool ShowModulation(bool & out_state) const;
37114 
37118  bool ShowParameterOffset(size_t & out_offset) const;
37119 
37123  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
37124 
37128  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
37129 
37133  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
37134 
37138  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
37139 
37143  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37144 };
37145 
37146 
37148 class HPS_API Image
37149 {
37150 public:
37153  enum class Format
37154  {
37155  RGB,
37156  RGBA,
37157  ARGB,
37158  Mapped8,
37159  Grayscale,
37160  Bmp,
37161  Jpeg,
37162  Png,
37163  Targa,
37164  DXT1,
37165  DXT3,
37166  DXT5
37167  };
37168 
37170  class HPS_API ExportOptionsKit : public Object
37171  {
37172  public:
37174  ExportOptionsKit();
37175 
37178  ExportOptionsKit(ExportOptionsKit const & in_kit);
37179 
37183  ExportOptionsKit(ExportOptionsKit && in_that);
37184 
37188  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
37189 
37190  virtual ~ExportOptionsKit();
37191 
37192  HPS::Type ObjectType() const { return HPS::Type::ImageExportOptionsKit; };
37193 
37197  static ExportOptionsKit GetDefault();
37198 
37201  void Set(ExportOptionsKit const & in_kit);
37202 
37205  void Show(ExportOptionsKit & out_kit) const;
37206 
37210  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
37211 
37214  bool Empty() const;
37215 
37219  bool Equals(ExportOptionsKit const & in_kit) const;
37220 
37224  bool operator==(ExportOptionsKit const & in_kit) const;
37225 
37229  bool operator!=(ExportOptionsKit const & in_kit) const;
37230 
37235  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37236 
37241  ExportOptionsKit & SetFormat(Image::Format in_format);
37242 
37245  ExportOptionsKit & UnsetSize();
37246 
37249  ExportOptionsKit & UnsetFormat();
37250 
37253  ExportOptionsKit & UnsetEverything();
37254 
37259  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37260 
37264  bool ShowFormat(Image::Format & out_format) const;
37265  };
37266 
37268  class HPS_API ImportOptionsKit : public Object
37269  {
37270  public:
37272  ImportOptionsKit();
37273 
37276  ImportOptionsKit(ImportOptionsKit const & in_kit);
37277 
37281  ImportOptionsKit(ImportOptionsKit && in_that);
37282 
37286  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37287 
37288  virtual ~ImportOptionsKit();
37289 
37290  HPS::Type ObjectType() const { return HPS::Type::ImageImportOptionsKit; };
37291 
37294  void Set(ImportOptionsKit const & in_kit);
37295 
37298  void Show(ImportOptionsKit & out_kit) const;
37299 
37303  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37304 
37307  bool Empty() const;
37308 
37312  bool Equals(ImportOptionsKit const & in_kit) const;
37313 
37317  bool operator==(ImportOptionsKit const & in_kit) const;
37318 
37322  bool operator!=(ImportOptionsKit const & in_kit) const;
37323 
37330  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37331 
37335  ImportOptionsKit & SetFormat(Image::Format in_format);
37336 
37341  ImportOptionsKit & SetDownSampling(bool in_state);
37342 
37347  ImportOptionsKit & SetCompressionQuality(float in_quality);
37348 
37351  ImportOptionsKit & UnsetSize();
37352 
37355  ImportOptionsKit & UnsetFormat();
37356 
37359  ImportOptionsKit & UnsetDownSampling();
37360 
37363  ImportOptionsKit & UnsetCompressionQuality();
37364 
37367  ImportOptionsKit & UnsetEverything();
37368 
37373  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37374 
37378  bool ShowFormat(Image::Format & out_format) const;
37379 
37383  bool ShowDownSampling(bool & out_state) const;
37384 
37388  bool ShowCompressionQuality(float & out_quality) const;
37389  };
37390 
37392  class HPS_API File
37393  {
37394  public:
37400  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
37401 
37408  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
37409 
37417  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);
37418 
37423  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
37424 
37425  private:
37427  File();
37428  };
37429 
37430 private:
37432  Image();
37433 };
37434 
37435 
37437 class HPS_API ImageKit : public Object
37438 {
37439 public:
37441  ImageKit();
37442 
37445  ImageKit(ImageKit const & in_kit);
37446 
37451  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
37452 
37456  ImageKit(ImageKit && in_that);
37457 
37461  ImageKit & operator=(ImageKit && in_that);
37462 
37463  virtual ~ImageKit();
37464 
37465  HPS::Type ObjectType() const { return HPS::Type::ImageKit; };
37466 
37469  void Set(ImageKit const & in_kit);
37470 
37473  void Show(ImageKit & out_kit) const;
37474 
37478  ImageKit & operator=(ImageKit const & in_kit);
37479 
37482  bool Empty() const;
37483 
37487  bool Equals(ImageKit const & in_kit) const;
37488 
37492  bool operator==(ImageKit const & in_kit) const;
37493 
37497  bool operator!=(ImageKit const & in_kit) const;
37498 
37502  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
37503 
37506  void Convert(HPS::Image::Format in_format);
37507 
37512  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
37513 
37517  ImageKit & SetData(ByteArray const & in_image_data);
37518 
37523  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
37524 
37528  ImageKit & SetFormat(Image::Format in_format);
37529 
37533  ImageKit & SetDownSampling(bool in_state);
37534 
37538  ImageKit & SetCompressionQuality(float in_quality);
37539 
37542  ImageKit & UnsetSize();
37543 
37546  ImageKit & UnsetData();
37547 
37550  ImageKit & UnsetFormat();
37551 
37554  ImageKit & UnsetDownSampling();
37555 
37558  ImageKit & UnsetCompressionQuality();
37559 
37562  ImageKit & UnsetEverything();
37563 
37568  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37569 
37573  bool ShowData(ByteArray & out_image_data) const;
37574 
37578  bool ShowFormat(Image::Format & out_format) const;
37579 
37583  bool ShowDownSampling(bool & out_state) const;
37584 
37588  bool ShowCompressionQuality(float & out_quality) const;
37589 };
37590 
37591 
37597 {
37598 public:
37602 
37607 
37612 
37617 
37619 
37620  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsControl; };
37621 
37625  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
37626 
37631  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
37632 
37637  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
37638 
37642  bool ShowDriver(Window::Driver & out_driver) const;
37643 
37648  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37649 
37654  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37655 
37660  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
37661 
37666  bool ShowImage(ByteArray & out_bytes) const;
37667 
37671  bool ShowHardwareResident(bool & out_state) const;
37672 
37677  bool ShowOpacity(bool & out_state, float & out_opacity) const;
37678 
37683  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
37684 
37685 
37686 private:
37689 };
37690 
37691 
37694 class HPS_API OffScreenWindowKey : public WindowKey
37695 {
37696 public:
37699 
37704  OffScreenWindowKey(Key const & in_key);
37705 
37708  OffScreenWindowKey(OffScreenWindowKey const & in_that);
37709 
37714 
37718  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
37719 
37720  ~OffScreenWindowKey();
37721 
37722  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowKey; };
37723 
37726  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
37727 
37730  OffScreenWindowOptionsControl GetWindowOptionsControl();
37731 
37735  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
37736 };
37737 
37738 
37739 
37740 
37742 class HPS_API ImageDefinition : public Definition
37743 {
37744 public:
37746  ImageDefinition();
37747 
37752  ImageDefinition(Definition const & in_that);
37753 
37756  ImageDefinition(ImageDefinition const & in_that);
37757 
37761  ImageDefinition & operator=(ImageDefinition const & in_that);
37762 
37766  ImageDefinition(ImageDefinition && in_that);
37767 
37771  ImageDefinition & operator=(ImageDefinition && in_that);
37772 
37773  ~ImageDefinition();
37774 
37775  HPS::Type ObjectType() const { return HPS::Type::ImageDefinition; };
37776 
37779  void Set(ImageKit const & in_kit);
37780 
37783  void Show(ImageKit & out_kit) const;
37784 };
37785 
37787 class HPS_API CubeMapDefinition : public Definition
37788 {
37789 public:
37792 
37797  CubeMapDefinition(Definition const & in_that);
37798 
37801  CubeMapDefinition(CubeMapDefinition const & in_that);
37802 
37806  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
37807 
37812 
37816  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
37817 
37818  ~CubeMapDefinition();
37819 
37820  HPS::Type ObjectType() const { return HPS::Type::CubeMapDefinition; };
37821 
37829  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
37830  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
37831  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
37832 
37840  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
37841  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
37842  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
37843 
37847  void ShowSource(ImageDefinitionArray & out_image_sources) const;
37848 
37851  void SetOptions(TextureOptionsKit const & in_options);
37852 
37855  void ShowOptions(TextureOptionsKit & out_options) const;
37856 };
37857 
37858 
37860 class HPS_API NamedStyleDefinition : public Definition
37861 {
37862 public:
37865 
37870  NamedStyleDefinition(Definition const & in_that);
37871 
37874  NamedStyleDefinition(NamedStyleDefinition const & in_that);
37875 
37879  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
37880 
37885 
37889  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
37890 
37892 
37893  HPS::Type ObjectType() const { return HPS::Type::NamedStyleDefinition; };
37894 
37898  SegmentKey GetSource() const;
37899 };
37900 
37901 
37904 {
37905 public:
37908 
37913  MaterialPaletteDefinition(Definition const & in_that);
37914 
37918 
37922  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
37923 
37928 
37932  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
37933 
37935 
37936  HPS::Type ObjectType() const { return HPS::Type::MaterialPaletteDefinition; };
37937 
37940  void Set(MaterialKitArray const & in_source);
37941 
37945  void Set(size_t in_count, MaterialKit const in_source []);
37946 
37949  void Show(MaterialKitArray & out_source) const;
37950 };
37951 
37952 
37953 
37955 class HPS_API LinePatternDefinition : public Definition
37956 {
37957 public:
37960 
37965  LinePatternDefinition(Definition const & in_that);
37966 
37970 
37974  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
37975 
37980 
37984  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
37985 
37987 
37988  HPS::Type ObjectType() const { return HPS::Type::LinePatternDefinition; };
37989 
37992  void Set(LinePatternKit const & in_kit);
37993 
37996  void Show(LinePatternKit & out_kit) const;
37997 };
37998 
37999 
38000 
38002 class HPS_API Shader
38003 {
38004 public:
38007  enum class Parameterization
38008  {
38010  Cylinder,
38012  PhysicalReflection,
38014  Object,
38020  NaturalUV,
38022  ReflectionVector,
38024  SurfaceNormal,
38026  Sphere,
38028  UV,
38030  World
38031  };
38032 
38034  class HPS_API ImportOptionsKit : public Object
38035  {
38036  public:
38038  ImportOptionsKit();
38039 
38042  ImportOptionsKit(ImportOptionsKit const & in_kit);
38043 
38047  ImportOptionsKit(ImportOptionsKit && in_that);
38048 
38052  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38053 
38054  virtual ~ImportOptionsKit();
38055 
38056  HPS::Type ObjectType() const { return HPS::Type::ShaderImportOptionsKit; };
38057 
38060  void Set(ImportOptionsKit const & in_kit);
38061 
38064  void Show(ImportOptionsKit & out_kit) const;
38065 
38069  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
38070 
38073  bool Empty() const;
38074 
38078  bool Equals(ImportOptionsKit const & in_kit) const;
38079 
38083  bool operator==(ImportOptionsKit const & in_kit) const;
38084 
38088  bool operator!=(ImportOptionsKit const & in_kit) const;
38089 
38096  ImportOptionsKit & SetMultitexture(bool in_state);
38097 
38101  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38102 
38106  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
38107 
38111  ImportOptionsKit & UnsetMultitexture();
38112 
38115  ImportOptionsKit & UnsetParameterizationSource();
38116 
38119  ImportOptionsKit & UnsetTransformMatrix();
38120 
38123  ImportOptionsKit & UnsetEverything();
38124 
38130  bool ShowMultitexture(bool & out_state) const;
38131 
38135  bool ShowParameterizationSource(Parameterization & out_source) const;
38136 
38140  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38141  };
38142 
38144  class HPS_API File
38145  {
38146  public:
38152  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
38153 
38154  private:
38156  File();
38157  };
38158 
38159 private:
38161  Shader();
38162 };
38163 
38164 
38166 class HPS_API ShaderKit : public Object
38167 {
38168 public:
38170  ShaderKit();
38171 
38174  ShaderKit(ShaderKit const & in_kit);
38175 
38179  ShaderKit(ShaderKit && in_that);
38180 
38184  ShaderKit & operator=(ShaderKit && in_that);
38185 
38186  virtual ~ShaderKit();
38187 
38188  HPS::Type ObjectType() const { return HPS::Type::ShaderKit; };
38189 
38192  void Set(ShaderKit const & in_kit);
38193 
38196  void Show(ShaderKit & out_kit) const;
38197 
38201  ShaderKit & operator=(ShaderKit const & in_kit);
38202 
38205  bool Empty() const;
38206 
38210  bool Equals(ShaderKit const & in_kit) const;
38211 
38215  bool operator==(ShaderKit const & in_kit) const;
38216 
38220  bool operator!=(ShaderKit const & in_kit) const;
38221 
38225  ShaderKit & SetSource(char const * in_source);
38226 
38233  ShaderKit & SetMultitexture(bool in_state);
38234 
38238  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38239 
38243  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
38244 
38247  ShaderKit & UnsetSource();
38248 
38252  ShaderKit & UnsetMultitexture();
38253 
38256  ShaderKit & UnsetParameterizationSource();
38257 
38260  ShaderKit & UnsetTransformMatrix();
38261 
38264  ShaderKit & UnsetEverything();
38265 
38269  bool ShowSource(UTF8 & out_source) const;
38270 
38276  bool ShowMultitexture(bool & out_state) const;
38277 
38281  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
38282 
38286  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38287 };
38288 
38289 
38291 class HPS_API ShaderDefinition : public Definition
38292 {
38293 public:
38295  ShaderDefinition();
38296 
38301  ShaderDefinition(Definition const & in_that);
38302 
38305  ShaderDefinition(ShaderDefinition const & in_that);
38306 
38310  ShaderDefinition & operator=(ShaderDefinition const & in_that);
38311 
38315  ShaderDefinition(ShaderDefinition && in_that);
38316 
38320  ShaderDefinition & operator=(ShaderDefinition && in_that);
38321 
38322  ~ShaderDefinition();
38323 
38324  HPS::Type ObjectType() const { return HPS::Type::ShaderDefinition; };
38325 
38328  void Set(ShaderKit const & in_kit);
38329 
38332  void Show(ShaderKit & out_kit) const;
38333 };
38334 
38335 
38336 
38337 
38341 
38343 {
38344 public:
38347 
38351 
38356 
38361 
38362  virtual ~CutGeometryGatheringOptionsKit();
38363 
38364  HPS::Type ObjectType() const {return HPS::Type::CutGeometryGatheringOptionsKit;};
38365 
38369  static CutGeometryGatheringOptionsKit GetDefault();
38370 
38373  void Set(CutGeometryGatheringOptionsKit const & in_kit);
38374 
38377  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
38378 
38383 
38386  bool Empty() const;
38387 
38391  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
38392 
38396  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
38397 
38401  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
38402 
38403 
38407  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
38408 
38412  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
38413 
38418 
38419 
38422  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
38423 
38426  CutGeometryGatheringOptionsKit & UnsetOffset();
38427 
38430  CutGeometryGatheringOptionsKit & UnsetLevel();
38431 
38434  CutGeometryGatheringOptionsKit & UnsetEverything();
38435 
38436 
38440  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
38441 
38445  bool ShowOffset(size_t & out_offset) const;
38446 
38450  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
38451 };
38452 
38454 class HPS_API SearchOptionsKit : public Object
38455 {
38456 public:
38458  SearchOptionsKit();
38459 
38462  SearchOptionsKit(SearchOptionsKit const & in_kit);
38463 
38467  SearchOptionsKit(SearchOptionsKit && in_that);
38468 
38472  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
38473 
38474  virtual ~SearchOptionsKit();
38475 
38476  HPS::Type ObjectType() const {return HPS::Type::SearchOptionsKit;};
38477 
38481  static SearchOptionsKit GetDefault();
38482 
38485  void Set(SearchOptionsKit const & in_kit);
38486 
38489  void Show(SearchOptionsKit & out_kit) const;
38490 
38494  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
38495 
38498  bool Empty() const;
38499 
38503  bool Equals(SearchOptionsKit const & in_kit) const;
38504 
38508  bool operator==(SearchOptionsKit const & in_kit) const;
38509 
38513  bool operator!=(SearchOptionsKit const & in_kit) const;
38514 
38518  SearchOptionsKit & SetCriteria(Search::Type in_request);
38519 
38523  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
38524 
38528  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
38529 
38534  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
38535 
38539  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
38540 
38543  SearchOptionsKit & UnsetBehavior();
38544 
38547  SearchOptionsKit & UnsetCriteria();
38548 
38551  SearchOptionsKit & UnsetSearchSpace();
38552 
38555  SearchOptionsKit & UnsetEverything();
38556 
38560  bool ShowBehavior(Search::Behavior & out_behavior) const;
38561 
38565  bool ShowCriteria(SearchTypeArray & out_types) const;
38566 
38570  bool ShowSearchSpace(Search::Space & out_search_space) const;
38571 };
38572 
38576 class HPS_API TreeContext : public Object
38577 {
38578 public:
38581  TreeContext(bool in_create = true);
38582 
38585  TreeContext(TreeContext const & in_that);
38586 
38590  TreeContext(TreeContext && in_that);
38591 
38595  TreeContext & operator=(TreeContext && in_that);
38596 
38598  virtual ~TreeContext();
38599 
38600  HPS::Type ObjectType() const {return HPS::Type::TreeContext;};
38601 
38605  TreeContext & operator=(TreeContext const & in_that);
38606 
38610  bool Equals(TreeContext const & in_that) const;
38611 
38615  bool operator==(TreeContext const & in_that) const;
38616 
38620  bool operator!=(TreeContext const & in_that) const;
38621 
38622 };
38623 
38625 class HPS_API SelectionOptionsKit : public Object
38626 {
38627 public:
38630 
38633  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
38634 
38639 
38643  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
38644 
38645  virtual ~SelectionOptionsKit();
38646 
38647  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsKit;};
38648 
38652  static SelectionOptionsKit GetDefault();
38653 
38656  void Set(SelectionOptionsKit const & in_kit);
38657 
38660  void Show(SelectionOptionsKit & out_kit) const;
38661 
38665  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
38666 
38669  bool Empty() const;
38670 
38674  bool Equals(SelectionOptionsKit const & in_kit) const;
38675 
38679  bool operator==(SelectionOptionsKit const & in_kit) const;
38680 
38684  bool operator!=(SelectionOptionsKit const & in_kit) const;
38685 
38693  SelectionOptionsKit & SetProximity(float in_proximity);
38694 
38700  SelectionOptionsKit & SetLevel(Selection::Level in_level);
38701 
38706  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
38707 
38716  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
38717 
38725  SelectionOptionsKit & SetSorting(bool in_sorted);
38726 
38732  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
38733 
38739  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
38740 
38745  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
38746 
38751  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
38752 
38757  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
38758 
38765  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
38766 
38773  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
38774 
38781  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
38782 
38789  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
38790 
38793  SelectionOptionsKit & UnsetProximity();
38794 
38797  SelectionOptionsKit & UnsetLevel();
38798 
38801  SelectionOptionsKit & UnsetInternalLimit();
38802 
38805  SelectionOptionsKit & UnsetRelatedLimit();
38806 
38809  SelectionOptionsKit & UnsetSorting();
38810 
38813  SelectionOptionsKit & UnsetAlgorithm();
38814 
38817  SelectionOptionsKit & UnsetGranularity();
38818 
38821  SelectionOptionsKit & UnsetScope();
38822 
38825  SelectionOptionsKit & UnsetTreeContext();
38826 
38829  SelectionOptionsKit & UnsetExtentCullingRespected();
38830 
38833  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
38834 
38837  SelectionOptionsKit & UnsetFrustumCullingRespected();
38838 
38841  SelectionOptionsKit & UnsetVectorCullingRespected();
38842 
38843 
38846  SelectionOptionsKit & UnsetEverything();
38847 
38851  bool ShowProximity(float & out_proximity) const;
38852 
38856  bool ShowLevel(Selection::Level & out_level) const;
38857 
38861  bool ShowInternalLimit(size_t & out_limit) const;
38862 
38866  bool ShowRelatedLimit(size_t & out_limit) const;
38867 
38871  bool ShowSorting(bool & out_sorted) const;
38872 
38876  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38877 
38881  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38882 
38886  bool ShowScope(KeyPath & out_start_path) const;
38887 
38891  bool ShowTreeContext(TreeContext & out_tree_context) const;
38892 
38896  bool ShowExtentCullingRespected(bool & out_state) const;
38897 
38901  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38902 
38906  bool ShowFrustumCullingRespected(bool & out_state) const;
38907 
38911  bool ShowVectorCullingRespected(bool & out_state) const;
38912 };
38913 
38914 
38915 
38919 class HPS_API SelectionOptionsControl : public Control
38920 {
38921 public:
38924  explicit SelectionOptionsControl(WindowKey const & in_window);
38925 
38929 
38934 
38938  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
38939 
38941 
38942  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsControl;};
38943 
38947  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
38948 
38954  SelectionOptionsControl & SetProximity(float in_proximity);
38955 
38961  SelectionOptionsControl & SetLevel(Selection::Level in_level);
38962 
38969  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
38970 
38979  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
38980 
38988  SelectionOptionsControl & SetSorting(bool in_sorted);
38989 
38995  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
38996 
39002  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
39003 
39010  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
39011 
39018  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
39019 
39026  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
39027 
39034  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
39035 
39036  // there is no way to unset default values, intentionally
39037 
39041  bool ShowProximity(float & out_proximity) const;
39042 
39046  bool ShowLevel(Selection::Level & out_level) const;
39047 
39051  bool ShowInternalLimit(size_t & out_limit) const;
39052 
39056  bool ShowRelatedLimit(size_t & out_limit) const;
39057 
39061  bool ShowSorting(bool & out_sorted) const;
39062 
39066  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
39067 
39071  bool ShowGranularity(Selection::Granularity & out_granularity) const;
39072 
39076  bool ShowExtentCullingRespected(bool & out_state) const;
39077 
39081  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
39082 
39086  bool ShowFrustumCullingRespected(bool & out_state) const;
39087 
39091  bool ShowVectorCullingRespected(bool & out_state) const;
39092 
39093 private:
39096 };
39097 
39098 
39099 
39101 class HPS_API SelectionItem : public Object
39102 {
39103 public:
39105  SelectionItem();
39106 
39109  SelectionItem(SelectionItem const & in_that);
39110 
39114  SelectionItem(SelectionItem && in_that);
39115 
39119  SelectionItem & operator=(SelectionItem && in_that);
39120 
39121  virtual ~SelectionItem();
39122 
39123  HPS::Type ObjectType() const {return HPS::Type::SelectionItem;};
39124 
39127  void Set(SelectionItem const & in_that);
39128 
39132  SelectionItem & operator=(SelectionItem const & in_that);
39133 
39137  bool Equals(SelectionItem const & in_that) const;
39138 
39142  bool operator==(SelectionItem const & in_that) const;
39143 
39147  bool operator!=(SelectionItem const & in_that) const;
39148 
39152  bool ShowSelectionLevel(Selection::Level & out_level) const;
39153 
39157  bool ShowSelectedItem(Key & out_selection) const;
39158 
39162  bool ShowPath(KeyPath & out_path) const;
39163 
39167  bool ShowFaces(SizeTArray & out_faces) const;
39168 
39172  bool ShowVertices(SizeTArray & out_vertices) const;
39173 
39178  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
39179 
39183  bool ShowCharacters(SizeTArray & out_characters) const;
39184 
39188  bool ShowSelectionPosition(WindowPoint & out_location) const;
39189 
39193  bool ShowSelectionPosition(WorldPoint & out_location) const;
39194 
39195 };
39196 
39198 class HPS_API SelectionResultsIterator : public Object
39199 {
39200 public:
39203 
39208 
39213 
39217  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
39218 
39220 
39221  HPS::Type ObjectType() const {return HPS::Type::SelectionResultsIterator;}
39222 
39226  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
39227 
39230  void Set(SelectionResultsIterator const & in_that);
39231 
39233  void Next();
39234 
39237  SelectionResultsIterator & operator++();
39238 
39241  SelectionResultsIterator operator++(int in_val);
39242 
39245  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
39246 
39249  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
39250 
39251 
39254  bool IsValid() const;
39255 
39257  void Reset();
39258 
39261  SelectionItem GetItem() const;
39262 
39265  SelectionItem operator*() const;
39266 
39267 
39268 };
39269 
39273 class HPS_API SelectionResults : public Object
39274 {
39275 public:
39277  SelectionResults();
39278 
39281  SelectionResults(SelectionResults const & in_that);
39282 
39286  SelectionResults(SelectionResults && in_that);
39287 
39291  SelectionResults & operator=(SelectionResults && in_that);
39292 
39293  ~SelectionResults();
39294 
39295  HPS::Type ObjectType() const {return HPS::Type::SelectionResults;}
39296 
39299  void Assign(SelectionResults const & in_that);
39300 
39304  SelectionResults & operator=(SelectionResults const & in_that);
39305 
39309  bool Equals(SelectionResults const & in_that) const;
39310 
39314  bool operator==(SelectionResults const & in_that) const;
39315 
39319  bool operator!=(SelectionResults const & in_that) const;
39320 
39322  virtual void Reset();
39323 
39326  Selection::Level GetSelectionLevel() const;
39327 
39330  size_t GetCount() const;
39331 
39334  SelectionResultsIterator GetIterator() const;
39335 
39341  bool Union(SelectionResults const & in_that);
39342 
39347  bool Intersect(SelectionResults const & in_that);
39348 
39354  bool SymmetricDifference(SelectionResults const & in_that);
39355 
39360  bool Difference(SelectionResults const & in_that);
39361 
39364  void Copy(SelectionResults const & in_that);
39365 };
39366 
39369 class HPS_API SelectionControl : public Object
39370 {
39371 public:
39374  explicit SelectionControl(WindowKey const & in_window);
39375 
39378  SelectionControl(SelectionControl const & in_that);
39379 
39383  SelectionControl(SelectionControl && in_that);
39384 
39388  SelectionControl & operator=(SelectionControl && in_that);
39389 
39390  ~SelectionControl();
39391 
39392  HPS::Type ObjectType() const {return HPS::Type::SelectionControl;};
39393 
39397  SelectionControl & operator=(SelectionControl const & in_that);
39398 
39404  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39405 
39410  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
39411 
39417  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39418 
39423  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
39424 
39430  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39431 
39436  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
39437 
39444  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39445 
39451  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39452 
39458  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39459 
39464  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
39465 
39472  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39473 
39479  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39480 
39481 
39482  //Object space selections
39483 
39489  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39490 
39495  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
39496 
39502  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39503 
39508  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
39509 
39510 
39517  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39518 
39524  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
39525 
39526 
39533  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39534 
39540  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
39541 
39542 private:
39544  SelectionControl();
39545 };
39546 
39547 
39548 
39550 class HPS_API HighlightOptionsKit : public Object
39551 {
39552 public:
39555 
39558  HighlightOptionsKit(char const * in_style_name);
39559 
39563  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
39564 
39567  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
39568 
39573 
39577  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
39578 
39579  virtual ~HighlightOptionsKit();
39580 
39581  HPS::Type ObjectType() const {return HPS::Type::HighlightOptionsKit;};
39582 
39586  static HighlightOptionsKit GetDefault();
39587 
39590  void Set(HighlightOptionsKit const & in_kit);
39591 
39594  void Show(HighlightOptionsKit & out_kit) const;
39595 
39599  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
39600 
39603  bool Empty() const;
39604 
39608  bool Equals(HighlightOptionsKit const & in_kit) const;
39609 
39613  bool operator==(HighlightOptionsKit const & in_kit) const;
39614 
39618  bool operator!=(HighlightOptionsKit const & in_kit) const;
39619 
39620 
39624  HighlightOptionsKit & SetStyleName(char const * in_style_name);
39625 
39629  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
39630 
39637  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
39638 
39644  HighlightOptionsKit & SetNotification(bool in_state);
39645 
39646 
39649  HighlightOptionsKit & UnsetStyleName();
39650 
39653  HighlightOptionsKit & UnsetSecondaryStyleName();
39654 
39657  HighlightOptionsKit & UnsetOverlay();
39658 
39661  HighlightOptionsKit & UnsetNotification();
39662 
39665  HighlightOptionsKit & UnsetEverything();
39666 
39667 
39671  bool ShowStyleName(UTF8 & out_style_name) const;
39672 
39676  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
39677 
39681  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
39682 
39686  bool ShowNotification(bool & out_state) const;
39687 };
39688 
39691 class HPS_API HighlightControl : public Control
39692 {
39693 public:
39696  explicit HighlightControl(WindowKey const & in_window);
39697 
39700  HighlightControl(HighlightControl const & in_that);
39701 
39705  HighlightControl(HighlightControl && in_that);
39706 
39710  HighlightControl & operator=(HighlightControl && in_that);
39711 
39712  ~HighlightControl();
39713 
39714  HPS::Type ObjectType() const {return HPS::Type::HighlightControl;};
39715 
39719  HighlightControl & operator=(HighlightControl const & in_that);
39720 
39725  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
39726 
39731  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
39732 
39737  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
39738 
39743  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
39744 
39749  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
39750 
39755  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39756 
39761  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39762 
39767  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39768 
39773  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39774 
39779  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39780 
39784  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
39785 
39788  HighlightControl & UnhighlightEverything();
39789 
39790 private:
39792  HighlightControl();
39793 };
39794 
39796 class HPS_API UpdateOptionsKit : public Object
39797 {
39798 public:
39800  UpdateOptionsKit();
39801 
39804  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
39805 
39809  UpdateOptionsKit(UpdateOptionsKit && in_that);
39810 
39814  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
39815 
39816  virtual ~UpdateOptionsKit();
39817 
39818  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsKit;};
39819 
39823  static UpdateOptionsKit GetDefault();
39824 
39827  void Set(UpdateOptionsKit const & in_kit);
39828 
39831  void Show(UpdateOptionsKit & out_kit) const;
39832 
39836  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
39837 
39840  bool Empty() const;
39841 
39845  bool Equals(UpdateOptionsKit const & in_kit) const;
39846 
39850  bool operator==(UpdateOptionsKit const & in_kit) const;
39851 
39855  bool operator!=(UpdateOptionsKit const & in_kit) const;
39856 
39860  UpdateOptionsKit & SetUpdateControl(HPS::Window::UpdateControl in_control);
39861 
39865  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
39866 
39869  UpdateOptionsKit & UnsetUpdateControl();
39870 
39873  UpdateOptionsKit & UnsetTimeLimit();
39874 
39877  UpdateOptionsKit & UnsetEverything();
39878 
39879 
39883  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39884 
39888  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39889 
39890 };
39891 
39892 
39893 
39899 class HPS_API UpdateOptionsControl : public Control
39900 {
39901 public:
39904  explicit UpdateOptionsControl(WindowKey const & in_window);
39905 
39908  UpdateOptionsControl(UpdateOptionsControl const & in_that);
39909 
39914 
39918  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
39919 
39921 
39922  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsControl;};
39923 
39927  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
39928 
39932  UpdateOptionsControl & SetUpdateControl(HPS::Window::UpdateControl in_control);
39933 
39937  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
39938 
39941  UpdateOptionsControl & UnsetUpdateControl();
39942 
39945  UpdateOptionsControl & UnsetTimeLimit();
39946 
39949  UpdateOptionsControl & UnsetEverything();
39950 
39954  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39955 
39959  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39960 
39961 private:
39964 };
39965 
39968 class HPS_API World : public Object
39969 {
39970 public:
39974  World(char const * in_license);
39975 
39977  ~World();
39978 
39979  HPS::Type ObjectType() const {return HPS::Type::World;};
39980 
39985  World & SetMaterialLibraryDirectory(char const * in_directory);
39986 
39991  World & SetFontDirectory(char const * in_directory);
39992 
39998  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
39999 
40004  World & SetFontDirectories(UTF8Array const & in_directories);
40005 
40011  World & SetDriverConfigFile(char const * in_filename);
40012 
40018  World & SetExchangeLibraryDirectory(char const * in_directory);
40019 
40025  World & SetPublishResourceDirectory(char const * in_directory);
40026 
40031  World & SetParasolidSchemaDirectory(char const * in_directory);
40032 
40035  World & UnsetMaterialLibraryDirectory();
40036 
40039  World & UnsetFontDirectories();
40040 
40043  World & UnsetDriverConfigFile();
40044 
40047  World & UnsetExchangeLibraryDirectory();
40048 
40051  World & UnsetPublishResourceDirectory();
40052 
40055  World & UnsetParasolidSchemaDirectory();
40056 
40060  bool ShowLicense(UTF8 & out_license) const;
40061 
40065  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
40066 
40070  bool ShowFontDirectories(UTF8Array & out_directories) const;
40071 
40075  bool ShowDriverConfigFile(UTF8 & out_filename) const;
40076 
40080  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
40081 
40085  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
40086 
40090  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
40091 
40092 private:
40094  World();
40095 
40097  virtual void Reset() {}
40098 };
40099 
40100 
40116 class HPS_API EmergencyHandler
40117 {
40118 public:
40119 
40122 
40123  virtual ~EmergencyHandler();
40124 
40126  intptr_t GetClassID() const;
40127 
40130  virtual EmergencyHandler * Clone() const = 0;
40131 
40135  virtual void Handle(const char * message, HPS::Emergency::Code code) const = 0;
40136 
40137  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
40138  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
40139 };
40140 
40141 
40144 class HPS_API Database
40145 {
40146 public:
40151  static void Execute(bool in_once=true);
40152 
40155  static Time GetTime();
40156 
40158  static void Sleep(Time milliseconds);
40159 
40184  static void RelinquishMemory();
40185 
40186 
40212  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
40213 
40221  static void Reset();
40222 
40224  static void Synchronize();
40225 
40228  static WindowKeyArray GetWindowKeys();
40229 
40232  static SegmentKeyArray GetRootSegments();
40233 
40236  static PortfolioKeyArray GetPortfolios();
40237 
40242  static PortfolioKey const GetMaterialLibraryPortfolio();
40243 
40249  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
40250 
40255  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
40256 
40260  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
40261 
40265  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
40266 
40273  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
40274 
40280  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
40281 
40287  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
40288 
40293  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
40294 
40297  static SegmentKey CreateRootSegment();
40298 
40301  static PortfolioKey CreatePortfolio();
40302 
40305  static EventDispatcher CreateEventDispatcher();
40306 
40310  static EventDispatcher CreateEventDispatcher(char const * in_name);
40311 
40317  static size_t SelectByShell(ShellKit const & in_shell,
40318  SelectionOptionsKit const & in_options,
40319  SelectionResults & out_results);
40320 
40326  static size_t SelectByShell(ShellKey const & in_shell,
40327  SelectionOptionsKit const & in_options,
40328  SelectionResults & out_results);
40329 
40336  static size_t SelectByVolume(SimpleCuboid const & in_volume,
40337  SelectionOptionsKit const & in_options,
40338  SelectionResults & out_results);
40339 
40346  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
40347  SelectionOptionsKit const & in_options,
40348  SelectionResults & out_results);
40349 
40352  static EventDispatcher const & GetEventDispatcher();
40353 
40354 
40358  static bool GetInformationEventFilter(HPS::Info::Code in_code);
40359 
40363  static bool GetWarningEventFilter(HPS::Info::Code in_code);
40364 
40368  static bool GetErrorEventFilter(HPS::Info::Code in_code);
40369 
40374  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
40375 
40380  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
40381 
40386  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
40387 
40388 
40391  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
40392 
40394  static void UnsetEmergencyHandler();
40395 
40398  static size_t GetSoftMemoryLimit();
40399 
40403  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
40404 
40408  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
40409 
40410 private:
40412  Database();
40413 };
40414 
40415 
40419 
40420 
40421 
40423 class HPS_API EventDispatcher : public Object
40424 {
40425 public:
40428  EventDispatcher();
40429 
40432  EventDispatcher(EventDispatcher const & in_that);
40433 
40437  EventDispatcher(EventDispatcher && in_that);
40438 
40442  EventDispatcher & operator=(EventDispatcher && in_that);
40443 
40444  virtual ~EventDispatcher();
40445 
40446  HPS::Type ObjectType() const {return HPS::Type::EventDispatcher;};
40447 
40451  EventDispatcher & operator=(EventDispatcher const & in_that);
40452 
40456  bool Equals(EventDispatcher const & in_that) const;
40457 
40461  bool operator==(EventDispatcher const & in_that) const;
40462 
40466  bool operator!=(EventDispatcher const & in_that) const;
40467 
40472  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
40473 
40478  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
40479 
40484  bool UnSubscribe(EventHandler const & in_handler) const;
40485 
40489  bool UnSubscribe(intptr_t in_type) const;
40490 
40494  bool InjectEvent(Event const & in_event) const;
40495 
40500  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
40501 
40504  void Shutdown() const;
40505 
40508  bool IsShutdown() const;
40509 
40510 
40513  void SetName(char const * in_name) const;
40514 
40517  void ShowName(UTF8 & out_name) const;
40518 
40519 private:
40521  virtual void Reset() {}
40522 };
40523 
40524 
40527 class HPS_API EventHandler : public Object
40528 {
40529 public:
40531  EventHandler();
40532 
40535  EventHandler(EventHandler const & in_that);
40536 
40540  EventHandler(EventHandler && in_that);
40541 
40545  EventHandler & operator=(EventHandler && in_that);
40546 
40550  EventHandler & operator=(EventHandler const & in_that);
40551 
40552  virtual ~EventHandler();
40553 
40554  HPS::Type ObjectType() const {return HPS::Type::EventHandler;};
40555 
40560  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40561 
40566  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40567 
40571  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
40572 
40574  void UnSubscribeEverything() const;
40575 
40577  virtual void Reset() { UnSubscribeEverything(); }
40578 
40581  void Shutdown();
40582 
40585  enum class HandleResult
40586  {
40587  Handled,
40588  NotHandled
40589  };
40590 
40595  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
40596 };
40597 
40598 
40599 
40601 class HPS_API TimerTickEvent : public Event
40602 {
40603 public:
40606  {
40607  channel = GetClassID();
40608  consumable = false;
40609  }
40610 
40611 
40614  TimerTickEvent(Event const & in_event) : Event(in_event)
40615  {
40616  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
40617  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40618  }
40619 
40620  ~TimerTickEvent();
40621 
40624  Event * Clone() const
40625  {
40626  TimerTickEvent * new_event = new TimerTickEvent(*this);
40627  return new_event;
40628  }
40629 
40633  virtual bool Drop(Event const * in_that_event) const
40634  {
40635  HPS_UNREFERENCED(in_that_event);
40636  return true;
40637  }
40638 
40639  virtual intptr_t Freshen() const {
40640  return GetClassID();
40641  }
40642 };
40643 
40645 class HPS_API HighlightEvent : public Event
40646 {
40647 public:
40648  enum class Action
40649  {
40650  None = 0,
40651  Highlight,
40652  Unhighlight,
40653  };
40654 
40657  {
40658  channel = GetClassID();
40659  consumable = false;
40660  action = Action::None;
40661  }
40662 
40663  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
40664  : Event(), action(in_action), results(in_results), options(in_options)
40665  {
40666  channel = GetClassID();
40667  consumable = false;
40668  }
40669 
40672  HighlightEvent(Event const & in_event) : Event(in_event)
40673  {
40674  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
40675  {
40676  auto that = static_cast<HighlightEvent const &>(in_event);
40677  action = that.action;
40678  results = that.results;
40679  options = that.options;
40680  }
40681  else
40682  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40683  }
40684 
40685  ~HighlightEvent();
40686 
40689  Event * Clone() const
40690  {
40691  HighlightEvent * new_event = new HighlightEvent(*this);
40692  return new_event;
40693  }
40694 
40695  Action action;
40696  SelectionResults results;
40697  HighlightOptionsKit options;
40698 };
40699 
40701 class HPS_API InformationEvent : public Event
40702 {
40703 public:
40705  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40706 
40709  InformationEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40710 
40714  InformationEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40715 
40718  InformationEvent(Event const & in_event) : Event(in_event)
40719  {
40720  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
40721  {
40722  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
40723  message = event->message;
40724  code = event->code;
40725  }
40726  else
40727  {
40728  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40729  }
40730  }
40731 
40732  ~InformationEvent();
40733 
40736  Event * Clone() const
40737  {
40738  InformationEvent * new_event = new InformationEvent(*this);
40739  return new_event;
40740  }
40741 
40745  virtual bool Equals(InformationEvent const & in_that) const
40746  {
40747  return message == in_that.message && code == in_that.code;
40748  }
40749 
40753  virtual bool operator== (InformationEvent const & in_that) const
40754  {
40755  return Equals(in_that);
40756  }
40757 
40761  virtual bool operator!= (InformationEvent const & in_that) const
40762  {
40763  return !Equals(in_that);
40764  }
40765 
40768 };
40769 
40770 
40772 class HPS_API WarningEvent : public Event
40773 {
40774 public:
40776  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40777 
40780  WarningEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40781 
40785  WarningEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40786 
40789  WarningEvent(Event const & in_event) : Event(in_event)
40790  {
40791  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
40792  {
40793  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
40794  message = event->message;
40795  code = event->code;
40796  }
40797  else
40798  {
40799  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40800  }
40801  }
40802 
40803  ~WarningEvent();
40804 
40807  Event * Clone() const
40808  {
40809  WarningEvent * new_event = new WarningEvent(*this);
40810  return new_event;
40811  }
40812 
40816  virtual bool Equals(WarningEvent const & in_that) const
40817  {
40818  return message == in_that.message && code == in_that.code;
40819  }
40820 
40824  virtual bool operator== (WarningEvent const & in_that) const
40825  {
40826  return Equals(in_that);
40827  }
40828 
40832  virtual bool operator!= (WarningEvent const & in_that) const
40833  {
40834  return !Equals(in_that);
40835  }
40836 
40839 };
40840 
40841 
40843 class HPS_API ErrorEvent : public Event
40844 {
40845 public:
40847  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40848 
40851  ErrorEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40852 
40856  ErrorEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40857 
40860  ErrorEvent(Event const & in_event) : Event(in_event)
40861  {
40862  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
40863  {
40864  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
40865  message = event->message;
40866  code = event->code;
40867  }
40868  else
40869  {
40870  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40871  }
40872  }
40873 
40874  ~ErrorEvent();
40875 
40878  Event * Clone() const
40879  {
40880  ErrorEvent * new_event = new ErrorEvent(*this);
40881  return new_event;
40882  }
40883 
40887  virtual bool Equals(ErrorEvent const & in_that) const
40888  {
40889  return message == in_that.message && code == in_that.code;
40890  }
40891 
40895  virtual bool operator== (ErrorEvent const & in_that) const
40896  {
40897  return Equals(in_that);
40898  }
40899 
40903  virtual bool operator!= (ErrorEvent const & in_that) const
40904  {
40905  return !Equals(in_that);
40906  }
40907 
40910 };
40911 
40912 
40914 class HPS_API StandAloneWindowEvent : public Event
40915 {
40916 public:
40917 
40920  enum class Action
40921  {
40922  Unknown,
40923  Close,
40924  FocusIn,
40925  FocusOut,
40926  };
40927 
40929  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
40930 
40931 
40934  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
40935 
40938  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
40939  {
40940  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40941  {
40942  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
40943  action = event->action;
40944  }
40945  else
40946  {
40947  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40948  }
40949  }
40950 
40952 
40955  Event * Clone() const
40956  {
40957  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
40958  return new_event;
40959  }
40960 
40964  virtual bool Equals(StandAloneWindowEvent const & in_that) const
40965  {
40966  return action == in_that.action;
40967  }
40968 
40972  virtual bool operator== (StandAloneWindowEvent const & in_that) const
40973  {
40974  return Equals(in_that);
40975  }
40976 
40980  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
40981  {
40982  return !Equals(in_that);
40983  }
40984 
40986 };
40987 
40989 class HPS_API FocusLostEvent : public Event
40990 {
40991 public:
40994  Event()
40995  { channel = GetClassID(); }
40996 
40997  ~FocusLostEvent() {};
40998 
41001  Event * Clone() const
41002  {
41003  FocusLostEvent * new_event = new FocusLostEvent(*this);
41004  return new_event;
41005  }
41006 };
41007 
41008 
41010 class HPS_API UpdateCompletedEvent : public Event
41011 {
41012 public:
41014  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
41015 
41017  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
41018 
41021  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
41022  {
41023  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41024  {
41025  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
41026  update_time = event->update_time;
41027  }
41028  else
41029  {
41030  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41031  }
41032  }
41033 
41034  virtual ~UpdateCompletedEvent();
41035 
41038  Event * Clone() const
41039  {
41040  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
41041  return new_event;
41042  }
41043 
41044  Time update_time;
41045 };
41046 
41048 class HPS_API ImportStatusEvent : public Event
41049 {
41050 public:
41053  : Event()
41054  , import_status_message(HPS::UTF8())
41055  { channel = GetClassID(); }
41056 
41057  ImportStatusEvent(char const * in_message)
41058  : Event()
41059  , import_status_message(in_message)
41060  { channel = GetClassID(); }
41061 
41064  ImportStatusEvent(Event const & in_event) : Event(in_event)
41065  {
41066  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
41067  {
41068  auto event = static_cast<ImportStatusEvent const &>(in_event);
41069  import_status_message = event.import_status_message;
41070  }
41071  else
41072  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41073  }
41074 
41075  ~ImportStatusEvent() {};
41076 
41079  Event * Clone() const
41080  {
41081  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
41082  return new_event;
41083  }
41084 
41085  HPS::UTF8 import_status_message;
41086 };
41087 
41089 class HPS_API ModifierKeys
41090 {
41091 public:
41093  ModifierKeys() : modifiers(_key_none) {}
41094 
41098  bool Equals(ModifierKeys const & in_that) const
41099  {
41100  return modifiers == in_that.modifiers;
41101  }
41102 
41106  bool operator== (ModifierKeys const & in_that) const
41107  {
41108  return Equals(in_that);
41109  }
41110 
41114  bool operator!= (ModifierKeys const & in_that) const
41115  {
41116  return !Equals(in_that);
41117  }
41118 
41121  bool None() const { return modifiers == _key_none; }
41122 
41125  bool Shift() const { return (modifiers & _key_shift) != 0; }
41126 
41129  bool Control() const { return (modifiers & _key_control) != 0; }
41130 
41133  bool Alt() const { return (modifiers & _key_alt) != 0; }
41134 
41137  bool Meta() const { return (modifiers & _key_meta) != 0; }
41138 
41139 
41143  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41144 
41148  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
41149 
41150 
41153  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
41154 
41157  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
41158 
41161  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
41162 
41165  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
41166 
41170  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
41171  {
41172  ModifierKeys ret;
41173  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41174  return ret;
41175  }
41176 
41180  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
41181  {
41182  ModifierKeys ret;
41183  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41184  return ret;
41185  }
41186 
41190  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
41191 
41195  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
41196 
41197 
41200  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
41201 
41204  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
41205 
41208  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
41209 
41212  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
41213 
41214 protected:
41215 
41219  {
41220  _key_none = 0x0000,
41221  _key_shift = 0x0001,
41222  _key_control = 0x0002,
41223  _key_alt = 0x0004,
41224  _key_meta = 0x0008,
41225  };
41226 
41227  int modifiers;
41228 };
41229 
41230 
41233 class HPS_API InputEvent : public Event
41234 {
41235 public:
41236 
41238  InputEvent() : Event() { channel = GetClassID(); }
41239 
41242  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
41243 
41244  ~InputEvent();
41245 
41248  Event * Clone() const
41249  {
41250  InputEvent * new_event = new InputEvent(*this);
41251  return new_event;
41252  }
41253 
41257  virtual bool Equals(InputEvent const & in_that) const
41258  {
41259  return ModifierKeyState == in_that.ModifierKeyState;
41260  }
41261 
41265  virtual bool operator== (InputEvent const & in_that) const
41266  {
41267  return Equals(in_that);
41268  }
41269 
41273  virtual bool operator!= (InputEvent const & in_that) const
41274  {
41275  return !Equals(in_that);
41276  }
41277 
41281  {
41282  return ModifierKeyState;
41283  }
41284 
41286 };
41287 
41289 class HPS_API TouchEvent : public InputEvent
41290 {
41291 public:
41294  enum class Action
41295  {
41296  TouchDown,
41297  TouchUp,
41298  Move,
41299  };
41300 
41302  TouchEvent() : InputEvent() { channel = GetClassID(); }
41303 
41308  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
41309  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41310 
41316  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
41317  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41318 
41325  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
41326  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41327 
41328 
41331  TouchEvent(Event const & in_event) : InputEvent()
41332  {
41333  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
41334  {
41335  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
41336  channel = GetClassID();
41337  CurrentAction = event->CurrentAction;
41338  Touches = event->Touches;
41339  ModifierKeyState = event->ModifierKeyState;
41340  }
41341  else
41342  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
41343  }
41344 
41345  ~TouchEvent();
41346 
41347 
41350  Event * Clone() const
41351  {
41352  TouchEvent * new_event = new TouchEvent(*this);
41353  return new_event;
41354  }
41355 
41359  virtual bool Equals(TouchEvent const & in_that) const
41360  {
41361  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
41362  }
41363 
41367  virtual bool operator== (TouchEvent const & in_that) const
41368  {
41369  return Equals(in_that);
41370  }
41371 
41375  virtual bool operator!= (TouchEvent const & in_that) const
41376  {
41377  return !Equals(in_that);
41378  }
41379 
41383  virtual bool Drop(Event const * in_that_event) const
41384  {
41385  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
41386 
41387  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
41388  && Touches.size() == that_touch_event->Touches.size() )
41389  {
41390  TouchArray these_touches = Touches;
41391  TouchArray those_touches = that_touch_event->Touches;
41392 
41393  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41394  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41395 
41396  for (size_t i = 0 ; i < these_touches.size() ; i++)
41397  {
41398  if (these_touches[i].ID != those_touches[i].ID)
41399  return false;
41400  }
41401  return true;
41402  }
41403 
41404  return false;
41405  }
41406 
41410  void SetTouches(size_t in_touch_count, Touch const in_touches[])
41411  {
41412  Touches.assign(in_touches, in_touches + in_touch_count);
41413  }
41414 
41417  void SetTouches(HPS::TouchArray const & in_touches)
41418  {
41419  Touches = in_touches;
41420  }
41421 
41423  HPS::TouchArray Touches;
41424 
41425 private:
41431  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
41432  {
41433  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
41434  }
41435 };
41436 
41437 
41439 class HPS_API MouseButtons
41440 {
41441 public:
41443  MouseButtons() : buttons(_button_none) {}
41444 
41448  bool Equals(MouseButtons const & in_that) const
41449  {
41450  return buttons == in_that.buttons;
41451  }
41452 
41456  bool operator== (MouseButtons const & in_that) const
41457  {
41458  return Equals(in_that);
41459  }
41460 
41464  bool operator!= (MouseButtons const & in_that) const
41465  {
41466  return !Equals(in_that);
41467  }
41468 
41471  bool None() const { return buttons == _button_none; }
41472 
41475  bool Left() const { return (buttons & _button_left) != 0; }
41476 
41479  bool Right() const { return (buttons & _button_right) != 0; }
41480 
41483  bool Middle() const { return (buttons & _button_middle) != 0; }
41484 
41487  bool X1() const { return (buttons & _button_x1) != 0; }
41488 
41491  bool X2() const { return (buttons & _button_x2) != 0; }
41492 
41493 
41497  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41498 
41502  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
41503 
41506  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
41507 
41510  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
41511 
41514  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
41515 
41518  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
41519 
41522  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
41523 
41527  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
41528  {
41529  MouseButtons ret;
41530  ret.buttons = buttons | in_buttons_to_merge.buttons;
41531  return ret;
41532  }
41533 
41537  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
41538  {
41539  MouseButtons ret;
41540  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41541  return ret;
41542  }
41543 
41547  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
41548 
41552  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
41553 
41554 
41557  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
41558 
41561  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
41562 
41565  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
41566 
41569  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
41570 
41573  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
41574 
41575 protected:
41576 
41579  enum Buttons
41580  {
41581  _button_none = 0x0000,
41582  _button_left = 0x0001,
41583  _button_right = 0x0002,
41584  _button_middle = 0x0004,
41585  _button_x1 = 0x0008,
41586  _button_x2 = 0x0010
41587  };
41588 
41589  int buttons;
41590 };
41591 
41593 class HPS_API MouseEvent : public InputEvent
41594 {
41595 public:
41596 
41599  enum class Action
41600  {
41601  ButtonUp,
41602  ButtonDown,
41603  Move,
41604  Scroll,
41605  Enter,
41606  Leave
41607  };
41608 
41610  MouseEvent() : InputEvent() { channel = GetClassID(); }
41611 
41618  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
41619  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41620 
41628  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)
41629  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41630 
41633  MouseEvent(Event const & in_event) : InputEvent()
41634  {
41635  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
41636  {
41637  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
41638  channel = GetClassID();
41639  CurrentAction = event->CurrentAction;
41640  Location = event->Location;
41641  CurrentButton = event->CurrentButton;
41642  WheelDelta = event->WheelDelta;
41643  ClickCount = event->ClickCount;
41644  }
41645  else
41646  {
41647  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41648  }
41649  }
41650 
41651  ~MouseEvent();
41652 
41655  Event * Clone() const
41656  {
41657  MouseEvent * new_event = new MouseEvent(*this);
41658  return new_event;
41659  }
41660 
41664  virtual bool Equals(MouseEvent const & in_that) const
41665  {
41666  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
41667  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
41668  && Location == in_that.Location && ClickCount == in_that.ClickCount;
41669  }
41670 
41674  virtual bool operator== (MouseEvent const & in_that) const
41675  {
41676  return Equals(in_that);
41677  }
41678 
41682  virtual bool operator!= (MouseEvent const & in_that) const
41683  {
41684  return !Equals(in_that);
41685  }
41686 
41690  virtual bool Drop(Event const * in_that_event) const
41691  {
41692  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
41693 
41694  if (CurrentAction == that_mouse_event->CurrentAction &&
41695  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41696  CurrentButton == that_mouse_event->CurrentButton)
41697  return true;
41698 
41699  return false;
41700  }
41701 
41702  virtual intptr_t Freshen() const {
41703 
41704  if (CurrentAction == Action::Move)
41705  return GetClassID();
41706 
41707  return 0;
41708  }
41709 
41713  float WheelDelta;
41714  size_t ClickCount;
41715 };
41716 
41717 
41719 class HPS_API KeyboardEvent : public InputEvent
41720 {
41721 public:
41724  enum class Action
41725  {
41726  None,
41727  KeyDown,
41728  KeyUp
41729  };
41730 
41732  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
41733 
41738  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41739 
41745  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
41746  : InputEvent(in_modifiers), CurrentAction(in_action)
41747  {
41748  channel = GetClassID();
41749  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41750  }
41751 
41756  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
41757  : InputEvent(in_modifiers), CurrentAction(in_action)
41758  {
41759  channel = GetClassID();
41760  KeyboardCodes = in_keyboardcodes;
41761  }
41762 
41765  KeyboardEvent(Event const & in_event) : InputEvent()
41766  {
41767  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
41768  {
41769  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
41770  channel = GetClassID();
41771  KeyboardCodes = event->KeyboardCodes;
41772  CurrentAction = event->CurrentAction;
41773  }
41774  else
41775  {
41776  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41777  }
41778  }
41779 
41780  ~KeyboardEvent();
41781 
41784  Event * Clone() const
41785  {
41786  KeyboardEvent * new_event = new KeyboardEvent(*this);
41787  return new_event;
41788  }
41789 
41793  virtual bool Equals(KeyboardEvent const & in_that) const
41794  {
41795  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
41796  }
41797 
41801  virtual bool operator== (KeyboardEvent const & in_that) const
41802  {
41803  return Equals(in_that);
41804  }
41805 
41809  virtual bool operator!= (KeyboardEvent const & in_that) const
41810  {
41811  return !Equals(in_that);
41812  }
41813 
41817  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
41818  {
41819  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41820  }
41821 
41824  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
41825  {
41826  KeyboardCodes = in_keyboardcodes;
41827  }
41828 
41829  HPS::KeyboardCodeArray KeyboardCodes;
41831 };
41832 
41833 
41835 class HPS_API MouseState : public Object
41836 {
41837 public:
41839  MouseState();
41840 
41843  MouseState(MouseState const & in_that);
41844 
41848  MouseState(MouseState && in_that);
41849 
41853  MouseState & operator=(MouseState && in_that);
41854 
41855  ~MouseState();
41856 
41857  HPS::Type ObjectType() const {return HPS::Type::MouseState;};
41858 
41861  void Assign(MouseState const & in_that);
41862 
41866  MouseState & operator=(MouseState const & in_that);
41867 
41871  bool Equals(MouseState const & in_that) const;
41872 
41876  bool operator== (MouseState const & in_that) const;
41877 
41881  bool operator!= (MouseState const & in_that) const;
41882 
41887  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
41888 
41895  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
41896 
41899  HPS::MouseEvent GetActiveEvent() const;
41900 
41904  HPS::WindowKey GetEventSource() const;
41905 
41909  HPS::KeyArray GetEventPath() const;
41910 
41913  MouseButtons GetButtons() const;
41914 
41917  WindowPoint GetLocation() const;
41918 
41921  ModifierKeys GetModifierKeys() const;
41922 
41925  void SetActiveEvent(MouseEvent const & in_event);
41926 
41929  void SetEventPath(KeyArray const & in_path);
41930 
41933  void SetButtons(MouseButtons in_buttons);
41934 
41937  void SetLocation(WindowPoint const & in_point);
41938 
41941  void SetModifierKeys(ModifierKeys in_modifiers);
41942 };
41943 
41944 
41945 
41947 class HPS_API TouchState : public Object
41948 {
41949 public:
41951  TouchState();
41952 
41955  TouchState(TouchState const & in_that);
41956 
41960  TouchState(TouchState && in_that);
41961 
41965  TouchState & operator=(TouchState && in_that);
41966 
41967  ~TouchState();
41968 
41969  HPS::Type ObjectType() const {return HPS::Type::TouchState;};
41970 
41973  void Assign(TouchState const & in_that);
41974 
41978  TouchState & operator=(TouchState const & in_that);
41979 
41983  bool Equals(TouchState const & in_that) const;
41984 
41988  bool operator== (TouchState const & in_that) const;
41989 
41993  bool operator!= (TouchState const & in_that) const;
41994 
42000  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
42001 
42004  HPS::TouchEvent GetActiveEvent() const;
42005 
42009  HPS::WindowKey GetEventSource() const;
42010 
42014  HPS::KeyArray GetEventPath() const;
42015 
42018  size_t GetTouchCount() const;
42019 
42022  HPS::TouchArray GetTouches() const;
42023 
42026  ModifierKeys GetModifierKeys() const;
42027 
42030  void SetActiveEvent(TouchEvent const & in_event);
42031 
42034  void SetEventPath(KeyArray const & in_path);
42035 
42038  void SetTouches(TouchArray const & in_touches);
42039 
42042  void SetModifierKeys(ModifierKeys in_modifiers);
42043 };
42044 
42045 
42046 
42048 class HPS_API KeyboardState : public Object
42049 {
42050 public:
42052  KeyboardState();
42053 
42056  KeyboardState(KeyboardState const & in_that);
42057 
42061  KeyboardState(KeyboardState && in_that);
42062 
42066  KeyboardState & operator=(KeyboardState && in_that);
42067 
42068  ~KeyboardState();
42069 
42070  HPS::Type ObjectType() const {return HPS::Type::KeyboardState;};
42071 
42074  void Assign(KeyboardState const & in_that);
42075 
42079  KeyboardState & operator=(KeyboardState const & in_that);
42080 
42084  bool Equals(KeyboardState const & in_that) const;
42085 
42089  bool operator== (KeyboardState const & in_that) const;
42090 
42094  bool operator!= (KeyboardState const & in_that) const;
42095 
42101  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
42102 
42105  HPS::KeyboardEvent GetActiveEvent() const;
42106 
42110  HPS::WindowKey GetEventSource() const;
42111 
42115  HPS::KeyArray GetEventPath() const;
42116 
42119  size_t GetKeyboardCodeCount() const;
42120 
42123  HPS::KeyboardCodeArray GetKeyboardCodes() const;
42124 
42128  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
42129 
42132  ModifierKeys GetModifierKeys() const;
42133 
42136  void SetActiveEvent(KeyboardEvent const & in_event);
42137 
42140  void SetEventPath(KeyArray const & in_path);
42141 
42144  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
42145 
42148  void SetModifierKeys(ModifierKeys in_modifiers);
42149 };
42150 
42151 
42155 
42158 class HPS_API IONotifier : public Object
42159 {
42160 public:
42162  IONotifier();
42163 
42166  IONotifier(IONotifier const & in_that);
42167 
42171  IONotifier(IONotifier && in_that);
42172 
42176  IONotifier & operator=(IONotifier && in_that);
42177 
42178  virtual ~IONotifier();
42179 
42180  HPS::Type ObjectType() const {return HPS::Type::IONotifier;};
42181 
42185  IONotifier & operator=(IONotifier const & in_that);
42186 
42189  void Assign(IONotifier const & in_that);
42190 
42192  void Wait();
42193 
42196  IOResult Status() const;
42197 
42201  IOResult Status(float & out_percent_complete) const;
42202 
42206  void Cancel();
42207 };
42208 
42210 class HPS_API Stream
42211 {
42212 public:
42214  class HPS_API Toolkit : public Object
42215  {
42216  public:
42218  Toolkit();
42219 
42222  Toolkit(Toolkit const & in_toolkit);
42223 
42227  Toolkit(Toolkit && in_toolkit);
42228 
42232  Toolkit & operator=(Toolkit const & in_toolkit);
42233 
42237  Toolkit & operator=(Toolkit && in_toolkit);
42238 
42239  HPS::Type ObjectType() const { return HPS::Type::StreamToolkit; }
42240 
42242  virtual void Restart();
42243  };
42244 
42247  static Toolkit CreateToolkit();
42248 
42250  class HPS_API ImportOptionsKit : public Object
42251  {
42252  public:
42254  ImportOptionsKit();
42255 
42258  ImportOptionsKit(ImportOptionsKit const & in_kit);
42259 
42263  ImportOptionsKit(ImportOptionsKit && in_that);
42264 
42268  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42269 
42270  virtual ~ImportOptionsKit();
42271 
42272  HPS::Type ObjectType() const { return HPS::Type::StreamImportOptionsKit; };
42273 
42276  void Set(ImportOptionsKit const & in_kit);
42277 
42280  void Show(ImportOptionsKit & out_kit) const;
42281 
42285  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42286 
42289  bool Empty() const;
42290 
42294  bool Equals(ImportOptionsKit const & in_kit) const;
42295 
42299  bool operator==(ImportOptionsKit const & in_kit) const;
42300 
42304  bool operator!=(ImportOptionsKit const & in_kit) const;
42305 
42308  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42309 
42312  ImportOptionsKit & UnsetToolkit();
42313 
42317  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42318 
42323  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42324 
42327  ImportOptionsKit & UnsetSegment();
42328 
42332  bool ShowSegment(SegmentKey & out_segment) const;
42333 
42338  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
42339 
42342  ImportOptionsKit & UnsetAlternateRoot();
42343 
42347  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42348 
42353  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42354 
42357  ImportOptionsKit & UnsetPortfolio();
42358 
42362  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42363 
42366  ImportOptionsKit & UnsetEverything();
42367  };
42368 
42370  class HPS_API ImportResultsKit : public Object
42371  {
42372  public:
42374  ImportResultsKit();
42375 
42378  ImportResultsKit(ImportResultsKit const & in_kit);
42379 
42383  ImportResultsKit(ImportResultsKit && in_that);
42384 
42388  ImportResultsKit & operator=(ImportResultsKit && in_that);
42389 
42390  virtual ~ImportResultsKit();
42391 
42392  HPS::Type ObjectType() const { return HPS::Type::StreamImportResultsKit; };
42393 
42396  void Set(ImportResultsKit const & in_kit);
42397 
42400  void Show(ImportResultsKit & out_kit) const;
42401 
42405  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42406 
42409  bool Empty() const;
42410 
42414  bool Equals(ImportResultsKit const & in_kit) const;
42415 
42419  bool operator==(ImportResultsKit const & in_kit) const;
42420 
42424  bool operator!=(ImportResultsKit const & in_kit) const;
42425 
42430  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42431 
42435  ImportResultsKit & UnsetSegment();
42436 
42441  bool ShowSegment(SegmentKey & out_segment) const;
42442 
42447  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
42448 
42452  ImportResultsKit & UnsetAlternateRoot();
42453 
42459  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42460 
42465  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42466 
42470  ImportResultsKit & UnsetPortfolio();
42471 
42477  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42478 
42483  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
42484 
42488  ImportResultsKit & UnsetDefaultCamera();
42489 
42493  bool ShowDefaultCamera(CameraKit & out_camera) const;
42494 
42495 
42501  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
42502 
42506  ImportResultsKit & UnsetAlternateCameras();
42507 
42512  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
42513 
42514 
42517  ImportResultsKit & UnsetEverything();
42518  };
42519 
42521  class HPS_API ExportOptionsKit : public Object
42522  {
42523  public:
42525  ExportOptionsKit();
42526 
42529  ExportOptionsKit(ExportOptionsKit const & in_kit);
42530 
42534  ExportOptionsKit(ExportOptionsKit && in_that);
42535 
42539  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42540 
42544  static ExportOptionsKit GetDefault();
42545 
42546  virtual ~ExportOptionsKit();
42547 
42548  HPS::Type ObjectType() const { return HPS::Type::StreamExportOptionsKit; };
42549 
42552  void Set(ExportOptionsKit const & in_kit);
42553 
42556  void Show(ExportOptionsKit & out_kit) const;
42557 
42561  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42562 
42565  bool Empty() const;
42566 
42570  bool Equals(ExportOptionsKit const & in_kit) const;
42571 
42575  bool operator==(ExportOptionsKit const & in_kit) const;
42576 
42580  bool operator!=(ExportOptionsKit const & in_kit) const;
42581 
42584  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42585 
42593  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
42594 
42602  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
42603 
42609  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
42610 
42618  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
42619 
42627  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
42628 
42634  ExportOptionsKit & SetConnectivityCompression(bool in_state);
42635 
42641  ExportOptionsKit & SetSerializeTristrips(bool in_state);
42642 
42651  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
42652 
42655  ExportOptionsKit & UnsetToolkit();
42656 
42659  ExportOptionsKit & UnsetVertexCompression();
42660 
42663  ExportOptionsKit & UnsetNormalCompression();
42664 
42667  ExportOptionsKit & UnsetParameterCompression();
42668 
42671  ExportOptionsKit & UnsetColorCompression();
42672 
42675  ExportOptionsKit & UnsetIndexCompression();
42676 
42679  ExportOptionsKit & UnsetConnectivityCompression();
42680 
42683  ExportOptionsKit & UnsetImageCompression();
42684 
42687  ExportOptionsKit & UnsetSerializeTristrips();
42688 
42691  ExportOptionsKit & UnsetEverything();
42692 
42696  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42697 
42702  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
42703 
42708  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
42709 
42714  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
42715 
42720  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
42721 
42726  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
42727 
42731  bool ShowConnectivityCompression(bool & out_state) const;
42732 
42737  bool ShowImageCompression(bool & out_state, float & out_quality) const;
42738 
42742  bool ShowSerializeTristrips(bool & out_state) const;
42743  };
42744 
42747  class HPS_API ImportNotifier : public IONotifier
42748  {
42749  public:
42751  ImportNotifier();
42752 
42755  ImportNotifier(ImportNotifier const & in_that);
42756 
42761  ImportNotifier(IONotifier const & in_that);
42762 
42766  ImportNotifier(ImportNotifier && in_that);
42767 
42771  ImportNotifier & operator=(ImportNotifier && in_that);
42772 
42773  virtual ~ImportNotifier();
42774 
42775  HPS::Type ObjectType() const {return HPS::Type::StreamImportNotifier;};
42776 
42780  ImportNotifier & operator=(ImportNotifier const & in_that);
42781 
42784  void Assign(ImportNotifier const & in_that);
42785 
42789  ImportResultsKit GetResults() const;
42790  };
42791 
42794  class HPS_API ExportNotifier : public IONotifier
42795  {
42796  public:
42798  ExportNotifier();
42799 
42802  ExportNotifier(ExportNotifier const & in_that);
42803 
42808  ExportNotifier(IONotifier const & in_that);
42809 
42813  ExportNotifier(ExportNotifier && in_that);
42814 
42818  ExportNotifier & operator=(ExportNotifier && in_that);
42819 
42820  virtual ~ExportNotifier();
42821 
42822  HPS::Type ObjectType() const {return HPS::Type::StreamExportNotifier;};
42823 
42827  ExportNotifier & operator=(ExportNotifier const & in_that);
42828 
42831  void Assign(ExportNotifier const & in_that);
42832  };
42833 
42834 
42836  class HPS_API File
42837  {
42838  public:
42844  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42845 
42852  static ExportNotifier Export(const char * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
42853 
42860  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
42861 
42862  private:
42864  File();
42865  };
42866 private:
42868  Stream();
42869 };
42870 
42874 
42879 class HPS_API Hardcopy
42880 {
42881 public:
42882 
42884  enum class SizeUnits
42885  {
42886  Centimeters,
42887  Inches,
42888  };
42889 
42891  enum class ResolutionUnits
42892  {
42893  DPCM,
42894  DPI,
42895  DotsPerCentimeter = DPCM,
42896  DotsPerInch = DPI,
42897  };
42898 
42900  class HPS_API File
42901  {
42902  public:
42903 
42905  class HPS_API ExportOptionsKit : public Object
42906  {
42907  public:
42909  ExportOptionsKit();
42910 
42913  ExportOptionsKit(ExportOptionsKit const & in_kit);
42914 
42918  ExportOptionsKit(ExportOptionsKit && in_that);
42919 
42923  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42924 
42925  virtual ~ExportOptionsKit();
42926 
42927  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
42928 
42931  void Set(ExportOptionsKit const & in_kit);
42932 
42935  void Show(ExportOptionsKit & out_kit) const;
42936 
42940  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42941 
42944  bool Empty() const;
42945 
42949  bool Equals(ExportOptionsKit const & in_kit) const;
42950 
42954  bool operator==(ExportOptionsKit const & in_kit) const;
42955 
42959  bool operator!=(ExportOptionsKit const & in_kit) const;
42960 
42961 
42962 
42963 
42969  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
42970 
42978  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
42979 
42982  ExportOptionsKit & UnsetSize();
42983 
42984 
42985 
42991  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
42992 
42999  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
43000 
43003  ExportOptionsKit & UnsetResolution();
43004 
43005 
43006 
43009  bool ShowWYSIWYG(bool & out_onoff) const;
43010 
43022  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
43023 
43026  ExportOptionsKit & UnsetWYSIWYG();
43027 
43028 
43031  ExportOptionsKit & UnsetEverything();
43032 
43033 
43037  static ExportOptionsKit GetDefault();
43038  };
43039 
43041  enum class Driver
43042  {
43043  PDF,
43044  Postscript
43045  };
43046 
43052  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
43053  private:
43054  File();
43055  };
43056 
43057 #ifdef _MSC_VER
43058  class HPS_API GDI
43059  {
43060  public:
43061 
43063  class HPS_API ExportOptionsKit : public Object
43064  {
43065  public:
43067  ExportOptionsKit();
43068 
43071  ExportOptionsKit(ExportOptionsKit const & in_kit);
43072 
43076  ExportOptionsKit(ExportOptionsKit && in_that);
43077 
43081  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
43082 
43083  virtual ~ExportOptionsKit();
43084 
43085  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
43086 
43089  void Set(ExportOptionsKit const & in_kit);
43090 
43093  void Show(ExportOptionsKit & out_kit) const;
43094 
43098  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
43099 
43102  bool Empty() const;
43103 
43107  bool Equals(ExportOptionsKit const & in_kit) const;
43108 
43112  bool operator==(ExportOptionsKit const & in_kit) const;
43113 
43117  bool operator!=(ExportOptionsKit const & in_kit) const;
43118 
43119 
43120 
43121 
43125  bool ShowResolution(float & out_resolution) const;
43126 
43130  ExportOptionsKit & SetResolution(float in_resolution);
43131 
43134  ExportOptionsKit & UnsetResolution();
43135 
43136 
43137 
43138 
43141  bool ShowWYSIWYG(bool & out_onoff) const;
43142 
43146  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
43147 
43150  ExportOptionsKit & UnsetWYSIWYG();
43151 
43152 
43155  ExportOptionsKit & UnsetEverything();
43156  };
43157 
43164  static IOResult Export(intptr_t hdc, intptr_t attribdc, HPS::WindowKey const & window, ExportOptionsKit const & options);
43165 
43166  private:
43167  GDI();
43168  };
43169 #endif
43170 
43171 private:
43172  Hardcopy();
43173 };
43174 
43178 
43180 class HPS_API OBJ
43181 {
43182 public:
43183 
43185  class HPS_API ImportOptionsKit : public Object
43186  {
43187  public:
43189  ImportOptionsKit();
43190 
43193  ImportOptionsKit(ImportOptionsKit const & in_kit);
43194 
43198  ImportOptionsKit(ImportOptionsKit && in_that);
43199 
43203  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43204 
43205  virtual ~ImportOptionsKit();
43206 
43207  HPS::Type ObjectType() const { return HPS::Type::OBJImportOptionsKit; };
43208 
43211  void Set(ImportOptionsKit const & in_kit);
43212 
43215  void Show(ImportOptionsKit & out_kit) const;
43216 
43220  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43221 
43224  bool Empty() const;
43225 
43229  bool Equals(ImportOptionsKit const & in_kit) const;
43230 
43234  bool operator==(ImportOptionsKit const & in_kit) const;
43235 
43239  bool operator!=(ImportOptionsKit const & in_kit) const;
43240 
43245  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43246 
43249  ImportOptionsKit & UnsetSegment();
43250 
43254  bool ShowSegment(SegmentKey & out_segment) const;
43255 
43260  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43261 
43264  ImportOptionsKit & UnsetPortfolio();
43265 
43269  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43270 
43276  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43277 
43280  ImportOptionsKit & UnsetHandedness();
43281 
43285  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43286 
43289  ImportOptionsKit & UnsetEverything();
43290  };
43291 
43293  class HPS_API ImportResultsKit : public Object
43294  {
43295  public:
43297  ImportResultsKit();
43298 
43301  ImportResultsKit(ImportResultsKit const & in_kit);
43302 
43306  ImportResultsKit(ImportResultsKit && in_that);
43307 
43311  ImportResultsKit & operator=(ImportResultsKit && in_that);
43312 
43313  virtual ~ImportResultsKit();
43314 
43315  HPS::Type ObjectType() const { return HPS::Type::OBJImportResultsKit; };
43316 
43319  void Set(ImportResultsKit const & in_kit);
43320 
43323  void Show(ImportResultsKit & out_kit) const;
43324 
43328  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43329 
43332  bool Empty() const;
43333 
43337  bool Equals(ImportResultsKit const & in_kit) const;
43338 
43342  bool operator==(ImportResultsKit const & in_kit) const;
43343 
43347  bool operator!=(ImportResultsKit const & in_kit) const;
43348 
43353  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43354 
43358  ImportResultsKit & UnsetSegment();
43359 
43364  bool ShowSegment(SegmentKey & out_segment) const;
43365 
43370  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43371 
43375  ImportResultsKit & UnsetPortfolio();
43376 
43382  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43383 
43388  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43389 
43393  ImportResultsKit & UnsetHandedness();
43394 
43399  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43400 
43403  ImportResultsKit & UnsetEverything();
43404  };
43405 
43408  class HPS_API ImportNotifier : public IONotifier
43409  {
43410  public:
43412  ImportNotifier();
43413 
43416  ImportNotifier(ImportNotifier const & in_that);
43417 
43422  ImportNotifier(IONotifier const & in_that);
43423 
43427  ImportNotifier(ImportNotifier && in_that);
43428 
43432  ImportNotifier & operator=(ImportNotifier && in_that);
43433 
43434  virtual ~ImportNotifier();
43435 
43436  HPS::Type ObjectType() const {return HPS::Type::OBJImportNotifier;};
43437 
43441  ImportNotifier & operator=(ImportNotifier const & in_that);
43442 
43445  void Assign(ImportNotifier const & in_that);
43446 
43450  ImportResultsKit GetResults() const;
43451  };
43452 
43453 
43455  class HPS_API File
43456  {
43457  public:
43463  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43464 
43465  private:
43467  File();
43468  };
43469 private:
43471  OBJ();
43472 };
43473 
43477 
43479 class HPS_API STL
43480 {
43481 public:
43482 
43484  class HPS_API ImportOptionsKit : public Object
43485  {
43486  public:
43488  ImportOptionsKit();
43489 
43492  ImportOptionsKit(ImportOptionsKit const & in_kit);
43493 
43497  ImportOptionsKit(ImportOptionsKit && in_that);
43498 
43502  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43503 
43504  virtual ~ImportOptionsKit();
43505 
43506  HPS::Type ObjectType() const { return HPS::Type::STLImportOptionsKit; };
43507 
43510  void Set(ImportOptionsKit const & in_kit);
43511 
43514  void Show(ImportOptionsKit & out_kit) const;
43515 
43519  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43520 
43523  bool Empty() const;
43524 
43528  bool Equals(ImportOptionsKit const & in_kit) const;
43529 
43533  bool operator==(ImportOptionsKit const & in_kit) const;
43534 
43538  bool operator!=(ImportOptionsKit const & in_kit) const;
43539 
43543  static ImportOptionsKit GetDefault();
43544 
43549  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43550 
43558  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
43559 
43566  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
43567 
43568 
43571  ImportOptionsKit & UnsetSegment();
43572 
43575  ImportOptionsKit & UnsetOptimization();
43576 
43579  ImportOptionsKit & UnsetEverything();
43580 
43581 
43585  bool ShowSegment(SegmentKey & out_segment) const;
43586 
43591  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
43592  };
43593 
43595  class HPS_API ImportResultsKit : public Object
43596  {
43597  public:
43599  ImportResultsKit();
43600 
43603  ImportResultsKit(ImportResultsKit const & in_kit);
43604 
43608  ImportResultsKit(ImportResultsKit && in_that);
43609 
43613  ImportResultsKit & operator=(ImportResultsKit && in_that);
43614 
43615  virtual ~ImportResultsKit();
43616 
43617  HPS::Type ObjectType() const { return HPS::Type::STLImportResultsKit; };
43618 
43621  void Set(ImportResultsKit const & in_kit);
43622 
43625  void Show(ImportResultsKit & out_kit) const;
43626 
43630  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43631 
43634  bool Empty() const;
43635 
43639  bool Equals(ImportResultsKit const & in_kit) const;
43640 
43644  bool operator==(ImportResultsKit const & in_kit) const;
43645 
43649  bool operator!=(ImportResultsKit const & in_kit) const;
43650 
43655  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43656 
43660  ImportResultsKit & UnsetSegment();
43661 
43666  bool ShowSegment(SegmentKey & out_segment) const;
43667 
43670  ImportResultsKit & UnsetEverything();
43671  };
43672 
43675  class HPS_API ImportNotifier : public IONotifier
43676  {
43677  public:
43679  ImportNotifier();
43680 
43683  ImportNotifier(ImportNotifier const & in_that);
43684 
43689  ImportNotifier(IONotifier const & in_that);
43690 
43694  ImportNotifier(ImportNotifier && in_that);
43695 
43699  ImportNotifier & operator=(ImportNotifier && in_that);
43700 
43701  virtual ~ImportNotifier();
43702 
43703  HPS::Type ObjectType() const {return HPS::Type::STLImportNotifier;};
43704 
43708  ImportNotifier & operator=(ImportNotifier const & in_that);
43709 
43712  void Assign(ImportNotifier const & in_that);
43713 
43717  ImportResultsKit GetResults() const;
43718  };
43719 
43720 
43722  class HPS_API File
43723  {
43724  public:
43730  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43731 
43732  private:
43734  File();
43735  };
43736 private:
43738  STL();
43739 };
43740 
43741 }
43742 
43743 #ifdef _MSC_VER
43744 # pragma warning(pop)
43745 #endif
43746 
43747 #endif
43748 
43749 
HPS::Type ObjectType() const
Definition: hps.h:39979
Rotation
Definition: hps.h:1595
HPS::Type ObjectType() const
Definition: hps.h:26946
bool Empty() const
Definition: hps.h:6824
CameraPoint(Point const &in_point)
Definition: hps.h:5775
Alignment
Definition: hps.h:1528
HPS::Type ObjectType() const
Definition: hps.h:19332
Space
Definition: hps.h:561
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41711
Definition: hps.h:3259
Definition: hps.h:6014
Channel
Definition: hps.h:945
HPS::Type ObjectType() const
Definition: hps.h:24118
Handedness
Definition: hps.h:1276
Definition: hps.h:14199
Definition: hps.h:1051
Definition: hps.h:11982
ColorSource
Definition: hps.h:1921
HPS::Type ObjectType() const
Definition: hps.h:17069
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:41497
HPS::Type ObjectType() const
Definition: hps.h:36281
Event(intptr_t in_channel=0)
Definition: hps.h:6128
Definition: hps.h:18184
HPS::Type ObjectType() const
Definition: hps.h:43436
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3751
float alpha
Definition: hps.h:4290
Definition: hps.h:34685
HPS::Type ObjectType() const
Definition: hps.h:35888
bool operator==(Touch const &in_that) const
Definition: hps.h:6418
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:41518
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41153
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40909
InformationEvent(char const *in_message)
Definition: hps.h:40709
HPS::Type ObjectType() const
Definition: hps.h:34351
Definition: hps.h:8676
HPS::Type ObjectType() const
Definition: hps.h:21848
HPS::Type ObjectType() const
Definition: hps.h:23646
HPS::Type ObjectType() const
Definition: hps.h:24392
Action
Definition: hps.h:41294
Orientation
Definition: hps.h:537
Definition: hps.h:20663
Code
Definition: hps.h:134
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1331
Multiline strings will be left justfied.
Definition: hps.h:39796
HPS::Type ObjectType() const
Definition: hps.h:14953
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40964
HPS::Type ObjectType() const
Definition: hps.h:8610
HPS::Type ObjectType() const
Definition: hps.h:28174
Event * Clone() const
Definition: hps.h:40807
Definition: hps.h:13258
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:41628
Definition: hps.h:43180
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40595
ImportStatusEvent()
Definition: hps.h:41052
HPS::Type ObjectType() const
Definition: hps.h:21464
HPS::Type ObjectType() const
Definition: hps.h:36063
Definition: hps.h:13765
HPS::Type ObjectType() const
Definition: hps.h:25909
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41359
HPS::Type ObjectType() const
Definition: hps.h:30214
HPS::Type ObjectType() const
Definition: hps.h:25520
HPS::Type ObjectType() const
Definition: hps.h:11633
static MouseButtons ButtonX2()
Definition: hps.h:41573
Definition: hps.h:19766
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:40856
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41817
Definition: hps.h:43595
Definition: hps.h:37955
Definition: hps.h:19126
HPS::Type ObjectType() const
Definition: hps.h:37775
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5672
Definition: hps.h:1494
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5920
bool Middle() const
Definition: hps.h:41483
Definition: hps.h:467
Driver
Definition: hps.h:154
HPS::Type ObjectType() const
Definition: hps.h:41857
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2192
Definition: hps.h:35384
HPS::Type ObjectType() const
Definition: hps.h:39123
CappingLevel
Definition: hps.h:1727
Definition: hps.h:41719
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8691
HPS::Type ObjectType() const
Definition: hps.h:23373
HPS::Type ObjectType() const
Definition: hps.h:35816
Definition: hps.h:9385
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12771
HPS::Type ObjectType() const
Definition: hps.h:41969
HPS::Type ObjectType() const
Definition: hps.h:20508
Definition: hps.h:26533
HPS::Type ObjectType() const
Definition: hps.h:13788
InputEvent()
Definition: hps.h:41238
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5532
static MouseButtons ButtonRight()
Definition: hps.h:41561
HPS::Type ObjectType() const
Definition: hps.h:28959
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3858
Definition: hps.h:5572
Definition: hps.h:35651
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41756
static ModifierKeys KeyMeta()
Definition: hps.h:41212
HPS::Type ObjectType() const
Definition: hps.h:35551
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1505
Definition: hps.h:23539
HPS::Type ObjectType() const
Definition: hps.h:36930
Definition: hps.h:16665
HPS::Type ObjectType() const
Definition: hps.h:42822
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:41448
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3737
Definition: hps.h:35042
HPS::Type ObjectType() const
Definition: hps.h:19571
HPS::Type ObjectType() const
Definition: hps.h:39295
HPS::Type ObjectType() const
Definition: hps.h:23571
HPS::Type ObjectType() const
Definition: hps.h:35121
Definition: hps.h:22396
HPS::Type ObjectType() const
Definition: hps.h:16778
MouseButtons()
Definition: hps.h:41443
HPS::Type ObjectType() const
Definition: hps.h:38364
Definition: hps.h:20276
Time GetTimeStamp() const
Definition: hps.h:6150
Definition: hps.h:43722
void Left(bool in_state)
Definition: hps.h:41506
HPS::Type ObjectType() const
Definition: hps.h:22366
NormalizedPoint(Point const &in_point)
Definition: hps.h:5825
HPS::Type ObjectType() const
Definition: hps.h:23920
Event * Clone() const
Definition: hps.h:40624
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3786
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:41502
Renderer
Definition: hps.h:1576
HPS::Type ObjectType() const
Definition: hps.h:34087
Definition: hps.h:40116
KeyboardEvent()
Definition: hps.h:41732
HPS::Type ObjectType() const
Definition: hps.h:7337
Definition: hps.h:37742
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3979
ObjectPoint(Point const &in_point)
Definition: hps.h:5675
HPS::Type ObjectType() const
Definition: hps.h:17656
Definition: hps.h:33537
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:39899
Definition: hps.h:4367
Definition: hps.h:6633
Definition: hps.h:1325
Definition: hps.h:40645
Definition: hps.h:24360
Point_3D< F > min
Definition: hps.h:3721
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40938
static ModifierKeys KeyAlt()
Definition: hps.h:41208
bool IsConsumable() const
Definition: hps.h:6153
Definition: hps.h:1048
size_t GetHash() const
Definition: hps.h:1666
MaterialPreference
Definition: hps.h:1744
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41745
Mobility
Definition: hps.h:194
HPS::Type ObjectType() const
Definition: hps.h:13281
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5873
Definition: hps.h:14636
InterpolationAlgorithm
Definition: hps.h:1511
Fill
Definition: hps.h:1912
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3774
Definition: hps.h:23814
Definition: hps.h:19309
HPS::Type ObjectType() const
Definition: hps.h:27451
HPS::Type ObjectType() const
Definition: hps.h:19149
char At(size_t in_index) const
Definition: hps.h:6867
Definition: hps.h:39968
Definition: hps.h:4393
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41148
HPS::Type ObjectType() const
Definition: hps.h:35943
Definition: hps.h:129
ReferenceFrame
Definition: hps.h:1543
Definition: hps.h:25877
Bloom Shape.
Definition: hps.h:42048
Definition: hps.h:3719
Definition: hps.h:3716
HPS::Type ObjectType() const
Definition: hps.h:16985
GreekingUnits
Definition: hps.h:1630
Definition: hps.h:18676
Definition: hps.h:7389
HPS::Type ObjectType() const
Definition: hps.h:12183
InnerConeUnits
Definition: hps.h:486
Definition: hps.h:26743
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5969
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3891
static MouseButtons ButtonX1()
Definition: hps.h:41569
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41014
Definition: hps.h:18395
Definition: hps.h:3406
OuterConeUnits
Definition: hps.h:472
Definition: hps.h:6400
void X2(bool in_state)
Definition: hps.h:41522
HPS::Type ObjectType() const
Definition: hps.h:18933
HPS::Type ObjectType() const
Definition: hps.h:40446
HPS::Type ObjectType() const
Definition: hps.h:39392
HPS::Type ObjectType() const
Definition: hps.h:14384
Definition: hps.h:14929
Definition: hps.h:1993
HPS::Type ObjectType() const
Definition: hps.h:33570
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41824
HPS::Type ObjectType() const
Definition: hps.h:26845
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41383
HPS::Type ObjectType() const
Definition: hps.h:12654
HPS::Type ObjectType() const
Definition: hps.h:25102
Definition: hps.h:441
HPS::Type ObjectType() const
Definition: hps.h:36394
Definition: hps.h:21826
Channel
Definition: hps.h:904
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40838
AreaUnits
Definition: hps.h:1457
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3828
HPS::Type ObjectType() const
Definition: hps.h:12006
Definition: hps.h:8561
Definition: hps.h:26823
Definition: hps.h:19548
HPS::Type ObjectType() const
Definition: hps.h:34707
Action
Definition: hps.h:40920
Event * Clone() const
Definition: hps.h:40736
HPS::Type ObjectType() const
Definition: hps.h:14222
Definition: hps.h:4642
HPS::Type ObjectType() const
Definition: hps.h:42548
HPS::Type ObjectType() const
Definition: hps.h:27552
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6433
Definition: hps.h:21254
Definition: hps.h:4524
HPS::Type ObjectType() const
Definition: hps.h:37893
HPS::Type ObjectType() const
Definition: hps.h:34224
Definition: hps.h:1384
Definition: hps.h:17866
Definition: hps.h:879
Definition: hps.h:5558
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41316
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3937
Border
Definition: hps.h:264
UpdateControl
Definition: hps.h:175
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41143
Definition: hps.h:37860
Definition: hps.h:36041
Definition: hps.h:7379
HPS::Type ObjectType() const
Definition: hps.h:23123
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41793
HPS::Type ObjectType() const
Definition: hps.h:21389
WarningEvent(Event const &in_event)
Definition: hps.h:40789
Definition: hps.h:36953
HPS::Type ObjectType() const
Definition: hps.h:11509
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1931
Definition: hps.h:1712
static ModifierKeys KeyShift()
Definition: hps.h:41200
Definition: hps.h:149
HPS::Type ObjectType() const
Definition: hps.h:28685
Shape
Definition: hps.h:1073
bool IsValid() const
Definition: hps.h:6817
Definition: hps.h:20485
Definition: hps.h:1523
Cuboid_3D()
Definition: hps.h:3729
ErrorEvent(Event const &in_event)
Definition: hps.h:40860
size_t GetWStrLength() const
Definition: hps.h:6846
Event * Clone() const
Definition: hps.h:40689
HPS::Type ObjectType() const
Definition: hps.h:11100
AppendMode
Definition: hps.h:332
Definition: hps.h:8590
Definition: hps.h:25350
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:41487
Definition: hps.h:236
Definition: hps.h:41048
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3922
void Meta(bool in_state)
Definition: hps.h:41165
Definition: hps.h:6585
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6068
Definition: hps.h:26924
HPS::Type ObjectType() const
Definition: hps.h:14662
UpdateStatus
Definition: hps.h:164
HPS_INLINE bool IsValid() const
Definition: hps.h:3779
HPS::Type ObjectType() const
Definition: hps.h:38476
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40985
Definition: hps.h:21054
Quality
Definition: hps.h:1057
ResolutionUnits
Definition: hps.h:42891
Event * Clone() const
Definition: hps.h:41248
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:41285
Definition: hps.h:4466
TimerTickEvent(Event const &in_event)
Definition: hps.h:40614
Component
Definition: hps.h:352
Definition: hps.h:43293
Definition: hps.h:5667
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6019
HPS::Type ObjectType() const
Definition: hps.h:12270
Definition: hps.h:12396
Default
Definition: hps.h:1885
HPS::Type ObjectType() const
Definition: hps.h:10730
Definition: hps.h:16962
Definition: hps.h:2132
Definition: hps.h:24808
InformationEvent()
Definition: hps.h:40705
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5065
Definition: hps.h:37694
Definition: hps.h:11609
Definition: hps.h:13845
Definition: hps.h:11076
Definition: hps.h:43675
bool Shift() const
Definition: hps.h:41125
SizeToleranceUnits
Definition: hps.h:1617
HPS::Type ObjectType() const
Definition: hps.h:38600
Definition: hps.h:1764
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4008
Cap
Definition: hps.h:1836
Point_3D< F > max
Definition: hps.h:3723
HPS::Type ObjectType() const
Definition: hps.h:7417
Definition: hps.h:11342
Definition: hps.h:20831
Definition: hps.h:13951
HPS::Type ObjectType() const
Definition: hps.h:43207
HPS::Type ObjectType() const
Definition: hps.h:43315
MouseEvent()
Definition: hps.h:41610
Definition: hps.h:14022
HPS::Type ObjectType() const
Definition: hps.h:12111
Definition: hps.h:20038
Definition: hps.h:27195
Definition: hps.h:1067
HPS::Type ObjectType() const
Definition: hps.h:16687
Definition: hps.h:12304
Definition: hps.h:32344
HPS::Type ObjectType() const
Definition: hps.h:35166
Definition: hps.h:12630
static const float Infinity
Definition: hps.h:2187
InsetBehavior
Definition: hps.h:1817
HPS::Type ObjectType() const
Definition: hps.h:25028
Definition: hps.h:5641
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2200
HPS::Type ObjectType() const
Definition: hps.h:13676
HPS::Type ObjectType() const
Definition: hps.h:27145
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6432
HPS::Type ObjectType() const
Definition: hps.h:35356
HPS::Type ObjectType() const
Definition: hps.h:37620
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3901
Algorithm
Definition: hps.h:1445
Definition: hps.h:41947
Definition: hps.h:8626
Decimation
Definition: hps.h:1014
StaticModel
Definition: hps.h:1115
Definition: hps.h:38576
Granularity
Definition: hps.h:1366
Definition: hps.h:36851
DisplayLists
Definition: hps.h:1093
Definition: hps.h:10908
Search the current segment only.
Definition: hps.h:42794
Definition: hps.h:2646
Definition: hps.h:42521
Definition: hps.h:556
KeyboardEvent(Event const &in_event)
Definition: hps.h:41765
Definition: hps.h:21105
Definition: hps.h:35093
ClipOperation
Definition: hps.h:1305
HPS::Type ObjectType() const
Definition: hps.h:8947
Definition: hps.h:2559
Definition: hps.h:30181
Method
Definition: hps.h:1435
Definition: hps.h:36897
HPS::Type ObjectType() const
Definition: hps.h:26565
Definition: hps.h:42836
Parameterization
Definition: hps.h:959
Definition: hps.h:4284
Definition: hps.h:37148
Definition: hps.h:36367
FocusLostEvent()
Definition: hps.h:40993
CuttingLevel
Definition: hps.h:1736
Channel
Definition: hps.h:925
Definition: hps.h:9466
Definition: hps.h:43484
HandleResult
Definition: hps.h:40585
Definition: hps.h:39101
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5077
Definition: hps.h:5915
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40908
Value
Definition: hps.h:1416
Definition: hps.h:1087
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2208
Code
Definition: hps.h:105
HPS::Type ObjectType() const
Definition: hps.h:26061
Event * Clone() const
Definition: hps.h:41001
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41664
Definition: hps.h:42214
Definition: hps.h:41593
ErrorEvent()
Definition: hps.h:40847
Definition: hps.h:40914
Justification
Definition: hps.h:1551
The vertex colors applied to faces.
Definition: hps.h:6505
HPS::Type ObjectType() const
Definition: hps.h:14046
Definition: hps.h:35222
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5550
ErrorEvent(char const *in_message)
Definition: hps.h:40851
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41021
Definition: hps.h:41289
FrameSize
Definition: hps.h:205
Definition: hps.h:2147
Definition: hps.h:9276
Definition: hps.h:23624
Definition: hps.h:12088
Justification
Definition: hps.h:1853
Definition: hps.h:21582
HPS::Type ObjectType() const
Definition: hps.h:11831
Definition: hps.h:40423
Definition: hps.h:37903
HPS::Type ObjectType() const
Definition: hps.h:19790
Definition: hps.h:1690
Definition: hps.h:1471
HPS::Type ObjectType() const
Definition: hps.h:22197
bool None() const
Definition: hps.h:41471
Definition: hps.h:316
Definition: hps.h:1410
HPS::Type ObjectType() const
Definition: hps.h:8730
HPS::Type ObjectType() const
Definition: hps.h:36884
HPS::Type ObjectType() const
Definition: hps.h:35070
Definition: hps.h:17633
GreekingMode
Definition: hps.h:1642
HPS::Type ObjectType() const
Definition: hps.h:20300
Definition: hps.h:36259
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41829
Operation
Definition: hps.h:455
Definition: hps.h:1429
HPS::Type ObjectType() const
Definition: hps.h:37465
Type
Definition: hps.h:1999
WorldPoint(Point const &in_point)
Definition: hps.h:5725
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41423
Definition: hps.h:43455
HPS::Type ObjectType() const
Definition: hps.h:9929
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2479
Definition: hps.h:22596
HPS::Type ObjectType() const
Definition: hps.h:6664
Definition: hps.h:34836
Definition: hps.h:17938
TouchEvent(Event const &in_event)
Definition: hps.h:41331
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41417
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6949
Definition: hps.h:5048
Definition: hps.h:39369
Definition: hps.h:43479
Definition: hps.h:35323
Definition: hps.h:4223
Relation
Definition: hps.h:378
Action
Definition: hps.h:41724
ChannelMapping
Definition: hps.h:1028
HPS::Type ObjectType() const
Definition: hps.h:22715
Definition: hps.h:6762
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5567
HPS::Type ObjectType() const
Definition: hps.h:38942
HPS::Type ObjectType() const
Definition: hps.h:39581
Definition: hps.h:23898
Definition: hps.h:5768
HPS::Type ObjectType() const
Definition: hps.h:42239
bool Alt() const
Definition: hps.h:41133
Definition: hps.h:41439
ToleranceUnits
Definition: hps.h:361
Definition: hps.h:24677
Definition: hps.h:27419
HPS::Type ObjectType() const
Definition: hps.h:12581
SizeUnits
Definition: hps.h:1804
Type
Definition: hps.h:2016
HPS::Type ObjectType() const
Definition: hps.h:17785
The vertex colors applied to faces.
RelationTest
Definition: hps.h:388
Definition: hps.h:39273
Definition: hps.h:8655
Type
Definition: hps.h:323
HPS::Type ObjectType() const
Definition: hps.h:14806
Behavior
Definition: hps.h:570
Definition: hps.h:5718
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6739
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41830
Definition: hps.h:40601
HPS::Type ObjectType() const
Definition: hps.h:18699
Style Append Mode.
ImageFormat
Definition: hps.h:220
Definition: hps.h:38625
Definition: hps.h:25498
Definition: hps.h:41835
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5541
float blue
Definition: hps.h:4289
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:40989
Type
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:21128
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6967
PixelPoint(Point const &in_point)
Definition: hps.h:6071
HPS::Type ObjectType() const
Definition: hps.h:6193
HPS::Type ObjectType() const
Definition: hps.h:7056
Definition: hps.h:17761
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41690
Definition: hps.h:20967
Definition: hps.h:42747
HPS::Type ObjectType() const
Definition: hps.h:21725
HPS::Type ObjectType() const
Definition: hps.h:21605
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:35309
HPS::Type ObjectType() const
Definition: hps.h:28828
HPS::Type ObjectType() const
Definition: hps.h:24191
HPS::Type ObjectType() const
Definition: hps.h:39221
HPS::Type ObjectType() const
Definition: hps.h:20990
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41710
Event * Clone() const
Definition: hps.h:41079
Definition: hps.h:14346
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5071
Definition: hps.h:35910
Definition: hps.h:41010
HPS::Type ObjectType() const
Definition: hps.h:34621
HPS::Type ObjectType() const
Definition: hps.h:40554
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:42370
HPS::Type ObjectType() const
Definition: hps.h:15837
Definition: hps.h:1907
Definition: hps.h:31278
Infinite line which extends infinitely in both directions along a vector.
InformationEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40714
intptr_t GetChannel() const
Definition: hps.h:6147
HPS::Type ObjectType() const
Definition: hps.h:9300
Definition: hps.h:1344
Definition: hps.h:13652
Algorithm
Definition: hps.h:1358
HPS::Type ObjectType() const
Definition: hps.h:31300
HPS::Type ObjectType() const
Definition: hps.h:37936
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3846
Definition: hps.h:12558
Definition: hps.h:10706
Driver
Definition: hps.h:43041
Definition: hps.h:7008
Definition: hps.h:42158
SizeUnits
Definition: hps.h:1672
StandAloneWindowEvent()
Definition: hps.h:40929
HPS::Type ObjectType() const
Definition: hps.h:36463
HPS::Type ObjectType() const
Definition: hps.h:34459
ModifierKeys GetModifierKeys() const
Definition: hps.h:41280
Definition: hps.h:41089
Definition: hps.h:39550
Definition: hps.h:40772
HPS::Type ObjectType() const
Definition: hps.h:12419
HPS::Type ObjectType() const
Definition: hps.h:11250
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40816
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41618
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5513
HPS::Type ObjectType() const
Definition: hps.h:17496
Level
Definition: hps.h:1349
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:40745
bool X2() const
Definition: hps.h:41491
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41098
Definition: hps.h:34437
Definition: hps.h:43408
bool Left() const
Definition: hps.h:41475
void Control(bool in_state)
Definition: hps.h:41157
Definition: hps.h:21693
Definition: hps.h:2896
Definition: hps.h:17045
Definition: hps.h:41233
HPS::Type ObjectType() const
Definition: hps.h:42775
HPS::Type ObjectType() const
Definition: hps.h:18207
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3993
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:40837
The base class of all HPS exceptions.
Definition: hps.h:5505
RegionAlignment
Definition: hps.h:1651
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41325
Event * Clone() const
Definition: hps.h:41655
Definition: hps.h:6114
HPS::Type ObjectType() const
Definition: hps.h:21277
Definition: hps.h:37392
InformationEvent(Event const &in_event)
Definition: hps.h:40718
Definition: hps.h:12833
void Invalidate()
Definition: hps.h:3791
Definition: hps.h:23091
Definition: hps.h:38919
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4785
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5564
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41017
HPS::Type ObjectType() const
Definition: hps.h:33947
Definition: hps.h:6064
HPS::Type ObjectType() const
Definition: hps.h:39818
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6140
Definition: hps.h:403
char const * GetBytes() const
Definition: hps.h:6853
virtual intptr_t Freshen() const
Definition: hps.h:41702
Definition: hps.h:34318
HPS::Type ObjectType() const
Definition: hps.h:35418
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:41242
float green
Definition: hps.h:4288
Action
Definition: hps.h:41599
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1696
HPS::Type ObjectType() const
Definition: hps.h:10334
HPS::Type ObjectType() const
Definition: hps.h:27217
HPS::Type ObjectType() const
Definition: hps.h:24709
HPS::Type ObjectType() const
Definition: hps.h:24465
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10533
HPS::Type ObjectType() const
Definition: hps.h:37988
HPS::Type ObjectType() const
Definition: hps.h:24830
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5972
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41064
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5822
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6412
static const float NegativeInfinity
Definition: hps.h:2189
HighlightEvent(Event const &in_event)
Definition: hps.h:40672
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6958
SizeUnits
Definition: hps.h:1477
HPS::Type ObjectType() const
Definition: hps.h:12857
HPS::Type ObjectType() const
Definition: hps.h:20686
Definition: hps.h:21366
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41712
HPS::Type ObjectType() const
Definition: hps.h:10555
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5923
GatheringLevel
Definition: hps.h:1752
HPS::Type ObjectType() const
Definition: hps.h:29038
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:40767
Definition: hps.h:40527
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3758
Definition: hps.h:12453
FrameOptions
Definition: hps.h:214
HPS::Type ObjectType() const
Definition: hps.h:35259
Space
Definition: hps.h:8568
void Alt(bool in_state)
Definition: hps.h:41161
Definition: hps.h:7017
Buttons
Definition: hps.h:41579
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41737
HPS::Type ObjectType() const
Definition: hps.h:37192
Type
Definition: hps.h:258
bool operator!=(Touch const &in_that) const
Definition: hps.h:6426
Definition: hps.h:40144
Definition: hps.h:24086
Definition: hps.h:100
Type
Definition: hps.h:446
HPS::Type ObjectType() const
Definition: hps.h:42272
HPS::Type ObjectType() const
Definition: hps.h:43617
HPS::Type ObjectType() const
Definition: hps.h:43506
HPS::Type ObjectType() const
Definition: hps.h:33678
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5722
HPS::Type ObjectType() const
Definition: hps.h:9490
HPS::Type ObjectType() const
Definition: hps.h:43703
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6940
Definition: hps.h:23351
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41410
Definition: hps.h:35144
Definition: hps.h:1271
Event * Clone() const
Definition: hps.h:41350
void Middle(bool in_state)
Definition: hps.h:41514
Definition: hps.h:29016
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40887
Definition: hps.h:4793
Event * Clone() const
Definition: hps.h:40955
size_t GetLength() const
Definition: hps.h:6838
HPS::Type ObjectType() const
Definition: hps.h:21077
HPS::Type ObjectType() const
Definition: hps.h:26775
Type
Definition: hps.h:1134
Definition: hps.h:423
HPS::Type ObjectType() const
Definition: hps.h:9408
bool None() const
Definition: hps.h:41121
size_t ClickCount
The number of clicks received.
Definition: hps.h:41714
virtual intptr_t Freshen() const
Definition: hps.h:6144
void Reset()
Definition: hps.h:6833
HPS::Type ObjectType() const
Definition: hps.h:37722
HPS::Type ObjectType() const
Definition: hps.h:23846
Definition: hps.h:34191
HPS::Type ObjectType() const
Definition: hps.h:39922
Definition: hps.h:39198
SizeUnits
Definition: hps.h:1605
Event * Clone() const
Definition: hps.h:40878
MouseEvent(Event const &in_event)
Definition: hps.h:41633
bool Right() const
Definition: hps.h:41479
Definition: hps.h:2011
virtual bool Empty() const
Definition: hps.h:5605
Join
Definition: hps.h:1827
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3915
Modifier
Definition: hps.h:1864
static MouseButtons ButtonLeft()
Definition: hps.h:41557
static MouseButtons ButtonMiddle()
Definition: hps.h:41565
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41308
HighlightEvent()
Definition: hps.h:40656
virtual HPS::Type ObjectType() const
Definition: hps.h:5601
Definition: hps.h:18909
HPS::Type ObjectType() const
Definition: hps.h:13869
Definition: hps.h:28668
Definition: hps.h:16756
Definition: hps.h:5817
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41422
Definition: hps.h:8701
Type
Definition: hps.h:581
virtual intptr_t Freshen() const
Definition: hps.h:40639
Background
Definition: hps.h:239
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3835
Definition: hps.h:42900
static ModifierKeys KeyControl()
Definition: hps.h:41204
HPS::Type ObjectType() const
Definition: hps.h:18419
Definition: hps.h:5523
HPS::Type ObjectType() const
Definition: hps.h:35673
Definition: hps.h:7311
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5870
HPS::Type ObjectType() const
Definition: hps.h:39714
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40934
Mode
Definition: hps.h:1717
Definition: hps.h:33317
Definition: hps.h:11227
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:40766
Event * Clone() const
Definition: hps.h:41038
Definition: hps.h:34053
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4052
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3870
Definition: hps.h:33915
Type
Definition: hps.h:884
Definition: hps.h:346
Definition: hps.h:14783
Definition: hps.h:21441
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3823
Definition: hps.h:919
HPS::Type ObjectType() const
Definition: hps.h:12328
Definition: hps.h:35855
HPS::Type ObjectType() const
Definition: hps.h:32377
HPS::Type ObjectType() const
Definition: hps.h:17889
Definition: hps.h:42210
HPS::Type ObjectType() const
Definition: hps.h:37820
Definition: hps.h:35529
HPS::Type ObjectType() const
Definition: hps.h:42392
Definition: hps.h:5866
HPS::Type ObjectType() const
Definition: hps.h:42070
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3809
HPS::Type ObjectType() const
Definition: hps.h:36975
Definition: hps.h:35794
HPS::Type ObjectType() const
Definition: hps.h:12477
HPS::Type ObjectType() const
Definition: hps.h:17962
Definition: hps.h:24169
Mode
Definition: hps.h:1770
Definition: hps.h:8915
Event * Clone() const
Definition: hps.h:41784
Definition: hps.h:10310
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3881
Tiling
Definition: hps.h:987
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4037
WindowPoint(Point const &in_point)
Definition: hps.h:6022
Transform
Definition: hps.h:1560
HPS::Type ObjectType() const
Definition: hps.h:37290
Definition: hps.h:11486
Definition: hps.h:8647
Definition: hps.h:40701
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:22049
Definition: hps.h:35277
Definition: hps.h:27530
Definition: hps.h:22334
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:38647
Definition: hps.h:26039
Definition: hps.h:939
ModifierKeys()
Definition: hps.h:41093
Definition: hps.h:25080
Definition: hps.h:1799
Definition: hps.h:22693
Definition: hps.h:28142
Preference
Definition: hps.h:1585
HPS::Type ObjectType() const
Definition: hps.h:25382
Capping
Definition: hps.h:526
Definition: hps.h:40843
HPS::Type ObjectType() const
Definition: hps.h:35491
TouchEvent()
Definition: hps.h:41302
Interpolation
Definition: hps.h:1003
HPS::Type ObjectType() const
Definition: hps.h:20061
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:41257
WarningEvent(char const *in_message)
Definition: hps.h:40780
HPS::Type ObjectType() const
Definition: hps.h:20854
Modifiers
Definition: hps.h:41218
Component
Definition: hps.h:518
Definition: hps.h:513
Definition: hps.h:9906
Definition: hps.h:37596
HPS::Type ObjectType() const
Definition: hps.h:35981
HPS::Type ObjectType() const
Definition: hps.h:6529
HPS::Type ObjectType() const
Definition: hps.h:22628
Definition: hps.h:17472
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4022
HPS::Type ObjectType() const
Definition: hps.h:42927
HPS::Type ObjectType() const
Definition: hps.h:22418
Definition: hps.h:3182
Format
Definition: hps.h:37153
WarningEvent()
Definition: hps.h:40776
Definition: hps.h:24996
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40633
Touch()
Definition: hps.h:6406
Definition: hps.h:12247
Definition: hps.h:35948
Component
Definition: hps.h:408
Definition: hps.h:33662
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:39691
Definition: hps.h:1129
float red
Definition: hps.h:4287
ClipSpace
Definition: hps.h:1313
Definition: hps.h:12159
Definition: hps.h:37787
Definition: hps.h:15814
Control & operator=(Control &&in_that)
Definition: hps.h:5658
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40785
HPS::Type ObjectType() const
Definition: hps.h:13974
Definition: hps.h:28937
SizeUnits
Definition: hps.h:42884
void Right(bool in_state)
Definition: hps.h:41510
virtual void Reset()
Definition: hps.h:40577
Definition: hps.h:11808
HPS::Type ObjectType() const
Definition: hps.h:11365
bool Meta() const
Definition: hps.h:41137
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4064
Definition: hps.h:35457
TimerTickEvent()
Definition: hps.h:40605
Definition: hps.h:38454
Definition: hps.h:37170
HPS::Type ObjectType() const
Definition: hps.h:22081
RenderingAlgorithm
Definition: hps.h:275
EmergencyHandler()
Definition: hps.h:40121
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5772
TouchID ID
TouchID for this Touch.
Definition: hps.h:6431
Definition: hps.h:36430
HPS::Type ObjectType() const
Definition: hps.h:10931
HPS::Type ObjectType() const
Definition: hps.h:33339
HPS::Type ObjectType() const
Definition: hps.h:8431
Definition: hps.h:42879
Definition: hps.h:6170
Definition: hps.h:24443
HandednessOptimization
Definition: hps.h:369
Definition: hps.h:6712
Projection
Definition: hps.h:1395
Control(Control &&in_that)
Definition: hps.h:5653
bool Control() const
Definition: hps.h:41129
Definition: hps.h:5431
HPS::Type ObjectType() const
Definition: hps.h:34858
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8680
Overlay
Definition: hps.h:1285
Definition: hps.h:28806
Definition: hps.h:5964
Definition: hps.h:37268
Definition: hps.h:43185
size_t GetHash() const
Status
Definition: hps.h:6120
Definition: hps.h:22175
HPS::Type ObjectType() const
Definition: hps.h:34988
HPS::Type ObjectType() const
Definition: hps.h:6611
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:41713
Definition: hps.h:37437
Definition: hps.h:42250
Definition: hps.h:27113
Definition: hps.h:2027
HPS::Type ObjectType() const
Definition: hps.h:42180