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  ExchangeTranslationOptionsKit = 0x8102000e,
5376 
5377  PublishMask = 0x80040000,
5378  PublishDocumentKit = 0x81040001,
5379  PublishPageKit = 0x81040002,
5380  PublishTemplateKit = 0x81040003,
5381  PublishAnnotationKit = 0x81040004,
5382  PublishArtworkKit = 0x81040005,
5383  PublishViewKit = 0x81040006,
5384  PublishTextKit = 0x81040007,
5385  PublishImageKit = 0x81040008,
5386  PublishTableKit = 0x81040009,
5387  PublishExportOptionsKit = 0x8104000a,
5388  PublishLinkKit = 0x8104000b,
5389  PublishButtonKit = 0x8104000c,
5390  PublishTextFieldKit = 0x8104000d,
5391  PublishSlideTableKit = 0x8104000e,
5392  PublishCheckBoxKit = 0x8104000f,
5393  PublishRadioButtonKit = 0x81040010,
5394  PublishListBoxKit = 0x81040011,
5395  PublishDropDownListKit = 0x81040012,
5396  PublishSignatureFieldKit = 0x81040013,
5397 
5398  PublishDocumentKey = 0x80040001,
5399  PublishPageControl = 0x80040002,
5400 
5401  SceneTree = 0x80008001,
5402  SceneTreeItem = 0x80008002,
5403 
5404  ComponentTree = 0x80008003,
5405  ComponentTreeItem = 0x80008004,
5406 
5407  SketchupMask = 0x80100000,
5408  SketchupImportOptionsKit = 0x81100001,
5409  SketchupImportResultsKit = 0x81100002,
5410 
5411  ParasolidMask = 0x80200000,
5412  ParasolidComponent = 0x80201201,
5413  ParasolidCADModel = 0x80200302,
5414  ParasolidImportOptionsKit = 0x81200003,
5415  ParasolidFacetTessellationKit = 0x81200004,
5416  ParasolidLineTessellationKit = 0x81200005,
5417  ParasolidExportOptionsKit = 0x81200006,
5418 
5419  IONotifierData = 0x84000200,
5420  StreamImportNotifierData = 0x84000201,
5421  STLImportNotifierData = 0x84000202,
5422  OBJImportNotifierData = 0x84000203,
5423  ExchangeImportNotifierData = 0x84020204,
5424  SketchupImportNotifierData = 0x84100205,
5425  ParasolidImportNotifierData = 0x84200206,
5426  ExchangeTranslationNotifierData = 0x84020207,
5427  ExchangeExportNotifierData = 0x84020208,
5428  StreamExportNotifierData = 0x84000209,
5429 };
5430 
5432 class HPS_API Memory
5433 {
5434 public:
5440  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5441 
5442 
5447  static void Free(void * in_pointer);
5448 
5449 private:
5451  Memory();
5452 };
5453 
5454 
5456 template <typename T>
5457 class NO_HPS_API Allocator
5458 {
5459 public:
5460  typedef T value_type;
5461  typedef value_type * pointer;
5462  typedef value_type const * const_pointer;
5463  typedef value_type & reference;
5464  typedef value_type const & const_reference;
5465  typedef size_t size_type;
5466  typedef ptrdiff_t difference_type;
5467 
5468 
5469  Allocator() {}
5470  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5471  ~Allocator() {}
5472 
5473  template <typename U> Allocator(Allocator<U> const &) {}
5474 
5475  template <typename U>
5476  struct rebind
5477  {
5478  typedef Allocator<U> other;
5479  };
5480 
5481 
5482  pointer address(reference x) const { return &x; }
5483  const_pointer address(const_reference x) const { return &x; }
5484 
5485  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5486  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5487 
5488 #if defined(_MSC_VER) || defined (__APPLE__)
5489  void construct(pointer p, const_reference x) { new(p) T(x); }
5490 #else
5491  template<typename U, typename... Args>
5492  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5493 #endif
5494  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5495 
5496  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5497 };
5498 
5499 template <typename T, typename U>
5500 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5501 
5502 template <typename T, typename U>
5503 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5504 
5506 class Exception : public std::runtime_error
5507 {
5508 public:
5509  Exception(char const * in_info) : std::runtime_error(in_info) { }
5510 };
5511 
5512 
5515 {
5516 public:
5517  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5518  Exception(in_info) {}
5519 };
5520 
5521 
5525 {
5526 public:
5527  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5528  Exception(in_info) {}
5529 };
5530 
5531 
5534 {
5535 public:
5536  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5537  Exception(in_info) {}
5538 };
5539 
5540 
5543 {
5544 public:
5545  InvalidLicenseException(char const * in_info) :
5546  Exception(in_info) {}
5547 };
5548 
5549 
5552 {
5553 public:
5554  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5555  Exception(in_info) {}
5556 };
5557 
5559 class IOException : public Exception
5560 {
5561 public:
5565  IOException(char const * in_info, IOResult in_result)
5566  : Exception(in_info), result(in_result) {}
5567 
5568  IOResult result;
5569 };
5570 
5571 
5573 class HPS_API Object
5574 {
5575 public:
5576 
5577  Object();
5578 
5579  virtual ~Object();
5580 
5581  Object & operator=(Object const & other_object);
5582 
5586  Object(Object && in_that);
5587 
5588 
5592  Object & operator=(Object && in_that);
5593 
5597  HPS::Type Type() const;
5598 
5602  virtual HPS::Type ObjectType() const { return HPS::Type::None; }
5603 
5606  virtual bool Empty() const {return (impl_ == 0);};
5607 
5609  virtual void Reset();
5610 
5614  bool HasType(HPS::Type in_mask) const;
5615 
5618  intptr_t GetClassID() const;
5619 
5623  intptr_t GetInstanceID() const;
5624 
5625  template <typename T>
5626  static intptr_t ClassID()
5627  {
5628  static const intptr_t ret = T().GetClassID();
5629  return ret;
5630  }
5631 private:
5632 
5633  friend class HPSI::Impl;
5634  friend class HPSI::KeyImpl;
5635  friend class HPSI::TicketImpl;
5636 
5637  HPSI::Impl * impl_;
5638 };
5639 
5640 
5642 class HPS_API Control : public Object
5643 {
5644  HPS::Type ObjectType() const {return HPS::Type::Control;}
5645 
5646 
5647 
5648 protected:
5649  Control() {}
5650 
5654  Control(Control && in_that) : Object(std::move(in_that)) {}
5655 
5659  Control & operator=(Control && in_that)
5660  {
5661  this->Object::operator=(std::move(in_that));
5662  return *this;
5663  }
5664 };
5665 
5666 
5668 class HPS_API ObjectPoint : public Point
5669 {
5670 public:
5671 
5673  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5674 
5676  ObjectPoint(Point const & in_point):Point(in_point){}
5677 
5679  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5680 
5682  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5683 
5685  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5686 
5688  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5689 
5691  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5692 
5694  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5695 
5697  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5698 
5700  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5701 
5703  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5704 
5705 private:
5706 
5707  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5708  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5709  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5710  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5711  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5712  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5713  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5714  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5715 
5716 };
5717 
5719 class HPS_API WorldPoint : public Point
5720 {
5721 public:
5723  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5724 
5726  WorldPoint(Point const & in_point):Point(in_point){}
5727 
5729  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5730 
5732  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5733 
5735  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5736 
5738  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5739 
5741  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5742 
5744  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5745 
5747  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5748 
5750  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5751 
5753  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5754 
5755 private:
5756 
5757  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5758  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5759  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5760  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5761  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5762  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5763  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5764  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5765 
5766 };
5767 
5769 class HPS_API CameraPoint : public Point
5770 {
5771 public:
5773  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5774 
5776  CameraPoint(Point const & in_point):Point(in_point){}
5777 
5779  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5780 
5782  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5783 
5785  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5786 
5788  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5789 
5791  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5792 
5794  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5795 
5797  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5798 
5800  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5801 
5803  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5804 
5805 private:
5806  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5807  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5808  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5809  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5810  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5811  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5812  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5813  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5814 
5815 };
5816 
5818 class HPS_API NormalizedPoint : public Point
5819 {
5820 public:
5821 
5823  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5824 
5826  NormalizedPoint(Point const & in_point):Point(in_point){}
5827 
5829  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5830 
5832  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5833 
5835  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5836 
5838  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5839 
5841  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5842 
5844  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5845 
5847  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5848 
5850  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5851 
5853  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5854 
5855 private:
5856  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5857  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5858  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5859  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5860  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5861  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5862  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5863  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5864 };
5865 
5867 class HPS_API ScreenRangePoint : public Point
5868 {
5869 public:
5871  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5872 
5874  ScreenRangePoint(Point const & in_point):Point(in_point){}
5875 
5877  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5878 
5880  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5881 
5883  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5884 
5886  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5887 
5889  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5890 
5892  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5893 
5895  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5896 
5898  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5899 
5901  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5902 
5903 private:
5904  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5905  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5906  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5907  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5908  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5909  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5910  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5911  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5912 
5913 };
5914 
5916 class HPS_API InnerWindowPoint : public Point
5917 {
5918 public:
5919 
5921  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5922 
5924  InnerWindowPoint(Point const & in_point):Point(in_point){}
5925 
5927  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5928 
5930  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5931 
5933  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5934 
5936  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5937 
5939  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5940 
5942  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5943 
5945  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5946 
5948  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5949 
5951  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5952 
5953 private:
5954  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5955  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5956  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5957  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5958  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5959  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5960  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5961  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5962 };
5963 
5965 class HPS_API InnerPixelPoint : public Point
5966 {
5967 public:
5968 
5970  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5971 
5973  InnerPixelPoint(Point const & in_point):Point(in_point){}
5974 
5976  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5977 
5979  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5980 
5982  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5983 
5985  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5986 
5988  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5989 
5991  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5992 
5994  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5995 
5997  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5998 
6000  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6001 
6002 private:
6003  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6004  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6005  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6006  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6007  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6008  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6009  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6010  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6011 
6012 };
6013 
6015 class HPS_API WindowPoint : public Point
6016 {
6017 public:
6018 
6020  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6021 
6023  WindowPoint(Point const & in_point):Point(in_point){}
6024 
6026  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6027 
6029  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6030 
6032  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6033 
6035  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6036 
6038  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6039 
6041  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6042 
6044  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6045 
6047  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6048 
6050  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6051 
6052 private:
6053  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6054  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6055  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6056  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6057  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6058  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6059  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6060  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6061 };
6062 
6063 
6065 class HPS_API PixelPoint : public Point
6066 {
6067 public:
6069  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6070 
6072  PixelPoint(Point const & in_point):Point(in_point){}
6073 
6075  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6076 
6078  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6079 
6081  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6082 
6084  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6085 
6087  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6088 
6090  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6091 
6093  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6094 
6096  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6097 
6099  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6100 
6101 private:
6102  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6103  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6104  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6105  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6106  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6107  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6108  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6109  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6110 
6111 };
6112 
6115 class HPS_API Event
6116 {
6117 public:
6121  enum class Status
6122  {
6123  InProgress,
6124  Completed,
6125  Failed
6126  };
6127 
6129  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6130 
6131  virtual ~Event();
6132 
6134  intptr_t GetClassID() const;
6135 
6138  virtual Event * Clone() const=0;
6139 
6141  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6142 
6145  virtual intptr_t Freshen() const { return 0; }
6146 
6148  intptr_t GetChannel() const { return channel; }
6149 
6151  Time GetTimeStamp() const { return time_stamp; }
6152 
6154  bool IsConsumable() const { return consumable; }
6155 
6156  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6157  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6158 
6159 protected:
6160  intptr_t channel;
6161  bool consumable;
6162 
6163 private:
6164  friend class HPSI::EventDispatcherImpl;
6165  Time time_stamp;
6166 };
6167 
6168 
6171 class HPS_API EventNotifier : public Object
6172 {
6173 public:
6174 
6176  EventNotifier();
6177 
6180  EventNotifier(EventNotifier const & in_that);
6181 
6185  EventNotifier(EventNotifier && in_that);
6186 
6190  EventNotifier & operator=(EventNotifier && in_that);
6191 
6192  virtual ~EventNotifier();
6193 
6194  HPS::Type ObjectType() const {return HPS::Type::EventNotifier;};
6195 
6199  EventNotifier & operator=(EventNotifier const & in_that);
6200 
6203  virtual void Assign(EventNotifier const & in_that);
6204 
6206  void Wait() const;
6207 
6210  Event::Status Status() const;
6211 };
6212 
6214 enum class KeyboardCode
6215 {
6216  None = 0,
6217 
6218  Backspace = 8,
6219  Tab = 9,
6220  Clear = 11,
6221  Return = 13,
6222  Shift = 16,
6223  Control = 17,
6224  Alt = 18,
6225  Pause = 19,
6226  Escape = 27,
6227 
6228  Space = 32,
6229  ExclamationMark,
6230  DoubleQuote,
6231  Number,
6232  Dollar,
6233  Percent,
6234  Ampersand,
6235  SingleQuote,
6236  OpenParen,
6237  CloseParen,
6238 
6239  Asterisk,
6240  Plus,
6241  Comma,
6242  Hyphen,
6243  Period,
6244  Slash,
6245 
6246  D0,
6247  D1,
6248  D2,
6249  D3,
6250  D4,
6251  D5,
6252  D6,
6253  D7,
6254  D8,
6255  D9,
6256 
6257  Colon,
6258  Semicolon,
6259  LessThan,
6260  Equal,
6261  GreaterThan,
6262  QuestionMark,
6263  AtSymbol,
6264 
6265  A,
6266  B,
6267  C,
6268  D,
6269  E,
6270  F,
6271  G,
6272  H,
6273  I,
6274  J,
6275  K,
6276  L,
6277  M,
6278  N,
6279  O,
6280  P,
6281  Q,
6282  R,
6283  S,
6284  T,
6285  U,
6286  V,
6287  W,
6288  X,
6289  Y,
6290  Z,
6291 
6292  OpenBrackets,
6293  Backslash,
6294  CloseBrackets,
6295  Caret,
6296  Underscore,
6297  Backtick,
6298 
6299  a,
6300  b,
6301  c,
6302  d,
6303  e,
6304  f,
6305  g,
6306  h,
6307  i,
6308  j,
6309  k,
6310  l,
6311  m,
6312  n,
6313  o,
6314  p,
6315  q,
6316  r,
6317  s,
6318  t,
6319  u,
6320  v,
6321  w,
6322  x,
6323  y,
6324  z,
6325 
6326  OpenBrace,
6327  VerticalBar,
6328  ClosingBrace,
6329  Tilde,
6330  Delete,
6331 
6332  Insert=1024,
6333  Home,
6334  End,
6335  PageUp,
6336  PageDown,
6337 
6338  Help,
6339 
6340  Left,
6341  Up,
6342  Right,
6343  Down,
6344 
6345  NumPad0,
6346  NumPad1,
6347  NumPad2,
6348  NumPad3,
6349  NumPad4,
6350  NumPad5,
6351  NumPad6,
6352  NumPad7,
6353  NumPad8,
6354  NumPad9,
6355 
6356  F1,
6357  F2,
6358  F3,
6359  F4,
6360  F5,
6361  F6,
6362  F7,
6363  F8,
6364  F9,
6365  F10,
6366  F11,
6367  F12,
6368  F13,
6369  F14,
6370  F15,
6371  F16,
6372  F17,
6373  F18,
6374  F19,
6375  F20,
6376  F21,
6377  F22,
6378  F23,
6379  F24,
6380 
6381  // these are not implemented
6382 // CapsLock, //!< The Caps Lock key.
6383 //
6384 // NumLock, //!< The Num Lock key.
6385 // ScrollLock, //!< The Scroll Lock key.
6386 // LeftShift, //!< The left Shift key.
6387 // RightShift, //!< The right Shift key.
6388 // LeftCtrl, //!< The left CTRL key.
6389 // RightCtrl, //!< The right CTRL key.
6390 // LeftAlt, //!< The left ALT key.
6391 // RightAlt, //!< The right ALT key.
6392 //
6393 // Select, //!< The Select key.
6394 // Print, //!< The Print key.
6395 // Execute, //!< The Execute key.
6396 // PrintScreen, //!< The Print Screen key.
6397 };
6398 
6399 
6401 class NO_HPS_API Touch
6402 {
6403 public:
6404 
6407  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6408 
6413  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6414  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6415 
6419  inline bool operator==(Touch const & in_that) const
6420  {
6421  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6422  }
6423 
6427  inline bool operator!=(Touch const & in_that) const
6428  {
6429  return !(*this == in_that);
6430  }
6431 
6432  TouchID ID;
6434  size_t TapCount;
6435 };
6436 
6437 
6438 typedef std::vector<Point, Allocator<Point> > PointArray;
6439 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6440 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6441 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6442 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6443 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6444 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6445 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6446 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6447 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6448 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6449 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6450 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6451 typedef std::vector<int, Allocator<int> > IntArray;
6452 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6453 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6454 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6455 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6456 typedef std::vector<float, Allocator<float> > FloatArray;
6457 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6458 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6459 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6460 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6461 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6462 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6463 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6464 typedef std::vector<bool, Allocator<bool> > BoolArray;
6465 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6466 typedef std::vector<Key, Allocator<Key> > KeyArray;
6467 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6468 typedef std::vector<char, Allocator<char> > CharArray;
6469 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6470 typedef std::vector<byte, Allocator<byte> > ByteArray;
6471 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6472 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6473 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6474 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6475 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6476 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6477 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6478 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6479 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6480 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6481 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6482 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6483 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6484 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6485 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6486 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6487 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6488 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6489 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6490 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6491 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6492 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6493 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6494 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6495 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6496 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6497 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6498 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6499 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6500 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6501 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6502 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6503 
6504 
6506 class HPS_API SearchResultsIterator : public Object
6507 {
6508 public:
6509 
6512 
6516  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6517 
6522 
6526  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6527 
6529 
6530  HPS::Type ObjectType() const {return HPS::Type::SearchResultsIterator;}
6531 
6536  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6537 
6542  void Set(SearchResultsIterator const & in_search_results_iterator);
6543 
6545  void Next();
6546 
6549  SearchResultsIterator & operator++();
6550 
6553  SearchResultsIterator operator++(int in_val);
6554 
6557  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6558 
6561  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6562 
6566  bool IsValid() const;
6567 
6569  void Reset();
6570 
6574  Key GetItem() const;
6575 
6578  Key operator*() const;
6579 
6582  SearchTypeArray GetResultTypes() const;
6583 };
6584 
6586 class HPS_API SearchResults : public Object
6587 {
6588 public:
6590  SearchResults();
6591 
6594  SearchResults(SearchResults const & in_search_results);
6595 
6599  SearchResults(SearchResults && in_that);
6600 
6604  SearchResults & operator=(SearchResults && in_that);
6605 
6607  virtual void Reset();
6608 
6610  ~SearchResults();
6611 
6612  HPS::Type ObjectType() const {return HPS::Type::SearchResults;}
6613 
6617  void Assign(SearchResults const & in_search_results);
6618 
6622  SearchResults & operator=(SearchResults const & in_search_results);
6623 
6626  size_t GetCount() const;
6627 
6630  SearchResultsIterator GetIterator() const;
6631 };
6632 
6634 class HPS_API FontSearchResultsIterator : public Object
6635 {
6636 public:
6637 
6640 
6644  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6645 
6650 
6655  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6656 
6657 
6661  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6662 
6664 
6665  HPS::Type ObjectType() const {return HPS::Type::FontSearchResultsIterator;}
6666 
6667 
6672  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6673 
6675  void Next();
6676 
6679  FontSearchResultsIterator & operator++();
6680 
6683  FontSearchResultsIterator operator++(int in_val);
6684 
6687  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6688 
6691  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6692 
6696  bool IsValid() const;
6697 
6699  void Reset();
6700 
6704  FontInfoState GetItem() const;
6705 
6708  FontInfoState operator*() const;
6709 
6710 };
6711 
6713 class HPS_API FontSearchResults : public Object
6714 {
6715 public:
6716 
6719 
6722  FontSearchResults(FontSearchResults const & in_search_results);
6723 
6728 
6732  FontSearchResults & operator=(FontSearchResults && in_that);
6733 
6735  virtual void Reset();
6736 
6738  ~FontSearchResults();
6739 
6740  HPS::Type ObjectType() const {return HPS::Type::FontSearchResults;}
6741 
6745  void Assign(FontSearchResults const & in_search_results);
6746 
6747 
6751  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6752 
6755  size_t GetCount() const;
6756 
6759  FontSearchResultsIterator GetIterator() const;
6760 };
6761 
6763 class HPS_API UTF8
6764 {
6765 public:
6766 
6768  UTF8();
6769 
6771  ~UTF8();
6772 
6779  UTF8(char const * in_string, char const * in_locale = 0);
6780 
6783  UTF8(wchar_t const * in_string);
6784 
6787  UTF8(UTF8 const & in_that);
6788 
6791  UTF8(UTF8 && in_that);
6792 
6796  UTF8 & Assign(UTF8 && in_utf8);
6797 
6800  inline UTF8 & operator= (UTF8 && in_utf8)
6801  {
6802  return Assign(std::move(in_utf8));
6803  }
6804 
6809  size_t ToWStr(wchar_t * out_wide_string) const;
6810 
6814  size_t ToWStr(WCharArray & out_wide_string) const;
6815 
6818  inline bool IsValid() const
6819  {
6820  return (_length > 0);
6821  }
6822 
6825  inline bool Empty() const
6826  {
6827  return (_length == 0);
6828  }
6829 
6831  void Clear();
6832 
6834  void Reset() { Clear(); }
6835 
6839  inline size_t GetLength() const
6840  {
6841  return _length;
6842  }
6843 
6847  inline size_t GetWStrLength() const
6848  {
6849  return ToWStr(0);
6850  }
6851 
6854  inline char const * GetBytes() const
6855  {
6856  return _text;
6857  }
6858 
6861  inline operator char const * () const
6862  {
6863  return _text;
6864  }
6865 
6868  char At(size_t in_index) const
6869  {
6870  if(!IsValid())
6871  throw InvalidObjectException();
6872  else if(in_index >= _length)
6873  throw IndexOutOfRangeException();
6874  else
6875  return _text[in_index];
6876  }
6877 
6881  UTF8 & Assign(UTF8 const & in_utf8);
6882 
6886  inline UTF8 & operator= (UTF8 const & in_utf8)
6887  {
6888  return Assign(in_utf8);
6889  }
6890 
6894  UTF8 & operator+= (UTF8 const & in_utf8);
6895 
6899  UTF8 & operator+= (char const * in_utf8);
6900 
6904  UTF8 operator+ (UTF8 const & in_utf8) const;
6905 
6909  UTF8 operator+ (char const * in_utf8) const;
6910 
6914  bool operator== (UTF8 const & in_utf8) const;
6915 
6919  bool operator!= (UTF8 const & in_utf8) const
6920  {
6921  return !(*this == in_utf8);
6922  }
6923 
6927  bool operator== (char const * in_utf8) const;
6928 
6932  bool operator!= (char const * in_utf8) const
6933  {
6934  return !(*this == in_utf8);
6935  }
6936 
6941  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
6942  {
6943  return in_right == in_left;
6944  }
6945 
6950  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
6951  {
6952  return in_right != in_left;
6953  }
6954 
6959  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
6960  {
6961  return in_right == UTF8(in_left);
6962  }
6963 
6968  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
6969  {
6970  return in_right != UTF8(in_left);
6971  }
6972 
6977  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
6978  {
6979  return UTF8(in_left) + in_right;
6980  }
6981 
6986  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
6987  {
6988  return UTF8(in_left) + in_right;
6989  }
6990 
6991 
6994  size_t GetHash() const;
6995 
6996 private:
6997 
6998  size_t internal_encode(wchar_t const * in_wide_string);
6999  size_t internal_decode(wchar_t * out_wide_string) const;
7000 
7001  char * _text;
7002  size_t _length;
7003  mutable size_t _hash_key;
7004  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7005  char _buffer[_buffer_size];
7006 };
7007 
7009 struct UTF8Hasher {
7010  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7011  {
7012  return in_utf8.GetHash();
7013  }
7014 };
7015 
7018 class HPS_API Condition : public Object
7019 {
7020 public:
7021 
7022  enum class Intrinsic
7023  {
7024  Extent,
7025  DrawPass
7026  };
7027 
7029  Condition();
7030 
7033  Condition(char const * in_utf8);
7034 
7037  Condition(float in_number);
7038 
7041  Condition(HPS::Condition::Intrinsic in_special);
7042 
7045  Condition(Condition const & in_that);
7046 
7050  Condition(Condition && in_that);
7051 
7055  Condition & operator=(Condition && in_that);
7056 
7057  HPS::Type ObjectType() const { return HPS::Type::Condition; }
7058 
7062  bool ShowCondition(UTF8 & out_condition) const;
7063 
7067  bool ShowNumber(float & out_number) const;
7068 
7072  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7073 
7077  bool ShowOperands(ConditionArray & out_operands) const;
7078 
7082  Condition & operator=(Condition const & in_that);
7083 
7087  bool Equals(Condition const & in_that) const;
7088 
7092  bool operator==(Condition const & in_that) const;
7093 
7097  bool operator!=(Condition const & in_that) const;
7098 
7102  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7103 
7107  bool IsSatisfiedBy(char const * in_condition) const;
7108 
7112  Condition OR(Condition const & in_operand2) const;
7113 
7117  Condition XOR(Condition const & in_operand2) const;
7118 
7122  Condition AND(Condition const & in_operand2) const;
7123 
7127  Condition EQ(Condition const & in_operand2) const;
7128 
7132  Condition NEQ(Condition const & in_operand2) const;
7133 
7137  Condition GT(Condition const & in_operand2) const;
7138 
7142  Condition LT(Condition const & in_operand2) const;
7143 
7147  Condition GTEQ(Condition const & in_operand2) const;
7148 
7152  Condition LTEQ(Condition const & in_operand2) const;
7153 
7156  Condition operator !() const;
7157 
7161  Condition operator ||(Condition const & in_operand2) const;
7162 
7166  Condition operator ^(Condition const & in_operand2) const;
7167 
7171  Condition operator &&(Condition const & in_operand2) const;
7172 
7173 
7177  static Condition NOT(Condition const & in_operand);
7178 
7183  static Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7184 
7185 
7190  static Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7191 
7196  static Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7197 
7202  static Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7203 
7208  static Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7209 
7214  static Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7215 
7220  static Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7221 
7226  static Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7227 
7232  static Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7233 
7234  friend HPS_API Condition NOT(Condition const & in_operand);
7235  friend HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7236  friend HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7237  friend HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7238 
7239  friend HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7240  friend HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7241  friend HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7242  friend HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7243  friend HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7244  friend HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7245 };
7246 
7247 
7251 HPS_API Condition NOT(Condition const & in_operand);
7252 
7257 HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7258 
7263 HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7264 
7269 HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7270 
7275 HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7276 
7281 HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7282 
7287 HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7288 
7293 HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7294 
7299 HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7300 
7305 HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7306 
7307 
7308 
7312 class HPS_API Key : public Object
7313 {
7314 public:
7315 
7317  Key();
7318 
7320  Key(Key const & in_that);
7321 
7323  explicit Key(Control const & in_control);
7324 
7328  Key(Key && in_that);
7329 
7333  Key & operator=(Key && in_that);
7334 
7336  virtual ~Key();
7337 
7338  HPS::Type ObjectType() const {return HPS::Type::Key;};
7339 
7341  bool HasOwner() const;
7342 
7344  SegmentKey Up() const;
7345 
7347  SegmentKey Owner() const;
7348 
7350  void Delete();
7351 
7353  void MoveTo(SegmentKey const & in_new_owner);
7354 
7357  Key CopyTo(SegmentKey const & in_destination) const;
7358 
7360  Key & operator=(Key const & in_that);
7361 
7363  virtual void Assign(Key const & in_that);
7364 
7366  bool Equals(Key const & in_that) const;
7367 
7369  bool operator!= (Key const & in_that) const;
7370 
7372  bool operator== (Key const & in_that) const;
7373 
7376  size_t GetHash() const;
7377 };
7378 
7380 struct KeyHasher {
7381  inline size_t operator()(const HPS::Key & in_key) const
7382  {
7383  return in_key.GetHash();
7384  }
7385 };
7386 
7387 
7390 class HPS_API SegmentKey : public Key
7391 {
7392 public:
7394  SegmentKey();
7395 
7397  SegmentKey(SegmentKey const & in_that);
7398 
7400  SegmentKey & operator=(SegmentKey const & other);
7401 
7405  SegmentKey(SegmentKey && in_that);
7406 
7410  SegmentKey & operator=(SegmentKey && in_that);
7411 
7413  explicit SegmentKey(Key const & in_that);
7414 
7416  ~SegmentKey();
7417 
7418  HPS::Type ObjectType() const {return HPS::Type::SegmentKey;};
7419 
7421  UTF8 Name() const;
7422 
7425  SegmentKey & SetName(char const * in_name);
7426 
7429  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7430 
7433  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7434 
7436  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7437 
7439  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7440 
7442  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7443 
7444 
7445 
7447  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7448 
7450  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7451 
7453  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7454 
7455 
7457  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7458 
7460  size_t Find(SearchOptionsKit const & in_options) const;
7461 
7462 
7465  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7466 
7470  IncludeKey IncludeSegment(SegmentKey const & in_seg, Condition const & in_condition);
7471 
7472 
7478  ReferenceKey ReferenceGeometry(Key const & in_key);
7479 
7487  ReferenceKey ReferenceGeometry(Key const & in_key, Condition const & in_condition);
7488 
7489 
7491  size_t ShowSubsegments() const;
7492 
7494  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7495 
7499  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7500 
7504  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7505 
7509  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7510 
7514  size_t ShowStylers(StyleKeyArray & out_styles) const;
7515 
7519  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7520 
7524  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7525 
7526 
7527 
7529  StyleControl GetStyleControl();
7530 
7532  StyleControl const GetStyleControl() const;
7533 
7534 
7536  PortfolioControl GetPortfolioControl();
7537 
7539  PortfolioControl const GetPortfolioControl() const;
7540 
7541 
7543  SegmentKey & SetCondition(char const * in_condition);
7544 
7546  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7547 
7549  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7550 
7552  SegmentKey & UnsetConditions();
7553 
7555  bool ShowConditions(UTF8Array & out_conditions) const;
7556 
7558  ConditionControl GetConditionControl();
7559 
7561  ConditionControl const GetConditionControl() const;
7562 
7563 
7565  SegmentKey & SetMaterialPalette(char const * in_name);
7566 
7568  SegmentKey & UnsetMaterialPalette();
7569 
7571  bool ShowMaterialPalette(UTF8 & out_name) const;
7572 
7573 
7580  SegmentKey & SetPriority(int in_priority);
7581 
7584  SegmentKey & UnsetPriority();
7585 
7589  bool ShowPriority(int & out_priority) const;
7590 
7595  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7596 
7602  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7603 
7608  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7609 
7613  SegmentKey & UnsetUserData(intptr_t in_index);
7614 
7619  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7620 
7624  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
7625 
7628  SegmentKey & UnsetAllUserData();
7629 
7631  size_t ShowUserDataCount() const;
7632 
7637  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
7638 
7642  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7643 
7648  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7649 
7650 
7652  LineKey InsertLine(LineKit const & in_kit);
7653 
7655  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7656 
7658  LineKey InsertLine(PointArray const & in_pts);
7659 
7661  LineKey InsertLine(Point const & pt1, Point const & pt2);
7662 
7663 
7665  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7666 
7668  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);
7669 
7671  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7672 
7674  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7675 
7676 
7681  SphereKey InsertSphere(SphereKit const & in_kit);
7682 
7690  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));
7691 
7693  CircleKey InsertCircle(CircleKit const & in_kit);
7694 
7696  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7697 
7699  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7700 
7701 
7703  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7704 
7706  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7707 
7708 
7710  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7711 
7713  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7714 
7715 
7717  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7718 
7720  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7721 
7722 
7724  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7725 
7727  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float start, float end);
7728 
7729 
7731  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7732 
7734  PolygonKey InsertPolygon(PointArray const & in_pts);
7735 
7737  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7738 
7739 
7741  ShellKey InsertShell(ShellKit const & in_kit);
7742 
7744  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7745 
7747  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7748 
7750  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
7751 
7753  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
7754 
7756  MeshKey InsertMesh(MeshKit const & in_kit);
7757 
7759  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7760 
7762  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7763 
7764 
7766  MarkerKey InsertMarker(Point const & in_position);
7767 
7769  MarkerKey InsertMarker(MarkerKit const & in_kit);
7770 
7771 
7773  DistantLightKey InsertDistantLight(Vector const & in_direction);
7774 
7776  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7777 
7778 
7780  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7781 
7783  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7784 
7786  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7787 
7789  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7790 
7791 
7793  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7794 
7796  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7797 
7798 
7800  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7801 
7803  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7804 
7805 
7807  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7808 
7810  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);
7811 
7813  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);
7814 
7815 
7817  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7818 
7820  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);
7821 
7823  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[]);
7824 
7826  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);
7827 
7829  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[]);
7830 
7831 
7833  TextKey InsertText(TextKit const & in_kit);
7834 
7840  TextKey InsertText(Point const & in_position, char const * in_text);
7841 
7842 
7843 
7845  GridKey InsertGrid(GridKit const & in_kit);
7846 
7848  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);
7849 
7850 
7851 
7859  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7860 
7868  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7869 
7877  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7878 
7886  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7887 
7895  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7896 
7904  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7905 
7910  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7911 
7916  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7917 
7922  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7923 
7928  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7929 
7934  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7935 
7940  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7941 
7942 
7944  SegmentKey & SetAttributeLocks(AttributeLockKit const & in_kit);
7945 
7947  SegmentKey & UnsetAttributeLocks();
7948 
7952  bool ShowAttributeLocks(AttributeLockKit & out_kit) const;
7953 
7955  AttributeLockControl GetAttributeLockControl();
7956 
7958  AttributeLockControl const GetAttributeLockControl() const;
7959 
7960 
7962  SegmentKey & SetBoundings(BoundingKit const & in_kit);
7963 
7965  SegmentKey & UnsetBoundings();
7966 
7970  bool ShowBoundings(BoundingKit & out_kit) const;
7971 
7973  BoundingControl GetBoundingControl();
7974 
7976  BoundingControl const GetBoundingControl() const;
7977 
7978 
7980  SegmentKey & SetCamera(CameraKit const & in_kit);
7981 
7983  SegmentKey & UnsetCamera();
7984 
7986  bool ShowCamera(CameraKit & out_kit) const;
7987 
7989  CameraControl GetCameraControl();
7990 
7992  CameraControl const GetCameraControl() const;
7993 
7995  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
7996 
7998  SegmentKey & UnsetColorInterpolation();
7999 
8001  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
8002 
8004  ColorInterpolationControl GetColorInterpolationControl();
8005 
8007  ColorInterpolationControl const GetColorInterpolationControl() const;
8008 
8009 
8011  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8012 
8014  SegmentKey & UnsetContourLine();
8015 
8017  bool ShowContourLine(ContourLineKit & out_kit) const;
8018 
8020  ContourLineControl GetContourLineControl();
8021 
8023  ContourLineControl const GetContourLineControl() const;
8024 
8025 
8027  SegmentKey & SetCulling(CullingKit const & in_kit);
8028 
8030  SegmentKey & UnsetCulling();
8031 
8035  bool ShowCulling(CullingKit & out_kit) const;
8036 
8038  CullingControl GetCullingControl();
8039 
8041  CullingControl const GetCullingControl() const;
8042 
8043 
8045  SegmentKey & SetCurveAttributes(CurveAttributeKit const & in_kit);
8046 
8048  SegmentKey & UnsetCurveAttributes();
8049 
8051  bool ShowCurveAttributes(CurveAttributeKit & out_kit) const;
8052 
8054  CurveAttributeControl GetCurveAttributeControl();
8055 
8057  CurveAttributeControl const GetCurveAttributeControl() const;
8058 
8059 
8061  SegmentKey & SetCuttingSectionAttributes(CuttingSectionAttributeKit const & in_kit);
8062 
8064  SegmentKey & UnsetCuttingSectionAttributes();
8065 
8067  bool ShowCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
8068 
8070  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8071 
8073  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8074 
8075 
8077  SegmentKey & SetCylinderAttributes(CylinderAttributeKit const & in_kit);
8078 
8080  SegmentKey & UnsetCylinderAttributes();
8081 
8083  bool ShowCylinderAttributes(CylinderAttributeKit & out_kit) const;
8084 
8086  CylinderAttributeControl GetCylinderAttributeControl();
8087 
8089  CylinderAttributeControl const GetCylinderAttributeControl() const;
8090 
8091 
8093  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8094 
8096  SegmentKey & UnsetDrawingAttribute();
8097 
8099  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8100 
8102  DrawingAttributeControl GetDrawingAttributeControl();
8103 
8105  DrawingAttributeControl const GetDrawingAttributeControl() const;
8106 
8107 
8109  SegmentKey & SetEdgeAttributes(EdgeAttributeKit const & in_kit);
8110 
8112  SegmentKey & UnsetEdgeAttributes();
8113 
8115  bool ShowEdgeAttributes(EdgeAttributeKit & out_kit) const;
8116 
8118  EdgeAttributeControl GetEdgeAttributeControl();
8119 
8121  EdgeAttributeControl const GetEdgeAttributeControl() const;
8122 
8123 
8125  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8126 
8128  SegmentKey & UnsetHiddenLineAttribute();
8129 
8131  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8132 
8134  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8135 
8137  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8138 
8139 
8141  SegmentKey & SetLightingAttributes(LightingAttributeKit const & in_kit);
8142 
8144  SegmentKey & UnsetLightingAttributes();
8145 
8147  bool ShowLightingAttributes(LightingAttributeKit & out_kit) const;
8148 
8150  LightingAttributeControl GetLightingAttributeControl();
8151 
8153  LightingAttributeControl const GetLightingAttributeControl() const;
8154 
8155 
8157  SegmentKey & SetLineAttributes(LineAttributeKit const & in_kit);
8158 
8160  SegmentKey & UnsetLineAttributes();
8161 
8163  bool ShowLineAttributes(LineAttributeKit & out_kit) const;
8164 
8166  LineAttributeControl GetLineAttributeControl();
8167 
8169  LineAttributeControl const GetLineAttributeControl() const;
8170 
8171 
8173  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8174 
8176  SegmentKey & UnsetMaterialMapping();
8177 
8179  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8180 
8182  MaterialMappingControl GetMaterialMappingControl();
8183 
8185  MaterialMappingControl const GetMaterialMappingControl() const;
8186 
8187 
8189  SegmentKey & SetMarkerAttributes(MarkerAttributeKit const & in_kit);
8190 
8192  SegmentKey & UnsetMarkerAttributes();
8193 
8195  bool ShowMarkerAttributes(MarkerAttributeKit & out_kit) const;
8196 
8198  MarkerAttributeControl GetMarkerAttributeControl();
8199 
8201  MarkerAttributeControl const GetMarkerAttributeControl() const;
8202 
8203 
8205  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8206 
8208  SegmentKey & UnsetModellingMatrix();
8209 
8211  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8212 
8214  ModellingMatrixControl GetModellingMatrixControl();
8215 
8217  ModellingMatrixControl const GetModellingMatrixControl() const;
8218 
8219 
8221  SegmentKey & SetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit const & in_kit);
8222 
8224  SegmentKey & UnsetNURBSSurfaceAttributes();
8225 
8227  bool ShowNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
8228 
8230  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8231 
8233  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8234 
8235 
8237  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8238 
8240  SegmentKey & UnsetPerformance();
8241 
8243  bool ShowPerformance(PerformanceKit & out_kit) const;
8244 
8246  PerformanceControl GetPerformanceControl();
8247 
8249  PerformanceControl const GetPerformanceControl() const;
8250 
8251 
8253  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8254 
8256  SegmentKey & UnsetSelectability();
8257 
8261  bool ShowSelectability(SelectabilityKit & out_kit) const;
8262 
8264  SelectabilityControl GetSelectabilityControl();
8265 
8267  SelectabilityControl const GetSelectabilityControl() const;
8268 
8269 
8271  SegmentKey & SetSphereAttributes(SphereAttributeKit const & in_kit);
8272 
8274  SegmentKey & UnsetSphereAttributes();
8275 
8279  bool ShowSphereAttributes(SphereAttributeKit & out_kit) const;
8280 
8282  SphereAttributeControl GetSphereAttributeControl();
8283 
8285  SphereAttributeControl const GetSphereAttributeControl() const;
8286 
8287 
8289  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8290 
8292  SegmentKey & UnsetSubwindow();
8293 
8297  bool ShowSubwindow(SubwindowKit & out_kit) const;
8298 
8300  SubwindowControl GetSubwindowControl();
8301 
8303  SubwindowControl const GetSubwindowControl() const;
8304 
8305 
8307  SegmentKey & SetTextAttributes(TextAttributeKit const & in_kit);
8308 
8310  SegmentKey & UnsetTextAttributes();
8311 
8313  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
8314 
8316  TextAttributeControl GetTextAttributeControl();
8317 
8319  TextAttributeControl const GetTextAttributeControl() const;
8320 
8321 
8323  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8324 
8326  SegmentKey & UnsetTextureMatrix();
8327 
8331  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8332 
8334  TextureMatrixControl GetTextureMatrixControl();
8335 
8337  TextureMatrixControl const GetTextureMatrixControl() const;
8338 
8340  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8341 
8343  SegmentKey & UnsetTransformMask();
8344 
8348  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8349 
8351  TransformMaskControl GetTransformMaskControl();
8352 
8354  TransformMaskControl const GetTransformMaskControl() const;
8355 
8356 
8358  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8359 
8361  SegmentKey & UnsetTransparency();
8362 
8366  bool ShowTransparency(TransparencyKit & out_kit) const;
8367 
8369  TransparencyControl GetTransparencyControl();
8370 
8372  TransparencyControl const GetTransparencyControl() const;
8373 
8374 
8376  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8377 
8379  SegmentKey & UnsetVisibility();
8380 
8384  bool ShowVisibility(VisibilityKit & out_kit) const;
8385 
8387  VisibilityControl GetVisibilityControl();
8388 
8390  VisibilityControl const GetVisibilityControl() const;
8391 
8392 
8394  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8395 
8397  SegmentKey & UnsetVisualEffects();
8398 
8402  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8403 
8405  VisualEffectsControl GetVisualEffectsControl();
8406 
8408  VisualEffectsControl const GetVisualEffectsControl() const;
8409 
8410  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8411 };
8412 
8413 
8416 {
8417 public:
8418 
8421 
8425 
8429 
8430  virtual ~SegmentOptimizationOptionsKit();
8431 
8432  HPS::Type ObjectType() const { return HPS::Type::SegmentOptimizationOptionsKit; }
8433 
8436  void Consume(SegmentOptimizationOptionsKit & in_kit);
8437 
8440  void Set(SegmentOptimizationOptionsKit const & in_kit);
8441 
8444  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8445 
8450 
8455 
8458  bool Empty() const;
8459 
8463  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8464 
8468  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8469 
8473  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8474 
8478  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8479 
8483  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8484 
8488  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8489 
8493  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8494 
8498  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8499 
8503  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8504 
8508  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8509 
8513  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8514 
8516  SegmentOptimizationOptionsKit & UnsetUserData();
8517 
8519  SegmentOptimizationOptionsKit & UnsetMatrix();
8520 
8522  SegmentOptimizationOptionsKit & UnsetExpansion();
8523 
8525  SegmentOptimizationOptionsKit & UnsetScope();
8526 
8528  SegmentOptimizationOptionsKit & UnsetReorganization();
8529 
8531  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8532 
8534  SegmentOptimizationOptionsKit & UnsetShellMerging();
8535 
8537  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8538 
8541  SegmentOptimizationOptionsKit & UnsetEverything();
8542 
8543  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8544 
8545  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8546 
8547  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8548 
8549  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8550 
8551  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8552 
8553  bool ShowShellInstancing(bool & out_shell_instancing) const;
8554 
8555  bool ShowShellMerging(bool & out_shell_merging) const;
8556 
8557  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
8558 };
8559 
8560 
8562 class HPS_API Coordinate
8563 {
8564 public:
8565 
8569  enum class Space
8570  {
8571  Object,
8572  World,
8573  Camera,
8574  Normalized,
8575  ScreenRange,
8576  InnerWindow,
8577  InnerPixel,
8578  Window,
8579  Pixel,
8580  };
8581 
8582 private:
8583  Coordinate();
8584 };
8585 
8586 
8587 
8588 
8591 class HPS_API UpdateNotifier : public Object
8592 {
8593 public:
8594 
8595  UpdateNotifier();
8596 
8597  UpdateNotifier(UpdateNotifier const & in_that);
8598 
8602  UpdateNotifier(UpdateNotifier && in_that);
8603 
8607  UpdateNotifier & operator=(UpdateNotifier && in_that);
8608 
8609  virtual ~UpdateNotifier();
8610 
8611  HPS::Type ObjectType() const {return HPS::Type::UpdateNotifier;};
8612 
8614  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8615 
8617  void Assign(UpdateNotifier const & in_that);
8618 
8619  void Wait() const;
8620 
8621  Window::UpdateStatus Status() const;
8622 
8623 };
8624 
8627 class HPS_API DriverEvent
8628 {
8629 public:
8630 
8631  virtual ~DriverEvent() {}
8632 
8634  intptr_t GetClassID() const;
8635 
8636 protected:
8637 
8638  DriverEvent(OpaqueHandle in_nr) : nr(in_nr)
8639  {
8640 
8641  }
8642 
8643  OpaqueHandle nr;
8644 };
8645 
8648 class HPS_API FinishPictureEvent : public DriverEvent
8649 {
8650 public:
8651 
8652  FinishPictureEvent(OpaqueHandle in_nr = 0);
8653 };
8654 
8656 class HPS_API DrawWindowEvent : public DriverEvent
8657 {
8658 public:
8659 
8660  DrawWindowEvent(OpaqueHandle in_nr = 0);
8661 
8663  Rectangle Extent;
8664 
8669  void DrawTexturedBackground(OpaqueHandle in_texture, MatrixKit const & in_matrix, Rectangle const & in_extent) const;
8670 
8671 private:
8672 
8673  mutable HPS::FloatArray matrix_elements;
8674 };
8675 
8677 class HPS_API DriverEventHandler : public Object
8678 {
8679 public:
8680 
8681  HPS::Type ObjectType() const OVERRIDE { return HPS::Type::DriverEventHandler; };
8682 
8684 
8685  DriverEventHandler(DriverEventHandler const & that);
8686 
8687  virtual ~DriverEventHandler();
8688 
8692  virtual void Handle(DriverEvent const * in_event)
8693  {
8694  HPS_UNREFERENCED(in_event);
8695  }
8696 };
8697 
8698 
8702 class HPS_API WindowKey : public SegmentKey
8703 {
8704 public:
8705 
8707  WindowKey();
8708 
8710  WindowKey(WindowKey const & in_window);
8711 
8713  WindowKey & operator=(WindowKey const & other);
8714 
8718  WindowKey(WindowKey && in_that);
8719 
8723  WindowKey & operator=(WindowKey && in_that);
8724 
8726  WindowKey(Key const & in_key);
8727 
8729  ~WindowKey();
8730 
8731  HPS::Type ObjectType() const {return HPS::Type::WindowKey;};
8732 
8734  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8735 
8740  size_t FindFonts(FontSearchResults & out_results) const;
8741 
8743  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8744 
8746  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8747 
8749  PostProcessEffectsControl GetPostProcessEffectsControl();
8750 
8752  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8753 
8754 
8756  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8757 
8761  WindowKey & SetDriverEventHandler(DriverEventHandler const & in_handler, intptr_t in_type);
8762 
8765  WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8766 
8770  bool ShowDebugging(DebuggingKit & out_kit) const;
8771 
8773  DebuggingControl GetDebuggingControl();
8774 
8776  DebuggingControl const GetDebuggingControl() const;
8777 
8779  WindowInfoControl const GetWindowInfoControl() const;
8780 
8781  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8782 
8784  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8785 
8787  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8788 
8790  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
8791 
8793  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
8794 
8795 
8797  SelectionOptionsControl GetSelectionOptionsControl();
8798 
8800  SelectionOptionsControl const GetSelectionOptionsControl() const;
8801 
8802 
8804  SelectionControl GetSelectionControl();
8805 
8807  SelectionControl const GetSelectionControl() const;
8808 
8810  HighlightControl GetHighlightControl();
8811 
8813  HighlightControl const GetHighlightControl() const;
8814 
8816  UpdateOptionsControl GetUpdateOptionsControl();
8817 
8819  UpdateOptionsControl const GetUpdateOptionsControl() const;
8820 
8822  void Update();
8823 
8828  void Update(UpdateOptionsKit const & in_kit);
8829 
8844  void Update(Window::UpdateControl in_control, Time in_time_limit=-1);
8845 
8849  UpdateNotifier UpdateWithNotifier();
8850 
8854  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
8855 
8861  UpdateNotifier UpdateWithNotifier(Window::UpdateControl in_control, Time in_time_limit=-1);
8862 
8864  EventDispatcher & GetEventDispatcher();
8865 
8867  EventDispatcher const & GetEventDispatcher() const;
8868 
8872  bool ShowSnapshot(ImageKit & out_kit) const;
8873 
8874 private:
8875 
8877  SegmentKey & UnsetAttributeLocks();
8878  SegmentKey & UnsetCamera();
8879  SegmentKey & UnsetColorInterpolation();
8880  SegmentKey & UnsetContourLine();
8881  SegmentKey & UnsetCulling();
8882  SegmentKey & UnsetCurveAttributes();
8883  SegmentKey & UnsetCuttingSectionAttributes();
8884  SegmentKey & UnsetCylinderAttributes();
8885  SegmentKey & UnsetDrawingAttribute();
8886  SegmentKey & UnsetEdgeAttributes();
8887  SegmentKey & UnsetHiddenLineAttribute();
8888  SegmentKey & UnsetLightingAttributes();
8889  SegmentKey & UnsetLineAttributes();
8890  SegmentKey & UnsetMaterialMapping();
8891  SegmentKey & UnsetMarkerAttributes();
8892  SegmentKey & UnsetModellingMatrix();
8893  SegmentKey & UnsetNURBSSurfaceAttributes();
8894  SegmentKey & UnsetPerformance();
8895  SegmentKey & UnsetSelectability();
8896  SegmentKey & UnsetSphereAttributes();
8897  SegmentKey & UnsetSubwindow();
8898  SegmentKey & UnsetTextAttributes();
8899  SegmentKey & UnsetTextureMatrix();
8900  SegmentKey & UnsetTransformMask();
8901  SegmentKey & UnsetTransparency();
8902  SegmentKey & UnsetVisibility();
8903  SegmentKey & UnsetVisualEffects();
8904 
8906  void MoveTo(SegmentKey const & in_new_owner);
8907 
8909  Key CopyTo(SegmentKey const & in_destination) const;
8910 };
8911 
8912 
8913 
8916 class HPS_API KeyPath : public Object
8917 {
8918 public:
8919 
8921  KeyPath();
8922 
8925  KeyPath(KeyArray const & in_path);
8926 
8930  KeyPath(size_t in_path_count, Key const in_path []);
8931 
8933  KeyPath(KeyPath const & in_that);
8934 
8938  KeyPath(KeyPath && in_that);
8939 
8943  KeyPath & operator=(KeyPath && in_that);
8944 
8946  virtual ~KeyPath();
8947 
8948  HPS::Type ObjectType() const { return HPS::Type::KeyPath; }
8949 
8953  KeyPath & operator+=(Key const & in_key);
8954 
8958  KeyPath & operator+=(KeyPath const & in_key_path);
8959 
8963  KeyPath & operator+=(KeyArray const & in_key_array);
8964 
8968  KeyPath & Append(Key const & in_key);
8969 
8973  KeyPath & Append(KeyPath const & in_key_path);
8974 
8978  KeyPath & Append(KeyArray const & in_key_array);
8979 
8983  KeyPath & operator=(KeyPath const & in_that);
8984 
8988  KeyPath & operator=(KeyArray const & in_path);
8989 
8992  void Set(KeyPath const & in_that);
8993 
8997  bool Equals(KeyPath const & in_that) const;
8998 
9002  bool operator!= (KeyPath const & in_that) const;
9003 
9007  bool operator== (KeyPath const & in_that) const;
9008 
9009 
9013  KeyPath & SetKeys(KeyArray const & in_keys);
9014 
9019  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
9020 
9021 
9024  KeyPath & UnsetKeys();
9025 
9026 
9029  bool ShowKeys(KeyArray & out_keys) const;
9030 
9031 
9038  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9039 
9046  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
9047 
9053  bool ComputeTextExtent(const char* in_text, float & out_xfrac, float & out_yfrac) const;
9054 
9055 
9061  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
9062 
9063 
9066  bool ShowNetVisibility(VisibilityKit & out_kit) const;
9067 
9070  bool ShowNetBounding(BoundingKit & out_kit) const;
9071 
9074  bool ShowNetCamera(CameraKit & out_kit) const;
9075 
9078  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
9079 
9082  bool ShowNetContourLine(ContourLineKit & out_kit) const;
9083 
9086  bool ShowNetPerformance(PerformanceKit & out_kit) const;
9087 
9090  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9091 
9094  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9095 
9098  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9099 
9102  bool ShowNetMarkerAttributes(MarkerAttributeKit & out_kit) const;
9103 
9106  bool ShowNetSphereAttributes(SphereAttributeKit & out_kit) const;
9107 
9110  bool ShowNetLightingAttributes(LightingAttributeKit & out_kit) const;
9111 
9114  bool ShowNetCylinderAttributes(CylinderAttributeKit & out_kit) const;
9115 
9118  bool ShowNetCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
9119 
9122  bool ShowNetTextAttributes(TextAttributeKit & out_kit) const;
9123 
9126  bool ShowNetLineAttributes(LineAttributeKit & out_kit) const;
9127 
9130  bool ShowNetEdgeAttributes(EdgeAttributeKit & out_kit) const;
9131 
9134  bool ShowNetCurveAttributes(CurveAttributeKit & out_kit) const;
9135 
9138  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9139 
9142  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9143 
9146  bool ShowNetCulling(CullingKit & out_kit) const;
9147 
9150  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9151 
9154  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9155 
9158  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9159 
9162  bool ShowNetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
9163 
9166  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9167 
9170  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9171 
9174  bool ShowNetAttributeLocks(AttributeLockKit & out_kit) const;
9175 
9178  bool ShowNetConditions(UTF8Array & out_conditions) const;
9179 
9185  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9186 
9187 };
9188 
9189 
9194 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9195 {
9196  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9197 }
9198 
9203 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9204 {
9205  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9206 }
9207 
9212 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9213 {
9214  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9215 }
9216 
9221 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9222 {
9223  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9224 }
9225 
9230 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9231 {
9232  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9233 }
9234 
9239 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9240 {
9241  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9242 }
9243 
9248 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9249 {
9250  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9251 }
9252 
9257 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9258 {
9259  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9260 }
9261 
9266 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9267 {
9268  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9269 }
9270 
9271 
9275 
9277 class HPS_API BoundingKit : public Object
9278 {
9279 public:
9280 
9282  BoundingKit();
9283 
9286  BoundingKit(BoundingKit const & in_kit);
9287 
9291  BoundingKit(BoundingKit && in_that);
9292 
9296  BoundingKit & operator=(BoundingKit && in_that);
9297 
9299  virtual ~BoundingKit();
9300 
9301  HPS::Type ObjectType() const {return HPS::Type::BoundingKit;};
9302 
9306  static BoundingKit GetDefault();
9307 
9310  void Set(BoundingKit const & in_kit);
9311 
9314  void Show(BoundingKit & out_kit) const;
9315 
9319  BoundingKit & operator=(BoundingKit const & in_kit);
9320 
9323  bool Empty() const;
9324 
9328  bool Equals(BoundingKit const & in_kit) const;
9329 
9333  bool operator==(BoundingKit const & in_kit) const;
9334 
9338  bool operator!=(BoundingKit const & in_kit) const;
9339 
9340 
9344  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
9345 
9349  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
9350 
9354  BoundingKit & SetExclusion(bool in_exclude);
9355 
9356 
9359  BoundingKit & UnsetVolume();
9360 
9363  BoundingKit & UnsetExclusion();
9364 
9367  BoundingKit & UnsetEverything();
9368 
9369 
9374  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9375 
9379  bool ShowExclusion(bool & out_exclusion) const;
9380 
9381 };
9382 
9383 
9386 class HPS_API BoundingControl : public Control
9387 {
9388 public:
9389 
9391  explicit BoundingControl(SegmentKey & in_seg);
9392 
9394  BoundingControl(BoundingControl const & in_that);
9395 
9399  BoundingControl(BoundingControl && in_that);
9400 
9404  BoundingControl & operator=(BoundingControl && in_that);
9405 
9407  ~BoundingControl();
9408 
9409  HPS::Type ObjectType() const {return HPS::Type::BoundingControl;};
9410 
9412  BoundingControl & operator=(BoundingControl const & in_that);
9413 
9418  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
9419 
9423  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
9424 
9428  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
9429 
9433  BoundingControl & SetExclusion(bool in_exclusion);
9434 
9435 
9438  BoundingControl & UnsetVolume();
9439 
9442  BoundingControl & UnsetExclusion();
9443 
9446  BoundingControl & UnsetEverything();
9447 
9448 
9453  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9454 
9458  bool ShowExclusion(bool & out_exclusion) const;
9459 
9460 private:
9462  BoundingControl();
9463 };
9464 
9465 
9467 class HPS_API VisibilityKit : public Object
9468 {
9469 public:
9470 
9472  VisibilityKit();
9473 
9476  VisibilityKit(VisibilityKit const & in_kit);
9477 
9481  VisibilityKit(VisibilityKit && in_that);
9482 
9486  VisibilityKit & operator=(VisibilityKit && in_that);
9487 
9489  virtual ~VisibilityKit();
9490 
9491  HPS::Type ObjectType() const {return HPS::Type::VisibilityKit;};
9492 
9496  static VisibilityKit GetDefault();
9497 
9500  void Set(VisibilityKit const & in_kit);
9501 
9504  void Show(VisibilityKit & out_kit) const;
9505 
9509  VisibilityKit & operator=(VisibilityKit const & in_kit);
9510 
9513  bool Empty() const;
9514 
9518  bool Equals(VisibilityKit const & in_kit) const;
9519 
9523  bool operator==(VisibilityKit const & in_kit) const;
9524 
9528  bool operator!=(VisibilityKit const & in_kit) const;
9529 
9530 
9534  VisibilityKit & SetCuttingSections(bool in_state);
9535 
9539  VisibilityKit & SetCutEdges(bool in_state);
9540 
9544  VisibilityKit & SetCutFaces(bool in_state);
9545 
9549  VisibilityKit & SetWindows(bool in_state);
9550 
9554  VisibilityKit & SetText(bool in_state);
9555 
9559  VisibilityKit & SetLines(bool in_state);
9560 
9564  VisibilityKit & SetEdgeLights(bool in_state);
9565 
9569  VisibilityKit & SetMarkerLights(bool in_state);
9570 
9574  VisibilityKit & SetFaceLights(bool in_state);
9575 
9579  VisibilityKit & SetGenericEdges(bool in_state);
9580 
9584  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9585 
9592  VisibilityKit & SetAdjacentEdges(bool in_state);
9593 
9597  VisibilityKit & SetHardEdges(bool in_state);
9598 
9602  VisibilityKit & SetMeshQuadEdges(bool in_state);
9603 
9607  VisibilityKit & SetNonCulledEdges(bool in_state);
9608 
9612  VisibilityKit & SetPerimeterEdges(bool in_state);
9613 
9617  VisibilityKit & SetFaces(bool in_state);
9618 
9622  VisibilityKit & SetVertices(bool in_state);
9623 
9627  VisibilityKit & SetMarkers(bool in_state);
9628 
9632  VisibilityKit & SetShadowCasting(bool in_state);
9633 
9637  VisibilityKit & SetShadowReceiving(bool in_state);
9638 
9642  VisibilityKit & SetShadowEmitting(bool in_state);
9643 
9644 
9648  VisibilityKit & SetCutGeometry(bool in_state);
9649 
9653  VisibilityKit & SetEdges(bool in_state);
9654 
9658  VisibilityKit & SetGeometry(bool in_state);
9659 
9663  VisibilityKit & SetLights(bool in_state);
9664 
9668  VisibilityKit & SetShadows(bool in_state);
9669 
9673  VisibilityKit & SetEverything(bool in_state);
9674 
9675 
9678  VisibilityKit & UnsetCuttingSections();
9679 
9682  VisibilityKit & UnsetCutEdges();
9683 
9686  VisibilityKit & UnsetCutFaces();
9687 
9690  VisibilityKit & UnsetWindows();
9691 
9694  VisibilityKit & UnsetText();
9695 
9698  VisibilityKit & UnsetLines();
9699 
9702  VisibilityKit & UnsetEdgeLights();
9703 
9706  VisibilityKit & UnsetMarkerLights();
9707 
9710  VisibilityKit & UnsetFaceLights();
9711 
9714  VisibilityKit & UnsetGenericEdges();
9715 
9718  VisibilityKit & UnsetInteriorSilhouetteEdges();
9719 
9722  VisibilityKit & UnsetAdjacentEdges();
9723 
9726  VisibilityKit & UnsetHardEdges();
9727 
9730  VisibilityKit & UnsetMeshQuadEdges();
9731 
9734  VisibilityKit & UnsetNonCulledEdges();
9735 
9738  VisibilityKit & UnsetPerimeterEdges();
9739 
9742  VisibilityKit & UnsetFaces();
9743 
9746  VisibilityKit & UnsetVertices();
9747 
9750  VisibilityKit & UnsetMarkers();
9751 
9754  VisibilityKit & UnsetShadowCasting();
9755 
9758  VisibilityKit & UnsetShadowReceiving();
9759 
9762  VisibilityKit & UnsetShadowEmitting();
9763 
9764 
9767  VisibilityKit & UnsetCutGeometry();
9768 
9771  VisibilityKit & UnsetEdges();
9772 
9775  VisibilityKit & UnsetGeometry();
9776 
9779  VisibilityKit & UnsetLights();
9780 
9783  VisibilityKit & UnsetShadows();
9784 
9787  VisibilityKit & UnsetEverything();
9788 
9789 
9793  bool ShowCuttingSections(bool & out_state) const;
9794 
9798  bool ShowCutEdges(bool & out_state) const;
9799 
9803  bool ShowCutFaces(bool & out_state) const;
9804 
9808  bool ShowWindows(bool & out_state) const;
9809 
9813  bool ShowText(bool & out_state) const;
9814 
9818  bool ShowLines(bool & out_state) const;
9819 
9823  bool ShowEdgeLights(bool & out_state) const;
9824 
9828  bool ShowMarkerLights(bool & out_state) const;
9829 
9833  bool ShowFaceLights(bool & out_state) const;
9834 
9838  bool ShowGenericEdges(bool & out_state) const;
9839 
9843  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9844 
9848  bool ShowAdjacentEdges(bool & out_state) const;
9849 
9853  bool ShowHardEdges(bool & out_state) const;
9854 
9858  bool ShowMeshQuadEdges(bool & out_state) const;
9859 
9863  bool ShowNonCulledEdges(bool & out_state) const;
9864 
9868  bool ShowPerimeterEdges(bool & out_state) const;
9869 
9873  bool ShowFaces(bool & out_state) const;
9874 
9878  bool ShowVertices(bool & out_state) const;
9879 
9883  bool ShowMarkers(bool & out_state) const;
9884 
9888  bool ShowShadowCasting(bool & out_state) const;
9889 
9893  bool ShowShadowReceiving(bool & out_state) const;
9894 
9898  bool ShowShadowEmitting(bool & out_state) const;
9899 };
9900 
9901 
9907 class HPS_API VisibilityControl : public Control
9908 {
9909 public:
9910 
9912  explicit VisibilityControl(SegmentKey & in_seg);
9913 
9915  VisibilityControl(VisibilityControl const & in_that);
9916 
9921 
9925  VisibilityControl & operator=(VisibilityControl && in_that);
9926 
9928  ~VisibilityControl();
9929 
9930  HPS::Type ObjectType() const {return HPS::Type::VisibilityControl;};
9931 
9933  VisibilityControl & operator=(VisibilityControl const & in_that);
9934 
9935 
9939  VisibilityControl & SetCuttingSections(bool in_state);
9940 
9944  VisibilityControl & SetCutEdges(bool in_state);
9945 
9949  VisibilityControl & SetCutFaces(bool in_state);
9950 
9954  VisibilityControl & SetWindows(bool in_state);
9955 
9959  VisibilityControl & SetText(bool in_state);
9960 
9964  VisibilityControl & SetLines(bool in_state);
9965 
9969  VisibilityControl & SetEdgeLights(bool in_state);
9970 
9974  VisibilityControl & SetMarkerLights(bool in_state);
9975 
9979  VisibilityControl & SetFaceLights(bool in_state);
9980 
9984  VisibilityControl & SetGenericEdges(bool in_state);
9985 
9989  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
9990 
9994  VisibilityControl & SetAdjacentEdges(bool in_state);
9995 
9999  VisibilityControl & SetHardEdges(bool in_state);
10000 
10004  VisibilityControl & SetMeshQuadEdges(bool in_state);
10005 
10009  VisibilityControl & SetNonCulledEdges(bool in_state);
10010 
10014  VisibilityControl & SetPerimeterEdges(bool in_state);
10015 
10019  VisibilityControl & SetFaces(bool in_state);
10020 
10024  VisibilityControl & SetVertices(bool in_state);
10025 
10029  VisibilityControl & SetMarkers(bool in_state);
10030 
10034  VisibilityControl & SetShadowCasting(bool in_state);
10035 
10039  VisibilityControl & SetShadowReceiving(bool in_state);
10040 
10044  VisibilityControl & SetShadowEmitting(bool in_state);
10045 
10046 
10050  VisibilityControl & SetCutGeometry(bool in_state);
10051 
10055  VisibilityControl & SetEdges(bool in_state);
10056 
10060  VisibilityControl & SetGeometry(bool in_state);
10061 
10065  VisibilityControl & SetLights(bool in_state);
10066 
10070  VisibilityControl & SetShadows(bool in_state);
10071 
10075  VisibilityControl & SetEverything(bool in_state);
10076 
10077 
10080  VisibilityControl & UnsetCuttingSections();
10081 
10084  VisibilityControl & UnsetCutEdges();
10085 
10088  VisibilityControl & UnsetCutFaces();
10089 
10092  VisibilityControl & UnsetWindows();
10093 
10096  VisibilityControl & UnsetText();
10097 
10100  VisibilityControl & UnsetLines();
10101 
10104  VisibilityControl & UnsetEdgeLights();
10105 
10108  VisibilityControl & UnsetMarkerLights();
10109 
10112  VisibilityControl & UnsetFaceLights();
10113 
10116  VisibilityControl & UnsetGenericEdges();
10117 
10120  VisibilityControl & UnsetInteriorSilhouetteEdges();
10121 
10124  VisibilityControl & UnsetAdjacentEdges();
10125 
10128  VisibilityControl & UnsetHardEdges();
10129 
10132  VisibilityControl & UnsetMeshQuadEdges();
10133 
10136  VisibilityControl & UnsetNonCulledEdges();
10137 
10140  VisibilityControl & UnsetPerimeterEdges();
10141 
10144  VisibilityControl & UnsetFaces();
10145 
10148  VisibilityControl & UnsetVertices();
10149 
10152  VisibilityControl & UnsetMarkers();
10153 
10156  VisibilityControl & UnsetShadowCasting();
10157 
10160  VisibilityControl & UnsetShadowReceiving();
10161 
10164  VisibilityControl & UnsetShadowEmitting();
10165 
10166 
10169  VisibilityControl & UnsetCutGeometry();
10170 
10173  VisibilityControl & UnsetEdges();
10174 
10177  VisibilityControl & UnsetGeometry();
10178 
10181  VisibilityControl & UnsetLights();
10182 
10185  VisibilityControl & UnsetShadows();
10186 
10189  VisibilityControl & UnsetEverything();
10190 
10191 
10195  bool ShowCuttingSections(bool & out_state) const;
10196 
10200  bool ShowCutEdges(bool & out_state) const;
10201 
10205  bool ShowCutFaces(bool & out_state) const;
10206 
10210  bool ShowWindows(bool & out_state) const;
10211 
10215  bool ShowText(bool & out_state) const;
10216 
10220  bool ShowLines(bool & out_state) const;
10221 
10225  bool ShowEdgeLights(bool & out_state) const;
10226 
10230  bool ShowMarkerLights(bool & out_state) const;
10231 
10235  bool ShowFaceLights(bool & out_state) const;
10236 
10240  bool ShowGenericEdges(bool & out_state) const;
10241 
10245  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10246 
10250  bool ShowAdjacentEdges(bool & out_state) const;
10251 
10255  bool ShowHardEdges(bool & out_state) const;
10256 
10260  bool ShowMeshQuadEdges(bool & out_state) const;
10261 
10265  bool ShowNonCulledEdges(bool & out_state) const;
10266 
10270  bool ShowPerimeterEdges(bool & out_state) const;
10271 
10275  bool ShowFaces(bool & out_state) const;
10276 
10280  bool ShowVertices(bool & out_state) const;
10281 
10285  bool ShowMarkers(bool & out_state) const;
10286 
10290  bool ShowShadowCasting(bool & out_state) const;
10291 
10295  bool ShowShadowReceiving(bool & out_state) const;
10296 
10300  bool ShowShadowEmitting(bool & out_state) const;
10301 
10302 private:
10305 };
10306 
10307 
10308 
10311 class HPS_API CameraKit : public Object
10312 {
10313 public:
10314 
10316  CameraKit();
10317 
10320  CameraKit(const CameraKit & in_kit);
10321 
10325  CameraKit(CameraKit && in_that);
10326 
10330  CameraKit & operator=(CameraKit && in_that);
10331 
10333  virtual ~CameraKit();
10334 
10335  HPS::Type ObjectType() const {return HPS::Type::CameraKit;};
10336 
10340  static CameraKit GetDefault();
10341 
10344  void Set(CameraKit const & in_kit);
10345 
10348  void Show(CameraKit & out_kit) const;
10349 
10353  CameraKit & operator=(CameraKit const & in_kit);
10354 
10357  bool Empty() const;
10358 
10362  bool Equals(CameraKit const & in_kit) const;
10363 
10367  bool operator==(CameraKit const & in_kit) const;
10368 
10372  bool operator!=(CameraKit const & in_kit) const;
10373 
10377  CameraKit & SetUpVector(Vector const & in_up);
10378 
10382  CameraKit & SetPosition(Point const & in_position);
10383 
10387  CameraKit & SetTarget(Point const & in_target);
10388 
10395  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
10396 
10402  CameraKit & SetField(float in_width, float in_height);
10403 
10413  CameraKit & SetNearLimit(float const in_limit);
10414 
10417  CameraKit & UnsetUpVector();
10418 
10421  CameraKit & UnsetPosition();
10422 
10425  CameraKit & UnsetTarget();
10426 
10429  CameraKit & UnsetProjection();
10430 
10433  CameraKit & UnsetField();
10434 
10437  CameraKit & UnsetNearLimit();
10438 
10441  CameraKit & UnsetEverything();
10442 
10443 
10447  bool ShowUpVector(Vector & out_up_vector) const;
10448 
10452  bool ShowPosition(Point & out_position) const;
10453 
10457  bool ShowTarget(Point & out_target) const;
10458 
10462  bool ShowProjection(Camera::Projection & out_type) const;
10463 
10469  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
10470 
10474  bool ShowWidth(float & out_width) const;
10475 
10479  bool ShowHeight(float & out_height) const;
10480 
10485  bool ShowField(float & out_width, float & out_height) const;
10486 
10490  bool ShowNearLimit(float & out_near_limit) const;
10491 
10498  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
10499 
10506  CameraKit & Orbit(float in_theta, float in_phi);
10507 
10514  CameraKit & Pan(float in_theta, float in_phi);
10515 
10521  CameraKit & Roll(float in_theta);
10522 
10528  CameraKit & Zoom(float in_zoom);
10529 };
10530 
10534 class HPS_API CameraControl : public Control
10535 {
10536 public:
10538  explicit CameraControl(SegmentKey & in_seg);
10539 
10541  CameraControl(CameraControl const & in_that);
10542 
10546  CameraControl(CameraControl && in_that);
10547 
10551  CameraControl & operator=(CameraControl && in_that);
10552 
10554  ~CameraControl();
10555 
10556  HPS::Type ObjectType() const {return HPS::Type::CameraControl;};
10557 
10559  CameraControl & operator=(CameraControl const & in_that);
10560 
10561 
10566  CameraControl & SetUpVector(Vector const & in_up);
10567 
10572  CameraControl & SetPosition(Point const & in_position);
10573 
10578  CameraControl & SetTarget(Point const & in_target);
10579 
10586  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10587 
10593  CameraControl & SetField(float in_width, float in_height);
10594 
10605  CameraControl & SetNearLimit(float in_double);
10606 
10610  CameraControl & UnsetEverything();
10611 
10612 
10616  bool ShowUpVector(Vector & out_up_vector) const;
10617 
10621  bool ShowPosition(Point & out_position) const;
10622 
10626  bool ShowTarget(Point & out_target) const;
10627 
10631  bool ShowProjection(Camera::Projection & out_type) const;
10632 
10638  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10639 
10643  bool ShowWidth(float & out_width) const;
10644 
10648  bool ShowHeight(float & out_height) const;
10649 
10654  bool ShowField(float & out_width, float & out_height) const;
10655 
10659  bool ShowNearLimit(float & out_width) const;
10660 
10667  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10668 
10675  CameraControl & Orbit(float in_theta, float in_phi);
10676 
10683  CameraControl & Pan(float in_theta, float in_phi);
10684 
10690  CameraControl & Roll(float in_theta);
10691 
10697  CameraControl & Zoom(float in_zoom);
10698 
10699 private:
10701  CameraControl();
10702 };
10703 
10704 
10705 
10707 class HPS_API SelectabilityKit : public Object
10708 {
10709 public:
10710 
10712  SelectabilityKit();
10713 
10716  SelectabilityKit(SelectabilityKit const & in_kit);
10717 
10721  SelectabilityKit(SelectabilityKit && in_that);
10722 
10726  SelectabilityKit & operator=(SelectabilityKit && in_that);
10727 
10729  virtual ~SelectabilityKit();
10730 
10731  HPS::Type ObjectType() const {return HPS::Type::SelectabilityKit;};
10732 
10736  static SelectabilityKit GetDefault();
10737 
10740  void Set(SelectabilityKit const & in_kit);
10741 
10744  void Show(SelectabilityKit & out_kit) const;
10745 
10749  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10750 
10753  bool Empty() const;
10754 
10758  bool Equals(SelectabilityKit const & in_kit) const;
10759 
10763  bool operator==(SelectabilityKit const & in_kit) const;
10764 
10768  bool operator!=(SelectabilityKit const & in_kit) const;
10769 
10770 
10774  SelectabilityKit & SetWindows(Selectability::Value in_val);
10775 
10779  SelectabilityKit & SetEdges(Selectability::Value in_val);
10780 
10784  SelectabilityKit & SetFaces(Selectability::Value in_val);
10785 
10789  SelectabilityKit & SetLights(Selectability::Value in_val);
10790 
10794  SelectabilityKit & SetLines(Selectability::Value in_val);
10795 
10799  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10800 
10804  SelectabilityKit & SetVertices(Selectability::Value in_val);
10805 
10809  SelectabilityKit & SetText(Selectability::Value in_val);
10810 
10814  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10815 
10819  SelectabilityKit & SetEverything(Selectability::Value in_val);
10820 
10821 
10824  SelectabilityKit & UnsetWindows();
10825 
10828  SelectabilityKit & UnsetEdges();
10829 
10832  SelectabilityKit & UnsetFaces();
10833 
10836  SelectabilityKit & UnsetLights();
10837 
10840  SelectabilityKit & UnsetLines();
10841 
10844  SelectabilityKit & UnsetMarkers();
10845 
10848  SelectabilityKit & UnsetVertices();
10849 
10852  SelectabilityKit & UnsetText();
10853 
10856  SelectabilityKit & UnsetGeometry();
10857 
10860  SelectabilityKit & UnsetEverything();
10861 
10862 
10866  bool ShowWindows(Selectability::Value & out_val) const;
10867 
10871  bool ShowEdges(Selectability::Value & out_val) const;
10872 
10876  bool ShowFaces(Selectability::Value & out_val) const;
10877 
10881  bool ShowLights(Selectability::Value & out_val) const;
10882 
10886  bool ShowLines(Selectability::Value & out_val) const;
10887 
10891  bool ShowMarkers(Selectability::Value & out_val) const;
10892 
10896  bool ShowVertices(Selectability::Value & out_val) const;
10897 
10901  bool ShowText(Selectability::Value & out_val) const;
10902 };
10903 
10909 class HPS_API SelectabilityControl : public Control
10910 {
10911 public:
10912 
10914  explicit SelectabilityControl(SegmentKey & in_seg);
10915 
10917  SelectabilityControl(SelectabilityControl const & in_that);
10918 
10923 
10927  SelectabilityControl & operator=(SelectabilityControl && in_that);
10928 
10931 
10932  HPS::Type ObjectType() const {return HPS::Type::SelectabilityControl;};
10933 
10935  SelectabilityControl & operator=(SelectabilityControl const & in_that);
10936 
10937 
10941  SelectabilityControl & SetWindows(Selectability::Value in_val);
10942 
10946  SelectabilityControl & SetEdges(Selectability::Value in_val);
10947 
10951  SelectabilityControl & SetFaces(Selectability::Value in_val);
10952 
10956  SelectabilityControl & SetLights(Selectability::Value in_val);
10957 
10961  SelectabilityControl & SetLines(Selectability::Value in_val);
10962 
10966  SelectabilityControl & SetMarkers(Selectability::Value in_val);
10967 
10971  SelectabilityControl & SetVertices(Selectability::Value in_val);
10972 
10976  SelectabilityControl & SetText(Selectability::Value in_val);
10977 
10981  SelectabilityControl & SetGeometry(Selectability::Value in_val);
10982 
10986  SelectabilityControl & SetEverything(Selectability::Value in_val);
10987 
10988 
10991  SelectabilityControl & UnsetWindows();
10992 
10995  SelectabilityControl & UnsetEdges();
10996 
10999  SelectabilityControl & UnsetFaces();
11000 
11003  SelectabilityControl & UnsetLights();
11004 
11007  SelectabilityControl & UnsetLines();
11008 
11011  SelectabilityControl & UnsetMarkers();
11012 
11015  SelectabilityControl & UnsetVertices();
11016 
11019  SelectabilityControl & UnsetText();
11020 
11023  SelectabilityControl & UnsetGeometry();
11024 
11027  SelectabilityControl & UnsetEverything();
11028 
11029 
11033  bool ShowWindows(Selectability::Value & out_val) const;
11034 
11038  bool ShowEdges(Selectability::Value & out_val) const;
11039 
11043  bool ShowFaces(Selectability::Value & out_val) const;
11044 
11048  bool ShowLights(Selectability::Value & out_val) const;
11049 
11053  bool ShowLines(Selectability::Value & out_val) const;
11054 
11058  bool ShowMarkers(Selectability::Value & out_val) const;
11059 
11063  bool ShowVertices(Selectability::Value & out_val) const;
11064 
11068  bool ShowText(Selectability::Value & out_val) const;
11069 
11070 private:
11073 };
11074 
11075 
11077 class HPS_API TransparencyKit : public Object
11078 {
11079 public:
11080 
11082  TransparencyKit();
11083 
11086  TransparencyKit(TransparencyKit const & in_kit);
11087 
11091  TransparencyKit(TransparencyKit && in_that);
11092 
11096  TransparencyKit & operator=(TransparencyKit && in_that);
11097 
11099  virtual ~TransparencyKit();
11100 
11101  HPS::Type ObjectType() const {return HPS::Type::TransparencyKit;};
11102 
11106  static TransparencyKit GetDefault();
11107 
11110  void Set(TransparencyKit const & in_kit);
11111 
11114  void Show(TransparencyKit & out_kit) const;
11115 
11119  TransparencyKit & operator=(TransparencyKit const & in_kit);
11120 
11123  bool Empty() const;
11124 
11128  bool Equals(TransparencyKit const & in_kit) const;
11129 
11133  bool operator==(TransparencyKit const & in_kit) const;
11134 
11138  bool operator!=(TransparencyKit const & in_kit) const;
11139 
11140 
11144  TransparencyKit & SetMethod(Transparency::Method in_style);
11145 
11149  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
11150 
11155  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
11156 
11162  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11163 
11168  TransparencyKit & SetDepthWriting(bool in_state);
11169 
11170 
11173  TransparencyKit & UnsetMethod();
11174 
11177  TransparencyKit & UnsetAlgorithm();
11178 
11181  TransparencyKit & UnsetDepthPeelingLayers();
11182 
11185  TransparencyKit & UnsetDepthPeelingMinimumArea();
11186 
11189  TransparencyKit & UnsetDepthWriting();
11190 
11193  TransparencyKit & UnsetEverything();
11194 
11195 
11199  bool ShowMethod(Transparency::Method & out_style) const;
11200 
11204  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11205 
11209  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11210 
11215  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11216 
11220  bool ShowDepthWriting(bool & out_state) const;
11221 };
11222 
11228 class HPS_API TransparencyControl : public Control
11229 {
11230 public:
11231 
11233  explicit TransparencyControl(SegmentKey & in_seg);
11234 
11236  TransparencyControl(TransparencyControl const & in_that);
11237 
11242 
11246  TransparencyControl & operator=(TransparencyControl && in_that);
11247 
11250 
11251  HPS::Type ObjectType() const {return HPS::Type::TransparencyControl;};
11252 
11254  TransparencyControl & operator=(TransparencyControl const & in_that);
11255 
11259  TransparencyControl & SetMethod(Transparency::Method in_style);
11260 
11264  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
11265 
11270  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
11271 
11277  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11278 
11283  TransparencyControl & SetDepthWriting(bool in_state);
11284 
11285 
11288  TransparencyControl & UnsetMethod();
11289 
11292  TransparencyControl & UnsetAlgorithm();
11293 
11296  TransparencyControl & UnsetDepthPeelingLayers();
11297 
11300  TransparencyControl & UnsetDepthPeelingMinimumArea();
11301 
11304  TransparencyControl & UnsetDepthWriting();
11305 
11308  TransparencyControl & UnsetEverything();
11309 
11310 
11314  bool ShowMethod(Transparency::Method & out_style) const;
11315 
11319  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11320 
11324  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11325 
11330  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11331 
11335  bool ShowDepthWriting(bool & out_state) const;
11336 
11337 private:
11340 };
11341 
11343 class HPS_API ColorInterpolationKit : public Object
11344 {
11345 public:
11346 
11349 
11352 
11357 
11361  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
11362 
11364  virtual ~ColorInterpolationKit();
11365 
11366  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationKit;};
11367 
11368  static ColorInterpolationKit GetDefault();
11369 
11371  void Set(ColorInterpolationKit const & in_kit);
11372 
11374  void Show(ColorInterpolationKit & out_kit) const;
11375 
11377  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
11378 
11380  bool Empty() const;
11381 
11383  bool Equals(ColorInterpolationKit const & in_kit) const;
11384 
11386  bool operator==(ColorInterpolationKit const & in_kit) const;
11387 
11389  bool operator!=(ColorInterpolationKit const & in_kit) const;
11390 
11391 
11395  ColorInterpolationKit & SetFaceColor(bool in_state);
11396 
11400  ColorInterpolationKit & SetEdgeColor(bool in_state);
11401 
11405  ColorInterpolationKit & SetVertexColor(bool in_state);
11406 
11410  ColorInterpolationKit & SetFaceIndex(bool in_state);
11411 
11415  ColorInterpolationKit & SetEdgeIndex(bool in_state);
11416 
11420  ColorInterpolationKit & SetVertexIndex(bool in_state);
11421 
11422 
11425  ColorInterpolationKit & UnsetFaceColor();
11426 
11429  ColorInterpolationKit & UnsetEdgeColor();
11430 
11433  ColorInterpolationKit & UnsetVertexColor();
11434 
11437  ColorInterpolationKit & UnsetFaceIndex();
11438 
11441  ColorInterpolationKit & UnsetEdgeIndex();
11442 
11445  ColorInterpolationKit & UnsetVertexIndex();
11446 
11449  ColorInterpolationKit & UnsetEverything();
11450 
11451 
11455  bool ShowFaceColor(bool & out_state) const;
11456 
11460  bool ShowEdgeColor(bool & out_state) const;
11461 
11465  bool ShowVertexColor(bool & out_state) const;
11466 
11470  bool ShowFaceIndex(bool & out_state) const;
11471 
11475  bool ShowEdgeIndex(bool & out_state) const;
11476 
11480  bool ShowVertexIndex(bool & out_state) const;
11481 };
11482 
11483 
11487 class HPS_API ColorInterpolationControl : public Control
11488 {
11489 public:
11490 
11492  explicit ColorInterpolationControl(SegmentKey & in_seg);
11493 
11496 
11501 
11505  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11506 
11509 
11510  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationControl;};
11511 
11512 
11516  ColorInterpolationControl & SetFaceColor(bool in_state);
11517 
11521  ColorInterpolationControl & SetEdgeColor(bool in_state);
11522 
11526  ColorInterpolationControl & SetVertexColor(bool in_state);
11527 
11531  ColorInterpolationControl & SetFaceIndex(bool in_state);
11532 
11536  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11537 
11541  ColorInterpolationControl & SetVertexIndex(bool in_state);
11542 
11543 
11546  ColorInterpolationControl & UnsetFaceColor();
11547 
11550  ColorInterpolationControl & UnsetEdgeColor();
11551 
11554  ColorInterpolationControl & UnsetVertexColor();
11555 
11558  ColorInterpolationControl & UnsetFaceIndex();
11559 
11562  ColorInterpolationControl & UnsetEdgeIndex();
11563 
11566  ColorInterpolationControl & UnsetVertexIndex();
11567 
11570  ColorInterpolationControl & UnsetEverything();
11571 
11572 
11576  bool ShowFaceColor(bool & out_state) const;
11577 
11581  bool ShowEdgeColor(bool & out_state) const;
11582 
11586  bool ShowVertexColor(bool & out_state) const;
11587 
11591  bool ShowFaceIndex(bool & out_state) const;
11592 
11596  bool ShowEdgeIndex(bool & out_state) const;
11597 
11601  bool ShowVertexIndex(bool & out_state) const;
11602 
11603 private:
11606 };
11607 
11608 
11610 class HPS_API CullingKit : public Object
11611 {
11612 public:
11613 
11615  CullingKit();
11616 
11619  CullingKit(CullingKit const & in_kit);
11620 
11624  CullingKit(CullingKit && in_that);
11625 
11629  CullingKit & operator=(CullingKit && in_that);
11630 
11632  virtual ~CullingKit();
11633 
11634  HPS::Type ObjectType() const {return HPS::Type::CullingKit;};
11635 
11639  static CullingKit GetDefault();
11640 
11643  void Set(CullingKit const & in_kit);
11644 
11647  void Show(CullingKit & out_kit) const;
11648 
11652  CullingKit & operator=(CullingKit const & in_kit);
11653 
11656  bool Empty() const;
11657 
11661  bool Equals(CullingKit const & in_kit) const;
11662 
11666  bool operator==(CullingKit const & in_kit) const;
11667 
11671  bool operator!=(CullingKit const & in_kit) const;
11672 
11677  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11678 
11683  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11684 
11689  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11690 
11695  CullingKit & SetExtent(unsigned int in_pixels);
11696 
11700  CullingKit & SetBackFace(bool in_state);
11701 
11708  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11709 
11716  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11717 
11724  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11725 
11731  CullingKit & SetVector(HPS::Vector const & in_vector);
11732 
11736  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11737 
11741  CullingKit & SetFrustum(bool in_state);
11742 
11745  CullingKit & UnsetDeferralExtent();
11746 
11749  CullingKit & UnsetExtent();
11750 
11753  CullingKit & UnsetBackFace();
11754 
11757  CullingKit & UnsetVector();
11758 
11761  CullingKit & UnsetVectorTolerance();
11762 
11765  CullingKit & UnsetFrustum();
11766 
11769  CullingKit & UnsetEverything();
11770 
11775  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11776 
11781  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11782 
11786  bool ShowBackFace(bool & out_state) const;
11787 
11793  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11794 
11798  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11799 
11803  bool ShowFrustum(bool & out_state) const;
11804 };
11805 
11809 class HPS_API CullingControl : public Control
11810 {
11811 public:
11812 
11814  explicit CullingControl(SegmentKey & in_seg);
11815 
11817  CullingControl(CullingControl const & in_that);
11818 
11820  ~CullingControl();
11821 
11825  CullingControl(CullingControl && in_that);
11826 
11830  CullingControl & operator=(CullingControl && in_that);
11831 
11832  HPS::Type ObjectType() const {return HPS::Type::CullingControl;};
11833 
11835  CullingControl & operator=(CullingControl const & in_that);
11836 
11843  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11844 
11851  CullingControl & SetDeferralExtent(unsigned int in_pixels);
11852 
11857  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
11858 
11863  CullingControl & SetExtent(unsigned int in_pixels);
11864 
11869  CullingControl & SetBackFace(bool in_state);
11870 
11877  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11878 
11885  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11886 
11893  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11894 
11900  CullingControl & SetVector(HPS::Vector const & in_vector);
11901 
11905  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
11906 
11910  CullingControl & SetFrustum(bool in_state);
11911 
11914  CullingControl & UnsetDeferralExtent();
11915 
11918  CullingControl & UnsetExtent();
11919 
11922  CullingControl & UnsetBackFace();
11923 
11926  CullingControl & UnsetVector();
11927 
11930  CullingControl & UnsetVectorTolerance();
11931 
11934  CullingControl & UnsetFrustum();
11935 
11938  CullingControl & UnsetEverything();
11939 
11944  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11945 
11950  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11951 
11955  bool ShowBackFace(bool & out_state) const;
11956 
11962  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11963 
11967  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11968 
11972  bool ShowFrustum(bool & out_state) const;
11973 
11974 private:
11976  CullingControl();
11977 };
11978 
11979 
11980 
11981 
11983 class HPS_API MarkerAttributeKit : public Object
11984 {
11985 public:
11986 
11989 
11992  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
11993 
11998 
12002  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
12003 
12005  virtual ~MarkerAttributeKit();
12006 
12007  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeKit;};
12008 
12012  static MarkerAttributeKit GetDefault();
12013 
12016  void Set(MarkerAttributeKit const & in_kit);
12017 
12020  void Show(MarkerAttributeKit & out_kit) const;
12021 
12025  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
12026 
12029  bool Empty() const;
12030 
12034  bool Equals(MarkerAttributeKit const & in_kit) const;
12035 
12039  bool operator==(MarkerAttributeKit const & in_kit) const;
12040 
12044  bool operator!=(MarkerAttributeKit const & in_kit) const;
12045 
12046 
12050  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
12051 
12056  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12057 
12058 
12061  MarkerAttributeKit & UnsetSymbol();
12062 
12065  MarkerAttributeKit & UnsetSize();
12066 
12069  MarkerAttributeKit & UnsetEverything();
12070 
12071 
12075  bool ShowSymbol(UTF8 & out_glyph_name) const;
12076 
12081  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12082 };
12083 
12089 class HPS_API MarkerAttributeControl : public Control
12090 {
12091 public:
12092 
12094  explicit MarkerAttributeControl(SegmentKey & in_seg);
12095 
12098 
12103 
12107  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
12108 
12111 
12112  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeControl;};
12113 
12115  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
12116 
12120  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
12121 
12126  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12127 
12128 
12131  MarkerAttributeControl & UnsetSymbol();
12132 
12135  MarkerAttributeControl & UnsetSize();
12136 
12139  MarkerAttributeControl & UnsetEverything();
12140 
12141 
12145  bool ShowSymbol(UTF8 & out_glyph_name) const;
12146 
12151  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12152 
12153 private:
12156 };
12157 
12158 
12160 class HPS_API SphereAttributeKit : public Object
12161 {
12162 public:
12163 
12166 
12169  SphereAttributeKit(SphereAttributeKit const & in_kit);
12170 
12175 
12179  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
12180 
12182  virtual ~SphereAttributeKit();
12183 
12184  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeKit;};
12185 
12189  static SphereAttributeKit GetDefault();
12190 
12193  void Set(SphereAttributeKit const & in_kit);
12194 
12197  void Show(SphereAttributeKit & out_kit) const;
12198 
12202  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
12203 
12206  bool Empty() const;
12207 
12211  bool Equals(SphereAttributeKit const & in_kit) const;
12212 
12216  bool operator==(SphereAttributeKit const & in_kit) const;
12217 
12221  bool operator!=(SphereAttributeKit const & in_kit) const;
12222 
12223 
12227  SphereAttributeKit & SetTessellation(size_t in_facets);
12228 
12229 
12232  SphereAttributeKit & UnsetTessellation();
12233 
12236  SphereAttributeKit & UnsetEverything();
12237 
12238 
12242  bool ShowTessellation(size_t & out_facets) const;
12243 };
12244 
12245 
12248 class HPS_API SphereAttributeControl : public Control
12249 {
12250 public:
12251 
12253  explicit SphereAttributeControl(SegmentKey const & in_seg);
12254 
12257 
12262 
12266  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
12267 
12270 
12271  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeControl;};
12272 
12274  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
12275 
12276 
12281  SphereAttributeControl & SetTessellation(size_t in_facets);
12282 
12283 
12286  SphereAttributeControl & UnsetTessellation();
12287 
12290  SphereAttributeControl & UnsetEverything();
12291 
12292 
12296  bool ShowTessellation(size_t & out_facets) const;
12297 
12298 private:
12301 };
12302 
12303 
12305 class HPS_API LightingAttributeKit : public Object
12306 {
12307 public:
12308 
12311 
12315 
12320 
12324  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
12325 
12327  virtual ~LightingAttributeKit();
12328 
12329  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeKit;};
12330 
12334  static LightingAttributeKit GetDefault();
12335 
12338  void Set(LightingAttributeKit const & in_kit);
12339 
12342  void Show(LightingAttributeKit & out_kit) const;
12343 
12347  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
12348 
12351  bool Empty() const;
12352 
12356  bool Equals(LightingAttributeKit const & in_kit) const;
12357 
12361  bool operator==(LightingAttributeKit const & in_kit) const;
12362 
12366  bool operator!=(LightingAttributeKit const & in_kit) const;
12367 
12368 
12372  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12373 
12374 
12377  LightingAttributeKit & UnsetInterpolationAlgorithm();
12378 
12381  LightingAttributeKit & UnsetEverything();
12382 
12383 
12387  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12388 };
12389 
12390 
12391 
12397 class HPS_API LightingAttributeControl : public Control
12398 {
12399 public:
12400 
12402  explicit LightingAttributeControl(SegmentKey & in_seg);
12403 
12406 
12411 
12415  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
12416 
12419 
12420  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeControl;};
12421 
12423  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
12424 
12425 
12429  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12430 
12431 
12434  LightingAttributeControl & UnsetInterpolationAlgorithm();
12435 
12438  LightingAttributeControl & UnsetEverything();
12439 
12440 
12444  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12445 
12446 private:
12449 };
12450 
12451 
12452 
12454 class HPS_API CylinderAttributeKit : public Object
12455 {
12456 public:
12457 
12460 
12464 
12469 
12473  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
12474 
12476  virtual ~CylinderAttributeKit();
12477 
12478  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeKit;};
12479 
12483  static CylinderAttributeKit GetDefault();
12484 
12487  void Set(CylinderAttributeKit const & in_kit);
12488 
12491  void Show(CylinderAttributeKit & out_kit) const;
12492 
12496  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
12497 
12500  bool Empty() const;
12501 
12505  bool Equals(CylinderAttributeKit const & in_kit) const;
12506 
12510  bool operator==(CylinderAttributeKit const & in_kit) const;
12511 
12515  bool operator!=(CylinderAttributeKit const & in_kit) const;
12516 
12517 
12521  CylinderAttributeKit & SetTessellation(size_t in_facets);
12522 
12527  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12528 
12529 
12532  CylinderAttributeKit & UnsetTessellation();
12533 
12536  CylinderAttributeKit & UnsetOrientation();
12537 
12540  CylinderAttributeKit & UnsetEverything();
12541 
12542 
12546  bool ShowTessellation(size_t & out_facets) const;
12547 
12551  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12552 };
12553 
12554 
12555 
12559 class HPS_API CylinderAttributeControl : public Control
12560 {
12561 public:
12562 
12564  explicit CylinderAttributeControl(SegmentKey & in_seg);
12565 
12568 
12573 
12577  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12578 
12581 
12582  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeControl;};
12583 
12585  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12586 
12587 
12591  CylinderAttributeControl & SetTessellation(size_t in_facets);
12592 
12597  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12598 
12599 
12602  CylinderAttributeControl & UnsetTessellation();
12603 
12606  CylinderAttributeControl & UnsetOrientation();
12607 
12610  CylinderAttributeControl & UnsetEverything();
12611 
12612 
12616  bool ShowTessellation(size_t & out_facets) const;
12617 
12621  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12622 
12623 private:
12626 };
12627 
12628 
12629 
12631 class HPS_API CuttingSectionAttributeKit : public Object
12632 {
12633 public:
12634 
12637 
12641 
12646 
12651 
12653  virtual ~CuttingSectionAttributeKit();
12654 
12655  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeKit;};
12656 
12660  static CuttingSectionAttributeKit GetDefault();
12661 
12664  void Set(CuttingSectionAttributeKit const & in_kit);
12665 
12668  void Show(CuttingSectionAttributeKit & out_kit) const;
12669 
12673  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12674 
12677  bool Empty() const;
12678 
12682  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12683 
12687  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12688 
12692  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12693 
12694 
12698  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12699 
12703  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12704 
12708  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12709 
12710 
12713  CuttingSectionAttributeKit & UnsetCuttingLevel();
12714 
12717  CuttingSectionAttributeKit & UnsetCappingLevel();
12718 
12721  CuttingSectionAttributeKit & UnsetMaterialPreference();
12722 
12725  CuttingSectionAttributeKit & UnsetEverything();
12726 
12727 
12731  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12732 
12736  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12737 
12741  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12742 };
12743 
12744 
12745 
12750 {
12751 public:
12752 
12754  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12755 
12758 
12763 
12768 
12771 
12772  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeControl;};
12773 
12776 
12777 
12782 
12787 
12791  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12792 
12793 
12796  CuttingSectionAttributeControl & UnsetCuttingLevel();
12797 
12800  CuttingSectionAttributeControl & UnsetCappingLevel();
12801 
12804  CuttingSectionAttributeControl & UnsetMaterialPreference();
12805 
12808  CuttingSectionAttributeControl & UnsetEverything();
12809 
12810 
12814  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12815 
12819  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12820 
12824  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12825 
12826 private:
12829 };
12830 
12831 
12832 
12834 class HPS_API TextAttributeKit : public Object
12835 {
12836 public:
12837 
12839  TextAttributeKit();
12840 
12843  TextAttributeKit(TextAttributeKit const & in_kit);
12844 
12848  TextAttributeKit(TextAttributeKit && in_that);
12849 
12853  TextAttributeKit & operator=(TextAttributeKit && in_that);
12854 
12856  virtual ~TextAttributeKit();
12857 
12858  HPS::Type ObjectType() const {return HPS::Type::TextAttributeKit;};
12859 
12863  static TextAttributeKit GetDefault();
12864 
12867  void Set(TextAttributeKit const & in_kit);
12868 
12871  void Show(TextAttributeKit & out_kit) const;
12872 
12876  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
12877 
12880  bool Empty() const;
12881 
12885  bool Equals(TextAttributeKit const & in_kit) const;
12886 
12890  bool operator==(TextAttributeKit const & in_kit) const;
12891 
12895  bool operator!=(TextAttributeKit const & in_kit) const;
12896 
12897 
12904 
12909  TextAttributeKit & SetBold(bool in_state);
12910 
12915  TextAttributeKit & SetItalic(bool in_state);
12916 
12920  TextAttributeKit & SetOverline(bool in_state);
12921 
12925  TextAttributeKit & SetStrikethrough(bool in_state);
12926 
12930  TextAttributeKit & SetUnderline(bool in_state);
12931 
12937  TextAttributeKit & SetSlant(float in_angle);
12938 
12943  TextAttributeKit & SetLineSpacing(float in_multiplier);
12944 
12949  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12950 
12955  TextAttributeKit & SetRotation(float in_angle);
12956 
12962  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12963 
12969  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12970 
12977  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12978 
12985 
12995  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12996 
13006  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13007 
13012  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
13013 
13020  TextAttributeKit & SetFont(char const * in_name);
13021 
13025  TextAttributeKit & SetTransform(Text::Transform in_trans);
13026 
13030  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
13031 
13036  TextAttributeKit & SetPreference(Text::Preference in_pref);
13037 
13045  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13046 
13051  TextAttributeKit & SetPath(Vector const & in_path);
13052 
13060  TextAttributeKit & SetSpacing(float in_multiplier);
13061 
13062 
13065  TextAttributeKit & UnsetAlignment();
13066 
13069  TextAttributeKit & UnsetBold();
13070 
13073  TextAttributeKit & UnsetItalic();
13074 
13077  TextAttributeKit & UnsetOverline();
13078 
13081  TextAttributeKit & UnsetStrikethrough();
13082 
13085  TextAttributeKit & UnsetUnderline();
13086 
13089  TextAttributeKit & UnsetSlant();
13090 
13093  TextAttributeKit & UnsetLineSpacing();
13094 
13097  TextAttributeKit & UnsetRotation();
13098 
13101  TextAttributeKit & UnsetExtraSpace();
13102 
13105  TextAttributeKit & UnsetGreeking();
13106 
13109  TextAttributeKit & UnsetSizeTolerance();
13110 
13113  TextAttributeKit & UnsetSize();
13114 
13117  TextAttributeKit & UnsetFont();
13118 
13121  TextAttributeKit & UnsetTransform();
13122 
13125  TextAttributeKit & UnsetRenderer();
13126 
13129  TextAttributeKit & UnsetPreference();
13130 
13133  TextAttributeKit & UnsetPath();
13134 
13137  TextAttributeKit & UnsetSpacing();
13138 
13141  TextAttributeKit & UnsetEverything();
13142 
13143 
13149  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13150 
13154  bool ShowBold(bool & out_state) const;
13155 
13159  bool ShowItalic(bool & out_state) const;
13160 
13164  bool ShowOverline(bool & out_state) const;
13165 
13169  bool ShowStrikethrough(bool & out_state) const;
13170 
13174  bool ShowUnderline(bool & out_state) const;
13175 
13179  bool ShowSlant(float & out_angle) const;
13180 
13184  bool ShowLineSpacing(float & out_multiplier) const;
13185 
13190  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13191 
13197  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13198 
13205  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13206 
13212  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13213 
13218  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13219 
13223  bool ShowFont(UTF8 & out_name) const;
13224 
13228  bool ShowTransform(Text::Transform & out_trans) const;
13229 
13233  bool ShowRenderer(Text::Renderer & out_rend) const;
13234 
13241  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13242 
13246  bool ShowPath(Vector & out_path) const;
13247 
13251  bool ShowSpacing(float & out_multiplier) const;
13252 };
13253 
13259 class HPS_API TextAttributeControl : public Control
13260 {
13261 public:
13262 
13264  explicit TextAttributeControl(SegmentKey & in_seg);
13265 
13267  TextAttributeControl(TextAttributeControl const & in_that);
13268 
13273 
13277  TextAttributeControl & operator=(TextAttributeControl && in_that);
13278 
13281 
13282  HPS::Type ObjectType() const {return HPS::Type::TextAttributeControl;};
13283 
13285  TextAttributeControl & operator=(TextAttributeControl const & in_that);
13286 
13287 
13294 
13299  TextAttributeControl & SetBold(bool in_state);
13300 
13305  TextAttributeControl & SetItalic(bool in_state);
13306 
13310  TextAttributeControl & SetOverline(bool in_state);
13311 
13315  TextAttributeControl & SetStrikethrough(bool in_state);
13316 
13320  TextAttributeControl & SetUnderline(bool in_state);
13321 
13327  TextAttributeControl & SetSlant(float in_angle);
13328 
13333  TextAttributeControl & SetLineSpacing(float in_multiplier);
13334 
13339  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13340 
13345  TextAttributeControl & SetRotation(float in_angle);
13346 
13352  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13353 
13359  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13360 
13367  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13368 
13375 
13385  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13386 
13396  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13397 
13402  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
13403 
13410  TextAttributeControl & SetFont(char const * in_name);
13411 
13415  TextAttributeControl & SetTransform(Text::Transform in_trans);
13416 
13420  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
13421 
13426  TextAttributeControl & SetPreference(Text::Preference in_pref);
13427 
13435  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13436 
13441  TextAttributeControl & SetPath(Vector const & in_path);
13442 
13450  TextAttributeControl & SetSpacing(float in_multiplier);
13451 
13452 
13455  TextAttributeControl & UnsetAlignment();
13456 
13459  TextAttributeControl & UnsetBold();
13460 
13463  TextAttributeControl & UnsetItalic();
13464 
13467  TextAttributeControl & UnsetOverline();
13468 
13471  TextAttributeControl & UnsetStrikethrough();
13472 
13475  TextAttributeControl & UnsetUnderline();
13476 
13479  TextAttributeControl & UnsetSlant();
13480 
13483  TextAttributeControl & UnsetLineSpacing();
13484 
13487  TextAttributeControl & UnsetRotation();
13488 
13491  TextAttributeControl & UnsetExtraSpace();
13492 
13495  TextAttributeControl & UnsetGreeking();
13496 
13499  TextAttributeControl & UnsetSizeTolerance();
13500 
13503  TextAttributeControl & UnsetSize();
13504 
13507  TextAttributeControl & UnsetFont();
13508 
13511  TextAttributeControl & UnsetTransform();
13512 
13515  TextAttributeControl & UnsetRenderer();
13516 
13519  TextAttributeControl & UnsetPreference();
13520 
13523  TextAttributeControl & UnsetPath();
13524 
13527  TextAttributeControl & UnsetSpacing();
13528 
13531  TextAttributeControl & UnsetEverything();
13532 
13533 
13539  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13540 
13544  bool ShowBold(bool & out_state) const;
13545 
13549  bool ShowItalic(bool & out_state) const;
13550 
13554  bool ShowOverline(bool & out_state) const;
13555 
13559  bool ShowStrikethrough(bool & out_state) const;
13560 
13564  bool ShowUnderline(bool & out_state) const;
13565 
13569  bool ShowSlant(float & out_angle) const;
13570 
13574  bool ShowLineSpacing(float & out_multiplier) const;
13575 
13580  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13581 
13587  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13588 
13595  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13596 
13602  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13603 
13608  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13609 
13613  bool ShowFont(UTF8 & out_name) const;
13614 
13618  bool ShowTransform(Text::Transform & out_trans) const;
13619 
13623  bool ShowRenderer(Text::Renderer & out_rend) const;
13624 
13631  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13632 
13636  bool ShowPath(Vector & out_path) const;
13637 
13641  bool ShowSpacing(float & out_multiplier) const;
13642 
13643 private:
13646 };
13647 
13648 
13649 
13650 
13651 
13653 class HPS_API LineAttributeKit : public Object
13654 {
13655 public:
13656 
13658  LineAttributeKit();
13659 
13662  LineAttributeKit(LineAttributeKit const & in_kit);
13663 
13667  LineAttributeKit(LineAttributeKit && in_that);
13668 
13672  LineAttributeKit & operator=(LineAttributeKit && in_that);
13673 
13675  virtual ~LineAttributeKit();
13676 
13677  HPS::Type ObjectType() const {return HPS::Type::LineAttributeKit;};
13678 
13682  static LineAttributeKit GetDefault();
13683 
13686  void Set(LineAttributeKit const & in_kit);
13687 
13690  void Show(LineAttributeKit & out_kit) const;
13691 
13695  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13696 
13699  bool Empty() const;
13700 
13704  bool Equals(LineAttributeKit const & in_kit) const;
13705 
13709  bool operator==(LineAttributeKit const & in_kit) const;
13710 
13714  bool operator!=(LineAttributeKit const & in_kit) const;
13715 
13716 
13720  LineAttributeKit & SetPattern(char const * in_name);
13721 
13726  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13727 
13732  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13733 
13734 
13737  LineAttributeKit & UnsetPattern();
13738 
13741  LineAttributeKit & UnsetWeight();
13742 
13745  LineAttributeKit & UnsetEverything();
13746 
13747 
13752  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13753 
13758  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13759 };
13760 
13766 class HPS_API LineAttributeControl : public Control
13767 {
13768 public:
13769 
13771  explicit LineAttributeControl(SegmentKey & in_seg);
13772 
13774  LineAttributeControl(LineAttributeControl const & in_that);
13775 
13780 
13784  LineAttributeControl & operator=(LineAttributeControl && in_that);
13785 
13788 
13789  HPS::Type ObjectType() const {return HPS::Type::LineAttributeControl;};
13790 
13792  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13793 
13794 
13798  LineAttributeControl & SetPattern(char const * in_pattern);
13799 
13804  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13805 
13810  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13811 
13812 
13815  LineAttributeControl & UnsetPattern();
13816 
13819  LineAttributeControl & UnsetWeight();
13820 
13823  LineAttributeControl & UnsetEverything();
13824 
13825 
13830  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13831 
13836  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13837 
13838 private:
13841 };
13842 
13843 
13844 
13846 class HPS_API EdgeAttributeKit : public Object
13847 {
13848 public:
13849 
13851  EdgeAttributeKit();
13852 
13855  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
13856 
13860  EdgeAttributeKit(EdgeAttributeKit && in_that);
13861 
13865  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
13866 
13868  virtual ~EdgeAttributeKit();
13869 
13870  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeKit;};
13871 
13875  static EdgeAttributeKit GetDefault();
13876 
13879  void Set(EdgeAttributeKit const & in_kit);
13880 
13883  void Show(EdgeAttributeKit & out_kit) const;
13884 
13888  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
13889 
13892  bool Empty() const;
13893 
13897  bool Equals(EdgeAttributeKit const & in_kit) const;
13898 
13902  bool operator==(EdgeAttributeKit const & in_kit) const;
13903 
13907  bool operator!=(EdgeAttributeKit const & in_kit) const;
13908 
13909 
13913  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
13914 
13919  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13920 
13921 
13924  EdgeAttributeKit & UnsetPattern();
13925 
13928  EdgeAttributeKit & UnsetWeight();
13929 
13932  EdgeAttributeKit & UnsetEverything();
13933 
13934 
13938  bool ShowPattern(UTF8 & out_pattern_name) const;
13939 
13944  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13945 };
13946 
13952 class HPS_API EdgeAttributeControl : public Control
13953 {
13954 public:
13955 
13957  explicit EdgeAttributeControl(SegmentKey & in_seg);
13958 
13960  EdgeAttributeControl(EdgeAttributeControl const & in_that);
13961 
13966 
13970  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
13971 
13974 
13975  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeControl;};
13976 
13978  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
13979 
13983  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
13984 
13989  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13990 
13991 
13994  EdgeAttributeControl & UnsetPattern();
13995 
13998  EdgeAttributeControl & UnsetWeight();
13999 
14002  EdgeAttributeControl & UnsetEverything();
14003 
14004 
14008  bool ShowPattern(UTF8 & out_pattern_name) const;
14009 
14014  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14015 
14016 private:
14019 };
14020 
14021 
14023 class HPS_API CurveAttributeKit : public Object
14024 {
14025 public:
14026 
14029 
14032  CurveAttributeKit(CurveAttributeKit const & in_kit);
14033 
14038 
14042  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
14043 
14045  virtual ~CurveAttributeKit();
14046 
14047  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeKit;};
14048 
14052  static CurveAttributeKit GetDefault();
14053 
14056  void Set(CurveAttributeKit const & in_kit);
14057 
14060  void Show(CurveAttributeKit & out_kit) const;
14061 
14065  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
14066 
14069  bool Empty() const;
14070 
14074  bool Equals(CurveAttributeKit const & in_kit) const;
14075 
14079  bool operator==(CurveAttributeKit const & in_kit) const;
14080 
14084  bool operator!=(CurveAttributeKit const & in_kit) const;
14085 
14086  //Set
14087  CurveAttributeKit & SetBudget(size_t in_budget);
14088 
14095  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14096 
14103  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
14104 
14105 
14112  CurveAttributeKit & SetViewDependent(bool in_state);
14113 
14117  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
14118 
14123  CurveAttributeKit & SetMaximumAngle(float in_degrees);
14124 
14129  CurveAttributeKit & SetMaximumLength(float in_length);
14130 
14131 
14134  CurveAttributeKit & UnsetBudget();
14135 
14138  CurveAttributeKit & UnsetContinuedBudget();
14139 
14142  CurveAttributeKit & UnsetViewDependent();
14143 
14146  CurveAttributeKit & UnsetMaximumDeviation();
14147 
14150  CurveAttributeKit & UnsetMaximumAngle();
14151 
14154  CurveAttributeKit & UnsetMaximumLength();
14155 
14158  CurveAttributeKit & UnsetEverything();
14159 
14160 
14164  bool ShowBudget(size_t & out_budget) const;
14165 
14170  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14171 
14175  bool ShowViewDependent(bool & out_state) const;
14176 
14181  bool ShowMaximumDeviation(float & out_deviation) const;
14182 
14187  bool ShowMaximumAngle(float & out_degrees) const;
14188 
14193  bool ShowMaximumLength(float & out_length) const;
14194 };
14195 
14196 
14200 class HPS_API CurveAttributeControl : public Control
14201 {
14202 public:
14203 
14205  explicit CurveAttributeControl(SegmentKey & in_seg);
14206 
14209 
14214 
14218  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
14219 
14222 
14223  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeControl;};
14224 
14226  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
14227 
14231  CurveAttributeControl & SetBudget(size_t in_budget);
14232 
14239  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14240 
14247  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
14248 
14255  CurveAttributeControl & SetViewDependent(bool in_state);
14256 
14260  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
14261 
14266  CurveAttributeControl & SetMaximumAngle(float in_degrees);
14267 
14272  CurveAttributeControl & SetMaximumLength(float in_length);
14273 
14274 
14277  CurveAttributeControl & UnsetBudget();
14278 
14281  CurveAttributeControl & UnsetContinuedBudget();
14282 
14285  CurveAttributeControl & UnsetViewDependent();
14286 
14289  CurveAttributeControl & UnsetMaximumDeviation();
14290 
14293  CurveAttributeControl & UnsetMaximumAngle();
14294 
14297  CurveAttributeControl & UnsetMaximumLength();
14298 
14301  CurveAttributeControl & UnsetEverything();
14302 
14303 
14307  bool ShowBudget(size_t & out_budget) const;
14308 
14313  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14314 
14318  bool ShowViewDependent(bool & out_state) const;
14319 
14324  bool ShowMaximumDeviation(float & out_deviation) const;
14325 
14330  bool ShowMaximumAngle(float & out_degrees) const;
14331 
14336  bool ShowMaximumLength(float & out_length) const;
14337 
14338 private:
14341 };
14342 
14343 
14344 
14345 
14347 class HPS_API MatrixKit : public Object
14348 {
14349 public:
14350 
14352  MatrixKit();
14353 
14356  MatrixKit(MatrixKit const & in_kit);
14357 
14361  MatrixKit(MatrixKit && in_that);
14362 
14366  MatrixKit & operator=(MatrixKit && in_that);
14367 
14371  MatrixKit(FloatArray const & in_matrix_source);
14372 
14376  MatrixKit(float const in_matrix_source []);
14377 
14380  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
14381 
14383  virtual ~MatrixKit();
14384 
14385  HPS::Type ObjectType() const {return HPS::Type::MatrixKit;};
14386 
14389  static MatrixKit GetDefault();
14390 
14393  void Set(MatrixKit const & in_kit);
14394 
14397  void Show(MatrixKit & out_kit) const;
14398 
14402  MatrixKit & operator=(MatrixKit const & in_kit);
14403 
14406  bool Empty() const;
14407 
14411  bool Equals(MatrixKit const & in_kit) const;
14412 
14416  bool operator==(MatrixKit const & in_kit) const;
14417 
14421  bool operator!=(MatrixKit const & in_kit) const;
14422 
14428  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
14429 
14434  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14435 
14439  MatrixKit & SetElements(FloatArray const & in_matrix);
14440 
14445  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
14446 
14447 
14450  MatrixKit & UnsetEverything();
14451 
14452 
14458  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14459 
14464  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14465 
14469  bool ShowElements(FloatArray & out_matrix) const;
14470 
14474  bool ShowDeterminant(float & out_determinant) const;
14475 
14479  bool ShowInverse(MatrixKit & out_matrix) const;
14480 
14485  bool ShowAdjoint(MatrixKit & out_matrix) const;
14486 
14487 
14493  MatrixKit & Rotate(float in_x, float in_y, float in_z);
14494 
14499  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
14500 
14506  MatrixKit & Translate(float in_x, float in_y, float in_z);
14507 
14513  MatrixKit & Scale(float in_x, float in_y, float in_z);
14514 
14518  MatrixKit & Concatenate(MatrixKit const & in_kit);
14519 
14522  MatrixKit & Normalize();
14523 
14526  MatrixKit & Invert();
14527 
14531  MatrixKit & Adjoint();
14532 
14533 
14537  MatrixKit Multiply(MatrixKit const & in_right) const;
14538 
14542  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14543 
14547  MatrixKit Multiply(float in_scalar) const;
14548 
14552  MatrixKit const & MultiplyAndAssign(float in_scalar);
14553 
14557  MatrixKit operator*(MatrixKit const & in_right) const;
14558 
14562  MatrixKit const & operator*=(MatrixKit const & in_right);
14563 
14567  MatrixKit operator*(float in_scalar) const;
14568 
14572  MatrixKit const & operator*=(float in_scalar);
14573 
14574 
14578  Point Transform(Point const & in_source) const;
14579 
14583  PointArray Transform(PointArray const & in_source) const;
14584 
14589  PointArray Transform(size_t in_count, Point const in_source []) const;
14590 
14594  Vector Transform(Vector const & in_source) const;
14595 
14599  VectorArray Transform(VectorArray const & in_source) const;
14600 
14605  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14606 
14610  Plane Transform(Plane const & in_source) const;
14611 
14615  PlaneArray Transform(PlaneArray const & in_source) const;
14616 
14621  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14622 
14626  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
14627 
14631  SimpleSphere Transform(SimpleSphere const & in_source) const;
14632 };
14633 
14637 class HPS_API ModellingMatrixControl : public Control
14638 {
14639 public:
14640 
14642  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14643 
14645  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14646 
14649 
14654 
14658  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14659 
14662 
14663  HPS::Type ObjectType() const {return HPS::Type::ModellingMatrixControl;};
14664 
14666  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14667 
14673  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14674 
14679  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14680 
14684  ModellingMatrixControl & SetElements(FloatArray const & in_matrix);
14685 
14690  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14691 
14692 
14695  ModellingMatrixControl & UnsetEverything();
14696 
14697 
14703  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14704 
14709  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14710 
14714  bool ShowElements(FloatArray & out_matrix) const;
14715 
14719  bool ShowDeterminant(float & out_determinant) const;
14720 
14724  bool ShowInverse(MatrixKit & out_matrix) const;
14725 
14730  bool ShowAdjoint(MatrixKit & out_matrix) const;
14731 
14737  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14738 
14743  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14744 
14750  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14751 
14757  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14758 
14762  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14763 
14766  ModellingMatrixControl & Normalize();
14767 
14770  ModellingMatrixControl & Invert();
14771 
14775  ModellingMatrixControl & Adjoint();
14776 
14777 private:
14780 };
14781 
14784 class HPS_API TextureMatrixControl : public Control
14785 {
14786 public:
14787 
14789  explicit TextureMatrixControl(SegmentKey & in_seg);
14790 
14792  TextureMatrixControl(const TextureMatrixControl & in_that);
14793 
14798 
14802  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
14803 
14806 
14807  HPS::Type ObjectType() const {return HPS::Type::TextureMatrixControl;};
14808 
14810  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
14811 
14812 
14818  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14819 
14824  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14825 
14829  TextureMatrixControl & SetElements(FloatArray const & in_matrix);
14830 
14835  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14836 
14837 
14840  TextureMatrixControl & UnsetEverything();
14841 
14842 
14848  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14849 
14854  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14855 
14859  bool ShowElements(FloatArray & out_matrix) const;
14860 
14864  bool ShowDeterminant(float & out_determinant) const;
14865 
14869  bool ShowInverse(MatrixKit & out_matrix) const;
14870 
14875  bool ShowAdjoint(MatrixKit & out_matrix) const;
14876 
14882  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
14883 
14888  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14889 
14895  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
14896 
14902  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
14903 
14907  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
14908 
14911  TextureMatrixControl & Normalize();
14912 
14915  TextureMatrixControl & Invert();
14916 
14920  TextureMatrixControl & Adjoint();
14921 
14922 private:
14925 };
14926 
14927 
14930 class HPS_API MaterialMappingKit : public Object
14931 {
14932 public:
14933 
14936 
14939  MaterialMappingKit(MaterialMappingKit const & in_kit);
14940 
14945 
14949  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
14950 
14952  ~MaterialMappingKit();
14953 
14954  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingKit;};
14955 
14959  static MaterialMappingKit GetDefault();
14960 
14963  void Set(MaterialMappingKit const & in_kit);
14964 
14967  void Show(MaterialMappingKit & out_kit) const;
14968 
14972  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
14973 
14976  bool Empty() const;
14977 
14981  bool Equals(MaterialMappingKit const & in_kit) const;
14982 
14986  bool operator==(MaterialMappingKit const & in_kit) const;
14987 
14991  bool operator!=(MaterialMappingKit const & in_kit) const;
14992 
14993  //Set
14994 
14998  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
14999 
15005  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
15006 
15007 
15011  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15012 
15018  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
15019 
15025  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15026 
15031  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
15032 
15039  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15040 
15049  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);
15050 
15054  MaterialMappingKit & SetBackFaceGloss(float in_value);
15055 
15059  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
15060 
15065  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
15066 
15072  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15073 
15078  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
15079 
15086  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15087 
15096  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);
15097 
15101  MaterialMappingKit & SetFrontFaceGloss(float in_value);
15102 
15106  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
15107 
15112  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
15113 
15114 
15118  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15119 
15125  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
15126 
15132  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15133 
15138  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
15139 
15146  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15147 
15156  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);
15157 
15161  MaterialMappingKit & SetCutFaceGloss(float in_value);
15162 
15166  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
15167 
15172  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
15173 
15178  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
15179 
15185  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15186 
15193  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15194 
15203  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);
15204 
15208  MaterialMappingKit & SetEdgeGloss(float in_value);
15209 
15213  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
15214 
15219  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
15220 
15225  MaterialMappingKit & SetFaceAlpha(float in_alpha);
15226 
15232  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15233 
15240  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15241 
15250  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);
15251 
15255  MaterialMappingKit & SetFaceGloss(float in_value);
15256 
15260  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
15261 
15266  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
15267 
15271  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
15272 
15273 
15274 
15275 
15276 
15280  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
15281 
15287  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
15288 
15289 
15293  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
15294 
15300  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
15301 
15302 
15306  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
15307 
15313  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
15314 
15315 
15319  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
15320 
15326  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
15327 
15332  MaterialMappingKit & SetVertexAlpha(float in_alpha);
15333 
15339  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15340 
15347  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15348 
15357  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);
15358 
15362  MaterialMappingKit & SetVertexGloss(float in_value);
15363 
15367  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
15368 
15373  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
15374 
15378  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
15379 
15380 
15384  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
15385 
15391  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
15392 
15393 
15397  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15398 
15404  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
15405 
15406  //Aggregate Sets
15407 
15411  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15412 
15417  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
15418 
15419 
15423  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15424 
15430  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
15431 
15432 
15433  //Unset
15434 
15437  MaterialMappingKit & UnsetAmbientLightUpColor();
15438 
15439 
15442  MaterialMappingKit & UnsetAmbientLightDownColor();
15443 
15444 
15447  MaterialMappingKit & UnsetBackFaceMaterial();
15448 
15451  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
15452 
15455  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15456 
15459  MaterialMappingKit & UnsetFrontFaceMaterial();
15460 
15463  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
15464 
15467  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15468 
15469 
15470 
15473  MaterialMappingKit & UnsetCutEdgeColor();
15474 
15475 
15478  MaterialMappingKit & UnsetCutFaceMaterial();
15479 
15482  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
15483 
15486  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15487 
15488 
15491  MaterialMappingKit & UnsetEdgeMaterial();
15492 
15495  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
15496 
15499  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15500 
15501 
15504  MaterialMappingKit & UnsetFaceMaterial();
15505 
15508  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
15509 
15512  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15513 
15514 
15517  MaterialMappingKit & UnsetLightColor();
15518 
15519 
15522  MaterialMappingKit & UnsetLineColor();
15523 
15524 
15527  MaterialMappingKit & UnsetMarkerColor();
15528 
15529 
15532  MaterialMappingKit & UnsetTextColor();
15533 
15534 
15537  MaterialMappingKit & UnsetVertexMaterial();
15538 
15541  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15542 
15545  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15546 
15547 
15550  MaterialMappingKit & UnsetWindowColor();
15551 
15552 
15555  MaterialMappingKit & UnsetWindowContrastColor();
15556 
15557 
15558  //Aggregate Unsets
15559 
15562  MaterialMappingKit & UnsetCutGeometryColor();
15563 
15566  MaterialMappingKit & UnsetAmbientLightColor();
15567 
15570  MaterialMappingKit & UnsetEverything();
15571 
15572 
15573  //Show
15574 
15580  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15581 
15587  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15588 
15589 
15597  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15598 
15607  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;
15608 
15614  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15615 
15616 
15624  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15625 
15634  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;
15635 
15641  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15642 
15643 
15644 
15650  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15651 
15652 
15660  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15661 
15670  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;
15671 
15677  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15678 
15679 
15687  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15688 
15697  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;
15698 
15704  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15705 
15706 
15714  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15715 
15724  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;
15725 
15731  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15732 
15733 
15739  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15740 
15741 
15747  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15748 
15749 
15755  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15756 
15757 
15763  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15764 
15765 
15773  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15774 
15783  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;
15784 
15790  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15791 
15792 
15798  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15799 
15800 
15806  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15807 };
15808 
15809 
15815 class HPS_API MaterialMappingControl : public Control
15816 {
15817 public:
15818 
15820  explicit MaterialMappingControl(SegmentKey & in_seg);
15821 
15824 
15829 
15833  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
15834 
15837 
15838  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingControl;};
15839 
15841  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
15842 
15843  //Set
15844 
15848  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15849 
15855  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
15856 
15857 
15861  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15862 
15868  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
15869 
15874  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
15875 
15881  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15882 
15889  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15890 
15899  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);
15900 
15904  MaterialMappingControl & SetBackFaceGloss(float in_value);
15905 
15909  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
15910 
15915  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
15916 
15917 
15922  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
15923 
15929  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15930 
15937  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15938 
15947  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);
15948 
15952  MaterialMappingControl & SetFrontFaceGloss(float in_value);
15953 
15957  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
15958 
15963  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
15964 
15968  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15969 
15975  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
15976 
15981  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
15982 
15988  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15989 
15996  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15997 
16006  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);
16007 
16011  MaterialMappingControl & SetCutFaceGloss(float in_value);
16012 
16016  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
16017 
16022  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
16023 
16028  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
16029 
16035  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16036 
16043  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16044 
16053  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);
16054 
16058  MaterialMappingControl & SetEdgeGloss(float in_value);
16059 
16063  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
16064 
16069  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
16070 
16076  MaterialMappingControl & SetFaceAlpha(float in_alpha);
16077 
16084  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16085 
16092  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16093 
16102  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);
16103 
16107  MaterialMappingControl & SetFaceGloss(float in_value);
16108 
16112  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
16113 
16118  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
16119 
16123  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
16124 
16125 
16129  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
16130 
16136  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
16137 
16138 
16142  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
16143 
16149  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
16150 
16151 
16155  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
16156 
16162  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
16163 
16164 
16168  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
16169 
16175  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
16176 
16177 
16182  MaterialMappingControl & SetVertexAlpha(float in_alpha);
16183 
16184 
16190  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16191 
16198  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16199 
16208  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);
16209 
16213  MaterialMappingControl & SetVertexGloss(float in_value);
16214 
16218  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
16219 
16224  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
16225 
16229  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
16230 
16231 
16235  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
16236 
16242  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
16243 
16244 
16248  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16249 
16255  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
16256 
16257  //Aggregate Sets
16258 
16262  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16263 
16268  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
16269 
16270 
16274  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16275 
16281  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
16282 
16283 
16284  //Unset
16285 
16288  MaterialMappingControl & UnsetAmbientLightUpColor();
16289 
16290 
16293  MaterialMappingControl & UnsetAmbientLightDownColor();
16294 
16295 
16298  MaterialMappingControl & UnsetFrontFaceMaterial();
16299 
16302  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
16303 
16306  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16307 
16308 
16311  MaterialMappingControl & UnsetBackFaceMaterial();
16312 
16315  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
16316 
16319  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16320 
16321 
16324  MaterialMappingControl & UnsetCutEdgeColor();
16325 
16326 
16329  MaterialMappingControl & UnsetCutFaceMaterial();
16330 
16333  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
16334 
16337  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16338 
16339 
16342  MaterialMappingControl & UnsetEdgeMaterial();
16343 
16346  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
16347 
16350  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
16351 
16352 
16355  MaterialMappingControl & UnsetFaceMaterial();
16356 
16359  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
16360 
16363  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
16364 
16365 
16368  MaterialMappingControl & UnsetLightColor();
16369 
16370 
16373  MaterialMappingControl & UnsetLineColor();
16374 
16375 
16378  MaterialMappingControl & UnsetMarkerColor();
16379 
16380 
16383  MaterialMappingControl & UnsetTextColor();
16384 
16385 
16388  MaterialMappingControl & UnsetVertexMaterial();
16389 
16392  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
16393 
16396  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
16397 
16398 
16401  MaterialMappingControl & UnsetWindowColor();
16402 
16403 
16406  MaterialMappingControl & UnsetWindowContrastColor();
16407 
16408 
16409  //Aggregate Unsets
16410 
16413  MaterialMappingControl & UnsetCutGeometryColor();
16414 
16417  MaterialMappingControl & UnsetAmbientLightColor();
16418 
16421  MaterialMappingControl & UnsetEverything();
16422 
16423 
16424  //Show
16425 
16431  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16432 
16433 
16439  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16440 
16441 
16449  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16450 
16459  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;
16460 
16466  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16467 
16468 
16476  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16477 
16486  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;
16487 
16493  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16494 
16495 
16501  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16502 
16503 
16511  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16512 
16521  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;
16522 
16528  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16529 
16530 
16538  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16539 
16548  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;
16549 
16555  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16556 
16557 
16565  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16566 
16575  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;
16576 
16582  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16583 
16584 
16590  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16591 
16592 
16598  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16599 
16600 
16606  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16607 
16608 
16614  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16615 
16616 
16624  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16625 
16634  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;
16635 
16641  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16642 
16643 
16649  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16650 
16651 
16657  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16658 
16659 private:
16661 };
16662 
16663 
16666 class HPS_API PortfolioControl : public Control
16667 {
16668 public:
16670  explicit PortfolioControl(SegmentKey & in_seg);
16671 
16673  PortfolioControl(PortfolioControl const & in_that);
16674 
16678  PortfolioControl(PortfolioControl && in_that);
16679 
16683  PortfolioControl & operator=(PortfolioControl && in_that);
16684 
16686  ~PortfolioControl();
16687 
16688  HPS::Type ObjectType() const { return HPS::Type::PortfolioControl; };
16689 
16691  PortfolioControl & operator=(PortfolioControl const & in_that);
16692 
16694  size_t GetCount() const;
16695 
16696 
16701  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16702 
16705  bool Pop();
16706 
16710  bool Pop(PortfolioKey & out_portfolio);
16711 
16712 
16716  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16717 
16721  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16722 
16727  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16728 
16729 
16732  PortfolioControl & UnsetTop();
16733 
16736  PortfolioControl & UnsetEverything();
16737 
16738 
16742  bool ShowTop(PortfolioKey & out_portfolio) const;
16743 
16747  bool Show(PortfolioKeyArray & out_portfolios) const;
16748 
16749 private:
16750  PortfolioControl();
16751 };
16752 
16753 
16754 
16757 class HPS_API StyleControl : public Control
16758 {
16759 public:
16761  explicit StyleControl(SegmentKey & in_seg);
16762 
16764  StyleControl(StyleControl const & in_that);
16765 
16769  StyleControl(StyleControl && in_that);
16770 
16774  StyleControl & operator=(StyleControl && in_that);
16775 
16777  ~StyleControl();
16778 
16779  HPS::Type ObjectType() const { return HPS::Type::StyleControl; };
16780 
16782  StyleControl & operator=(StyleControl const & in_that);
16783 
16785  size_t GetCount() const;
16786 
16787 
16789  StyleKey PushNamed(char const * in_style_name);
16790 
16792  StyleKey PushNamed(char const * in_style_name, Condition const & in_condition);
16793 
16795  StyleKey AppendNamed(char const * in_style_name, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16796 
16800  StyleKey PushSegment(SegmentKey const & in_style_source);
16801 
16805  StyleKey PushSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16806 
16809  StyleKey AppendSegment(SegmentKey const & in_style_source, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16810 
16811 
16812 
16815  bool Pop();
16816 
16823  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition);
16824 
16828  void Flush(SegmentKey const & in_style_source);
16829 
16836  void Flush(SegmentKey const & in_style_source, Condition const & in_condition);
16837 
16841  void Flush(char const * in_style_name);
16842 
16849  void Flush(char const * in_style_name, Condition const & in_condition);
16850 
16851 
16854  StyleKey SetNamed(char const * in_style_name);
16855 
16859  StyleKey SetNamed(char const * in_style_name, Condition const & in_condition);
16860 
16861 
16864  StyleKey SetSegment(SegmentKey const & in_style_source);
16865 
16869  StyleKey SetSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16870 
16871 
16877  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionArray const & in_conditions);
16878 
16883  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
16884 
16891  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[]);
16892 
16893 
16894 
16896  void UnsetTop();
16897 
16899  void UnsetAllSegment();
16900 
16902  void UnsetAllNamed();
16903 
16905  void UnsetEverything();
16906 
16907 
16914  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition) const;
16915 
16919  bool ShowTop(StyleKey & out_style) const;
16920 
16927  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions) const;
16928 
16932  bool Show(StyleKeyArray & out_styles) const;
16933 
16938  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions) const;
16939 
16943  bool ShowAllSegment(StyleKeyArray & out_styles) const;
16944 
16949  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions) const;
16950 
16954  bool ShowAllNamed(StyleKeyArray & out_styles) const;
16955 
16956 private:
16957  StyleControl();
16958 };
16959 
16960 
16963 class HPS_API ConditionControl : public Control
16964 {
16965 public:
16967  explicit ConditionControl(SegmentKey & in_seg);
16968 
16970  ConditionControl(ConditionControl const & in_that);
16971 
16975  ConditionControl(ConditionControl && in_that);
16976 
16980  ConditionControl & operator=(ConditionControl && in_that);
16981 
16983  ~ConditionControl();
16984 
16985 
16986  HPS::Type ObjectType() const { return HPS::Type::ConditionControl; };
16987 
16989  ConditionControl & operator=(ConditionControl const & in_that);
16990 
16993  size_t GetCount() const;
16994 
16998  ConditionControl & AddCondition(char const * in_condition);
16999 
17000 
17004  ConditionControl & SetCondition(char const * in_condition);
17005 
17009  ConditionControl & SetConditions(UTF8Array const & in_conditions);
17010 
17015  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
17016 
17017 
17021  ConditionControl & UnsetCondition(char const * in_condition);
17022 
17025  ConditionControl & UnsetEverything();
17026 
17027 
17031  bool ShowCondition(char const * in_condition) const;
17032 
17036  bool ShowConditions(UTF8Array & out_conditions) const;
17037 
17038 private:
17040  ConditionControl();
17041 };
17042 
17043 
17046 class HPS_API MaterialKit : public Object
17047 {
17048 public:
17049 
17051  MaterialKit();
17052 
17055  MaterialKit(MaterialKit const & in_kit);
17056 
17060  MaterialKit(MaterialKit && in_that);
17061 
17065  MaterialKit & operator=(MaterialKit && in_that);
17066 
17068  ~MaterialKit();
17069 
17070  HPS::Type ObjectType() const {return HPS::Type::MaterialKit;};
17071 
17074  void Set(MaterialKit const & in_kit);
17075 
17078  void Show(MaterialKit & out_kit) const;
17079 
17083  MaterialKit & operator=(MaterialKit const & in_kit);
17084 
17087  bool Empty() const;
17088 
17092  bool Equals(MaterialKit const & in_kit) const;
17093 
17097  bool operator==(MaterialKit const & in_kit) const;
17098 
17102  bool operator!=(MaterialKit const & in_kit) const;
17103 
17104 
17105  //Set
17106 
17110  MaterialKit & SetDiffuse(RGBColor const & in_color);
17111 
17115  MaterialKit & SetDiffuse(RGBAColor const & in_color);
17116 
17120  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
17121 
17125  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
17126 
17131  MaterialKit & SetDiffuseAlpha(float in_alpha);
17132 
17139  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
17140 
17148  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
17149 
17154  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
17155 
17161  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
17162 
17169  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
17170 
17178  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
17179 
17180 
17184  MaterialKit & SetShader(char const * in_shader_name);
17185 
17186 
17187 
17191  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
17192 
17196  MaterialKit & SetSpecular(char const * in_texture_name);
17197 
17202  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
17203 
17204 
17205 
17209  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
17210 
17214  MaterialKit & SetMirror(char const * in_texture_name);
17215 
17220  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
17221 
17222 
17223 
17227  MaterialKit & SetTransmission(char const * in_texture_name);
17228 
17233  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17234 
17235 
17236 
17240  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
17241 
17245  MaterialKit & SetEmission(char const * in_texture_name);
17246 
17251  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17252 
17253 
17254 
17258  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
17259 
17264  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
17265 
17269  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
17270 
17275  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
17276 
17279  MaterialKit & SetEnvironmentTexture();
17280 
17281 
17285  MaterialKit & SetBump(char const * in_texture_name);
17286 
17287 
17288 
17295  MaterialKit & SetGloss(float in_gloss);
17296 
17299  MaterialKit & UnsetDiffuseColorRGB();
17300 
17303  MaterialKit & UnsetDiffuseColor();
17304 
17307  MaterialKit & UnsetDiffuseAlpha();
17308 
17311  MaterialKit & UnsetDiffuseTexture();
17312 
17316  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
17317 
17320  MaterialKit & UnsetShader();
17321 
17324  MaterialKit & UnsetSpecular();
17325 
17328  MaterialKit & UnsetMirror();
17329 
17332  MaterialKit & UnsetTransmission();
17333 
17336  MaterialKit & UnsetEmission();
17337 
17340  MaterialKit & UnsetEnvironment();
17341 
17344  MaterialKit & UnsetBump();
17345 
17348  MaterialKit & UnsetGloss();
17349 
17352  MaterialKit & UnsetEverything();
17353 
17354 
17357  bool ShowDiffuse() const;
17358 
17362  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
17363 
17367  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
17368 
17372  bool ShowDiffuseAlpha(float & out_alpha) const;
17373 
17380  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17381 
17389  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17390 
17397  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
17398 
17402  bool ShowShader(UTF8 & out_shader_name) const;
17403 
17412  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17413 
17422  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17423 
17424 
17425 
17434  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17435 
17436 
17445  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17446 
17447 
17456  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17457 
17458 
17462  bool ShowBump(UTF8 & out_texture_name) const;
17463 
17468  bool ShowGloss(float & out_gloss) const;
17469 };
17470 
17471 
17473 class HPS_API NURBSSurfaceAttributeKit : public Object
17474 {
17475 public:
17476 
17479 
17483 
17488 
17492  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
17493 
17495  virtual ~NURBSSurfaceAttributeKit();
17496 
17497  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeKit;};
17498 
17502  static NURBSSurfaceAttributeKit GetDefault();
17503 
17506  void Set(NURBSSurfaceAttributeKit const & in_kit);
17507 
17510  void Show(NURBSSurfaceAttributeKit & out_kit) const;
17511 
17515  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17516 
17519  bool Empty() const;
17520 
17524  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17525 
17529  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17530 
17534  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17535 
17536 
17540  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17541 
17546  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17547 
17551  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17552 
17556  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17557 
17561  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17562 
17567  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17568 
17569 
17572  NURBSSurfaceAttributeKit & UnsetBudget();
17573 
17576  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17577 
17580  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17581 
17584  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17585 
17588  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17589 
17592  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17593 
17596  NURBSSurfaceAttributeKit & UnsetEverything();
17597 
17601  bool ShowBudget(size_t & out_budget) const;
17602 
17606  bool ShowMaximumDeviation(float & out_deviation) const;
17607 
17611  bool ShowMaximumAngle(float & out_degrees) const;
17612 
17616  bool ShowMaximumWidth(float & out_width) const;
17617 
17621  bool ShowTrimBudget(size_t & out_budget) const;
17622 
17626  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17627 };
17628 
17635 {
17636 public:
17637 
17639  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17640 
17643 
17648 
17653 
17656 
17657  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeControl;};
17658 
17660  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17661 
17665  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17666 
17671  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17672 
17676  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17677 
17681  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17682 
17686  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17687 
17692  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17693 
17694 
17697  NURBSSurfaceAttributeControl & UnsetBudget();
17698 
17701  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17702 
17705  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17706 
17709  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17710 
17713  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17714 
17717  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17718 
17721  NURBSSurfaceAttributeControl & UnsetEverything();
17722 
17723 
17727  bool ShowBudget(size_t & out_budget) const;
17728 
17732  bool ShowMaximumDeviation(float & out_deviation) const;
17733 
17737  bool ShowMaximumAngle(float & out_degrees) const;
17738 
17742  bool ShowMaximumWidth(float & out_width) const;
17743 
17747  bool ShowTrimBudget(size_t & out_budget) const;
17748 
17752  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17753 
17754 private:
17757 };
17758 
17759 
17760 
17762 class HPS_API PerformanceKit : public Object
17763 {
17764 public:
17765 
17767  PerformanceKit();
17768 
17771  PerformanceKit(PerformanceKit const & in_kit);
17772 
17776  PerformanceKit(PerformanceKit && in_that);
17777 
17781  PerformanceKit & operator=(PerformanceKit && in_that);
17782 
17784  virtual ~PerformanceKit();
17785 
17786  HPS::Type ObjectType() const {return HPS::Type::PerformanceKit;};
17787 
17791  static PerformanceKit GetDefault();
17792 
17795  void Set(PerformanceKit const & in_kit);
17796 
17799  void Show(PerformanceKit & out_kit) const;
17800 
17804  PerformanceKit & operator=(PerformanceKit const & in_kit);
17805 
17808  bool Empty() const;
17809 
17813  bool Equals(PerformanceKit const & in_kit) const;
17814 
17818  bool operator==(PerformanceKit const & in_kit) const;
17819 
17823  bool operator!=(PerformanceKit const & in_kit) const;
17824 
17825 
17830 
17835  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
17836 
17837 
17840  PerformanceKit & UnsetDisplayLists();
17841 
17844  PerformanceKit & UnsetStaticModel();
17845 
17848  PerformanceKit & UnsetEverything();
17849 
17853  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17854 
17858  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17859 };
17860 
17861 
17867 class HPS_API PerformanceControl : public Control
17868 {
17869 public:
17870 
17872  explicit PerformanceControl(SegmentKey & in_seg);
17873 
17875  PerformanceControl(PerformanceControl const & in_that);
17876 
17881 
17885  PerformanceControl & operator=(PerformanceControl && in_that);
17886 
17888  ~PerformanceControl();
17889 
17890  HPS::Type ObjectType() const {return HPS::Type::PerformanceControl;};
17891 
17893  PerformanceControl & operator=(PerformanceControl const & in_that);
17894 
17895 
17900 
17905  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
17906 
17907 
17910  PerformanceControl & UnsetDisplayLists();
17911 
17914  PerformanceControl & UnsetStaticModel();
17915 
17918  PerformanceControl & UnsetEverything();
17919 
17920 
17924  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17925 
17929  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17930 
17931 private:
17934 };
17935 
17936 
17937 
17939 class HPS_API HiddenLineAttributeKit : public Object
17940 {
17941 public:
17942 
17945 
17949 
17954 
17958  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
17959 
17961  virtual ~HiddenLineAttributeKit();
17962 
17963  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeKit;};
17964 
17968  static HiddenLineAttributeKit GetDefault();
17969 
17972  void Set(HiddenLineAttributeKit const & in_kit);
17973 
17976  void Show(HiddenLineAttributeKit & out_kit) const;
17977 
17981  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
17982 
17985  bool Empty() const;
17986 
17990  bool Equals(HiddenLineAttributeKit const & in_kit) const;
17991 
17995  bool operator==(HiddenLineAttributeKit const & in_kit) const;
17996 
18000  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
18001 
18002 
18006  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
18007 
18013  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
18014 
18024  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
18025 
18029  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
18030 
18034  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
18035 
18039  HiddenLineAttributeKit & SetRenderText(bool in_state);
18040 
18045  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18046 
18052  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
18053 
18057  HiddenLineAttributeKit & SetVisibility(bool in_state);
18058 
18063  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18064 
18070  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
18071 
18072 
18075  HiddenLineAttributeKit & UnsetColor();
18076 
18079  HiddenLineAttributeKit & UnsetDimFactor();
18080 
18083  HiddenLineAttributeKit & UnsetFaceDisplacement();
18084 
18087  HiddenLineAttributeKit & UnsetLinePattern();
18088 
18091  HiddenLineAttributeKit & UnsetRenderFaces();
18092 
18095  HiddenLineAttributeKit & UnsetRenderText();
18096 
18099  HiddenLineAttributeKit & UnsetAlgorithm();
18100 
18103  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
18104 
18107  HiddenLineAttributeKit & UnsetVisibility();
18108 
18111  HiddenLineAttributeKit & UnsetWeight();
18112 
18115  HiddenLineAttributeKit & UnsetTransparencyCutoff();
18116 
18119  HiddenLineAttributeKit & UnsetEverything();
18120 
18121 
18125  bool ShowColor(RGBAColor & out_color) const;
18126 
18130  bool ShowDimFactor(float & out_zero_to_one) const;
18131 
18135  bool ShowFaceDisplacement(float & out_buckets) const;
18136 
18140  bool ShowLinePattern(UTF8 & out_pattern) const;
18141 
18145  bool ShowRenderFaces(bool & out_state) const;
18146 
18150  bool ShowRenderText(bool & out_state) const;
18151 
18155  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18156 
18160  bool ShowSilhouetteCleanup(bool & out_state) const;
18161 
18165  bool ShowVisibility(bool & out_state) const;
18166 
18171  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18172 
18176  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18177 };
18178 
18179 
18185 class HPS_API HiddenLineAttributeControl : public Control
18186 {
18187 public:
18188 
18190  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
18191 
18194 
18199 
18204 
18207 
18208  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeControl;};
18209 
18211  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
18212 
18216  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
18217 
18223  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
18224 
18234  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
18235 
18239  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
18240 
18244  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
18245 
18249  HiddenLineAttributeControl & SetRenderText(bool in_state);
18250 
18255  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18256 
18262  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
18263 
18267  HiddenLineAttributeControl & SetVisibility(bool in_state);
18268 
18273  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18274 
18280  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
18281 
18282 
18285  HiddenLineAttributeControl & UnsetColor();
18286 
18289  HiddenLineAttributeControl & UnsetDimFactor();
18290 
18293  HiddenLineAttributeControl & UnsetFaceDisplacement();
18294 
18297  HiddenLineAttributeControl & UnsetLinePattern();
18298 
18301  HiddenLineAttributeControl & UnsetRenderFaces();
18302 
18305  HiddenLineAttributeControl & UnsetRenderText();
18306 
18309  HiddenLineAttributeControl & UnsetAlgorithm();
18310 
18313  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
18314 
18317  HiddenLineAttributeControl & UnsetVisibility();
18318 
18321  HiddenLineAttributeControl & UnsetWeight();
18322 
18325  HiddenLineAttributeControl & UnsetTransparencyCutoff();
18326 
18329  HiddenLineAttributeControl & UnsetEverything();
18330 
18331 
18335  bool ShowColor(RGBAColor & out_color) const;
18336 
18340  bool ShowDimFactor(float & out_zero_to_one) const;
18341 
18345  bool ShowFaceDisplacement(float & out_buckets) const;
18346 
18350  bool ShowLinePattern(UTF8 & out_pattern) const;
18351 
18355  bool ShowRenderFaces(bool & out_state) const;
18356 
18360  bool ShowRenderText(bool & out_state) const;
18361 
18365  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18366 
18370  bool ShowSilhouetteCleanup(bool & out_state) const;
18371 
18375  bool ShowVisibility(bool & out_state) const;
18376 
18381  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18382 
18386  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18387 
18388 private:
18391 };
18392 
18393 
18394 
18396 class HPS_API DrawingAttributeKit : public Object
18397 {
18398 public:
18399 
18402 
18405  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
18406 
18411 
18415  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
18416 
18418  virtual ~DrawingAttributeKit();
18419 
18420  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeKit;};
18421 
18425  static DrawingAttributeKit GetDefault();
18426 
18429  void Set(DrawingAttributeKit const & in_kit);
18430 
18433  void Show(DrawingAttributeKit & out_kit) const;
18434 
18438  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
18439 
18442  bool Empty() const;
18443 
18447  bool Equals(DrawingAttributeKit const & in_kit) const;
18448 
18452  bool operator==(DrawingAttributeKit const & in_kit) const;
18453 
18457  bool operator!=(DrawingAttributeKit const & in_kit) const;
18458 
18474  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
18475 
18481  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
18482 
18495  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
18496 
18503  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
18504 
18509  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
18510 
18517  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18518 
18523  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18524 
18531  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18532 
18537  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18538 
18542  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18543 
18548  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18549 
18555  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18556 
18563  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);
18564 
18570  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18571 
18574  DrawingAttributeKit & UnsetPolygonHandedness();
18575 
18578  DrawingAttributeKit & UnsetWorldHandedness();
18579 
18582  DrawingAttributeKit & UnsetDepthRange();
18583 
18586  DrawingAttributeKit & UnsetFaceDisplacement();
18587 
18590  DrawingAttributeKit & UnsetGeneralDisplacement();
18591 
18594  DrawingAttributeKit & UnsetVertexDisplacement();
18595 
18598  DrawingAttributeKit & UnsetOverlay();
18599 
18602  DrawingAttributeKit & UnsetDeferral();
18603 
18606  DrawingAttributeKit & UnsetClipRegion();
18607 
18610  DrawingAttributeKit & UnsetEverything();
18611 
18615  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18616 
18620  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18621 
18626  bool ShowDepthRange(float & out_near, float & out_far) const;
18627 
18632  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18633 
18638  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18639 
18644  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18645 
18649  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18650 
18654  bool ShowDeferral(int & out_defer_batch) const;
18655 
18661  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18662 
18663 };
18664 
18665 
18677 class HPS_API DrawingAttributeControl : public Control
18678 {
18679 public:
18680 
18682  explicit DrawingAttributeControl(SegmentKey & in_seg);
18683 
18686 
18691 
18695  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18696 
18699 
18700  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeControl;};
18701 
18703  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18704 
18714  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18715 
18721  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18722 
18735  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18736 
18743  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18744 
18749  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18750 
18757  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18758 
18763  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
18764 
18771  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
18772 
18777  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
18778 
18782  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
18783 
18789  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18790 
18797  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);
18798 
18804  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18805 
18810  DrawingAttributeControl & SetDeferral(int in_deferral);
18813  DrawingAttributeControl & UnsetPolygonHandedness();
18814 
18817  DrawingAttributeControl & UnsetWorldHandedness();
18818 
18821  DrawingAttributeControl & UnsetDepthRange();
18822 
18825  DrawingAttributeControl & UnsetFaceDisplacement();
18826 
18829  DrawingAttributeControl & UnsetGeneralDisplacement();
18830 
18833  DrawingAttributeControl & UnsetVertexDisplacement();
18834 
18837  DrawingAttributeControl & UnsetOverlay();
18838 
18841  DrawingAttributeControl & UnsetDeferral();
18842 
18845  DrawingAttributeControl & UnsetClipRegion();
18846 
18849  DrawingAttributeControl & UnsetEverything();
18850 
18851 
18855  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18856 
18860  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18861 
18866  bool ShowDepthRange(float & out_x, float & out_y) const;
18867 
18872  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18873 
18878  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18879 
18884  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18885 
18889  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18890 
18894  bool ShowDeferral(int & out_defer_batch) const;
18895 
18901  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation);
18902 
18903 private:
18906 };
18907 
18908 
18910 class HPS_API PostProcessEffectsKit : public Object
18911 {
18912 public:
18913 
18916 
18920 
18925 
18929  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
18930 
18932  virtual ~PostProcessEffectsKit();
18933 
18934  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsKit;};
18935 
18939  static PostProcessEffectsKit GetDefault();
18940 
18943  void Set(PostProcessEffectsKit const & in_kit);
18944 
18947  void Show(PostProcessEffectsKit & out_kit) const;
18948 
18952  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
18953 
18956  bool Empty() const;
18957 
18961  bool Equals(PostProcessEffectsKit const & in_kit) const;
18962 
18966  bool operator==(PostProcessEffectsKit const & in_kit) const;
18967 
18971  bool operator!=(PostProcessEffectsKit const & in_kit) const;
18972 
18973 
18981  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18982 
18989  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18990 
18997  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18998 
19004  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19005 
19012  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19013 
19019  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19020 
19028  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19029 
19036  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19037 
19045  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19046 
19053  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
19054 
19057  PostProcessEffectsKit & UnsetAmbientOcclusion();
19058 
19061  PostProcessEffectsKit & UnsetBloom();
19062 
19065  PostProcessEffectsKit & UnsetDepthOfField();
19066 
19069  PostProcessEffectsKit & UnsetSilhouetteEdges();
19070 
19073  PostProcessEffectsKit & UnsetEyeDomeLighting();
19074 
19077  PostProcessEffectsKit & UnsetEverything();
19078 
19079 
19086  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19087 
19094  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19095 
19102  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19103 
19111  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19112 
19120  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19121 };
19122 
19123 
19127 class HPS_API PostProcessEffectsControl : public Control
19128 {
19129 public:
19130 
19132  explicit PostProcessEffectsControl(WindowKey & in_seg);
19133 
19136 
19141 
19145  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
19146 
19149 
19150  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsControl;};
19151 
19153  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
19154 
19155 
19163  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19164 
19171  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19172 
19179  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19180 
19186  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19187 
19194  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19195 
19201  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19202 
19210  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19211 
19218  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19219 
19226  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19227 
19234  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
19235 
19236 
19239  PostProcessEffectsControl & UnsetAmbientOcclusion();
19240 
19243  PostProcessEffectsControl & UnsetBloom();
19244 
19247  PostProcessEffectsControl & UnsetDepthOfField();
19248 
19251  PostProcessEffectsControl & UnsetSilhouetteEdges();
19252 
19255  PostProcessEffectsControl & UnsetEyeDomeLighting();
19256 
19259  PostProcessEffectsControl & UnsetEverything();
19260 
19261 
19268  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19269 
19276  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19277 
19284  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19285 
19293  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19294 
19302  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19303 
19304 private:
19307 };
19308 
19310 class HPS_API TransformMaskKit : public Object
19311 {
19312 public:
19313 
19315  TransformMaskKit();
19316 
19318  TransformMaskKit(TransformMaskKit const & in_kit);
19319 
19323  TransformMaskKit(TransformMaskKit && in_that);
19324 
19328  TransformMaskKit & operator=(TransformMaskKit && in_that);
19329 
19331  virtual ~TransformMaskKit();
19332 
19333  HPS::Type ObjectType() const {return HPS::Type::TransformMaskKit;};
19334 
19335  static TransformMaskKit GetDefault();
19336 
19338  void Set(TransformMaskKit const & in_kit);
19339 
19341  void Show(TransformMaskKit & out_kit) const;
19342 
19344  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
19345 
19347  bool Empty() const;
19348 
19350  bool Equals(TransformMaskKit const & in_kit) const;
19351 
19353  bool operator==(TransformMaskKit const & in_kit) const;
19354 
19356  bool operator!=(TransformMaskKit const & in_kit) const;
19357 
19358 
19362  TransformMaskKit & SetCameraRotation(bool in_state);
19363 
19367  TransformMaskKit & SetCameraScale(bool in_state);
19368 
19372  TransformMaskKit & SetCameraTranslation(bool in_state);
19373 
19377  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
19378 
19382  TransformMaskKit & SetCameraProjection(bool in_state);
19383 
19387  TransformMaskKit & SetCameraOffset(bool in_state);
19388 
19392  TransformMaskKit & SetCameraNearLimit(bool in_state);
19393 
19397  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
19398 
19402  TransformMaskKit & SetModellingMatrixScale(bool in_state);
19403 
19407  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
19408 
19412  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
19413 
19414 
19418  TransformMaskKit & SetCameraEverything(bool in_state);
19419 
19423  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
19424 
19428  TransformMaskKit & SetEverything(bool in_state);
19429 
19430 
19433  TransformMaskKit & UnsetCameraRotation();
19434 
19437  TransformMaskKit & UnsetCameraScale();
19438 
19441  TransformMaskKit & UnsetCameraTranslation();
19442 
19445  TransformMaskKit & UnsetCameraPerspectiveScale();
19446 
19449  TransformMaskKit & UnsetCameraProjection();
19450 
19453  TransformMaskKit & UnsetCameraOffset();
19454 
19457  TransformMaskKit & UnsetCameraNearLimit();
19458 
19461  TransformMaskKit & UnsetCameraEverything();
19462 
19465  TransformMaskKit & UnsetModellingMatrixRotation();
19466 
19469  TransformMaskKit & UnsetModellingMatrixScale();
19470 
19473  TransformMaskKit & UnsetModellingMatrixTranslation();
19474 
19477  TransformMaskKit & UnsetModellingMatrixOffset();
19478 
19481  TransformMaskKit & UnsetModellingMatrixEverything();
19482 
19485  TransformMaskKit & UnsetEverything();
19486 
19487 
19491  bool ShowCameraRotation(bool & out_state) const;
19492 
19496  bool ShowCameraScale(bool & out_state) const;
19497 
19501  bool ShowCameraTranslation(bool & out_state) const;
19502 
19506  bool ShowCameraPerspectiveScale(bool & out_state) const;
19507 
19511  bool ShowCameraProjection(bool & out_state) const;
19512 
19516  bool ShowCameraOffset(bool & out_state) const;
19517 
19521  bool ShowCameraNearLimit(bool & out_state) const;
19522 
19526  bool ShowModellingMatrixRotation(bool & out_state) const;
19527 
19531  bool ShowModellingMatrixScale(bool & out_state) const;
19532 
19536  bool ShowModellingMatrixTranslation(bool & out_state) const;
19537 
19541  bool ShowModellingMatrixOffset(bool & out_state) const;
19542 };
19543 
19544 
19549 class HPS_API TransformMaskControl : public Control
19550 {
19551 public:
19552 
19554  explicit TransformMaskControl(SegmentKey & in_seg);
19555 
19557  TransformMaskControl(TransformMaskControl const & in_that);
19558 
19563 
19567  TransformMaskControl & operator=(TransformMaskControl && in_that);
19568 
19571 
19572  HPS::Type ObjectType() const {return HPS::Type::TransformMaskControl;};
19573 
19574 
19578  TransformMaskControl & SetCameraRotation(bool in_state);
19579 
19583  TransformMaskControl & SetCameraScale(bool in_state);
19584 
19588  TransformMaskControl & SetCameraTranslation(bool in_state);
19589 
19593  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19594 
19598  TransformMaskControl & SetCameraProjection(bool in_state);
19599 
19603  TransformMaskControl & SetCameraOffset(bool in_state);
19604 
19608  TransformMaskControl & SetCameraNearLimit(bool in_state);
19609 
19613  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19614 
19618  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19619 
19623  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19624 
19628  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19629 
19630 
19634  TransformMaskControl & SetCameraEverything(bool in_state);
19635 
19639  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19640 
19644  TransformMaskControl & SetEverything(bool in_state);
19645 
19646 
19649  TransformMaskControl & UnsetCameraRotation();
19650 
19653  TransformMaskControl & UnsetCameraScale();
19654 
19657  TransformMaskControl & UnsetCameraTranslation();
19658 
19661  TransformMaskControl & UnsetCameraPerspectiveScale();
19662 
19665  TransformMaskControl & UnsetCameraProjection();
19666 
19669  TransformMaskControl & UnsetCameraOffset();
19670 
19673  TransformMaskControl & UnsetCameraNearLimit();
19674 
19677  TransformMaskControl & UnsetCameraEverything();
19678 
19681  TransformMaskControl & UnsetModellingMatrixRotation();
19682 
19685  TransformMaskControl & UnsetModellingMatrixScale();
19686 
19689  TransformMaskControl & UnsetModellingMatrixTranslation();
19690 
19693  TransformMaskControl & UnsetModellingMatrixOffset();
19694 
19697  TransformMaskControl & UnsetModellingMatrixEverything();
19698 
19701  TransformMaskControl & UnsetEverything();
19702 
19703 
19707  bool ShowCameraRotation(bool & out_state) const;
19708 
19712  bool ShowCameraScale(bool & out_state) const;
19713 
19717  bool ShowCameraTranslation(bool & out_state) const;
19718 
19722  bool ShowCameraPerspectiveScale(bool & out_state) const;
19723 
19727  bool ShowCameraProjection(bool & out_state) const;
19728 
19732  bool ShowCameraOffset(bool & out_state) const;
19733 
19737  bool ShowCameraNearLimit(bool & out_state) const;
19738 
19742  bool ShowModellingMatrixRotation(bool & out_state) const;
19743 
19747  bool ShowModellingMatrixScale(bool & out_state) const;
19748 
19752  bool ShowModellingMatrixTranslation(bool & out_state) const;
19753 
19757  bool ShowModellingMatrixOffset(bool & out_state) const;
19758 
19759 private:
19762 };
19763 
19764 
19765 
19767 class HPS_API VisualEffectsKit : public Object
19768 {
19769 public:
19770 
19772  VisualEffectsKit();
19773 
19776  VisualEffectsKit(VisualEffectsKit const & in_kit);
19777 
19781  VisualEffectsKit(VisualEffectsKit && in_that);
19782 
19786  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
19787 
19789  virtual ~VisualEffectsKit();
19790 
19791  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsKit;};
19792 
19796  static VisualEffectsKit GetDefault();
19797 
19800  void Set(VisualEffectsKit const & in_kit);
19801 
19804  void Show(VisualEffectsKit & out_kit) const;
19805 
19809  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
19810 
19813  bool Empty() const;
19814 
19818  bool Equals(VisualEffectsKit const & in_kit) const;
19819 
19823  bool operator==(VisualEffectsKit const & in_kit) const;
19824 
19828  bool operator!=(VisualEffectsKit const & in_kit) const;
19829 
19833  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
19834 
19838  VisualEffectsKit & SetAntiAliasing(bool in_state);
19839 
19849  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19850 
19859  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19860 
19867  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19868 
19874  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19875 
19879  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19880 
19884  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19885 
19889  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19890 
19901  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);
19902 
19912  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19913 
19917  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19918 
19922  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19923 
19924 
19927  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
19928 
19931  VisualEffectsKit & UnsetAntiAliasing();
19932 
19935  VisualEffectsKit & UnsetShadowMaps();
19936 
19939  VisualEffectsKit & UnsetSimpleShadow();
19940 
19943  VisualEffectsKit & UnsetSimpleShadowPlane();
19944 
19947  VisualEffectsKit & UnsetSimpleShadowLightDirection();
19948 
19951  VisualEffectsKit & UnsetSimpleShadowColor();
19952 
19955  VisualEffectsKit & UnsetSimpleReflection();
19956 
19959  VisualEffectsKit & UnsetSimpleReflectionPlane();
19960 
19963  VisualEffectsKit & UnsetSimpleReflectionVisibility();
19964 
19967  VisualEffectsKit & UnsetEverything();
19968 
19972  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19973 
19977  bool ShowAntiAliasing(bool & out_state) const;
19978 
19986  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19987 
19994  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19995 
19999  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20000 
20004  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20005 
20009  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20010 
20019  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;
20020 
20021 
20025  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20026 
20030  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20031 };
20032 
20033 
20039 class HPS_API VisualEffectsControl : public Control
20040 {
20041 public:
20042 
20044  explicit VisualEffectsControl(SegmentKey & in_seg);
20045 
20047  VisualEffectsControl(VisualEffectsControl const & in_that);
20048 
20053 
20057  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
20058 
20061 
20062  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsControl;};
20063 
20065  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
20066 
20070  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
20071 
20075  VisualEffectsControl & SetAntiAliasing(bool in_state);
20076 
20086  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
20087 
20096  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
20097 
20104  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
20105 
20111  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20112 
20116  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20117 
20121  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20122 
20126  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20127 
20138  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);
20139 
20149  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20150 
20154  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20155 
20159  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20160 
20161 
20164  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
20165 
20168  VisualEffectsControl & UnsetAntiAliasing();
20169 
20172  VisualEffectsControl & UnsetShadowMaps();
20173 
20176  VisualEffectsControl & UnsetSimpleShadow();
20177 
20180  VisualEffectsControl & UnsetSimpleShadowPlane();
20181 
20184  VisualEffectsControl & UnsetSimpleShadowLightDirection();
20185 
20188  VisualEffectsControl & UnsetSimpleShadowColor();
20189 
20192  VisualEffectsControl & UnsetSimpleReflection();
20193 
20196  VisualEffectsControl & UnsetSimpleReflectionPlane();
20197 
20200  VisualEffectsControl & UnsetSimpleReflectionVisibility();
20201 
20204  VisualEffectsControl & UnsetEverything();
20205 
20206 
20210  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20211 
20215  bool ShowAntiAliasing(bool & out_state) const;
20216 
20224  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20225 
20232  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20233 
20237  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20238 
20242  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20243 
20247  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20248 
20257  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;
20258 
20262  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20263 
20267  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20268 
20269 private:
20272 };
20273 
20274 
20275 
20277 class HPS_API ContourLineKit : public Object
20278 {
20279 public:
20280 
20282  ContourLineKit();
20283 
20286  ContourLineKit(ContourLineKit const & in_kit);
20287 
20291  ContourLineKit(ContourLineKit && in_that);
20292 
20296  ContourLineKit & operator=(ContourLineKit && in_that);
20297 
20299  virtual ~ContourLineKit();
20300 
20301  HPS::Type ObjectType() const { return HPS::Type::ContourLineKit; };
20302 
20306  static ContourLineKit GetDefault();
20307 
20310  void Set(ContourLineKit const & in_kit);
20311 
20314  void Show(ContourLineKit & out_kit) const;
20315 
20319  ContourLineKit & operator=(ContourLineKit const & in_kit);
20320 
20323  bool Empty() const;
20324 
20328  bool Equals(ContourLineKit const & in_kit) const;
20329 
20333  bool operator==(ContourLineKit const & in_kit) const;
20334 
20338  bool operator!=(ContourLineKit const & in_kit) const;
20339 
20340 
20344  ContourLineKit & SetVisibility(bool in_state);
20345 
20350  ContourLineKit & SetPositions(float in_interval, float in_offset);
20351 
20355  ContourLineKit & SetPositions(FloatArray const & in_positions);
20356 
20361  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
20362 
20366  ContourLineKit & SetColors(RGBColorArray const & in_colors);
20367 
20372  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
20373 
20377  ContourLineKit & SetColors(RGBColor const & in_color);
20378 
20382  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
20383 
20388  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20389 
20393  ContourLineKit & SetPatterns(char const * in_pattern);
20394 
20399  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20400 
20406  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20407 
20412  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20413 
20417  ContourLineKit & SetLighting(bool in_state);
20418 
20419 
20422  ContourLineKit & UnsetVisibility();
20423 
20426  ContourLineKit & UnsetPositions();
20427 
20430  ContourLineKit & UnsetColors();
20431 
20434  ContourLineKit & UnsetPatterns();
20435 
20438  ContourLineKit & UnsetWeights();
20439 
20442  ContourLineKit & UnsetLighting();
20443 
20446  ContourLineKit & UnsetEverything();
20447 
20448 
20452  bool ShowVisibility(bool & out_state) const;
20453 
20459  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20460 
20464  bool ShowColors(RGBColorArray & out_colors) const;
20465 
20469  bool ShowPatterns(UTF8Array & out_patterns) const;
20470 
20475  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20476 
20480  bool ShowLighting(bool & out_state) const;
20481 };
20482 
20486 class HPS_API ContourLineControl : public Control
20487 {
20488 public:
20489 
20491  explicit ContourLineControl(SegmentKey & in_seg);
20492 
20494  ContourLineControl(ContourLineControl const & in_that);
20495 
20500 
20504  ContourLineControl & operator=(ContourLineControl && in_that);
20505 
20507  ~ContourLineControl();
20508 
20509  HPS::Type ObjectType() const { return HPS::Type::ContourLineControl; };
20510 
20512  ContourLineControl & operator=(ContourLineControl const & in_that);
20513 
20514 
20518  ContourLineControl & SetVisibility(bool in_state);
20519 
20524  ContourLineControl & SetPositions(float in_interval, float in_offset);
20525 
20529  ContourLineControl & SetPositions(FloatArray const & in_positions);
20530 
20535  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20536 
20540  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20541 
20546  ContourLineControl & SetColors(size_t in_count, RGBColor const in_rgb_colors[]);
20547 
20551  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20552 
20556  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20557 
20562  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20563 
20567  ContourLineControl & SetPatterns(char const * in_pattern);
20568 
20573  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20574 
20580  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20581 
20586  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20587 
20591  ContourLineControl & SetLighting(bool in_state);
20592 
20593 
20596  ContourLineControl & UnsetVisibility();
20597 
20600  ContourLineControl & UnsetPositions();
20601 
20604  ContourLineControl & UnsetColors();
20605 
20608  ContourLineControl & UnsetPatterns();
20609 
20612  ContourLineControl & UnsetWeights();
20613 
20616  ContourLineControl & UnsetLighting();
20617 
20620  ContourLineControl & UnsetEverything();
20621 
20622 
20626  bool ShowVisibility(bool & out_state) const;
20627 
20633  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20634 
20638  bool ShowColors(RGBColorArray & out_colors) const;
20639 
20643  bool ShowPatterns(UTF8Array & out_patterns) const;
20644 
20649  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20650 
20654  bool ShowLighting(bool & out_state) const;
20655 
20656 private:
20659 };
20660 
20661 
20662 
20664 class HPS_API SubwindowKit : public Object
20665 {
20666 public:
20667 
20669  SubwindowKit();
20670 
20672  SubwindowKit(SubwindowKit const & in_kit);
20673 
20677  SubwindowKit(SubwindowKit && in_that);
20678 
20682  SubwindowKit & operator=(SubwindowKit && in_that);
20683 
20685  virtual ~SubwindowKit();
20686 
20687  HPS::Type ObjectType() const {return HPS::Type::SubwindowKit;}
20688 
20692  static SubwindowKit GetDefault();
20693 
20696  void Set(SubwindowKit const & in_kit);
20697 
20700  void Show(SubwindowKit & out_kit) const;
20701 
20705  SubwindowKit & operator=(SubwindowKit const & in_kit);
20706 
20709  bool Empty() const;
20710 
20714  bool Equals(SubwindowKit const & in_kit) const;
20715 
20719  bool operator==(SubwindowKit const & in_kit) const;
20720 
20724  bool operator!=(SubwindowKit const & in_kit) const;
20725 
20726 
20736  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20737 
20744  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20745 
20750  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
20751 
20756  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20757 
20763  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20764 
20769  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20770 
20773  SubwindowKit & UnsetSubwindow();
20774 
20777  SubwindowKit & UnsetBackground();
20778 
20781  SubwindowKit & UnsetBorder();
20782 
20785  SubwindowKit & UnsetRenderingAlgorithm();
20786 
20789  SubwindowKit & UnsetModelCompareMode();
20790 
20793  SubwindowKit & UnsetEverything();
20794 
20799  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
20800 
20805  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20806 
20810  bool ShowBorder(Subwindow::Border & out_border_type) const;
20811 
20815  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20816 
20822  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20823 };
20824 
20825 
20826 
20832 class HPS_API SubwindowControl : public Control
20833 {
20834 public:
20835 
20837  explicit SubwindowControl(SegmentKey & in_seg);
20838 
20840  SubwindowControl(SubwindowControl const & in_that);
20841 
20845  SubwindowControl(SubwindowControl && in_that);
20846 
20850  SubwindowControl & operator=(SubwindowControl && in_that);
20851 
20853  ~SubwindowControl();
20854 
20855  HPS::Type ObjectType() const {return HPS::Type::SubwindowControl;}
20856 
20858  SubwindowControl & operator=(SubwindowControl const & in_that);
20859 
20870  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
20871 
20878  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20879 
20884  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
20885 
20891  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20892 
20898  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20899 
20904  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20905 
20908  SubwindowControl & UnsetSubwindow();
20909 
20912  SubwindowControl & UnsetBackground();
20913 
20916  SubwindowControl & UnsetBorder();
20917 
20920  SubwindowControl & UnsetRenderingAlgorithm();
20921 
20924  SubwindowControl & UnsetModelCompareMode();
20925 
20928  SubwindowControl & UnsetEverything();
20929 
20930 
20935  bool ShowSubwindow(Rectangle & out_window_position, Subwindow::Type & out_subwindow_type) const;
20936 
20941  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20942 
20946  bool ShowBorder(Subwindow::Border & out_border_type) const;
20947 
20951  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20952 
20958  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20959 
20960 private:
20962  SubwindowControl();
20963 };
20964 
20965 
20966 
20968 class HPS_API DebuggingKit : public Object
20969 {
20970 public:
20971 
20973  DebuggingKit();
20974 
20976  DebuggingKit(DebuggingKit const & in_kit);
20977 
20981  DebuggingKit(DebuggingKit && in_that);
20982 
20986  DebuggingKit & operator=(DebuggingKit && in_that);
20987 
20989  virtual ~DebuggingKit();
20990 
20991  HPS::Type ObjectType() const {return HPS::Type::DebuggingKit;}
20992 
20996  static DebuggingKit GetDefault();
20997 
21000  void Set(DebuggingKit const & in_kit);
21001 
21004  void Show(DebuggingKit & out_kit) const;
21005 
21009  DebuggingKit & operator=(DebuggingKit const & in_kit);
21010 
21013  bool Empty() const;
21014 
21018  bool Equals(DebuggingKit const & in_kit) const;
21019 
21023  bool operator==(DebuggingKit const & in_kit) const;
21024 
21028  bool operator!=(DebuggingKit const & in_kit) const;
21029 
21030 
21034  DebuggingKit & SetResourceMonitor(bool in_display);
21035 
21036 
21039  DebuggingKit & UnsetResourceMonitor();
21040 
21043  DebuggingKit & UnsetEverything();
21044 
21045 
21049  bool ShowResourceMonitor(bool & out_display) const;
21050 };
21051 
21052 
21055 class HPS_API DebuggingControl : public Control
21056 {
21057 public:
21058 
21060  explicit DebuggingControl(WindowKey & in_window);
21061 
21063  DebuggingControl(DebuggingControl const & in_that);
21064 
21068  DebuggingControl(DebuggingControl && in_that);
21069 
21073  DebuggingControl & operator=(DebuggingControl && in_that);
21074 
21076  ~DebuggingControl();
21077 
21078  HPS::Type ObjectType() const {return HPS::Type::DebuggingControl;}
21079 
21081  DebuggingControl & operator=(DebuggingControl const & in_that);
21082 
21087  DebuggingControl & SetResourceMonitor(bool in_display);
21088 
21092  bool ShowResourceMonitor(bool & out_display) const;
21093 
21097  bool ShowLastUpdateInfo(UpdateInfo & out_info);
21098 
21099 private:
21101  DebuggingControl();
21102 };
21103 
21104 
21106 class HPS_API WindowInfoKit : public Object
21107 {
21108 public:
21109 
21111  WindowInfoKit();
21112 
21114  WindowInfoKit(WindowInfoKit const & in_kit);
21115 
21119  WindowInfoKit(WindowInfoKit && in_that);
21120 
21124  WindowInfoKit & operator=(WindowInfoKit && in_that);
21125 
21127  virtual ~WindowInfoKit();
21128 
21129  HPS::Type ObjectType() const {return HPS::Type::WindowInfoKit;}
21130 
21133  void Set(WindowInfoKit const & in_kit);
21134 
21137  void Show(WindowInfoKit & out_kit) const;
21138 
21142  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
21143 
21146  bool Empty() const;
21147 
21151  bool Equals(WindowInfoKit const & in_kit) const;
21152 
21156  bool operator==(WindowInfoKit const & in_kit) const;
21157 
21161  bool operator!=(WindowInfoKit const & in_kit) const;
21162 
21163 
21168  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
21169 
21174  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
21175 
21180  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
21181 
21186  WindowInfoKit & SetWindowSize(float in_width, float in_height);
21187 
21188 
21191  WindowInfoKit & UnsetPhysicalPixels();
21192 
21195  WindowInfoKit & UnsetPhysicalSize();
21196 
21199  WindowInfoKit & UnsetWindowPixels();
21200 
21203  WindowInfoKit & UnsetWindowSize();
21204 
21207  WindowInfoKit & UnsetEverything();
21208 
21209 
21214  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21215 
21220  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21221 
21226  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21227 
21232  bool ShowWindowSize(float & out_width, float & out_height) const;
21233 
21239  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21240 
21244  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21245 
21249  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21250 };
21251 
21252 
21255 class HPS_API WindowInfoControl : public Control
21256 {
21257 public:
21258 
21260  explicit WindowInfoControl(WindowKey & in_window);
21261 
21263  WindowInfoControl(WindowInfoControl const & in_that);
21264 
21269 
21273  WindowInfoControl & operator=(WindowInfoControl && in_that);
21274 
21276  ~WindowInfoControl();
21277 
21278  HPS::Type ObjectType() const {return HPS::Type::WindowInfoControl;}
21279 
21281  WindowInfoControl & operator=(WindowInfoControl const & in_that);
21282 
21287  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21288 
21293  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21294 
21299  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21300 
21305  bool ShowWindowSize(float & out_width, float & out_height) const;
21306 
21312  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21313 
21317  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21318 
21322  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21323 
21328  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
21329 
21334  bool ShowLastUpdateTime(Time & out_time) const;
21335 
21339  bool ShowDepthPeelingLayers(size_t & out_layers) const;
21340 
21344  bool ShowVideoMemory(size_t & out_video_memory) const;
21345 
21349  bool ShowDepthBufferSize(size_t & out_bits) const;
21350 
21354  bool ShowMaxLights(size_t & out_lights) const;
21355 
21359  bool ShowColorBitPlanes(size_t & out_planes) const;
21360 
21361 private:
21364 };
21365 
21367 class HPS_API FontInfoState : public Object
21368 {
21369 public:
21370 
21372  FontInfoState();
21373 
21375  FontInfoState(FontInfoState const & in_kit);
21376 
21380  FontInfoState(FontInfoState && in_that);
21381 
21385  FontInfoState & operator=(FontInfoState && in_that);
21386 
21388  virtual ~FontInfoState();
21389 
21390  HPS::Type ObjectType() const {return HPS::Type::FontInfoState;}
21391 
21394  void Assign(FontInfoState const & in_that);
21395 
21398  void Set(FontInfoState const & in_kit);
21399 
21402  void Show(FontInfoState & out_kit) const;
21403 
21407  FontInfoState & operator=(FontInfoState const & in_kit);
21408 
21411  bool Empty() const;
21412 
21416  bool Equals(FontInfoState const & in_kit) const;
21417 
21421  bool operator==(FontInfoState const & in_kit) const;
21422 
21426  bool operator!=(FontInfoState const & in_kit) const;
21427 
21430  UTF8 GetName() const;
21431 
21434  bool GetShellConvertibility() const;
21435 };
21436 
21437 
21442 class HPS_API AttributeLockKit : public Object
21443 {
21444 public:
21445 
21447  AttributeLockKit();
21448 
21450  AttributeLockKit(AttributeLockKit const & in_kit);
21451 
21455  AttributeLockKit(AttributeLockKit && in_that);
21456 
21460  AttributeLockKit & operator=(AttributeLockKit && in_that);
21461 
21463  virtual ~AttributeLockKit();
21464 
21465  HPS::Type ObjectType() const {return HPS::Type::AttributeLockKit;}
21466 
21470  static AttributeLockKit GetDefault();
21471 
21474  void Set(AttributeLockKit const & in_kit);
21475 
21478  void Show(AttributeLockKit & out_kit) const;
21479 
21483  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
21484 
21487  bool Empty() const;
21488 
21492  bool Equals(AttributeLockKit const & in_kit) const;
21493 
21497  bool operator==(AttributeLockKit const & in_kit) const;
21498 
21502  bool operator!=(AttributeLockKit const & in_kit) const;
21503 
21509  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
21510 
21515  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21516 
21522  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21523 
21529  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21530 
21531 
21534  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21535 
21538  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
21539 
21542  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21543 
21546  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21547 
21550  AttributeLockKit & UnsetEverything();
21551 
21552 
21557  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21558 
21563  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21564 
21569  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21570 
21575  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21576 };
21577 
21578 
21583 class HPS_API AttributeLockControl : public Control
21584 {
21585 public:
21586 
21588  explicit AttributeLockControl(SegmentKey & in_seg);
21589 
21594 
21598  AttributeLockControl & operator=(AttributeLockControl && in_that);
21599 
21601  AttributeLockControl(AttributeLockControl const & in_that);
21602 
21605 
21606  HPS::Type ObjectType() const {return HPS::Type::AttributeLockControl;}
21607 
21609  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21610 
21611 
21617  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21618 
21623  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21624 
21630  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21631 
21637  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21638 
21639 
21642  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21643 
21646  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21647 
21650  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21651 
21654  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21655 
21658  AttributeLockControl & UnsetEverything();
21659 
21660 
21665  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21666 
21671  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21672 
21677  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21678 
21683  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21684 
21685 private:
21688 };
21689 
21693 
21694 class HPS_API GeometryKey : public Key
21695 {
21696 public:
21698  GeometryKey();
21699 
21703  explicit GeometryKey(Key const & in_that);
21704 
21707  GeometryKey(GeometryKey const & in_that);
21708 
21712  GeometryKey & operator=(GeometryKey const & in_that);
21713 
21717  GeometryKey(GeometryKey && in_that);
21718 
21722  GeometryKey & operator=(GeometryKey && in_that);
21723 
21724  ~GeometryKey();
21725 
21726  HPS::Type ObjectType() const { return HPS::Type::GeometryKey; };
21727 
21728 
21732  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21733 
21737  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
21738 
21739 
21740 
21747  GeometryKey & SetPriority(int in_priority);
21748 
21751  GeometryKey & UnsetPriority();
21752 
21756  bool ShowPriority(int & out_priority) const;
21757 
21758 
21764  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21765 
21770  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
21771 
21776  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21777 
21781  GeometryKey & UnsetUserData(intptr_t in_index);
21782 
21787  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21788 
21792  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
21793 
21796  GeometryKey & UnsetAllUserData();
21797 
21799  size_t ShowUserDataCount() const;
21800 
21804  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21805 
21810  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21811 
21816  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21817 
21822  bool ShowBoundings(BoundingKit & out_kit) const;
21823 };
21824 
21825 
21827 class HPS_API LineKit : public Object
21828 {
21829 public:
21831  LineKit();
21832 
21835  LineKit(LineKit const & in_kit);
21836 
21840  LineKit(LineKit && in_that);
21841 
21845  LineKit & operator=(LineKit && in_that);
21846 
21847  virtual ~LineKit();
21848 
21849  HPS::Type ObjectType() const { return HPS::Type::LineKit; };
21850 
21853  void Consume(LineKit & in_kit);
21854 
21857  void Set(LineKit const & in_kit);
21858 
21861  void Show(LineKit & out_kit) const;
21862 
21866  LineKit & operator=(LineKit const & in_kit);
21867 
21870  bool Empty() const;
21871 
21875  bool Equals(LineKit const & in_kit) const;
21876 
21880  bool operator==(LineKit const & in_kit) const;
21881 
21885  bool operator!=(LineKit const & in_kit) const;
21886 
21889  size_t GetPointCount() const;
21890 
21897  LineKit & SetPriority(int in_priority);
21898 
21901  LineKit & UnsetPriority();
21902 
21906  bool ShowPriority(int & out_priority) const;
21907 
21908 
21912  LineKit & SetPoints(PointArray const & in_points);
21913 
21918  LineKit & SetPoints(size_t in_count, Point const in_points []);
21919 
21920 
21923  LineKit & UnsetPoints();
21924 
21927  LineKit & UnsetEverything();
21928 
21929 
21933  bool ShowPoints(PointArray & out_points) const;
21934 
21940  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
21941 
21946  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
21947 
21953  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
21954 
21955 
21961  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21962 
21967  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21968 
21973  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
21974 
21980  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21981 
21987  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21988 
21994  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21995 
22000  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22001 
22006  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22007 
22011  LineKit & UnsetUserData(intptr_t in_index);
22012 
22017  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22018 
22022  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
22023 
22026  LineKit & UnsetAllUserData();
22027 
22029  size_t ShowUserDataCount() const;
22030 
22034  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22035 
22040  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22041 
22046  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22047 };
22048 
22050 class HPS_API LineKey : public GeometryKey
22051 {
22052 public:
22054  LineKey();
22055 
22059  explicit LineKey(Key const & in_that);
22060 
22063  LineKey(LineKey const & in_that);
22064 
22068  LineKey & operator=(LineKey const & in_that);
22069 
22073  LineKey(LineKey && in_that);
22074 
22078  LineKey & operator=(LineKey && in_that);
22079 
22080  ~LineKey();
22081 
22082  HPS::Type ObjectType() const { return HPS::Type::LineKey; };
22083 
22084 
22087  void Consume(LineKit & in_kit);
22088 
22091  void Set(LineKit const & in_kit);
22092 
22095  void Show(LineKit & out_kit) const;
22096 
22099  size_t GetPointCount() const;
22100 
22104  LineKey & SetPoints(PointArray const & in_points);
22105 
22110  LineKey & SetPoints(size_t in_count, Point const in_points []);
22111 
22112 
22116  bool ShowPoints(PointArray & out_points) const;
22117 
22123  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22124 
22129  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22130 
22136  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22137 
22138 
22144  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22145 
22150  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22151 
22156  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22157 
22163  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22164 
22170  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22171 };
22172 
22173 
22174 
22176 class HPS_API MarkerKit : public Object
22177 {
22178 public:
22180  MarkerKit();
22181 
22184  MarkerKit(MarkerKit const & in_kit);
22185 
22189  MarkerKit(MarkerKit && in_that);
22190 
22194  MarkerKit & operator=(MarkerKit && in_that);
22195 
22196  virtual ~MarkerKit();
22197 
22198  HPS::Type ObjectType() const { return HPS::Type::MarkerKit; };
22199 
22202  void Consume(MarkerKit & in_kit);
22203 
22206  void Set(MarkerKit const & in_kit);
22207 
22210  void Show(MarkerKit & out_kit) const;
22211 
22215  MarkerKit & operator=(MarkerKit const & in_kit);
22216 
22219  bool Empty() const;
22220 
22224  bool Equals(MarkerKit const & in_kit) const;
22225 
22229  bool operator==(MarkerKit const & in_kit) const;
22230 
22234  bool operator!=(MarkerKit const & in_kit) const;
22235 
22236 
22243  MarkerKit & SetPriority(int in_priority);
22244 
22247  MarkerKit & UnsetPriority();
22248 
22252  bool ShowPriority(int & out_priority) const;
22253 
22257  MarkerKit & SetPoint(Point const & in_point);
22258 
22259 
22262  MarkerKit & UnsetPoint();
22263 
22266  MarkerKit & UnsetEverything();
22267 
22268 
22272  bool ShowPoint(HPS::Point & out_point) const;
22273 
22279  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22280 
22285  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22286 
22291  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22292 
22296  MarkerKit & UnsetUserData(intptr_t in_index);
22297 
22302  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22303 
22307  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
22308 
22311  MarkerKit & UnsetAllUserData();
22312 
22314  size_t ShowUserDataCount() const;
22315 
22319  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22320 
22325  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22326 
22331  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22332 };
22333 
22335 class HPS_API MarkerKey : public GeometryKey
22336 {
22337 public:
22339  MarkerKey();
22340 
22344  explicit MarkerKey(Key const & in_that);
22345 
22348  MarkerKey(MarkerKey const & in_that);
22349 
22353  MarkerKey & operator=(MarkerKey const & in_that);
22354 
22358  MarkerKey(MarkerKey && in_that);
22359 
22363  MarkerKey & operator=(MarkerKey && in_that);
22364 
22365  ~MarkerKey();
22366 
22367  HPS::Type ObjectType() const { return HPS::Type::MarkerKey; };
22368 
22369 
22372  void Consume(MarkerKit & in_kit);
22373 
22376  void Set(MarkerKit const & in_kit);
22377 
22380  void Show(MarkerKit & out_kit) const;
22381 
22382 
22386  MarkerKey & SetPoint(Point const & in_point);
22387 
22391  bool ShowPoint(Point & out_point) const;
22392 };
22393 
22394 
22395 
22397 class HPS_API DistantLightKit : public Object
22398 {
22399 public:
22401  DistantLightKit();
22402 
22405  DistantLightKit(DistantLightKit const & in_kit);
22406 
22410  DistantLightKit(DistantLightKit && in_that);
22411 
22415  DistantLightKit & operator=(DistantLightKit && in_that);
22416 
22417  virtual ~DistantLightKit();
22418 
22419  HPS::Type ObjectType() const { return HPS::Type::DistantLightKit; };
22420 
22423  void Consume(DistantLightKit & in_kit);
22424 
22427  void Set(DistantLightKit const & in_kit);
22428 
22431  void Show(DistantLightKit & out_kit) const;
22432 
22436  DistantLightKit & operator=(DistantLightKit const & in_kit);
22437 
22440  bool Empty() const;
22441 
22445  bool Equals(DistantLightKit const & in_kit) const;
22446 
22450  bool operator==(DistantLightKit const & in_kit) const;
22451 
22455  bool operator!=(DistantLightKit const & in_kit) const;
22456 
22457 
22464  DistantLightKit & SetPriority(int in_priority);
22465 
22471  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
22472 
22476  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
22477 
22481  DistantLightKit & SetColorByIndex(float in_index);
22482 
22488  DistantLightKit & SetCameraRelative(bool in_state);
22489 
22490 
22493  DistantLightKit & UnsetPriority();
22494 
22497  DistantLightKit & UnsetDirection();
22498 
22501  DistantLightKit & UnsetColor();
22502 
22505  DistantLightKit & UnsetCameraRelative();
22506 
22509  DistantLightKit & UnsetEverything();
22510 
22511 
22515  bool ShowPriority(int & out_priority) const;
22516 
22520  bool ShowDirection(HPS::Vector & out_vector) const;
22521 
22527  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22528 
22532  bool ShowCameraRelative(bool & out_state) const;
22533 
22539  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22540 
22545  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22546 
22551  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22552 
22556  DistantLightKit & UnsetUserData(intptr_t in_index);
22557 
22562  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22563 
22567  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
22568 
22571  DistantLightKit & UnsetAllUserData();
22572 
22574  size_t ShowUserDataCount() const;
22575 
22579  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22580 
22585  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22586 
22591  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22592 };
22593 
22594 
22595 
22597 class HPS_API DistantLightKey : public GeometryKey
22598 {
22599 public:
22601  DistantLightKey();
22602 
22606  explicit DistantLightKey(Key const & in_that);
22607 
22610  DistantLightKey(DistantLightKey const & in_that);
22611 
22615  DistantLightKey & operator=(DistantLightKey const & in_that);
22616 
22620  DistantLightKey(DistantLightKey && in_that);
22621 
22625  DistantLightKey & operator=(DistantLightKey && in_that);
22626 
22627  ~DistantLightKey();
22628 
22629  HPS::Type ObjectType() const { return HPS::Type::DistantLightKey; };
22630 
22633  void Consume(DistantLightKit & in_kit);
22634 
22637  void Set(DistantLightKit const & in_kit);
22638 
22641  void Show(DistantLightKit & out_kit) const;
22642 
22643 
22648  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
22649 
22653  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22654 
22658  DistantLightKey & SetColorByIndex(float in_index);
22659 
22664  DistantLightKey & SetCameraRelative(bool in_state);
22665 
22666 
22669  DistantLightKey & UnsetColor();
22670 
22671 
22675  bool ShowDirection(HPS::Vector & out_vector) const;
22676 
22682  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22683 
22687  bool ShowCameraRelative(bool & out_state) const;
22688 };
22689 
22690 
22691 
22692 
22694 class HPS_API CylinderKit : public Object
22695 {
22696 public:
22698  CylinderKit();
22699 
22702  CylinderKit(CylinderKit const & in_kit);
22703 
22707  CylinderKit(CylinderKit && in_that);
22708 
22712  CylinderKit & operator=(CylinderKit && in_that);
22713 
22714  virtual ~CylinderKit();
22715 
22716  HPS::Type ObjectType() const { return HPS::Type::CylinderKit; };
22717 
22720  void Consume(CylinderKit & in_kit);
22721 
22724  void Set(CylinderKit const & in_kit);
22725 
22728  void Show(CylinderKit & out_kit) const;
22729 
22733  CylinderKit & operator=(CylinderKit const & in_kit);
22734 
22737  bool Empty() const;
22738 
22742  bool Equals(CylinderKit const & in_kit) const;
22743 
22747  bool operator==(CylinderKit const & in_kit) const;
22748 
22752  bool operator!=(CylinderKit const & in_kit) const;
22753 
22756  size_t GetPointCount() const;
22757 
22764  CylinderKit & SetPriority(int in_priority);
22765 
22768  CylinderKit & UnsetPriority();
22769 
22773  bool ShowPriority(int & out_priority) const;
22774 
22775 
22779  CylinderKit & SetPoints(PointArray const & in_points);
22780 
22785  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
22786 
22790  CylinderKit & SetRadii(FloatArray const & in_radii);
22791 
22796  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
22797 
22801  CylinderKit & SetCaps(Cylinder::Capping in_capping);
22802 
22803 
22806  CylinderKit & UnsetPoints();
22807 
22810  CylinderKit & UnsetRadii();
22811 
22814  CylinderKit & UnsetCaps();
22815 
22818  CylinderKit & UnsetEverything();
22819 
22820 
22824  bool ShowPoints(PointArray & out_points) const;
22825 
22831  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22832 
22837  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22838 
22844  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22845 
22849  bool ShowRadii(FloatArray & out_radii) const;
22850 
22854  bool ShowCaps(Cylinder::Capping & out_caps) const;
22855 
22856 
22863  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22864 
22870  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22871 
22878  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22879 
22886  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22887 
22894  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22895 
22902  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22903 
22909  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22910 
22911 
22918  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22919 
22925  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22926 
22933  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22934 
22941  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22942 
22949  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22950 
22957  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22958 
22964  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22965 
22966 
22969  CylinderKit & UnsetVertexColors();
22970 
22975  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22976 
22980  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
22981 
22982 
22986  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
22987 
22993  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22994 
22999  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
23000 
23001 
23013  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;
23014 
23027  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23028 
23034  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23035 
23040  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23041 
23046  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23047 
23051  CylinderKit & UnsetUserData(intptr_t in_index);
23052 
23057  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23058 
23062  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
23063 
23066  CylinderKit & UnsetAllUserData();
23067 
23069  size_t ShowUserDataCount() const;
23070 
23074  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23075 
23080  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23081 
23086  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23087 };
23088 
23089 
23090 
23092 class HPS_API CylinderKey : public GeometryKey
23093 {
23094 public:
23096  CylinderKey();
23097 
23101  explicit CylinderKey(Key const & in_that);
23102 
23105  CylinderKey(CylinderKey const & in_that);
23106 
23110  CylinderKey & operator=(CylinderKey const & in_that);
23111 
23115  CylinderKey(CylinderKey && in_that);
23116 
23120  CylinderKey & operator=(CylinderKey && in_that);
23121 
23122  ~CylinderKey();
23123 
23124  HPS::Type ObjectType() const { return HPS::Type::CylinderKey; };
23125 
23128  void Consume(CylinderKit & in_kit);
23129 
23132  void Set(CylinderKit const & in_kit);
23133 
23134 
23140  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23141 
23146  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23147 
23152  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
23153 
23159  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23160 
23166  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23167 
23168 
23174  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
23175 
23180  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
23181 
23186  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
23187 
23193  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
23194 
23200  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
23201 
23202 
23205  void Show(CylinderKit & out_kit) const;
23206 
23209  size_t GetPointCount() const;
23210 
23214  bool ShowPoints(PointArray & out_points) const;
23215 
23221  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23222 
23227  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23228 
23234  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23235 
23239  bool ShowRadii(FloatArray & out_radii) const;
23240 
23244  bool ShowCaps(Cylinder::Capping & out_caps) const;
23245 
23246 
23253  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23254 
23261  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23262 
23269  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23270 
23271 
23278  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23279 
23286  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23287 
23294  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23295 
23296 
23299  CylinderKey & UnsetVertexColors();
23300 
23305  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23306 
23310  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
23311 
23317  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23318 
23319 
23331  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;
23332 
23345  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23346 };
23347 
23348 
23349 
23350 
23352 class HPS_API SphereKit : public Object
23353 {
23354 public:
23356  SphereKit();
23357 
23360  SphereKit(SphereKit const & in_kit);
23361 
23365  SphereKit(SphereKit && in_that);
23366 
23370  SphereKit & operator=(SphereKit && in_that);
23371 
23372  virtual ~SphereKit();
23373 
23374  HPS::Type ObjectType() const { return HPS::Type::SphereKit; };
23375 
23378  void Consume(SphereKit & in_kit);
23379 
23382  void Set(SphereKit const & in_kit);
23383 
23386  void Show(SphereKit & out_kit) const;
23387 
23391  SphereKit & operator=(SphereKit const & in_kit);
23392 
23395  bool Empty() const;
23396 
23400  bool Equals(SphereKit const & in_kit) const;
23401 
23405  bool operator==(SphereKit const & in_kit) const;
23406 
23410  bool operator!=(SphereKit const & in_kit) const;
23411 
23418  SphereKit & SetPriority(int in_priority);
23419 
23422  SphereKit & UnsetPriority();
23423 
23427  bool ShowPriority(int & out_priority) const;
23428 
23432  SphereKit & SetCenter(Point const & in_center);
23433 
23437  SphereKit & SetRadius(float in_radius);
23438 
23443  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23444 
23445 
23448  SphereKit & UnsetCenter();
23449 
23452  SphereKit & UnsetRadius();
23453 
23456  SphereKit & UnsetBasis();
23457 
23460  SphereKit & UnsetEverything();
23461 
23462 
23466  bool ShowCenter(Point & out_center) const;
23467 
23471  bool ShowRadius(float & out_radius) const;
23472 
23477  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23478 
23484  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23485 
23490  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23491 
23496  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23497 
23501  SphereKit & UnsetUserData(intptr_t in_index);
23502 
23507  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23508 
23512  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
23513 
23516  SphereKit & UnsetAllUserData();
23517 
23519  size_t ShowUserDataCount() const;
23520 
23524  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23525 
23530  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23531 
23536  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23537 };
23538 
23540 class HPS_API SphereKey : public GeometryKey
23541 {
23542 public:
23544  SphereKey();
23545 
23549  explicit SphereKey(Key const & in_that);
23550 
23553  SphereKey(SphereKey const & in_that);
23554 
23558  SphereKey & operator=(SphereKey const & in_that);
23559 
23563  SphereKey(SphereKey && in_that);
23564 
23568  SphereKey & operator=(SphereKey && in_that);
23569 
23570  ~SphereKey();
23571 
23572  HPS::Type ObjectType() const {return HPS::Type::SphereKey;};
23573 
23576  void Consume(SphereKit & in_kit);
23577 
23580  void Set(SphereKit const & in_kit);
23581 
23584  void Show(SphereKit & out_kit) const;
23585 
23586 
23590  SphereKey & SetCenter(Point const & in_center);
23591 
23595  SphereKey & SetRadius(float in_radius);
23596 
23601  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23602 
23603 
23607  bool ShowCenter(Point & out_center) const;
23608 
23612  bool ShowRadius(float & out_radius) const;
23613 
23618  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23619 };
23620 
23621 
23622 
23623 
23625 class HPS_API CircleKit : public Object
23626 {
23627 public:
23629  CircleKit();
23630 
23633  CircleKit(CircleKit const & in_kit);
23634 
23638  CircleKit(CircleKit && in_that);
23639 
23643  CircleKit & operator=(CircleKit && in_that);
23644 
23645  virtual ~CircleKit();
23646 
23647  HPS::Type ObjectType() const { return HPS::Type::CircleKit; };
23648 
23651  void Consume(CircleKit & in_kit);
23652 
23655  void Set(CircleKit const & in_kit);
23656 
23659  void Show(CircleKit & out_kit) const;
23660 
23664  CircleKit & operator=(CircleKit const & in_kit);
23665 
23668  bool Empty() const;
23669 
23673  bool Equals(CircleKit const & in_kit) const;
23674 
23678  bool operator==(CircleKit const & in_kit) const;
23679 
23683  bool operator!=(CircleKit const & in_kit) const;
23684 
23691  CircleKit & SetPriority(int const in_priority);
23692 
23695  CircleKit & UnsetPriority();
23696 
23700  bool ShowPriority(int & out_priority) const;
23701 
23702 
23703 
23707  CircleKit & SetCenter(Point const & in_center);
23708 
23712  CircleKit & SetRadius(float in_radius);
23713 
23717  CircleKit & SetNormal(Vector const & in_normal);
23718 
23719 
23722  CircleKit & UnsetCenter();
23723 
23726  CircleKit & UnsetRadius();
23727 
23730  CircleKit & UnsetNormal();
23731 
23734  CircleKit & UnsetEverything();
23735 
23736 
23740  bool ShowCenter(Point & out_center) const;
23741 
23745  bool ShowRadius(float & out_radius) const;
23746 
23750  bool ShowNormal(Vector & out_normal) const;
23751 
23757  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23758 
23763  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23764 
23769  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23770 
23774  CircleKit & UnsetUserData(intptr_t in_index);
23775 
23780  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23781 
23785  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
23786 
23789  CircleKit & UnsetAllUserData();
23790 
23792  size_t ShowUserDataCount() const;
23793 
23797  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23798 
23803  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23804 
23809  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23810 };
23811 
23812 
23815 class HPS_API CircleKey : public GeometryKey
23816 {
23817 public:
23819  CircleKey();
23820 
23824  explicit CircleKey(Key const & in_that);
23825 
23828  CircleKey(CircleKey const & in_that);
23829 
23833  CircleKey & operator=(CircleKey const & in_that);
23834 
23838  CircleKey(CircleKey && in_that);
23839 
23843  CircleKey & operator=(CircleKey && in_that);
23844 
23845  ~CircleKey();
23846 
23847  HPS::Type ObjectType() const { return HPS::Type::CircleKey; };
23848 
23849 
23852  void Consume(CircleKit & in_kit);
23853 
23856  void Set(CircleKit const & in_kit);
23857 
23860  void Show(CircleKit & out_kit) const;
23861 
23862 
23866  CircleKey & SetCenter(Point const & in_center);
23867 
23871  CircleKey & SetRadius(float in_radius);
23872 
23876  CircleKey & SetNormal(Vector const & in_normal);
23877 
23878 
23882  bool ShowCenter(Point & out_center) const;
23883 
23887  bool ShowRadius(float & out_radius) const;
23888 
23892  bool ShowNormal(Vector & out_normal) const;
23893 };
23894 
23895 
23896 
23897 
23899 class HPS_API CircularArcKit : public Object
23900 {
23901 public:
23903  CircularArcKit();
23904 
23907  CircularArcKit(CircularArcKit const & in_kit);
23908 
23912  CircularArcKit(CircularArcKit && in_that);
23913 
23917  CircularArcKit & operator=(CircularArcKit && in_that);
23918 
23919  virtual ~CircularArcKit();
23920 
23921  HPS::Type ObjectType() const { return HPS::Type::CircularArcKit; };
23922 
23925  void Consume(CircularArcKit & in_kit);
23926 
23929  void Set(CircularArcKit const & in_kit);
23930 
23933  void Show(CircularArcKit & out_kit) const;
23934 
23938  CircularArcKit & operator=(CircularArcKit const & in_kit);
23939 
23942  bool Empty() const;
23943 
23947  bool Equals(CircularArcKit const & in_kit) const;
23948 
23952  bool operator==(CircularArcKit const & in_kit) const;
23953 
23957  bool operator!=(CircularArcKit const & in_kit) const;
23958 
23965  CircularArcKit & SetPriority(int in_priority);
23966 
23969  CircularArcKit & UnsetPriority();
23970 
23974  bool ShowPriority(int & out_priority) const;
23975 
23976 
23980  CircularArcKit & SetStart(Point const & in_start);
23981 
23985  CircularArcKit & SetMiddle(Point const & in_middle);
23986 
23990  CircularArcKit & SetEnd(Point const & in_end);
23991 
23992 
23995  CircularArcKit & UnsetStart();
23996 
23999  CircularArcKit & UnsetMiddle();
24000 
24003  CircularArcKit & UnsetEnd();
24004 
24007  CircularArcKit & UnsetEverything();
24008 
24009 
24013  bool ShowStart(Point & out_start) const;
24014 
24018  bool ShowMiddle(Point & out_middle) const;
24019 
24023  bool ShowEnd(Point & out_end) const;
24024 
24030  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24031 
24036  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24037 
24042  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24043 
24047  CircularArcKit & UnsetUserData(intptr_t in_index);
24048 
24053  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24054 
24058  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
24059 
24062  CircularArcKit & UnsetAllUserData();
24063 
24065  size_t ShowUserDataCount() const;
24066 
24070  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24071 
24076  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24077 
24082  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24083 };
24084 
24087 class HPS_API CircularArcKey : public GeometryKey
24088 {
24089 public:
24091  CircularArcKey();
24092 
24096  explicit CircularArcKey(Key const & in_that);
24097 
24100  CircularArcKey(CircularArcKey const & in_that);
24101 
24105  CircularArcKey & operator=(CircularArcKey const & in_that);
24106 
24110  CircularArcKey(CircularArcKey && in_that);
24111 
24115  CircularArcKey & operator=(CircularArcKey && in_that);
24116 
24117  ~CircularArcKey();
24118 
24119  HPS::Type ObjectType() const { return HPS::Type::CircularArcKey; };
24120 
24121 
24124  void Consume(CircularArcKit & in_kit);
24125 
24128  void Set(CircularArcKit const & in_kit);
24129 
24132  void Show(CircularArcKit & out_kit) const;
24133 
24134 
24138  CircularArcKey & SetStart(Point const & in_start);
24139 
24143  CircularArcKey & SetMiddle(Point const & in_middle);
24144 
24148  CircularArcKey & SetEnd(Point const & in_end);
24149 
24150 
24154  bool ShowStart(Point & out_start) const;
24155 
24159  bool ShowMiddle(Point & out_middle) const;
24160 
24164  bool ShowEnd(Point & out_end) const;
24165 };
24166 
24167 
24168 
24170 class HPS_API CircularWedgeKit : public Object
24171 {
24172 public:
24174  CircularWedgeKit();
24175 
24178  CircularWedgeKit(CircularWedgeKit const & in_kit);
24179 
24183  CircularWedgeKit(CircularWedgeKit && in_that);
24184 
24188  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
24189 
24190  virtual ~CircularWedgeKit();
24191 
24192  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKit; };
24193 
24196  void Consume(CircularWedgeKit & in_kit);
24197 
24200  void Set(CircularWedgeKit const & in_kit);
24201 
24204  void Show(CircularWedgeKit & out_kit) const;
24205 
24209  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
24210 
24213  bool Empty() const;
24214 
24218  bool Equals(CircularWedgeKit const & in_kit) const;
24219 
24223  bool operator==(CircularWedgeKit const & in_kit) const;
24224 
24228  bool operator!=(CircularWedgeKit const & in_kit) const;
24229 
24230 
24237  CircularWedgeKit & SetPriority(int in_priority);
24238 
24241  CircularWedgeKit & UnsetPriority();
24242 
24246  bool ShowPriority(int & out_priority) const;
24247 
24248 
24252  CircularWedgeKit & SetStart(Point const & in_start);
24253 
24257  CircularWedgeKit & SetMiddle(Point const & in_middle);
24258 
24262  CircularWedgeKit & SetEnd(Point const & in_end);
24263 
24264 
24267  CircularWedgeKit & UnsetStart();
24268 
24271  CircularWedgeKit & UnsetMiddle();
24272 
24275  CircularWedgeKit & UnsetEnd();
24276 
24279  CircularWedgeKit & UnsetEverything();
24280 
24281 
24285  bool ShowStart(Point & out_start) const;
24286 
24290  bool ShowMiddle(Point & out_middle) const;
24291 
24295  bool ShowEnd(Point & out_end) const;
24296 
24302  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24303 
24308  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24309 
24314  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24315 
24319  CircularWedgeKit & UnsetUserData(intptr_t in_index);
24320 
24325  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24326 
24330  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
24331 
24334  CircularWedgeKit & UnsetAllUserData();
24335 
24337  size_t ShowUserDataCount() const;
24338 
24342  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24343 
24348  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24349 
24354  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24355 };
24356 
24357 
24361 class HPS_API CircularWedgeKey : public GeometryKey
24362 {
24363 public:
24365  CircularWedgeKey();
24366 
24370  explicit CircularWedgeKey(Key const & in_that);
24371 
24374  CircularWedgeKey(CircularWedgeKey const & in_that);
24375 
24379  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
24380 
24384  CircularWedgeKey(CircularWedgeKey && in_that);
24385 
24389  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
24390 
24391  ~CircularWedgeKey();
24392 
24393  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKey; };
24394 
24395 
24398  void Consume(CircularWedgeKit & in_kit);
24399 
24402  void Set(CircularWedgeKit const & in_kit);
24403 
24406  void Show(CircularWedgeKit & out_kit) const;
24407 
24408 
24412  CircularWedgeKey & SetStart(Point const & in_start);
24413 
24417  CircularWedgeKey & SetMiddle(Point const & in_middle);
24418 
24422  CircularWedgeKey & SetEnd(Point const & in_end);
24423 
24424 
24428  bool ShowStart(Point & out_start) const;
24429 
24433  bool ShowMiddle(Point & out_middle) const;
24434 
24438  bool ShowEnd(Point & out_end) const;
24439 };
24440 
24441 
24442 
24444 class HPS_API CuttingSectionKit : public Object
24445 {
24446 public:
24449 
24452  CuttingSectionKit(CuttingSectionKit const & in_kit);
24453 
24458 
24462  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
24463 
24464  virtual ~CuttingSectionKit();
24465 
24466  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKit; };
24467 
24470  void Consume(CuttingSectionKit & in_kit);
24471 
24474  void Set(CuttingSectionKit const & in_kit);
24475 
24478  void Show(CuttingSectionKit & out_kit) const;
24479 
24483  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
24484 
24487  bool Empty() const;
24488 
24492  bool Equals(CuttingSectionKit const & in_kit) const;
24493 
24497  bool operator==(CuttingSectionKit const & in_kit) const;
24498 
24502  bool operator!=(CuttingSectionKit const & in_kit) const;
24503 
24510  CuttingSectionKit & SetPriority(int in_priority);
24511 
24514  CuttingSectionKit & UnsetPriority();
24515 
24519  bool ShowPriority(int & out_priority) const;
24520 
24521 
24525  CuttingSectionKit & SetPlanes(Plane const & in_plane);
24526 
24530  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
24531 
24536  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
24537 
24543  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24544 
24545 
24548  CuttingSectionKit & UnsetPlanes();
24549 
24552  CuttingSectionKit & UnsetVisualization();
24553 
24556  CuttingSectionKit & UnsetEverything();
24557 
24558 
24561  size_t GetPlaneCount() const;
24562 
24566  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24567 
24573  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24574 
24575 
24582  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24583 
24589  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24590 
24597  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24598 
24605  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24606 
24614  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24615 
24621  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24622 
24627  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24628 
24633  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24634 
24638  CuttingSectionKit & UnsetUserData(intptr_t in_index);
24639 
24644  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24645 
24649  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
24650 
24653  CuttingSectionKit & UnsetAllUserData();
24654 
24656  size_t ShowUserDataCount() const;
24657 
24661  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24662 
24667  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24668 
24673  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24674 };
24675 
24676 
24678 class HPS_API CuttingSectionKey : public GeometryKey
24679 {
24680 public:
24683 
24687  explicit CuttingSectionKey(Key const & in_that);
24688 
24691  CuttingSectionKey(CuttingSectionKey const & in_that);
24692 
24696  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24697 
24702 
24706  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24707 
24708  ~CuttingSectionKey();
24709 
24710  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKey; };
24711 
24712 
24715  void Consume(CuttingSectionKit & in_kit);
24716 
24719  void Set(CuttingSectionKit const & in_kit);
24720 
24723  void Show(CuttingSectionKit & out_kit) const;
24724 
24725 
24729  CuttingSectionKey & SetPlanes(Plane const & in_plane);
24730 
24734  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
24735 
24740  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
24741 
24747  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24748 
24749 
24752  size_t GetPlaneCount() const;
24753 
24757  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24758 
24764  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24765 
24766 
24773  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24774 
24780  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24781 
24788  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24789 
24796  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24797 
24803  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24804 };
24805 
24806 
24807 
24809 class HPS_API InfiniteLineKit : public Object
24810 {
24811 public:
24813  InfiniteLineKit();
24814 
24817  InfiniteLineKit(InfiniteLineKit const & in_kit);
24818 
24822  InfiniteLineKit(InfiniteLineKit && in_that);
24823 
24827  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
24828 
24829  virtual ~InfiniteLineKit();
24830 
24831  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKit; };
24832 
24835  void Consume(InfiniteLineKit & in_kit);
24836 
24839  void Set(InfiniteLineKit const & in_kit);
24840 
24843  void Show(InfiniteLineKit & out_kit) const;
24844 
24848  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
24849 
24852  bool Empty() const;
24853 
24857  bool Equals(InfiniteLineKit const & in_kit) const;
24858 
24862  bool operator==(InfiniteLineKit const & in_kit) const;
24863 
24867  bool operator!=(InfiniteLineKit const & in_kit) const;
24868 
24875  InfiniteLineKit & SetPriority(int in_priority);
24876 
24879  InfiniteLineKit & UnsetPriority();
24880 
24884  bool ShowPriority(int & out_priority) const;
24885 
24886 
24890  InfiniteLineKit & SetFirst(Point const & in_first);
24891 
24895  InfiniteLineKit & SetSecond(Point const & in_second);
24896 
24900  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
24901 
24902 
24905  InfiniteLineKit & UnsetFirst();
24906 
24909  InfiniteLineKit & UnsetSecond();
24910 
24913  InfiniteLineKit & UnsetType();
24914 
24917  InfiniteLineKit & UnsetEverything();
24918 
24919 
24923  bool ShowFirst(Point & out_first) const;
24924 
24928  bool ShowSecond(Point & out_second) const;
24929 
24933  bool ShowType(InfiniteLine::Type & out_type) const;
24934 
24940  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24941 
24946  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24947 
24952  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24953 
24957  InfiniteLineKit & UnsetUserData(intptr_t in_index);
24958 
24963  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24964 
24968  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
24969 
24972  InfiniteLineKit & UnsetAllUserData();
24973 
24975  size_t ShowUserDataCount() const;
24976 
24980  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24981 
24986  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24987 
24992  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24993 };
24994 
24995 
24997 class HPS_API InfiniteLineKey : public GeometryKey
24998 {
24999 public:
25001  InfiniteLineKey();
25002 
25006  explicit InfiniteLineKey(Key const & in_that);
25007 
25010  InfiniteLineKey(InfiniteLineKey const & in_that);
25011 
25015  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
25016 
25020  InfiniteLineKey(InfiniteLineKey && in_that);
25021 
25025  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
25026 
25027  ~InfiniteLineKey();
25028 
25029  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKey; };
25030 
25033  void Consume(InfiniteLineKit & in_kit);
25034 
25037  void Set(InfiniteLineKit const & in_kit);
25038 
25041  void Show(InfiniteLineKit & out_kit) const;
25042 
25043 
25047  InfiniteLineKey & SetFirst(Point const & in_first);
25048 
25052  InfiniteLineKey & SetSecond(Point const & in_second);
25053 
25057  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
25058 
25059 
25063  bool ShowFirst(Point & out_first) const;
25064 
25068  bool ShowSecond(Point & out_second) const;
25069 
25073  bool ShowType(InfiniteLine::Type & out_type) const;
25074 };
25075 
25076 
25077 
25081 class HPS_API SpotlightKit : public Object
25082 {
25083 public:
25085  SpotlightKit();
25086 
25089  SpotlightKit(SpotlightKit const & in_kit);
25090 
25094  SpotlightKit(SpotlightKit && in_that);
25095 
25099  SpotlightKit & operator=(SpotlightKit && in_that);
25100 
25101  virtual ~SpotlightKit();
25102 
25103  HPS::Type ObjectType() const { return HPS::Type::SpotlightKit; };
25104 
25108  static SpotlightKit GetDefault();
25109 
25112  void Consume(SpotlightKit & in_kit);
25113 
25116  void Set(SpotlightKit const & in_kit);
25117 
25120  void Show(SpotlightKit & out_kit) const;
25121 
25125  SpotlightKit & operator=(SpotlightKit const & in_kit);
25126 
25129  bool Empty() const;
25130 
25134  bool Equals(SpotlightKit const & in_kit) const;
25135 
25139  bool operator==(SpotlightKit const & in_kit) const;
25140 
25144  bool operator!=(SpotlightKit const & in_kit) const;
25145 
25146 
25153  SpotlightKit & SetPriority(int in_priority);
25154 
25160  SpotlightKit & SetPosition(HPS::Point const & in_position);
25161 
25167  SpotlightKit & SetTarget(HPS::Point const & in_target);
25168 
25172  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
25173 
25177  SpotlightKit & SetColorByIndex(float in_index);
25178 
25185 
25192 
25198  SpotlightKit & SetConcentration(float in_concentration);
25199 
25205  SpotlightKit & SetCameraRelative(bool in_state);
25206 
25207 
25210  SpotlightKit & UnsetPriority();
25211 
25214  SpotlightKit & UnsetPosition();
25215 
25218  SpotlightKit & UnsetTarget();
25219 
25222  SpotlightKit & UnsetColor();
25223 
25226  SpotlightKit & UnsetOuterCone();
25227 
25230  SpotlightKit & UnsetInnerCone();
25231 
25234  SpotlightKit & UnsetConcentration();
25235 
25238  SpotlightKit & UnsetCameraRelative();
25239 
25242  SpotlightKit & UnsetEverything();
25243 
25244 
25248  bool ShowPriority(int & out_priority) const;
25249 
25253  bool ShowPosition(HPS::Point & out_position) const;
25254 
25258  bool ShowTarget(HPS::Point & out_target) const;
25259 
25265  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25266 
25271  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25272 
25277  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25278 
25282  bool ShowConcentration(float & out_concentration) const;
25283 
25287  bool ShowCameraRelative(bool & out_state) const;
25288 
25294  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25295 
25300  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25301 
25306  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25307 
25311  SpotlightKit & UnsetUserData(intptr_t in_index);
25312 
25317  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25318 
25322  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
25323 
25326  SpotlightKit & UnsetAllUserData();
25327 
25329  size_t ShowUserDataCount() const;
25330 
25334  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25335 
25340  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25341 
25346  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25347 };
25348 
25349 
25351 class HPS_API SpotlightKey : public GeometryKey
25352 {
25353 public:
25355  SpotlightKey();
25356 
25360  explicit SpotlightKey(Key const & in_that);
25361 
25364  SpotlightKey(SpotlightKey const & in_that);
25365 
25369  SpotlightKey & operator=(SpotlightKey const & in_that);
25370 
25374  SpotlightKey(SpotlightKey && in_that);
25375 
25379  SpotlightKey & operator=(SpotlightKey && in_that);
25380 
25381  ~SpotlightKey();
25382 
25383  HPS::Type ObjectType() const { return HPS::Type::SpotlightKey; };
25384 
25387  void Consume(SpotlightKit & in_kit);
25388 
25391  void Set(SpotlightKit const & in_kit);
25392 
25395  void Show(SpotlightKit & out_kit) const;
25396 
25397 
25403  SpotlightKey & SetPosition(HPS::Point const & in_position);
25404 
25410  SpotlightKey & SetTarget(HPS::Point const & in_target);
25411 
25415  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
25416 
25420  SpotlightKey & SetColorByIndex(float in_index);
25421 
25428 
25435 
25441  SpotlightKey & SetConcentration(float in_concentration);
25442 
25448  SpotlightKey & SetCameraRelative(bool in_state);
25449 
25450 
25453  SpotlightKey & UnsetColor();
25454 
25455 
25459  bool ShowPosition(HPS::Point & out_position) const;
25460 
25464  bool ShowTarget(HPS::Point & out_target) const;
25465 
25471  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25472 
25477  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25478 
25483  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25484 
25488  bool ShowConcentration(float & out_concentration) const;
25489 
25493  bool ShowCameraRelative(bool & out_state) const;
25494 };
25495 
25496 
25497 
25499 class HPS_API NURBSCurveKit : public Object
25500 {
25501 public:
25503  NURBSCurveKit();
25504 
25507  NURBSCurveKit(NURBSCurveKit const & in_kit);
25508 
25512  NURBSCurveKit(NURBSCurveKit && in_that);
25513 
25517  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
25518 
25519  virtual ~NURBSCurveKit();
25520 
25521  HPS::Type ObjectType() const { return HPS::Type::NURBSCurveKit; };
25522 
25525  void Consume(NURBSCurveKit & in_kit);
25526 
25529  void Set(NURBSCurveKit const & in_kit);
25530 
25533  void Show(NURBSCurveKit & out_kit) const;
25534 
25538  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
25539 
25542  bool Empty() const;
25543 
25547  bool Equals(NURBSCurveKit const & in_kit) const;
25548 
25552  bool operator==(NURBSCurveKit const & in_kit) const;
25553 
25557  bool operator!=(NURBSCurveKit const & in_kit) const;
25558 
25561  size_t GetPointCount() const;
25562 
25569  NURBSCurveKit & SetPriority(int in_priority);
25570 
25573  NURBSCurveKit & UnsetPriority();
25574 
25578  bool ShowPriority(int & out_priority) const;
25579 
25583  NURBSCurveKit & SetDegree(size_t in_degree);
25584 
25588  NURBSCurveKit & SetPoints(PointArray const & in_points);
25589 
25594  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
25595 
25599  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
25600 
25605  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
25606 
25610  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
25611 
25616  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
25617 
25622  NURBSCurveKit & SetParameters(float in_start, float in_end);
25623 
25624 
25627  NURBSCurveKit & UnsetDegree();
25628 
25631  NURBSCurveKit & UnsetPoints();
25632 
25635  NURBSCurveKit & UnsetWeights();
25636 
25639  NURBSCurveKit & UnsetKnots();
25640 
25643  NURBSCurveKit & UnsetParameters();
25644 
25647  NURBSCurveKit & UnsetEverything();
25648 
25649 
25653  bool ShowDegree(size_t & out_degree) const;
25654 
25658  bool ShowPoints(PointArray & out_points) const;
25659 
25665  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25666 
25671  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25672 
25678  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25679 
25683  bool ShowWeights(FloatArray & out_weights) const;
25684 
25688  bool ShowKnots(FloatArray & out_knots) const;
25689 
25694  bool ShowParameters(float & out_start, float & out_end) const;
25695 
25696 
25703  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25704 
25710  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25711 
25718  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25719 
25726  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25727 
25734  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25735 
25736 
25744  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25745 
25752  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25753 
25761  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25762 
25769  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25770 
25777  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25778 
25779 
25785  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25786 
25791  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25792 
25798  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
25799 
25806  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25807 
25814  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25815 
25821  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25822 
25827  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25828 
25833  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25834 
25838  NURBSCurveKit & UnsetUserData(intptr_t in_index);
25839 
25844  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25845 
25849  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
25850 
25853  NURBSCurveKit & UnsetAllUserData();
25854 
25856  size_t ShowUserDataCount() const;
25857 
25861  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25862 
25867  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25868 
25873  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25874 };
25875 
25876 
25878 class HPS_API NURBSCurveKey : public GeometryKey
25879 {
25880 public:
25882  NURBSCurveKey();
25883 
25887  explicit NURBSCurveKey(Key const & in_that);
25888 
25891  NURBSCurveKey(NURBSCurveKey const & in_that);
25892 
25896  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
25897 
25901  NURBSCurveKey(NURBSCurveKey && in_that);
25902 
25906  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
25907 
25908  ~NURBSCurveKey();
25909 
25910  HPS::Type ObjectType() const {return HPS::Type::NURBSCurveKey;};
25911 
25914  void Consume(NURBSCurveKit & in_kit);
25915 
25918  void Set(NURBSCurveKit const & in_kit);
25919 
25922  void Show(NURBSCurveKit & out_kit) const;
25923 
25926  size_t GetPointCount() const;
25927 
25932  NURBSCurveKey & SetParameters(float in_start, float in_end);
25933 
25937  bool ShowDegree(size_t & out_degree) const;
25938 
25942  bool ShowPoints(PointArray & out_points) const;
25943 
25949  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25950 
25955  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25956 
25962  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25963 
25967  bool ShowWeights(FloatArray & out_weights) const;
25968 
25972  bool ShowKnots(FloatArray & out_knots) const;
25973 
25978  bool ShowParameters(float & out_start, float & out_end) const;
25979 
25980 
25988  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25989 
25996  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25997 
25998 
26007  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26008 
26016  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26017 
26018 
26026  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26027 
26034  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26035 };
26036 
26037 
26038 
26040 class HPS_API NURBSSurfaceKit : public Object
26041 {
26042 public:
26044  NURBSSurfaceKit();
26045 
26048  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
26049 
26053  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
26054 
26058  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
26059 
26060  virtual ~NURBSSurfaceKit();
26061 
26062  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKit; };
26063 
26066  void Consume(NURBSSurfaceKit & in_kit);
26067 
26070  void Set(NURBSSurfaceKit const & in_kit);
26071 
26074  void Show(NURBSSurfaceKit & out_kit) const;
26075 
26079  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
26080 
26083  bool Empty() const;
26084 
26088  bool Equals(NURBSSurfaceKit const & in_kit) const;
26089 
26093  bool operator==(NURBSSurfaceKit const & in_kit) const;
26094 
26098  bool operator!=(NURBSSurfaceKit const & in_kit) const;
26099 
26102  size_t GetPointCount() const;
26103 
26110  NURBSSurfaceKit & SetPriority(int in_priority);
26111 
26114  NURBSSurfaceKit & UnsetPriority();
26115 
26119  bool ShowPriority(int & out_priority) const;
26120 
26124  NURBSSurfaceKit & SetUDegree(size_t in_degree);
26125 
26129  NURBSSurfaceKit & SetVDegree(size_t in_degree);
26130 
26134  NURBSSurfaceKit & SetUCount(size_t in_count);
26135 
26139  NURBSSurfaceKit & SetVCount(size_t in_count);
26140 
26144  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
26145 
26150  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
26151 
26156  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
26157 
26163  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
26164 
26169  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
26170 
26176  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
26177 
26182  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
26183 
26189  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
26190 
26194  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
26195 
26200  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
26201 
26202 
26205  NURBSSurfaceKit & UnsetUDegree();
26206 
26209  NURBSSurfaceKit & UnsetVDegree();
26210 
26213  NURBSSurfaceKit & UnsetUCount();
26214 
26217  NURBSSurfaceKit & UnsetVCount();
26218 
26221  NURBSSurfaceKit & UnsetPoints();
26222 
26225  NURBSSurfaceKit & UnsetWeights();
26226 
26229  NURBSSurfaceKit & UnsetUKnots();
26230 
26233  NURBSSurfaceKit & UnsetVKnots();
26234 
26237  NURBSSurfaceKit & UnsetTrims();
26238 
26241  NURBSSurfaceKit & UnsetEverything();
26242 
26243 
26247  bool ShowUDegree(size_t & out_degree) const;
26248 
26252  bool ShowVDegree(size_t & out_degree) const;
26253 
26257  bool ShowUCount(size_t & out_count) const;
26258 
26262  bool ShowVCount(size_t & out_count) const;
26263 
26267  bool ShowPoints(PointArray & out_points) const;
26268 
26274  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26275 
26280  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26281 
26287  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26288 
26292  bool ShowWeights(FloatArray & out_weights) const;
26293 
26297  bool ShowUKnots(FloatArray & out_knots) const;
26298 
26302  bool ShowVKnots(FloatArray & out_knots) const;
26303 
26307  bool ShowTrims(TrimKitArray & out_trims) const;
26308 
26309 
26316  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
26317 
26323  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
26324 
26331  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
26332 
26339  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26340 
26347  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26348 
26349 
26357  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
26358 
26365  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
26366 
26374  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
26375 
26382  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26383 
26390  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26391 
26392 
26399  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26400 
26406  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26407 
26414  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
26415 
26422  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26423 
26430  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26431 
26432 
26439  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26440 
26446  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26447 
26454  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
26455 
26462  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26463 
26470  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26471 
26477  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26478 
26483  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26484 
26489  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26490 
26494  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
26495 
26500  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26501 
26505  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
26506 
26509  NURBSSurfaceKit & UnsetAllUserData();
26510 
26512  size_t ShowUserDataCount() const;
26513 
26517  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26518 
26523  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26524 
26529  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26530 };
26531 
26532 
26534 class HPS_API NURBSSurfaceKey : public GeometryKey
26535 {
26536 public:
26538  NURBSSurfaceKey();
26539 
26543  explicit NURBSSurfaceKey(Key const & in_that);
26544 
26547  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
26548 
26552  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
26553 
26557  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
26558 
26562  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
26563 
26564  ~NURBSSurfaceKey();
26565 
26566  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKey; };
26567 
26570  void Consume(NURBSSurfaceKit & in_kit);
26571 
26574  void Set(NURBSSurfaceKit const & in_kit);
26575 
26578  void Show(NURBSSurfaceKit & out_kit) const;
26579 
26582  size_t GetPointCount() const;
26583 
26588  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
26589 
26593  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
26594 
26595 
26598  NURBSSurfaceKey & UnsetTrims();
26599 
26600 
26604  bool ShowUDegree(size_t & out_degree) const;
26605 
26609  bool ShowVDegree(size_t & out_degree) const;
26610 
26614  bool ShowUCount(size_t & out_count) const;
26615 
26619  bool ShowVCount(size_t & out_count) const;
26620 
26624  bool ShowPoints(PointArray & out_points) const;
26625 
26631  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26632 
26637  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26638 
26644  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26645 
26649  bool ShowWeights(FloatArray & out_weights) const;
26650 
26654  bool ShowUKnots(FloatArray & out_knots) const;
26655 
26659  bool ShowVKnots(FloatArray & out_knots) const;
26660 
26664  bool ShowTrims(TrimKitArray & out_trims) const;
26665 
26666 
26674  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26675 
26682  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26683 
26684 
26693  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26694 
26702  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26703 
26704 
26712  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26713 
26720  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26721 
26722 
26730  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26731 
26738  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26739 };
26740 
26741 
26742 
26744 class HPS_API TrimElement : public Object
26745 {
26746 public:
26748  TrimElement();
26749 
26752  TrimElement(TrimElement const & in_that);
26753 
26757  TrimElement(LineKit const & in_line);
26758 
26762  TrimElement(NURBSCurveKit const & in_curve);
26763 
26767  TrimElement(TrimElement && in_that);
26768 
26772  TrimElement & operator=(TrimElement && in_that);
26773 
26774  ~TrimElement();
26775 
26776  HPS::Type ObjectType() const { return HPS::Type::TrimElement; };
26777 
26780  void Set(TrimElement const & in_that);
26781 
26785  TrimElement & operator=(TrimElement const & in_that);
26786 
26790  bool Equals(TrimElement const & in_that) const;
26791 
26795  bool operator==(TrimElement const & in_that) const;
26796 
26800  bool operator!=(TrimElement const & in_that) const;
26801 
26802 
26806  void SetCurve(LineKit const & in_line);
26807 
26811  void SetCurve(NURBSCurveKit const & in_curve);
26812 
26818  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
26819 };
26820 
26821 
26822 
26824 class HPS_API TrimKit : public Object
26825 {
26826 public:
26828  TrimKit();
26829 
26832  TrimKit(TrimKit const & in_kit);
26833 
26837  TrimKit(TrimKit && in_that);
26838 
26842  TrimKit & operator=(TrimKit && in_that);
26843 
26844  virtual ~TrimKit();
26845 
26846  HPS::Type ObjectType() const { return HPS::Type::TrimKit; };
26847 
26850  void Set(TrimKit const & in_kit);
26851 
26854  void Show(TrimKit & out_kit) const;
26855 
26859  TrimKit & operator=(TrimKit const & in_kit);
26860 
26863  bool Empty() const;
26864 
26868  bool Equals(TrimKit const & in_kit) const;
26869 
26873  bool operator==(TrimKit const & in_kit) const;
26874 
26878  bool operator!=(TrimKit const & in_kit) const;
26879 
26880 
26885  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
26886 
26890  TrimKit & SetShape(TrimElementArray const & in_shape);
26891 
26895  TrimKit & SetOperation(Trim::Operation in_operation);
26896 
26897 
26900  TrimKit & UnsetShape();
26901 
26904  TrimKit & UnsetOperation();
26905 
26908  TrimKit & UnsetEverything();
26909 
26910 
26914  bool ShowShape(TrimElementArray & out_shape) const;
26915 
26919  bool ShowOperation(Trim::Operation & out_operation) const;
26920 };
26921 
26922 
26923 
26925 class HPS_API EllipseKit : public Object
26926 {
26927 public:
26929  EllipseKit();
26930 
26933  EllipseKit(EllipseKit const & in_kit);
26934 
26938  EllipseKit(EllipseKit && in_that);
26939 
26943  EllipseKit & operator=(EllipseKit && in_that);
26944 
26945  virtual ~EllipseKit();
26946 
26947  HPS::Type ObjectType() const { return HPS::Type::EllipseKit; };
26948 
26951  void Consume(EllipseKit & in_kit);
26952 
26955  void Set(EllipseKit const & in_kit);
26956 
26959  void Show(EllipseKit & out_kit) const;
26960 
26964  EllipseKit & operator=(EllipseKit const & in_kit);
26965 
26968  bool Empty() const;
26969 
26973  bool Equals(EllipseKit const & in_kit) const;
26974 
26978  bool operator==(EllipseKit const & in_kit) const;
26979 
26983  bool operator!=(EllipseKit const & in_kit) const;
26984 
26991  EllipseKit & SetPriority(int in_priority);
26992 
26995  EllipseKit & UnsetPriority();
26996 
27000  bool ShowPriority(int & out_priority) const;
27001 
27002 
27006  EllipseKit & SetCenter(Point const & in_center);
27007 
27011  EllipseKit & SetMajor(Point const & in_major);
27012 
27016  EllipseKit & SetMinor(Point const & in_minor);
27017 
27018 
27021  EllipseKit & UnsetCenter();
27022 
27025  EllipseKit & UnsetMajor();
27026 
27029  EllipseKit & UnsetMinor();
27030 
27033  EllipseKit & UnsetEverything();
27034 
27035 
27039  bool ShowCenter(Point & out_center) const;
27040 
27044  bool ShowMajor(Point & out_major) const;
27045 
27049  bool ShowMinor(Point & out_minor) const;
27050 
27056  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27057 
27062  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27063 
27068  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27069 
27073  EllipseKit & UnsetUserData(intptr_t in_index);
27074 
27079  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27080 
27084  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
27085 
27088  EllipseKit & UnsetAllUserData();
27089 
27091  size_t ShowUserDataCount() const;
27092 
27096  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27097 
27102  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27103 
27108  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27109 };
27110 
27111 
27112 
27114 class HPS_API EllipseKey : public GeometryKey
27115 {
27116 public:
27118  EllipseKey();
27119 
27123  explicit EllipseKey(Key const & in_that);
27124 
27127  EllipseKey(EllipseKey const & in_that);
27128 
27132  EllipseKey & operator=(EllipseKey const & other);
27133 
27137  EllipseKey(EllipseKey && in_that);
27138 
27142  EllipseKey & operator=(EllipseKey && in_that);
27143 
27144  ~EllipseKey();
27145 
27146  HPS::Type ObjectType() const { return HPS::Type::EllipseKey; };
27147 
27150  void Consume(EllipseKit & in_kit);
27151 
27154  void Set(EllipseKit const & in_kit);
27155 
27158  void Show(EllipseKit & out_kit) const;
27159 
27160 
27164  EllipseKey & SetCenter(Point const & in_center);
27165 
27169  EllipseKey & SetMajor(Point const & in_major);
27170 
27174  EllipseKey & SetMinor(Point const & in_minor);
27175 
27176 
27180  bool ShowCenter(Point & out_center) const;
27181 
27185  bool ShowMajor(Point & out_major) const;
27186 
27190  bool ShowMinor(Point & out_minor) const;
27191 };
27192 
27193 
27194 
27196 class HPS_API EllipticalArcKit : public Object
27197 {
27198 public:
27200  EllipticalArcKit();
27201 
27204  EllipticalArcKit(EllipticalArcKit const & in_kit);
27205 
27209  EllipticalArcKit(EllipticalArcKit && in_that);
27210 
27214  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
27215 
27216  virtual ~EllipticalArcKit();
27217 
27218  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKit; };
27219 
27222  void Consume(EllipticalArcKit & in_kit);
27223 
27226  void Set(EllipticalArcKit const & in_kit);
27227 
27230  void Show(EllipticalArcKit & out_kit) const;
27231 
27235  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
27236 
27239  bool Empty() const;
27240 
27244  bool Equals(EllipticalArcKit const & in_kit) const;
27245 
27249  bool operator==(EllipticalArcKit const & in_kit) const;
27250 
27254  bool operator!=(EllipticalArcKit const & in_kit) const;
27255 
27262  EllipticalArcKit & SetPriority(int in_priority);
27263 
27266  EllipticalArcKit & UnsetPriority();
27267 
27271  bool ShowPriority(int & out_priority) const;
27272 
27273 
27277  EllipticalArcKit & SetCenter(Point const & in_center);
27278 
27282  EllipticalArcKit & SetMajor(Point const & in_major);
27283 
27287  EllipticalArcKit & SetMinor(Point const & in_minor);
27288 
27296  EllipticalArcKit & SetStart(float in_start);
27297 
27305  EllipticalArcKit & SetEnd(float in_end);
27306 
27307 
27310  EllipticalArcKit & UnsetCenter();
27311 
27314  EllipticalArcKit & UnsetMajor();
27315 
27318  EllipticalArcKit & UnsetMinor();
27319 
27322  EllipticalArcKit & UnsetStart();
27323 
27326  EllipticalArcKit & UnsetEnd();
27327 
27330  EllipticalArcKit & UnsetEverything();
27331 
27332 
27336  bool ShowCenter(Point & out_center) const;
27337 
27341  bool ShowMajor(Point & out_major) const;
27342 
27346  bool ShowMinor(Point & out_minor) const;
27347 
27351  bool ShowStart(float & out_start) const;
27352 
27356  bool ShowEnd(float & out_end) const;
27357 
27363  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27364 
27369  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27370 
27375  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27376 
27380  EllipticalArcKit & UnsetUserData(intptr_t in_index);
27381 
27386  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27387 
27391  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
27392 
27395  EllipticalArcKit & UnsetAllUserData();
27396 
27398  size_t ShowUserDataCount() const;
27399 
27403  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27404 
27409  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27410 
27415  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27416 };
27417 
27418 
27420 class HPS_API EllipticalArcKey : public GeometryKey
27421 {
27422 public:
27424  EllipticalArcKey();
27425 
27429  explicit EllipticalArcKey(Key const & in_that);
27430 
27433  EllipticalArcKey(EllipticalArcKey const & in_that);
27434 
27438  EllipticalArcKey & operator=(EllipticalArcKey const & other);
27439 
27443  EllipticalArcKey(EllipticalArcKey && in_that);
27444 
27448  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
27449 
27450  ~EllipticalArcKey();
27451 
27452  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKey; };
27453 
27454 
27457  void Consume(EllipticalArcKit & in_kit);
27458 
27461  void Set(EllipticalArcKit const & in_kit);
27462 
27465  void Show(EllipticalArcKit & out_kit) const;
27466 
27467 
27471  EllipticalArcKey & SetCenter(Point const & in_center);
27472 
27476  EllipticalArcKey & SetMajor(Point const & in_major);
27477 
27481  EllipticalArcKey & SetMinor(Point const & in_minor);
27482 
27490  EllipticalArcKey & SetStart(float in_start);
27491 
27499  EllipticalArcKey & SetEnd(float in_end);
27500 
27501 
27505  bool ShowCenter(Point & out_center) const;
27506 
27510  bool ShowMajor(Point & out_major) const;
27511 
27515  bool ShowMinor(Point & out_minor) const;
27516 
27520  bool ShowStart(float & out_start) const;
27521 
27525  bool ShowEnd(float & out_end) const;
27526 };
27527 
27528 
27529 
27531 class HPS_API TextKit : public Object
27532 {
27533 public:
27535  TextKit();
27536 
27539  TextKit(TextKit const & in_kit);
27540 
27544  TextKit(TextKit && in_that);
27545 
27549  TextKit & operator=(TextKit && in_that);
27550 
27551  virtual ~TextKit();
27552 
27553  HPS::Type ObjectType() const { return HPS::Type::TextKit; };
27554 
27557  void Consume(TextKit & in_kit);
27558 
27561  void Set(TextKit const & in_kit);
27562 
27565  void Show(TextKit & out_kit) const;
27566 
27570  TextKit & operator=(TextKit const & in_kit);
27571 
27574  bool Empty() const;
27575 
27579  bool Equals(TextKit const & in_kit) const;
27580 
27584  bool operator==(TextKit const & in_kit) const;
27585 
27589  bool operator!=(TextKit const & in_kit) const;
27590 
27597  TextKit & SetPriority(int in_priority);
27598 
27601  TextKit & UnsetPriority();
27602 
27606  bool ShowPriority(int & out_priority) const;
27607 
27611  TextKit & SetPosition(Point const & in_position);
27612 
27616  TextKit & SetText(char const * in_string);
27617 
27621  TextKit & SetColor(RGBAColor const & in_rgba_color);
27622 
27626  TextKit & SetColorByIndex(float in_index);
27627 
27631  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
27632 
27639 
27643  TextKit & SetBold(bool in_state);
27644 
27648  TextKit & SetItalic(bool in_state);
27649 
27653  TextKit & SetOverline(bool in_state);
27654 
27658  TextKit & SetStrikethrough(bool in_state);
27659 
27663  TextKit & SetUnderline(bool in_state);
27664 
27669  TextKit & SetSlant(float in_angle);
27670 
27674  TextKit & SetLineSpacing(float in_multiplier);
27675 
27681  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27682 
27686  TextKit & SetRotation(float in_angle);
27687 
27693  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27694 
27699  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
27700 
27707  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27708 
27714  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27715 
27724  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
27725 
27733  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
27734 
27739  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
27740 
27746  TextKit & SetFont(char const * in_name);
27747 
27751  TextKit & SetTransform(Text::Transform in_trans);
27752 
27756  TextKit & SetRenderer(Text::Renderer in_rend);
27757 
27761  TextKit & SetPreference(Text::Preference in_pref);
27762 
27769  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27770 
27774  TextKit & SetPath(Vector const & in_path);
27775 
27781  TextKit & SetSpacing(float in_multiplier);
27782 
27783 
27786  TextKit & UnsetPosition();
27787 
27790  TextKit & UnsetText();
27791 
27794  TextKit & UnsetColor();
27795 
27798  TextKit & UnsetModellingMatrix();
27799 
27802  TextKit & UnsetAlignment();
27803 
27806  TextKit & UnsetBold();
27807 
27810  TextKit & UnsetItalic();
27811 
27814  TextKit & UnsetOverline();
27815 
27818  TextKit & UnsetStrikethrough();
27819 
27822  TextKit & UnsetUnderline();
27823 
27826  TextKit & UnsetSlant();
27827 
27830  TextKit & UnsetLineSpacing();
27831 
27834  TextKit & UnsetRotation();
27835 
27838  TextKit & UnsetExtraSpace();
27839 
27842  TextKit & UnsetGreeking();
27843 
27846  TextKit & UnsetSizeTolerance();
27847 
27850  TextKit & UnsetSize();
27851 
27854  TextKit & UnsetFont();
27855 
27858  TextKit & UnsetTransform();
27859 
27862  TextKit & UnsetRenderer();
27863 
27866  TextKit & UnsetPreference();
27867 
27870  TextKit & UnsetPath();
27871 
27874  TextKit & UnsetSpacing();
27875 
27878  TextKit & UnsetEverything();
27879 
27880 
27884  bool ShowPosition(Point & out_position) const;
27885 
27889  bool ShowText(UTF8 & out_string) const;
27890 
27896  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27897 
27901  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27902 
27908  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27909 
27913  bool ShowBold(bool & out_state) const;
27914 
27918  bool ShowItalic(bool & out_state) const;
27919 
27923  bool ShowOverline(bool & out_state) const;
27924 
27928  bool ShowStrikethrough(bool & out_state) const;
27929 
27933  bool ShowUnderline(bool & out_state) const;
27934 
27938  bool ShowSlant(float & out_angle) const;
27939 
27943  bool ShowLineSpacing(float & out_multiplier) const;
27944 
27949  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27950 
27956  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27957 
27964  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27965 
27971  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27972 
27977  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27978 
27982  bool ShowFont(UTF8 & out_name) const;
27983 
27987  bool ShowTransform(Text::Transform & out_trans) const;
27988 
27992  bool ShowRenderer(Text::Renderer & out_renderer) const;
27993 
28000  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28001 
28005  bool ShowPath(Vector & out_path) const;
28006 
28010  bool ShowSpacing(float & out_multiplier) const;
28011 
28012 
28020  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28021 
28028  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28029 
28036  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28037 
28046  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;
28047 
28060  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);
28061 
28075  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);
28076 
28082  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28083 
28086  TextKit & UnsetRegion();
28087 
28092  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28093 
28098  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28099 
28103  TextKit & UnsetUserData(intptr_t in_index);
28104 
28109  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28110 
28114  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
28115 
28118  TextKit & UnsetAllUserData();
28119 
28121  size_t ShowUserDataCount() const;
28122 
28126  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28127 
28132  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28133 
28138  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28139 };
28140 
28141 
28143 class HPS_API TextKey : public GeometryKey
28144 {
28145 public:
28147  TextKey();
28148 
28152  explicit TextKey(Key const & in_that);
28153 
28156  TextKey(TextKey const & in_that);
28157 
28161  TextKey & operator=(TextKey const & other);
28162 
28166  TextKey(TextKey && in_that);
28167 
28171  TextKey & operator=(TextKey && in_that);
28172 
28173  ~TextKey();
28174 
28175  HPS::Type ObjectType() const {return HPS::Type::TextKey;};
28176 
28179  void Consume(TextKit & in_kit);
28180 
28183  void Set(TextKit const & in_kit);
28184 
28187  void Show(TextKit & out_kit) const;
28188 
28191  TextKey & SetTextAttributes(TextAttributeKit const & in_kit);
28192 
28196  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
28197 
28201  TextKey & SetPosition(Point const & in_position);
28202 
28206  TextKey & SetText(char const * in_string);
28207 
28211  TextKey & SetColor(RGBAColor const & in_rgba_color);
28212 
28216  TextKey & SetColorByIndex(float in_index);
28217 
28221  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
28222 
28229 
28233  TextKey & SetBold(bool in_state);
28234 
28238  TextKey & SetItalic(bool in_state);
28239 
28243  TextKey & SetOverline(bool in_state);
28244 
28248  TextKey & SetStrikethrough(bool in_state);
28249 
28253  TextKey & SetUnderline(bool in_state);
28254 
28259  TextKey & SetSlant(float in_angle);
28260 
28265  TextKey & SetLineSpacing(float in_multiplier);
28266 
28272  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
28273 
28277  TextKey & SetRotation(float in_angle);
28278 
28284  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
28285 
28290  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
28291 
28298  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28299 
28305  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28306 
28315  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
28316 
28324  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
28325 
28330  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
28331 
28337  TextKey & SetFont(char const * in_name);
28338 
28342  TextKey & SetTransform(Text::Transform in_transform);
28343 
28347  TextKey & SetRenderer(Text::Renderer in_renderer);
28348 
28352  TextKey & SetPreference(Text::Preference in_preference);
28353 
28361  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
28362 
28367  TextKey & SetPath(Vector const & in_path);
28368 
28374  TextKey & SetSpacing(float in_multiplier);
28375 
28388  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);
28389 
28403  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);
28404 
28405 
28408  TextKey & UnsetColor();
28409 
28412  TextKey & UnsetModellingMatrix();
28413 
28416  TextKey & UnsetAlignment();
28417 
28420  TextKey & UnsetBold();
28421 
28424  TextKey & UnsetItalic();
28425 
28428  TextKey & UnsetOverline();
28429 
28432  TextKey & UnsetStrikethrough();
28433 
28436  TextKey & UnsetUnderline();
28437 
28440  TextKey & UnsetSlant();
28441 
28444  TextKey & UnsetLineSpacing();
28445 
28448  TextKey & UnsetRotation();
28449 
28452  TextKey & UnsetExtraSpace();
28453 
28456  TextKey & UnsetGreeking();
28457 
28460  TextKey & UnsetSizeTolerance();
28461 
28464  TextKey & UnsetSize();
28465 
28468  TextKey & UnsetFont();
28469 
28472  TextKey & UnsetTransform();
28473 
28476  TextKey & UnsetRenderer();
28477 
28480  TextKey & UnsetPreference();
28481 
28484  TextKey & UnsetPath();
28485 
28488  TextKey & UnsetSpacing();
28489 
28492  TextKey & UnsetRegion();
28493 
28496  TextKey & UnsetEverything();
28497 
28498 
28502  bool ShowPosition(Point & out_position) const;
28503 
28507  bool ShowText(UTF8 & out_string) const;
28508 
28514  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28515 
28519  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28520 
28526  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28527 
28531  bool ShowBold(bool & out_state) const;
28532 
28536  bool ShowItalic(bool & out_state) const;
28537 
28541  bool ShowOverline(bool & out_state) const;
28542 
28546  bool ShowStrikethrough(bool & out_state) const;
28547 
28551  bool ShowUnderline(bool & out_state) const;
28552 
28556  bool ShowSlant(float & out_angle) const;
28557 
28561  bool ShowLineSpacing(float & out_multiplier) const;
28562 
28567  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28568 
28574  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28575 
28582  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28583 
28589  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28590 
28595  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28596 
28600  bool ShowFont(UTF8 & out_name) const;
28601 
28605  bool ShowTransform(Text::Transform & out_trans) const;
28606 
28610  bool ShowRenderer(Text::Renderer & out_renderer) const;
28611 
28618  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28619 
28623  bool ShowPath(Vector & out_path) const;
28624 
28628  bool ShowSpacing(float & out_multiplier) const;
28629 
28638  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;
28639 
28640 
28648  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28649 
28656  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28657 
28664  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28665 };
28666 
28667 
28669 class HPS_API ShellOptimizationOptionsKit : public Object
28670 {
28671 public:
28674 
28678 
28683 
28684  virtual ~ShellOptimizationOptionsKit();
28685 
28686  HPS::Type ObjectType() const { return HPS::Type::ShellOptimizationOptionsKit; };
28687 
28690  void Consume(ShellOptimizationOptionsKit & in_kit);
28691 
28694  void Set(ShellOptimizationOptionsKit const & in_kit);
28695 
28698  void Show(ShellOptimizationOptionsKit & out_kit) const;
28699 
28703  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
28704 
28709 
28712  bool Empty() const;
28713 
28717  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
28718 
28722  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
28723 
28727  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
28728 
28732  static ShellOptimizationOptionsKit GetDefault();
28733 
28734 
28738  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
28739 
28744  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
28745 
28750  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
28751 
28756  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
28757 
28758 
28761  ShellOptimizationOptionsKit & UnsetNormalTolerance();
28762 
28765  ShellOptimizationOptionsKit & UnsetTolerance();
28766 
28769  ShellOptimizationOptionsKit & UnsetOrphanElimination();
28770 
28773  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
28774 
28777  ShellOptimizationOptionsKit & UnsetEverything();
28778 
28779 
28783  bool ShowNormalTolerance(float & out_normal_tolerance) const;
28784 
28789  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
28790 
28794  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
28795 
28800  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
28801 };
28802 
28803 
28807 class HPS_API ShellRelationOptionsKit : public Object
28808 {
28809 public:
28812 
28816 
28821 
28825  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
28826 
28827  virtual ~ShellRelationOptionsKit();
28828 
28829  HPS::Type ObjectType() const { return HPS::Type::ShellRelationOptionsKit; };
28830 
28834  static ShellRelationOptionsKit GetDefault();
28835 
28838  void Consume(ShellRelationOptionsKit & in_kit);
28839 
28842  void Set(ShellRelationOptionsKit const & in_kit);
28843 
28846  void Show(ShellRelationOptionsKit & out_kit) const;
28847 
28851  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
28852 
28855  bool Empty() const;
28856 
28860  bool Equals(ShellRelationOptionsKit const & in_kit) const;
28861 
28865  bool operator==(ShellRelationOptionsKit const & in_kit) const;
28866 
28870  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
28871 
28872 
28876  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
28877 
28881  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
28882 
28887  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
28888 
28892  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
28893 
28894 
28897  ShellRelationOptionsKit & UnsetTolerance();
28898 
28901  ShellRelationOptionsKit & UnsetTest();
28902 
28905  ShellRelationOptionsKit & UnsetTreeContext();
28906 
28909  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
28910 
28913  ShellRelationOptionsKit & UnsetEverything();
28914 
28915 
28919  bool ShowTolerance(float & out_tolerance) const;
28920 
28924  bool ShowTest(Shell::RelationTest & out_test) const;
28925 
28929  bool ShowTreeContext(TreeContext & out_tree_context) const;
28930 
28934  bool ShowNearestFaceCalculation(bool & out_state) const;
28935 };
28936 
28938 class HPS_API ShellRelationResultsKit : public Object
28939 {
28940 public:
28943 
28947 
28952 
28956  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
28957 
28958  virtual ~ShellRelationResultsKit();
28959 
28960  HPS::Type ObjectType() const { return HPS::Type::ShellRelationResultsKit; };
28961 
28964  void Consume(ShellRelationResultsKit & in_kit);
28965 
28968  void Set(ShellRelationResultsKit const & in_kit);
28969 
28972  void Show(ShellRelationResultsKit & out_kit) const;
28973 
28977  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
28978 
28981  bool Empty() const;
28982 
28986  bool Equals(ShellRelationResultsKit const & in_kit) const;
28987 
28991  bool operator==(ShellRelationResultsKit const & in_kit) const;
28992 
28996  bool operator!=(ShellRelationResultsKit const & in_kit) const;
28997 
28998 
29002  bool ShowRelations(ShellRelationArray & out_results) const;
29003 
29007  bool ShowNearestFaces(SizeTArray & out_faces) const;
29008 
29012  bool ShowDistances(FloatArray & out_distances) const;
29013 };
29014 
29015 
29017 class HPS_API ShellKit : public Object
29018 {
29019 public:
29021  ShellKit();
29022 
29025  ShellKit(ShellKit const & in_kit);
29026 
29030  ShellKit(ShellKit && in_that);
29031 
29035  ShellKit & operator=(ShellKit && in_that);
29036 
29037  virtual ~ShellKit();
29038 
29039  HPS::Type ObjectType() const { return HPS::Type::ShellKit; };
29040 
29043  void Consume(ShellKit & in_kit);
29044 
29047  void Set(ShellKit const & in_kit);
29048 
29051  void Show(ShellKit & out_kit) const;
29052 
29055  size_t GetPointCount() const;
29056 
29059  size_t GetFaceCount() const;
29060 
29064  ShellKit & operator=(ShellKit const & in_kit);
29065 
29068  bool Empty() const;
29069 
29073  bool Equals(ShellKit const & in_kit) const;
29074 
29078  bool operator==(ShellKit const & in_kit) const;
29079 
29083  bool operator!=(ShellKit const & in_kit) const;
29084 
29091  ShellKit & SetPriority(int in_priority);
29092 
29095  ShellKit & UnsetPriority();
29096 
29100  bool ShowPriority(int & out_priority) const;
29101 
29102 
29103 
29107  ShellKit & SetPoints(PointArray const & in_points);
29108 
29113  ShellKit & SetPoints(size_t in_count, Point const in_points []);
29114 
29118  ShellKit & SetFacelist(IntArray const & in_facelist);
29119 
29124  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
29125 
29129  ShellKit & SetTristrips(IntArray const & in_tristrips);
29130 
29135  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
29136 
29139  ShellKit & UnsetPoints();
29140 
29143  ShellKit & UnsetFacelist();
29144 
29147  ShellKit & UnsetTristrips();
29148 
29151  ShellKit & UnsetEverything();
29152 
29156  bool ShowPoints(PointArray & out_points) const;
29157 
29163  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29164 
29169  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29170 
29176  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29177 
29181  bool ShowFacelist(IntArray & out_facelist) const;
29182 
29186  bool ShowTristrips(IntArray & out_tristrips) const;
29187 
29193  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
29194 
29195 
29202  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29203 
29209  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29210 
29217  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29218 
29225  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29226 
29233  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29234 
29241  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29242 
29248  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29249 
29250 
29257  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29258 
29264  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29265 
29272  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29273 
29280  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29281 
29288  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29289 
29296  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29297 
29303  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29304 
29305 
29312  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29313 
29319  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29320 
29327  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29328 
29335  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29336 
29343  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29344 
29351  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29352 
29358  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29359 
29360 
29366  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29367 
29372  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29373 
29379  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29380 
29386  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29387 
29392  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29393 
29399  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29400 
29405  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29406 
29407 
29414  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29415 
29422  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29423 
29432  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);
29433 
29441  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29442 
29443 
29449  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29450 
29455  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29456 
29462  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29463 
29469  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29470 
29475  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29476 
29482  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29483 
29488  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29489 
29490 
29493  ShellKit & UnsetMaterialMapping();
29494 
29495 
29498  ShellKit & UnsetVertexColors();
29499 
29504  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29505 
29509  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29510 
29511 
29515  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
29516 
29522  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29523 
29528  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29529 
29530 
29533  ShellKit & UnsetVertexNormals();
29534 
29539  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29540 
29544  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29545 
29546 
29549  ShellKit & UnsetVertexParameters();
29550 
29555  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29556 
29560  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29561 
29562 
29565  ShellKit & UnsetVertexVisibilities();
29566 
29571  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29572 
29576  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29577 
29578 
29581  ShellKit & UnsetVertexEverything();
29582 
29583 
29587  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29588 
29589 
29603  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29604  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29605 
29620  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29621  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29622 
29623 
29632  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29633 
29642  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29643 
29644 
29654  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29655 
29665  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29666 
29676  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
29677 
29687  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29688 
29689 
29698  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29699 
29708  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
29709 
29710 
29711 
29717  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
29718 
29723  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
29724 
29730  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
29731 
29737  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
29738 
29743  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
29744 
29750  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
29751 
29756  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
29757 
29758 
29764  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
29765 
29770  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
29771 
29777  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
29778 
29784  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
29785 
29790  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
29791 
29797  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
29798 
29803  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
29804 
29805 
29811  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29812 
29817  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
29818 
29824  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29825 
29831  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
29832 
29837  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
29838 
29844  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
29845 
29850  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
29851 
29852 
29858  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29859 
29864  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29865 
29871  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29872 
29878  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
29879 
29884  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
29885 
29891  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
29892 
29897  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
29898 
29899 
29902  ShellKit & UnsetFaceColors();
29903 
29908  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
29909 
29913  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
29914 
29915 
29918  ShellKit & UnsetFaceNormals();
29919 
29924  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
29925 
29929  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
29930 
29931 
29934  ShellKit & UnsetFaceVisibilities();
29935 
29940  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
29941 
29945  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
29946 
29947 
29950  ShellKit & UnsetFaceEverything();
29951 
29952 
29962  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29963 
29974  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29975 
29976 
29985  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29986 
29995  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
29996 
29997 
30006  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30007 
30016  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
30017 
30018 
30025  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
30026 
30032  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
30033 
30039  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
30040 
30046  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
30047 
30053  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
30054 
30055 
30062  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
30063 
30069  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
30070 
30076  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
30077 
30086  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
30087 
30095  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
30096 
30099  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
30100 
30105  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30106 
30111  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30112 
30117  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30118 
30124  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30125 
30130  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30131 
30136  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30137 
30141  ShellKit & UnsetUserData(intptr_t in_index);
30142 
30147  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30148 
30152  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
30153 
30156  ShellKit & UnsetAllUserData();
30157 
30159  size_t ShowUserDataCount() const;
30160 
30164  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30165 
30170  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30171 
30176  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30177 };
30178 
30179 
30180 
30182 class HPS_API ShellKey : public GeometryKey
30183 {
30184 public:
30186  ShellKey();
30187 
30192  explicit ShellKey(Key const & in_that);
30193 
30196  ShellKey(ShellKey const & in_that);
30197 
30201  ShellKey & operator=(ShellKey const & other);
30202 
30206  ShellKey(ShellKey && in_that);
30207 
30211  ShellKey & operator=(ShellKey && in_that);
30212 
30213  ~ShellKey();
30214 
30215  HPS::Type ObjectType() const { return HPS::Type::ShellKey; };
30216 
30219  void Consume(ShellKit & in_kit);
30220 
30223  void Set(ShellKit const & in_kit);
30224 
30227  void Show(ShellKit & out_kit) const;
30228 
30231  size_t GetPointCount() const;
30232 
30235  size_t GetFaceCount() const;
30236 
30237 
30241  ShellKey & SetPoints(PointArray const & in_points);
30242 
30247  ShellKey & SetPoints(size_t in_count, Point const in_points []);
30248 
30252  ShellKey & SetFacelist(IntArray const & in_facelist);
30253 
30258  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
30259 
30263  ShellKey & SetTristrips(IntArray const & in_tristrips);
30264 
30269  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
30270 
30275  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
30276 
30279  ShellKey & UnsetPoints();
30280 
30283  ShellKey & UnsetFacelist();
30284 
30287  ShellKey & UnsetTristrips();
30288 
30291  ShellKey & UnsetMaterialMapping();
30292 
30295  ShellKey & UnsetEverything();
30296 
30300  bool ShowPoints(PointArray & out_points) const;
30301 
30307  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
30308 
30313  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
30314 
30320  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
30321 
30325  bool ShowFacelist(IntArray & out_facelist) const;
30326 
30330  bool ShowTristrips(IntArray & out_tristrips) const;
30331 
30335  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30336 
30337 
30344  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30345 
30352  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30353 
30360  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30361 
30368  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30369 
30376  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30377 
30384  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30385 
30391  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30392 
30393 
30400  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30401 
30408  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30409 
30416  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30417 
30424  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30425 
30432  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30433 
30440  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30441 
30447  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30448 
30449 
30456  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30457 
30464  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30465 
30472  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30473 
30480  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30481 
30488  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30489 
30496  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30497 
30503  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30504 
30505 
30511  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30512 
30518  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30519 
30525  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30526 
30532  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30533 
30538  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30539 
30545  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30546 
30551  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30552 
30553 
30561  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30562 
30569  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30570 
30579  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);
30580 
30588  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30589 
30590 
30596  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30597 
30603  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30604 
30610  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30611 
30617  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30618 
30623  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
30624 
30630  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
30631 
30636  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
30637 
30638 
30641  ShellKey & UnsetVertexColors();
30642 
30647  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
30648 
30652  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
30653 
30654 
30658  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
30659 
30665  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
30666 
30671  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
30672 
30673 
30676  ShellKey & UnsetVertexNormals();
30677 
30682  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
30683 
30687  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
30688 
30689 
30692  ShellKey & UnsetVertexParameters();
30693 
30698  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
30699 
30703  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
30704 
30705 
30708  ShellKey & UnsetVertexVisibilities();
30709 
30714  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
30715 
30719  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
30720 
30721 
30724  ShellKey & UnsetVertexEverything();
30725 
30726 
30740  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30741  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30742 
30757  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30758  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30759 
30760 
30769  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30770 
30779  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
30780 
30781 
30791  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
30792 
30802  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30803 
30813  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
30814 
30824  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30825 
30826 
30835  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30836 
30845  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30846 
30847 
30853  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30854 
30860  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
30861 
30867  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
30868 
30874  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
30875 
30880  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
30881 
30887  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
30888 
30893  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
30894 
30895 
30901  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
30902 
30908  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
30909 
30915  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
30916 
30922  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
30923 
30928  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
30929 
30935  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
30936 
30941  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
30942 
30943 
30949  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30950 
30956  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
30957 
30963  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30964 
30970  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
30971 
30976  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
30977 
30983  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
30984 
30989  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
30990 
30991 
30997  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30998 
31004  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31005 
31011  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31012 
31018  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
31019 
31024  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
31025 
31031  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
31032 
31037  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
31038 
31039 
31042  ShellKey & UnsetFaceColors();
31043 
31048  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
31049 
31053  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
31054 
31055 
31058  ShellKey & UnsetFaceNormals();
31059 
31064  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
31065 
31069  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
31070 
31071 
31074  ShellKey & UnsetFaceVisibilities();
31075 
31080  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
31081 
31085  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
31086 
31087 
31090  ShellKey & UnsetFaceEverything();
31091 
31092 
31102  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31103 
31114  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31115 
31116 
31125  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31126 
31135  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31136 
31137 
31143  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
31144 
31151  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
31152 
31153 
31162  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31163 
31172  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31173 
31174 
31181  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
31182 
31188  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
31189 
31195  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
31196 
31202  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
31203 
31209  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
31210 
31211 
31218  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
31219 
31225  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
31226 
31232  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
31233 
31242  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
31243 
31251  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
31252 
31255  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
31256 
31261  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31262 
31267  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31268 
31273  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31274 };
31275 
31276 
31277 
31279 class HPS_API MeshKit : public Object
31280 {
31281 public:
31283  MeshKit();
31284 
31287  MeshKit(MeshKit const & in_kit);
31288 
31292  MeshKit(MeshKit && in_that);
31293 
31297  MeshKit & operator=(MeshKit && in_that);
31298 
31299  virtual ~MeshKit();
31300 
31301  HPS::Type ObjectType() const { return HPS::Type::MeshKit; };
31302 
31305  void Consume(MeshKit & in_kit);
31306 
31309  void Set(MeshKit const & in_kit);
31310 
31313  void Show(MeshKit & out_kit) const;
31314 
31318  MeshKit & operator=(MeshKit const & in_kit);
31319 
31322  bool Empty() const;
31323 
31327  bool Equals(MeshKit const & in_kit) const;
31328 
31332  bool operator==(MeshKit const & in_kit) const;
31333 
31337  bool operator!=(MeshKit const & in_kit) const;
31338 
31341  size_t GetPointCount() const;
31342 
31349  MeshKit & SetPriority(int in_priority);
31350 
31353  MeshKit & UnsetPriority();
31354 
31358  bool ShowPriority(int & out_priority) const;
31359 
31363  MeshKit & SetPoints(PointArray const & in_points);
31364 
31369  MeshKit & SetPoints(size_t in_count, Point const in_points []);
31370 
31376  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
31377 
31384  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31385 
31389  MeshKit & SetRows(size_t in_rows);
31390 
31394  MeshKit & SetColumns(size_t in_columns);
31395 
31398  MeshKit & UnsetPoints();
31399 
31402  MeshKit & UnsetRows();
31403 
31406  MeshKit & UnsetColumns();
31407 
31410  MeshKit & UnsetEverything();
31411 
31415  bool ShowPoints(PointArray & out_points) const;
31416 
31422  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
31423 
31428  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
31429 
31435  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
31436 
31442  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31443 
31447  bool ShowRows(size_t & out_rows) const;
31448 
31452  bool ShowColumns(size_t & out_columns) const;
31453 
31454 
31460  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
31461 
31468  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31469 
31475  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31476 
31483  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31484 
31491  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31492 
31499  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31500 
31507  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31508 
31514  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31515 
31516 
31523  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31524 
31530  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31531 
31538  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31539 
31546  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31547 
31554  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31555 
31562  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31563 
31569  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31570 
31571 
31578  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31579 
31585  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31586 
31593  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31594 
31601  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31602 
31609  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31610 
31617  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31618 
31624  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31625 
31626 
31632  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31633 
31638  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31639 
31645  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31646 
31652  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31653 
31658  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31659 
31665  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31666 
31671  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31672 
31673 
31680  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31681 
31688  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31689 
31698  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);
31699 
31707  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31708 
31709 
31715  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31716 
31721  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31722 
31728  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31729 
31735  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31736 
31741  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31742 
31748  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31749 
31754  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31755 
31756 
31759  MeshKit & UnsetMaterialMapping();
31760 
31763  MeshKit & UnsetVertexColors();
31764 
31769  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31770 
31774  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31775 
31776 
31780  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
31781 
31787  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
31788 
31793  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
31794 
31795 
31798  MeshKit & UnsetVertexNormals();
31799 
31804  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31805 
31809  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31810 
31811 
31814  MeshKit & UnsetVertexParameters();
31815 
31820  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31821 
31825  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31826 
31827 
31830  MeshKit & UnsetVertexVisibilities();
31831 
31836  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31837 
31841  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31842 
31843 
31846  MeshKit & UnsetVertexEverything();
31847 
31848 
31852  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31853 
31867  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31868  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31869 
31884  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31885  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31886 
31887 
31896  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31897 
31906  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31907 
31908 
31918  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31919 
31929  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31930 
31940  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31941 
31951  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31952 
31953 
31962  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31963 
31972  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31973 
31974 
31980  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31981 
31986  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31987 
31993  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31994 
32000  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32001 
32006  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32007 
32013  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32014 
32019  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32020 
32021 
32027  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32028 
32033  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32034 
32040  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32041 
32047  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32048 
32053  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32054 
32060  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32061 
32066  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32067 
32068 
32074  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32075 
32080  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
32081 
32087  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32088 
32094  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
32095 
32100  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
32101 
32107  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32108 
32113  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32114 
32115 
32121  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32122 
32127  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32128 
32134  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32135 
32141  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32142 
32147  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32148 
32154  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32155 
32160  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32161 
32162 
32165  MeshKit & UnsetFaceColors();
32166 
32171  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32172 
32176  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
32177 
32178 
32181  MeshKit & UnsetFaceNormals();
32182 
32187  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32188 
32192  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
32193 
32194 
32197  MeshKit & UnsetFaceVisibilities();
32198 
32203  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32204 
32208  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
32209 
32210 
32213  MeshKit & UnsetFaceEverything();
32214 
32215 
32225  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32226 
32237  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32238 
32239 
32248  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32249 
32258  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32259 
32260 
32269  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32270 
32279  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32280 
32286  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32287 
32292  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32293 
32298  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32299 
32303  MeshKit & UnsetUserData(intptr_t in_index);
32304 
32309  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32310 
32314  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
32315 
32318  MeshKit & UnsetAllUserData();
32319 
32321  size_t ShowUserDataCount() const;
32322 
32326  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32327 
32332  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32333 
32338  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32339 
32340 };
32341 
32342 
32343 
32345 class HPS_API MeshKey : public GeometryKey
32346 {
32347 public:
32349  MeshKey();
32350 
32355  explicit MeshKey(Key const & in_that);
32356 
32359  MeshKey(MeshKey const & in_that);
32360 
32364  MeshKey & operator=(MeshKey const & in_that);
32365 
32369  MeshKey(MeshKey && in_that);
32370 
32374  MeshKey & operator=(MeshKey && in_that);
32375 
32376  ~MeshKey();
32377 
32378  HPS::Type ObjectType() const { return HPS::Type::MeshKey; };
32379 
32382  void Consume(MeshKit & in_kit);
32383 
32386  void Set(MeshKit const & in_kit);
32387 
32390  void Show(MeshKit & out_kit) const;
32391 
32394  size_t GetPointCount() const;
32395 
32401  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
32402 
32409  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
32410 
32414  bool ShowPoints(PointArray & out_points) const;
32415 
32421  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32422 
32427  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32428 
32434  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32435 
32441  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
32442 
32446  bool ShowRows(size_t & out_rows) const;
32447 
32451  bool ShowColumns(size_t & out_columns) const;
32452 
32453 
32458  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
32459 
32462  MeshKey & UnsetMaterialMapping();
32463 
32467  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32468 
32469 
32476  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32477 
32484  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32485 
32492  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32493 
32500  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32501 
32508  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32509 
32516  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32517 
32523  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32524 
32525 
32532  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32533 
32540  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32541 
32548  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32549 
32556  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32557 
32564  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32565 
32572  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32573 
32579  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32580 
32581 
32588  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32589 
32596  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32597 
32604  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32605 
32612  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32613 
32620  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32621 
32628  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32629 
32635  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32636 
32637 
32643  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32644 
32650  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32651 
32657  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32658 
32664  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32665 
32670  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32671 
32677  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32678 
32683  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32684 
32685 
32693  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32694 
32701  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32702 
32711  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);
32712 
32720  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32721 
32722 
32728  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32729 
32735  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32736 
32742  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32743 
32749  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32750 
32755  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32756 
32762  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32763 
32768  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32769 
32770 
32773  MeshKey & UnsetVertexColors();
32774 
32779  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32780 
32784  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32785 
32786 
32790  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
32791 
32797  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
32798 
32803  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
32804 
32805 
32808  MeshKey & UnsetVertexNormals();
32809 
32814  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
32815 
32819  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
32820 
32821 
32824  MeshKey & UnsetVertexParameters();
32825 
32830  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
32831 
32835  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
32836 
32837 
32840  MeshKey & UnsetVertexVisibilities();
32841 
32846  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
32847 
32851  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
32852 
32853 
32856  MeshKey & UnsetVertexEverything();
32857 
32860  MeshKey & UnsetEverything();
32861 
32862 
32876  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32877  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32878 
32893  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32894  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32895 
32896 
32905  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32906 
32915  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32916 
32917 
32927  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32928 
32938  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32939 
32949  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32950 
32960  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32961 
32962 
32971  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32972 
32981  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32982 
32983 
32989  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32990 
32996  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32997 
33003  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
33004 
33010  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
33011 
33016  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
33017 
33023  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
33024 
33029  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
33030 
33031 
33037  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
33038 
33044  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
33045 
33051  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
33052 
33058  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
33059 
33064  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
33065 
33071  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
33072 
33077  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
33078 
33079 
33085  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33086 
33092  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33093 
33099  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33100 
33106  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33107 
33112  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33113 
33119  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33120 
33125  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33126 
33127 
33133  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33134 
33140  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33141 
33147  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33148 
33154  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33155 
33160  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33161 
33167  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33168 
33173  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33174 
33175 
33178  MeshKey & UnsetFaceColors();
33179 
33184  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33185 
33189  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
33190 
33191 
33194  MeshKey & UnsetFaceNormals();
33195 
33200  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33201 
33205  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
33206 
33207 
33210  MeshKey & UnsetFaceVisibilities();
33211 
33216  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33217 
33221  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
33222 
33223 
33226  MeshKey & UnsetFaceEverything();
33227 
33228 
33238  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33239 
33250  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33251 
33252 
33261  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33262 
33271  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33272 
33273 
33282  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33283 
33292  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33293 
33302  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[]);
33303 
33311  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);
33312 };
33313 
33314 
33315 
33316 
33318 class HPS_API PolygonKit : public Object
33319 {
33320 public:
33322  PolygonKit();
33323 
33326  PolygonKit(PolygonKit const & in_kit);
33327 
33331  PolygonKit(PolygonKit && in_that);
33332 
33336  PolygonKit & operator=(PolygonKit && in_that);
33337 
33338  virtual ~PolygonKit();
33339 
33340  HPS::Type ObjectType() const { return HPS::Type::PolygonKit; };
33341 
33344  void Consume(PolygonKit & in_kit);
33345 
33348  void Set(PolygonKit const & in_kit);
33349 
33352  void Show(PolygonKit & out_kit) const;
33353 
33357  PolygonKit & operator=(PolygonKit const & in_kit);
33358 
33361  bool Empty() const;
33362 
33366  bool Equals(PolygonKit const & in_kit) const;
33367 
33371  bool operator==(PolygonKit const & in_kit) const;
33372 
33376  bool operator!=(PolygonKit const & in_kit) const;
33377 
33380  size_t GetPointCount() const;
33381 
33388  PolygonKit & SetPriority(int in_priority);
33389 
33392  PolygonKit & UnsetPriority();
33393 
33397  bool ShowPriority(int & out_priority) const;
33398 
33399 
33403  PolygonKit & SetPoints(PointArray const & in_points);
33404 
33409  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
33410 
33413  PolygonKit & UnsetPoints();
33414 
33417  PolygonKit & UnsetEverything();
33418 
33422  bool ShowPoints(PointArray & out_points) const;
33423 
33429  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33430 
33435  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33436 
33442  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33443 
33449  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33450 
33455  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33456 
33461  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
33462 
33468  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33469 
33474  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33475 
33481  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33482 
33487  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33488 
33493  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33494 
33498  PolygonKit & UnsetUserData(intptr_t in_index);
33499 
33504  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33505 
33509  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
33510 
33513  PolygonKit & UnsetAllUserData();
33514 
33516  size_t ShowUserDataCount() const;
33517 
33521  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33522 
33527  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33528 
33533  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33534 };
33535 
33536 
33538 class HPS_API PolygonKey : public GeometryKey
33539 {
33540 public:
33542  PolygonKey();
33543 
33548  explicit PolygonKey(Key const & in_that);
33549 
33552  PolygonKey(PolygonKey const & in_that);
33553 
33557  PolygonKey & operator=(PolygonKey const & in_that);
33558 
33562  PolygonKey(PolygonKey && in_that);
33563 
33567  PolygonKey & operator=(PolygonKey && in_that);
33568 
33569  ~PolygonKey();
33570 
33571  HPS::Type ObjectType() const { return HPS::Type::PolygonKey; };
33572 
33573 
33576  void Consume(PolygonKit & in_kit);
33577 
33580  void Set(PolygonKit const & in_kit);
33581 
33584  void Show(PolygonKit & out_kit) const;
33585 
33588  size_t GetPointCount() const;
33589 
33593  PolygonKey & SetPoints(PointArray const & in_points);
33594 
33599  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
33600 
33604  bool ShowPoints(PointArray & out_points) const;
33605 
33611  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33612 
33617  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33618 
33624  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33625 
33631  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33632 
33637  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33638 
33643  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
33644 
33650  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33651 
33656  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33657 };
33658 
33659 
33660 
33661 
33663 class HPS_API GridKit : public Object
33664 {
33665 public:
33667  GridKit();
33668 
33671  GridKit(GridKit const & in_kit);
33672 
33675  GridKit(GridKit && in_that);
33676 
33677  virtual ~GridKit();
33678 
33679  HPS::Type ObjectType() const { return HPS::Type::GridKit; };
33680 
33683  void Consume(GridKit & in_kit);
33684 
33687  void Set(GridKit const & in_kit);
33688 
33691  void Show(GridKit & out_kit) const;
33692 
33696  GridKit & operator=(GridKit const & in_kit);
33697 
33701  GridKit & operator=(GridKit && in_that);
33702 
33705  bool Empty() const;
33706 
33710  bool Equals(GridKit const & in_kit) const;
33711 
33715  bool operator==(GridKit const & in_kit) const;
33716 
33720  bool operator!=(GridKit const & in_kit) const;
33721 
33722 
33729  GridKit & SetPriority(int in_priority);
33730 
33734  GridKit & SetType(Grid::Type in_type);
33735 
33739  GridKit & SetOrigin(Point const & in_origin);
33740 
33747  GridKit & SetFirstPoint(Point const & in_first_point);
33748 
33756  GridKit & SetSecondPoint(Point const & in_second_point);
33757 
33771  GridKit & SetFirstCount(int in_first_count);
33772 
33783  GridKit & SetSecondCount(int in_second_count);
33784 
33785 
33788  GridKit & UnsetPriority();
33789 
33792  GridKit & UnsetType();
33793 
33796  GridKit & UnsetOrigin();
33797 
33800  GridKit & UnsetFirstPoint();
33801 
33804  GridKit & UnsetSecondPoint();
33805 
33808  GridKit & UnsetFirstCount();
33809 
33812  GridKit & UnsetSecondCount();
33813 
33816  GridKit & UnsetEverything();
33817 
33818 
33822  bool ShowPriority(int & out_priority) const;
33823 
33827  bool ShowType(Grid::Type & out_type) const;
33828 
33832  bool ShowOrigin(Point & out_origin) const;
33833 
33837  bool ShowFirstPoint(Point & out_first_point) const;
33838 
33842  bool ShowSecondPoint(Point & out_second_point) const;
33843 
33847  bool ShowFirstCount(int & out_first_count) const;
33848 
33852  bool ShowSecondCount(int & out_second_count) const;
33853 
33859  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33860 
33865  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33866 
33871  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33872 
33876  GridKit & UnsetUserData(intptr_t in_index);
33877 
33882  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33883 
33887  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
33888 
33891  GridKit & UnsetAllUserData();
33892 
33894  size_t ShowUserDataCount() const;
33895 
33899  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33900 
33905  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33906 
33911  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33912 };
33913 
33914 
33916 class HPS_API GridKey : public GeometryKey
33917 {
33918 public:
33920  GridKey();
33921 
33926  explicit GridKey(Key const & in_that);
33927 
33930  GridKey(GridKey const & in_that);
33931 
33934  GridKey(GridKey && in_that);
33935 
33939  GridKey & operator=(GridKey const & in_that);
33940 
33944  GridKey & operator=(GridKey && in_that);
33945 
33946  ~GridKey();
33947 
33948  HPS::Type ObjectType() const { return HPS::Type::GridKey; };
33949 
33952  void Consume(GridKit & in_kit);
33953 
33956  void Set(GridKit const & in_kit);
33957 
33960  void Show(GridKit & out_kit) const;
33961 
33962 
33966  GridKey & SetType(Grid::Type in_type);
33967 
33971  GridKey & SetOrigin(Point const & in_origin);
33972 
33979  GridKey & SetFirstPoint(Point const & in_first_point);
33980 
33988  GridKey & SetSecondPoint(Point const & in_second_point);
33989 
34003  GridKey & SetFirstCount(int in_first_count);
34004 
34015  GridKey & SetSecondCount(int in_second_count);
34016 
34017 
34018 
34022  bool ShowType(Grid::Type & out_type) const;
34023 
34027  bool ShowOrigin(Point & out_origin) const;
34028 
34032  bool ShowFirstPoint(Point & out_first_point) const;
34033 
34037  bool ShowSecondPoint(Point & out_second_point) const;
34038 
34042  bool ShowFirstCount(int & out_first_count) const;
34043 
34047  bool ShowSecondCount(int & out_second_count) const;
34048 };
34049 
34050 
34051 
34052 
34054 class HPS_API IncludeKey : public Key
34055 {
34056 public:
34058  IncludeKey();
34059 
34064  explicit IncludeKey(Key const & in_that);
34065 
34068  IncludeKey(IncludeKey const & in_that);
34069 
34073  IncludeKey & operator=(IncludeKey const & in_that);
34074 
34078  IncludeKey(IncludeKey && in_that);
34079 
34083  IncludeKey & operator=(IncludeKey && in_that);
34084 
34085  ~IncludeKey();
34086 
34087 
34088  HPS::Type ObjectType() const { return HPS::Type::IncludeKey; };
34089 
34092  SegmentKey GetTarget() const;
34093 
34094 
34099  IncludeKey & SetPriority(int in_priority);
34100 
34108  IncludeKey & SetCondition(Condition const & in_condition);
34109 
34110 
34113  IncludeKey & UnsetPriority();
34114 
34117  IncludeKey & UnsetCondition();
34118 
34119 
34123  bool ShowPriority(int & out_priority) const;
34124 
34128  bool ShowCondition(Condition & out_condition) const;
34129 
34135  IncludeKey & SetFilter(AttributeLock::Type in_type);
34136 
34143  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34144 
34150  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
34151 
34157  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
34158 
34165  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34166 
34172  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34173 
34179  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34180 
34186  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34187 };
34188 
34189 
34190 
34192 class HPS_API StyleKey : public Key
34193 {
34194 public:
34196  StyleKey();
34197 
34202  explicit StyleKey(Key const & in_that);
34203 
34206  StyleKey(StyleKey const & in_that);
34207 
34211  StyleKey & operator=(StyleKey const & other);
34212 
34216  StyleKey(StyleKey && in_that);
34217 
34221  StyleKey & operator=(StyleKey && in_that);
34222 
34223  ~StyleKey();
34224 
34225  HPS::Type ObjectType() const { return HPS::Type::StyleKey; };
34226 
34227 
34233  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
34234 
34235 
34243  StyleKey & SetCondition(Condition const & in_condition);
34244 
34245 
34248  StyleKey & UnsetCondition();
34249 
34250 
34254  bool ShowCondition(Condition & out_condition) const;
34255 
34256 
34262  StyleKey & SetFilter(AttributeLock::Type in_type);
34263 
34270  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34271 
34277  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
34278 
34284  StyleKey & UnsetFilter(AttributeLock::Type in_type);
34285 
34292  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34293 
34299  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34300 
34306  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34307 
34313  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34314 };
34315 
34316 
34317 
34319 class HPS_API ReferenceKey : public GeometryKey
34320 {
34321 public:
34323  ReferenceKey();
34324 
34329  explicit ReferenceKey(Key const & in_that);
34330 
34333  ReferenceKey(ReferenceKey const & in_that);
34334 
34338  ReferenceKey & operator=(ReferenceKey const & in_that);
34339 
34343  ReferenceKey(ReferenceKey && in_that);
34344 
34348  ReferenceKey & operator=(ReferenceKey && in_that);
34349 
34350  ~ReferenceKey();
34351 
34352  HPS::Type ObjectType() const { return HPS::Type::ReferenceKey; };
34353 
34357  Key GetTarget() const;
34358 
34362  size_t ShowTargets(bool masked=true) const;
34363 
34368  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
34369 
34373  size_t ShowGeometryMask() const;
34374 
34379  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
34380 
34384  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
34385 
34388  ReferenceKey & UnsetGeometryMask();
34389 
34392  void SetModellingMatrix(MatrixKit const & in_kit);
34393 
34402  ReferenceKey & SetCondition(Condition const & in_condition);
34403 
34404 
34406  void UnsetModellingMatrix();
34407 
34410  ReferenceKey & UnsetCondition();
34411 
34412 
34416  bool ShowModellingMatrix(MatrixKit & out_kit) const;
34417 
34421  bool ShowCondition(Condition & out_condition) const;
34422 
34423 
34426  ModellingMatrixControl GetModellingMatrixControl();
34427 
34430  ModellingMatrixControl const GetModellingMatrixControl() const;
34431 };
34432 
34433 
34434 
34438 class HPS_API StandAloneWindowOptionsKit : public Object
34439 {
34440 public:
34443 
34447 
34452 
34457 
34458  virtual ~StandAloneWindowOptionsKit();
34459 
34460  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsKit; };
34461 
34465  static StandAloneWindowOptionsKit GetDefault();
34466 
34469  void Set(StandAloneWindowOptionsKit const & in_kit);
34470 
34473  void Show(StandAloneWindowOptionsKit & out_kit) const;
34474 
34478  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
34479 
34482  bool Empty() const;
34483 
34487  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
34488 
34492  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
34493 
34497  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
34498 
34502  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
34503 
34508  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34509 
34513  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
34514 
34519  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
34520 
34524  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
34525 
34529  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
34530 
34533  StandAloneWindowOptionsKit & UnsetDriver();
34534 
34537  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
34538 
34541  StandAloneWindowOptionsKit & UnsetTitle();
34542 
34545  StandAloneWindowOptionsKit & UnsetSubscreen();
34546 
34549  StandAloneWindowOptionsKit & UnsetMobility();
34550 
34553  StandAloneWindowOptionsKit & UnsetFullScreen();
34554 
34557  StandAloneWindowOptionsKit & UnsetEverything();
34558 
34562  bool ShowDriver(Window::Driver & out_driver) const;
34563 
34568  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34569 
34573  bool ShowTitle(UTF8 & out_window_name) const;
34574 
34578  bool ShowSubscreen(Rectangle & out_subscreen) const;
34579 
34583  bool ShowMobility(Window::Mobility & out_mobility) const;
34584 
34588  bool ShowFullScreen(bool & out_state) const;
34589 };
34590 
34591 
34592 
34599 {
34600 public:
34604 
34608 
34613 
34618 
34621 
34622  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsControl; };
34623 
34628 
34633  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
34634 
34638  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
34639 
34643  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
34644 
34648  bool ShowDriver(Window::Driver & out_driver) const;
34649 
34654  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34655 
34659  bool ShowTitle(UTF8 & out_window_name) const;
34660 
34664  bool ShowSubscreen(Rectangle & out_subscreen) const;
34665 
34669  bool ShowMobility(Window::Mobility & out_mobility) const;
34670 
34674  bool ShowFullScreen(bool & out_state) const;
34675 
34676 private:
34679 };
34680 
34681 
34682 
34686 class HPS_API OffScreenWindowOptionsKit : public Object
34687 {
34688 public:
34691 
34695 
34700 
34704  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
34705 
34706  virtual ~OffScreenWindowOptionsKit();
34707 
34708  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsKit; };
34709 
34713  static OffScreenWindowOptionsKit GetDefault();
34714 
34717  void Set(OffScreenWindowOptionsKit const & in_kit);
34718 
34721  void Show(OffScreenWindowOptionsKit & out_kit) const;
34722 
34726  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
34727 
34730  bool Empty() const;
34731 
34735  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
34736 
34740  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
34741 
34745  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
34746 
34750  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
34751 
34756  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34757 
34762  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
34763 
34768  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
34769 
34774  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
34775 
34779  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
34780 
34783  OffScreenWindowOptionsKit & UnsetDriver();
34784 
34787  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
34788 
34791  OffScreenWindowOptionsKit & UnsetHardwareResident();
34792 
34795  OffScreenWindowOptionsKit & UnsetNativeFormat();
34796 
34799  OffScreenWindowOptionsKit & UnsetOpacity();
34800 
34803  OffScreenWindowOptionsKit & UnsetEverything();
34804 
34808  bool ShowDriver(Window::Driver & out_driver) const;
34809 
34814  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34815 
34819  bool ShowHardwareResident(bool & out_state) const;
34820 
34825  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
34826 
34831  bool ShowOpacity(bool & out_state, float & out_opacity) const;
34832 };
34833 
34837 class HPS_API ApplicationWindowOptionsKit : public Object
34838 {
34839 public:
34842 
34846 
34851 
34856 
34857  virtual ~ApplicationWindowOptionsKit();
34858 
34859  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsKit; };
34860 
34864  static ApplicationWindowOptionsKit GetDefault();
34865 
34868  void Set(ApplicationWindowOptionsKit const & in_kit);
34869 
34872  void Show(ApplicationWindowOptionsKit & out_kit) const;
34873 
34877  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
34878 
34881  bool Empty() const;
34882 
34886  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
34887 
34891  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
34892 
34896  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
34897 
34901  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
34902 
34907  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34908 
34912  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
34913 
34917  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
34918 
34921  ApplicationWindowOptionsKit & UnsetDriver();
34922 
34925  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
34926 
34929  ApplicationWindowOptionsKit & UnsetPlatformData();
34930 
34933  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
34934 
34937  ApplicationWindowOptionsKit & UnsetEverything();
34938 
34942  bool ShowDriver(Window::Driver & out_driver) const;
34943 
34948  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34949 
34953  bool ShowPlatformData(PlatformData & out_platform_data) const;
34954 
34958  bool ShowFramebufferRetention(bool & out_retain) const;
34959 
34960 };
34961 
34962 
34963 
34966 {
34967 public:
34971 
34975 
34980 
34985 
34988 
34989  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsControl; };
34990 
34995 
35000  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
35001 
35005  bool ShowDriver(Window::Driver & out_driver) const;
35006 
35010  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
35011 
35015  bool ShowPlatformData(PlatformData & out_platform_data) const;
35016 
35020  bool ShowFramebufferRetention(bool & out_retain) const;
35021 
35025  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
35026 
35030  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
35031 
35032 private:
35035 };
35036 
35037 
35038 
35043 class HPS_API StandAloneWindowKey : public WindowKey
35044 {
35045 public:
35048 
35053  StandAloneWindowKey(Key const & in_key);
35054 
35057  StandAloneWindowKey(StandAloneWindowKey const & in_that);
35058 
35063 
35067  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
35068 
35070 
35071  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowKey; };
35072 
35075  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
35076 
35079  StandAloneWindowOptionsControl GetWindowOptionsControl();
35080 
35084  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
35085 
35088  Window::UpdateStatus Pause();
35089 };
35090 
35091 
35092 
35094 class HPS_API ApplicationWindowKey : public WindowKey
35095 {
35096 public:
35099 
35104  ApplicationWindowKey(Key const & in_key);
35105 
35108  ApplicationWindowKey(ApplicationWindowKey const & in_that);
35109 
35114 
35118  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
35119 
35121 
35122  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowKey; };
35123 
35126  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
35127 
35130  ApplicationWindowOptionsControl GetWindowOptionsControl();
35131 
35135  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
35136 };
35137 
35141 
35142 
35143 
35145 class HPS_API GlyphElement : public Object
35146 {
35147 public:
35149  GlyphElement();
35150 
35153  GlyphElement(GlyphElement const & in_that);
35154 
35158  GlyphElement(GlyphElement && in_that);
35159 
35163  GlyphElement & operator=(GlyphElement && in_that);
35164 
35165  virtual ~GlyphElement();
35166 
35167  HPS::Type ObjectType() const { return HPS::Type::GlyphElement; };
35168 
35171  void Set(GlyphElement const & in_that);
35172 
35176  GlyphElement & operator=(GlyphElement const & in_that);
35177 
35181  bool Equals(GlyphElement const & in_that) const;
35182 
35186  bool operator==(GlyphElement const & in_that) const;
35187 
35191  bool operator!=(GlyphElement const & in_that) const;
35192 
35195  void SetFill(Glyph::Fill in_fill);
35196 
35199  void SetIndexedColor(byte in_index);
35200 
35202  void SetNormalColor();
35203 
35206  void SetExplicitColor(RGBAColor const & in_color);
35207 
35211  bool ShowFill(Glyph::Fill & out_fill) const;
35212 
35218  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
35219 };
35220 
35221 
35223 class HPS_API LineGlyphElement : public GlyphElement
35224 {
35225 public:
35227  LineGlyphElement();
35228 
35233  LineGlyphElement(GlyphElement const & in_that);
35234 
35237  LineGlyphElement(LineGlyphElement const & in_that);
35238 
35241  explicit LineGlyphElement(GlyphPointArray const & in_points);
35242 
35246  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
35247 
35251  LineGlyphElement(LineGlyphElement && in_that);
35252 
35256  LineGlyphElement & operator=(LineGlyphElement && in_that);
35257 
35258  ~LineGlyphElement();
35259 
35260  HPS::Type ObjectType() const { return HPS::Type::LineGlyphElement; };
35261 
35264  void SetPoints(GlyphPointArray const & in_points);
35265 
35269  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
35270 
35274  bool ShowPoints(GlyphPointArray & out_points) const;
35275 };
35276 
35278 class HPS_API DotGlyphElement : public GlyphElement
35279 {
35280 public:
35282  DotGlyphElement();
35283 
35288  DotGlyphElement(GlyphElement const & in_that);
35289 
35292  DotGlyphElement(DotGlyphElement const & in_that);
35293 
35296  explicit DotGlyphElement(GlyphPoint const & in_point);
35297 
35301  DotGlyphElement(DotGlyphElement && in_that);
35302 
35306  DotGlyphElement & operator=(DotGlyphElement && in_that);
35307 
35308  ~DotGlyphElement();
35309 
35310  HPS::Type ObjectType() const { return HPS::Type::DotGlyphElement; };
35311 
35314  void SetPoint(GlyphPoint const & in_point);
35315 
35319  bool ShowPoint(GlyphPoint & out_point) const;
35320 };
35321 
35322 
35324 class HPS_API EllipseGlyphElement : public GlyphElement
35325 {
35326 public:
35329 
35334  EllipseGlyphElement(GlyphElement const & in_that);
35335 
35338  EllipseGlyphElement(EllipseGlyphElement const & in_that);
35339 
35343  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35344 
35349 
35353  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
35354 
35356 
35357  HPS::Type ObjectType() const { return HPS::Type::EllipseGlyphElement; };
35358 
35361  void SetLowerLeft(GlyphPoint const & in_point);
35362 
35365  void SetUpperRight(GlyphPoint const & in_point);
35366 
35370  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35371 
35375  bool ShowLowerLeft(GlyphPoint & out_point) const;
35376 
35380  bool ShowUpperRight(GlyphPoint & out_point) const;
35381 };
35382 
35383 
35386 {
35387 public:
35390 
35395  CircularArcGlyphElement(GlyphElement const & in_that);
35396 
35400 
35405  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35406 
35411 
35415  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
35416 
35418 
35419  HPS::Type ObjectType() const { return HPS::Type::CircularArcGlyphElement; };
35420 
35423  void SetStartPoint(GlyphPoint const & in_point);
35424 
35427  void SetIntermediatePoint(GlyphPoint const & in_point);
35428 
35431  void SetEndPoint(GlyphPoint const & in_point);
35432 
35437  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35438 
35442  bool ShowStartPoint(GlyphPoint & out_point) const;
35443 
35447  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
35448 
35452  bool ShowEndPoint(GlyphPoint & out_point) const;
35453 };
35454 
35455 
35456 
35459 {
35460 public:
35463 
35468  InfiniteLineGlyphElement(GlyphElement const & in_that);
35469 
35473 
35478  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
35479 
35484 
35488  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
35489 
35491 
35492  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineGlyphElement; };
35493 
35496  void SetFirstPoint(GlyphPoint const & in_point);
35497 
35500  void SetSecondPoint(GlyphPoint const & in_point);
35501 
35505  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
35506 
35509  void SetInfiniteType(InfiniteLine::Type in_type);
35510 
35514  bool ShowFirstPoint(GlyphPoint & out_point) const;
35515 
35519  bool ShowSecondPoint(GlyphPoint & out_point) const;
35520 
35524  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
35525 };
35526 
35527 
35528 
35530 class HPS_API GlyphKit : public Object
35531 {
35532 public:
35534  GlyphKit();
35535 
35538  GlyphKit(GlyphKit const & in_kit);
35539 
35543  GlyphKit(GlyphKit && in_that);
35544 
35548  GlyphKit & operator=(GlyphKit && in_that);
35549 
35550  virtual ~GlyphKit();
35551 
35552  HPS::Type ObjectType() const { return HPS::Type::GlyphKit; };
35553 
35557  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
35558 
35561  void Set(GlyphKit const & in_kit);
35562 
35565  void Show(GlyphKit & out_kit) const;
35566 
35570  GlyphKit & operator=(GlyphKit const & in_kit);
35571 
35574  bool Empty() const;
35575 
35579  bool Equals(GlyphKit const & in_kit) const;
35580 
35584  bool operator==(GlyphKit const & in_kit) const;
35585 
35589  bool operator!=(GlyphKit const & in_kit) const;
35590 
35594  GlyphKit & SetRadius(sbyte in_radius);
35595 
35600  GlyphKit & SetOffset(GlyphPoint const & in_point);
35601 
35605  GlyphKit & SetElements(GlyphElementArray const & in_def);
35606 
35611  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
35612 
35615  GlyphKit & UnsetRadius();
35616 
35619  GlyphKit & UnsetOffset();
35620 
35623  GlyphKit & UnsetElements();
35624 
35627  GlyphKit & UnsetEverything();
35628 
35632  bool ShowRadius(sbyte & out_radius) const;
35633 
35637  bool ShowOffset(GlyphPoint & out_point) const;
35638 
35642  bool ShowElements(GlyphElementArray & out_def) const;
35643 };
35644 
35648 
35649 
35652 class HPS_API LinePatternOptionsKit : public Object
35653 {
35654 public:
35657 
35661 
35666 
35670  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
35671 
35672  virtual ~LinePatternOptionsKit();
35673 
35674  HPS::Type ObjectType() const { return HPS::Type::LinePatternOptionsKit; };
35675 
35678  void Set(LinePatternOptionsKit const & in_kit);
35679 
35682  void Show(LinePatternOptionsKit & out_kit) const;
35683 
35687  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
35688 
35691  bool Empty() const;
35692 
35696  bool Equals(LinePatternOptionsKit const & in_kit) const;
35697 
35701  bool operator==(LinePatternOptionsKit const & in_kit) const;
35702 
35706  bool operator!=(LinePatternOptionsKit const & in_kit) const;
35707 
35711  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
35712 
35716  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
35717 
35721  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
35722 
35726  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
35727 
35731  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
35732 
35736  LinePatternOptionsKit & SetJoin(char const * in_glyph);
35737 
35741  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
35742 
35746  LinePatternOptionsKit & UnsetStartCap();
35747 
35751  LinePatternOptionsKit & UnsetEndCap();
35752 
35755  LinePatternOptionsKit & UnsetInnerCap();
35756 
35760  LinePatternOptionsKit & UnsetJoin();
35761 
35764  LinePatternOptionsKit & UnsetEverything();
35765 
35771  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35772 
35778  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35779 
35783  bool ShowInnerCap(LinePattern::Cap & out_type) const;
35784 
35790  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
35791 };
35792 
35795 class HPS_API LinePatternElement : public Object
35796 {
35797 public:
35800 
35803  LinePatternElement(LinePatternElement const & in_that);
35804 
35809 
35813  LinePatternElement & operator=(LinePatternElement && in_that);
35814 
35815  ~LinePatternElement();
35816 
35817  HPS::Type ObjectType() const { return HPS::Type::LinePatternElement; };
35818 
35821  void Set(LinePatternElement const & in_that);
35822 
35826  LinePatternElement & operator=(LinePatternElement const & in_that);
35827 
35831  bool Equals(LinePatternElement const & in_that) const;
35832 
35836  bool operator==(LinePatternElement const & in_that) const;
35837 
35841  bool operator!=(LinePatternElement const & in_that) const;
35842 
35846  void SetSize(float in_size, LinePattern::SizeUnits in_units);
35847 
35852  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
35853 };
35854 
35857 {
35858 public:
35861 
35867 
35871 
35875  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35876 
35881 
35885  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
35886 
35888 
35889  HPS::Type ObjectType() const { return HPS::Type::SolidLinePatternElement; };
35890 
35894  void SetColor(RGBAColor const & in_color);
35895 
35899  void SetMaterialByIndex(float in_material_index);
35900 
35906  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
35907 };
35908 
35909 
35912 {
35913 public:
35916 
35922 
35926 
35930  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35931 
35936 
35940  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
35941 
35943 
35944  HPS::Type ObjectType() const { return HPS::Type::BlankLinePatternElement; };
35945 };
35946 
35947 
35950 {
35951 public:
35954 
35960 
35964 
35968  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
35969 
35974 
35978  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
35979 
35981 
35982  HPS::Type ObjectType() const { return HPS::Type::GlyphLinePatternElement; };
35983 
35986  void SetSource(char const * in_source);
35987 
35991  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
35992 
35995  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
35996 
35999  void SetMirror(bool in_state);
36000 
36003  void SetFixed(bool in_state);
36004 
36007  void SetRotation(float in_degrees);
36008 
36012  bool ShowSource(UTF8 & out_source) const;
36013 
36018  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
36019 
36023  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
36024 
36028  bool ShowMirror(bool & out_state) const;
36029 
36033  bool ShowFixed(bool & out_state) const;
36034 
36038  bool ShowRotation(float & out_degrees) const;
36039 };
36040 
36042 class HPS_API LinePatternParallelKit : public Object
36043 {
36044 public:
36047 
36051 
36056 
36060  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
36061 
36062  virtual ~LinePatternParallelKit();
36063 
36064  HPS::Type ObjectType() const { return HPS::Type::LinePatternParallelKit; };
36065 
36068  void Set(LinePatternParallelKit const & in_kit);
36069 
36072  void Show(LinePatternParallelKit & out_kit) const;
36073 
36077  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
36078 
36081  bool Empty() const;
36082 
36086  bool Equals(LinePatternParallelKit const & in_kit) const;
36087 
36091  bool operator==(LinePatternParallelKit const & in_kit) const;
36092 
36096  bool operator!=(LinePatternParallelKit const & in_kit) const;
36097 
36101  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
36102 
36106  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
36107 
36111  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
36112 
36116  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
36117 
36122  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
36123 
36127  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
36128 
36132  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
36133 
36137  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
36138 
36145  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
36146 
36152  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
36153 
36157  LinePatternParallelKit & SetContinuous(bool in_state);
36158 
36161  LinePatternParallelKit & UnsetStartCap();
36162 
36165  LinePatternParallelKit & UnsetEndCap();
36166 
36169  LinePatternParallelKit & UnsetJoin();
36170 
36173  LinePatternParallelKit & UnsetBody();
36174 
36177  LinePatternParallelKit & UnsetAbsoluteLength();
36178 
36181  LinePatternParallelKit & UnsetAbsoluteWeight();
36182 
36185  LinePatternParallelKit & UnsetJustification();
36186 
36189  LinePatternParallelKit & UnsetOffset();
36190 
36193  LinePatternParallelKit & UnsetWeight();
36194 
36197  LinePatternParallelKit & UnsetContinuous();
36198 
36201  LinePatternParallelKit & UnsetEverything();
36202 
36206  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
36207 
36211  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
36212 
36216  bool ShowJoin(GlyphLinePatternElement & out_join) const;
36217 
36221  bool ShowBody(LinePatternElementArray & out_elements) const;
36222 
36226  bool ShowAbsoluteLength(bool & out_state) const;
36227 
36231  bool ShowAbsoluteWeight(bool & out_state) const;
36232 
36236  bool ShowJustification(LinePattern::Justification & out_type) const;
36237 
36243  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36244 
36250  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36251 
36255  bool ShowContinuous(bool & out_state) const;
36256 };
36257 
36258 
36260 class HPS_API LinePatternKit : public Object
36261 {
36262 public:
36264  LinePatternKit();
36265 
36268  LinePatternKit(LinePatternKit const & in_kit);
36269 
36273  LinePatternKit(LinePatternKit && in_that);
36274 
36278  LinePatternKit & operator=(LinePatternKit && in_that);
36279 
36280  virtual ~LinePatternKit();
36281 
36282  HPS::Type ObjectType() const { return HPS::Type::LinePatternKit; };
36283 
36287  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
36288 
36291  void Set(LinePatternKit const & in_kit);
36292 
36295  void Show(LinePatternKit & out_kit) const;
36296 
36300  LinePatternKit & operator=(LinePatternKit const & in_kit);
36301 
36304  bool Empty() const;
36305 
36309  bool Equals(LinePatternKit const & in_kit) const;
36310 
36314  bool operator==(LinePatternKit const & in_kit) const;
36315 
36319  bool operator!=(LinePatternKit const & in_kit) const;
36320 
36324  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
36325 
36330  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
36331 
36335  LinePatternKit & SetJoin(LinePattern::Join in_type);
36336 
36339  LinePatternKit & UnsetParallels();
36340 
36343  LinePatternKit & UnsetJoin();
36344 
36347  LinePatternKit & UnsetEverything();
36348 
36352  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
36353 
36357  bool ShowJoin(LinePattern::Join & out_type) const;
36358 };
36359 
36360 
36361 
36365 
36366 
36368 class HPS_API Definition : public Object
36369 {
36370 public:
36372  Definition();
36373 
36376  Definition(Definition const & in_that);
36377 
36381  Definition & operator=(Definition const & in_that);
36382 
36386  Definition(Definition && in_that);
36387 
36391  Definition & operator=(Definition && in_that);
36392 
36393  virtual ~Definition();
36394 
36395  HPS::Type ObjectType() const { return HPS::Type::Definition; };
36396 
36398  void Undefine();
36399 
36402  PortfolioKey Owner() const;
36403 
36406  UTF8 Name() const;
36407 
36410  virtual void Assign(Definition const & in_that);
36411 
36415  bool Equals(Definition const & in_that) const;
36416 
36420  bool operator==(Definition const & in_that) const;
36421 
36425  bool operator!=(Definition const & in_that) const;
36426 };
36427 
36428 
36431 class HPS_API PortfolioKey : public Key
36432 {
36433 public:
36435  PortfolioKey();
36436 
36441  explicit PortfolioKey(Key const & in_that);
36442 
36445  PortfolioKey(PortfolioKey const & in_that);
36446 
36450  PortfolioKey & operator=(PortfolioKey const & in_that);
36451 
36455  PortfolioKey(PortfolioKey && in_that);
36456 
36460  PortfolioKey & operator=(PortfolioKey && in_that);
36461 
36462  ~PortfolioKey();
36463 
36464  HPS::Type ObjectType() const { return HPS::Type::PortfolioKey; };
36465 
36466  // Define
36467 
36474  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
36475 
36483  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
36484 
36485 
36497  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36498  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36499  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
36500 
36513  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36514  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36515  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
36516 
36517 
36523  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
36524 
36525 
36531  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
36532 
36533 
36539  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
36540 
36547  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
36548 
36549 
36555  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
36556 
36557 
36563  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
36564 
36565 
36571  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
36572 
36573 
36574  // UnDefine
36575 
36579  PortfolioKey & UndefineTexture(char const * in_name);
36580 
36584  PortfolioKey & UndefineCubeMap(char const * in_name);
36585 
36589  PortfolioKey & UndefineImage(char const * in_name);
36590 
36594  PortfolioKey & UndefineNamedStyle(char const * in_name);
36595 
36599  PortfolioKey & UndefineMaterialPalette(char const * in_name);
36600 
36604  PortfolioKey & UndefineGlyph(char const * in_name);
36605 
36609  PortfolioKey & UndefineLinePattern(char const * in_name);
36610 
36614  PortfolioKey & UndefineShader(char const * in_name);
36615 
36616 
36617  // Import collections
36623  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36624 
36625 
36631  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36632 
36638  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36639 
36645  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36646 
36652  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36653 
36659  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36660 
36666  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36667 
36673  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36674 
36680  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36681 
36682 
36683  // Import individual definitions
36687  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
36688 
36692  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
36693 
36697  ImageDefinition ImportImage(ImageDefinition const & in_definition);
36698 
36702  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
36703 
36707  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
36708 
36712  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
36713 
36717  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
36718 
36722  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
36723 
36724 
36725  // Show
36727  size_t GetDefinitionCount() const;
36728 
36730  size_t GetTextureDefinitionCount() const;
36731 
36733  size_t GetCubeMapDefinitionCount() const;
36734 
36736  size_t GetImageDefinitionCount() const;
36737 
36739  size_t GetNamedStyleDefinitionCount() const;
36740 
36742  size_t GetMaterialPaletteDefinitionCount() const;
36743 
36745  size_t GetGlyphDefinitionCount() const;
36746 
36748  size_t GetLinePatternDefinitionCount() const;
36749 
36751  size_t GetShaderDefinitionCount() const;
36752 
36757  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
36758 
36762  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
36763 
36768  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
36769 
36773  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
36774 
36779  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
36780 
36784  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
36785 
36790  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
36791 
36795  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
36796 
36801  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
36802 
36806  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
36807 
36812  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
36813 
36817  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
36818 
36823  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
36824 
36828  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
36829 
36834  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
36835 
36839  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
36840 
36841 private:
36843  void MoveTo(SegmentKey const & in_new_owner);
36844 
36846  Key CopyTo(SegmentKey const & in_destination) const;
36847 };
36848 
36849 
36850 
36852 class HPS_API GlyphDefinition : public Definition
36853 {
36854 public:
36856  GlyphDefinition();
36857 
36862  GlyphDefinition(Definition const & in_that);
36863 
36866  GlyphDefinition(GlyphDefinition const & in_that);
36867 
36871  GlyphDefinition & operator=(GlyphDefinition const & in_that);
36872 
36876  GlyphDefinition(GlyphDefinition && in_that);
36877 
36881  GlyphDefinition & operator=(GlyphDefinition && in_that);
36882 
36883  ~GlyphDefinition();
36884 
36885  HPS::Type ObjectType() const { return HPS::Type::GlyphDefinition; };
36886 
36889  void Set(GlyphKit const & in_kit);
36890 
36893  void Show(GlyphKit & out_kit) const;
36894 };
36895 
36896 
36898 class HPS_API TextureDefinition : public Definition
36899 {
36900 public:
36903 
36908  TextureDefinition(Definition const & in_that);
36909 
36912  TextureDefinition(TextureDefinition const & in_that);
36913 
36917  TextureDefinition & operator=(TextureDefinition const & in_that);
36918 
36923 
36927  TextureDefinition & operator=(TextureDefinition && in_that);
36928 
36929  ~TextureDefinition();
36930 
36931  HPS::Type ObjectType() const { return HPS::Type::TextureDefinition; };
36932 
36935  void SetSource(ImageDefinition const & in_source);
36936 
36939  void ShowSource(ImageDefinition & out_source) const;
36940 
36943  void SetOptions(TextureOptionsKit const & in_options);
36944 
36947  void ShowOptions(TextureOptionsKit & out_options) const;
36948 
36949 };
36950 
36954 class HPS_API TextureOptionsKit : public Object
36955 {
36956 public:
36959 
36962  TextureOptionsKit(TextureOptionsKit const & in_kit);
36963 
36968 
36972  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
36973 
36974  virtual ~TextureOptionsKit();
36975 
36976  HPS::Type ObjectType() const { return HPS::Type::TextureOptionsKit; };
36977 
36981  static TextureOptionsKit GetDefault();
36982 
36985  void Set(TextureOptionsKit const & in_kit);
36986 
36989  void Show(TextureOptionsKit & out_kit) const;
36990 
36994  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
36995 
36998  bool Empty() const;
36999 
37003  bool Equals(TextureOptionsKit const & in_kit) const;
37004 
37008  bool operator==(TextureOptionsKit const & in_kit) const;
37009 
37013  bool operator!=(TextureOptionsKit const & in_kit) const;
37014 
37019  TextureOptionsKit & SetDecal(bool in_state);
37020 
37024  TextureOptionsKit & SetDownSampling(bool in_state);
37025 
37029  TextureOptionsKit & SetModulation(bool in_state);
37030 
37034  TextureOptionsKit & SetParameterOffset(size_t in_offset);
37035 
37039  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
37040 
37044  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
37045 
37049  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
37050 
37054  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
37055 
37059  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
37060 
37063  TextureOptionsKit & UnsetDecal();
37064 
37067  TextureOptionsKit & UnsetDownSampling();
37068 
37071  TextureOptionsKit & UnsetModulation();
37072 
37075  TextureOptionsKit & UnsetParameterOffset();
37076 
37079  TextureOptionsKit & UnsetParameterizationSource();
37080 
37083  TextureOptionsKit & UnsetTiling();
37084 
37087  TextureOptionsKit & UnsetInterpolationFilter();
37088 
37091  TextureOptionsKit & UnsetDecimationFilter();
37092 
37095  TextureOptionsKit & UnsetTransformMatrix();
37096 
37099  TextureOptionsKit & UnsetEverything();
37100 
37104  bool ShowDecal(bool & out_state) const;
37105 
37109  bool ShowDownSampling(bool & out_state) const;
37110 
37114  bool ShowModulation(bool & out_state) const;
37115 
37119  bool ShowParameterOffset(size_t & out_offset) const;
37120 
37124  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
37125 
37129  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
37130 
37134  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
37135 
37139  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
37140 
37144  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37145 };
37146 
37147 
37149 class HPS_API Image
37150 {
37151 public:
37154  enum class Format
37155  {
37156  RGB,
37157  RGBA,
37158  ARGB,
37159  Mapped8,
37160  Grayscale,
37161  Bmp,
37162  Jpeg,
37163  Png,
37164  Targa,
37165  DXT1,
37166  DXT3,
37167  DXT5
37168  };
37169 
37171  class HPS_API ExportOptionsKit : public Object
37172  {
37173  public:
37175  ExportOptionsKit();
37176 
37179  ExportOptionsKit(ExportOptionsKit const & in_kit);
37180 
37184  ExportOptionsKit(ExportOptionsKit && in_that);
37185 
37189  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
37190 
37191  virtual ~ExportOptionsKit();
37192 
37193  HPS::Type ObjectType() const { return HPS::Type::ImageExportOptionsKit; };
37194 
37198  static ExportOptionsKit GetDefault();
37199 
37202  void Set(ExportOptionsKit const & in_kit);
37203 
37206  void Show(ExportOptionsKit & out_kit) const;
37207 
37211  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
37212 
37215  bool Empty() const;
37216 
37220  bool Equals(ExportOptionsKit const & in_kit) const;
37221 
37225  bool operator==(ExportOptionsKit const & in_kit) const;
37226 
37230  bool operator!=(ExportOptionsKit const & in_kit) const;
37231 
37236  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37237 
37242  ExportOptionsKit & SetFormat(Image::Format in_format);
37243 
37246  ExportOptionsKit & UnsetSize();
37247 
37250  ExportOptionsKit & UnsetFormat();
37251 
37254  ExportOptionsKit & UnsetEverything();
37255 
37260  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37261 
37265  bool ShowFormat(Image::Format & out_format) const;
37266  };
37267 
37269  class HPS_API ImportOptionsKit : public Object
37270  {
37271  public:
37273  ImportOptionsKit();
37274 
37277  ImportOptionsKit(ImportOptionsKit const & in_kit);
37278 
37282  ImportOptionsKit(ImportOptionsKit && in_that);
37283 
37287  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37288 
37289  virtual ~ImportOptionsKit();
37290 
37291  HPS::Type ObjectType() const { return HPS::Type::ImageImportOptionsKit; };
37292 
37295  void Set(ImportOptionsKit const & in_kit);
37296 
37299  void Show(ImportOptionsKit & out_kit) const;
37300 
37304  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37305 
37308  bool Empty() const;
37309 
37313  bool Equals(ImportOptionsKit const & in_kit) const;
37314 
37318  bool operator==(ImportOptionsKit const & in_kit) const;
37319 
37323  bool operator!=(ImportOptionsKit const & in_kit) const;
37324 
37331  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37332 
37336  ImportOptionsKit & SetFormat(Image::Format in_format);
37337 
37342  ImportOptionsKit & SetDownSampling(bool in_state);
37343 
37348  ImportOptionsKit & SetCompressionQuality(float in_quality);
37349 
37352  ImportOptionsKit & UnsetSize();
37353 
37356  ImportOptionsKit & UnsetFormat();
37357 
37360  ImportOptionsKit & UnsetDownSampling();
37361 
37364  ImportOptionsKit & UnsetCompressionQuality();
37365 
37368  ImportOptionsKit & UnsetEverything();
37369 
37374  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37375 
37379  bool ShowFormat(Image::Format & out_format) const;
37380 
37384  bool ShowDownSampling(bool & out_state) const;
37385 
37389  bool ShowCompressionQuality(float & out_quality) const;
37390  };
37391 
37393  class HPS_API File
37394  {
37395  public:
37401  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
37402 
37409  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
37410 
37418  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);
37419 
37424  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
37425 
37426  private:
37428  File();
37429  };
37430 
37431 private:
37433  Image();
37434 };
37435 
37436 
37438 class HPS_API ImageKit : public Object
37439 {
37440 public:
37442  ImageKit();
37443 
37446  ImageKit(ImageKit const & in_kit);
37447 
37452  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
37453 
37457  ImageKit(ImageKit && in_that);
37458 
37462  ImageKit & operator=(ImageKit && in_that);
37463 
37464  virtual ~ImageKit();
37465 
37466  HPS::Type ObjectType() const { return HPS::Type::ImageKit; };
37467 
37470  void Set(ImageKit const & in_kit);
37471 
37474  void Show(ImageKit & out_kit) const;
37475 
37479  ImageKit & operator=(ImageKit const & in_kit);
37480 
37483  bool Empty() const;
37484 
37488  bool Equals(ImageKit const & in_kit) const;
37489 
37493  bool operator==(ImageKit const & in_kit) const;
37494 
37498  bool operator!=(ImageKit const & in_kit) const;
37499 
37503  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
37504 
37507  void Convert(HPS::Image::Format in_format);
37508 
37513  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
37514 
37518  ImageKit & SetData(ByteArray const & in_image_data);
37519 
37524  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
37525 
37529  ImageKit & SetFormat(Image::Format in_format);
37530 
37534  ImageKit & SetDownSampling(bool in_state);
37535 
37539  ImageKit & SetCompressionQuality(float in_quality);
37540 
37543  ImageKit & UnsetSize();
37544 
37547  ImageKit & UnsetData();
37548 
37551  ImageKit & UnsetFormat();
37552 
37555  ImageKit & UnsetDownSampling();
37556 
37559  ImageKit & UnsetCompressionQuality();
37560 
37563  ImageKit & UnsetEverything();
37564 
37569  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37570 
37574  bool ShowData(ByteArray & out_image_data) const;
37575 
37579  bool ShowFormat(Image::Format & out_format) const;
37580 
37584  bool ShowDownSampling(bool & out_state) const;
37585 
37589  bool ShowCompressionQuality(float & out_quality) const;
37590 };
37591 
37592 
37598 {
37599 public:
37603 
37608 
37613 
37618 
37620 
37621  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsControl; };
37622 
37626  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
37627 
37632  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
37633 
37638  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
37639 
37643  bool ShowDriver(Window::Driver & out_driver) const;
37644 
37649  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37650 
37655  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37656 
37661  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
37662 
37667  bool ShowImage(ByteArray & out_bytes) const;
37668 
37672  bool ShowHardwareResident(bool & out_state) const;
37673 
37678  bool ShowOpacity(bool & out_state, float & out_opacity) const;
37679 
37684  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
37685 
37686 
37687 private:
37690 };
37691 
37692 
37695 class HPS_API OffScreenWindowKey : public WindowKey
37696 {
37697 public:
37700 
37705  OffScreenWindowKey(Key const & in_key);
37706 
37709  OffScreenWindowKey(OffScreenWindowKey const & in_that);
37710 
37715 
37719  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
37720 
37721  ~OffScreenWindowKey();
37722 
37723  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowKey; };
37724 
37727  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
37728 
37731  OffScreenWindowOptionsControl GetWindowOptionsControl();
37732 
37736  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
37737 };
37738 
37739 
37740 
37741 
37743 class HPS_API ImageDefinition : public Definition
37744 {
37745 public:
37747  ImageDefinition();
37748 
37753  ImageDefinition(Definition const & in_that);
37754 
37757  ImageDefinition(ImageDefinition const & in_that);
37758 
37762  ImageDefinition & operator=(ImageDefinition const & in_that);
37763 
37767  ImageDefinition(ImageDefinition && in_that);
37768 
37772  ImageDefinition & operator=(ImageDefinition && in_that);
37773 
37774  ~ImageDefinition();
37775 
37776  HPS::Type ObjectType() const { return HPS::Type::ImageDefinition; };
37777 
37780  void Set(ImageKit const & in_kit);
37781 
37784  void Show(ImageKit & out_kit) const;
37785 };
37786 
37788 class HPS_API CubeMapDefinition : public Definition
37789 {
37790 public:
37793 
37798  CubeMapDefinition(Definition const & in_that);
37799 
37802  CubeMapDefinition(CubeMapDefinition const & in_that);
37803 
37807  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
37808 
37813 
37817  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
37818 
37819  ~CubeMapDefinition();
37820 
37821  HPS::Type ObjectType() const { return HPS::Type::CubeMapDefinition; };
37822 
37830  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
37831  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
37832  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
37833 
37841  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
37842  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
37843  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
37844 
37848  void ShowSource(ImageDefinitionArray & out_image_sources) const;
37849 
37852  void SetOptions(TextureOptionsKit const & in_options);
37853 
37856  void ShowOptions(TextureOptionsKit & out_options) const;
37857 };
37858 
37859 
37861 class HPS_API NamedStyleDefinition : public Definition
37862 {
37863 public:
37866 
37871  NamedStyleDefinition(Definition const & in_that);
37872 
37875  NamedStyleDefinition(NamedStyleDefinition const & in_that);
37876 
37880  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
37881 
37886 
37890  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
37891 
37893 
37894  HPS::Type ObjectType() const { return HPS::Type::NamedStyleDefinition; };
37895 
37899  SegmentKey GetSource() const;
37900 };
37901 
37902 
37905 {
37906 public:
37909 
37914  MaterialPaletteDefinition(Definition const & in_that);
37915 
37919 
37923  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
37924 
37929 
37933  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
37934 
37936 
37937  HPS::Type ObjectType() const { return HPS::Type::MaterialPaletteDefinition; };
37938 
37941  void Set(MaterialKitArray const & in_source);
37942 
37946  void Set(size_t in_count, MaterialKit const in_source []);
37947 
37950  void Show(MaterialKitArray & out_source) const;
37951 };
37952 
37953 
37954 
37956 class HPS_API LinePatternDefinition : public Definition
37957 {
37958 public:
37961 
37966  LinePatternDefinition(Definition const & in_that);
37967 
37971 
37975  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
37976 
37981 
37985  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
37986 
37988 
37989  HPS::Type ObjectType() const { return HPS::Type::LinePatternDefinition; };
37990 
37993  void Set(LinePatternKit const & in_kit);
37994 
37997  void Show(LinePatternKit & out_kit) const;
37998 };
37999 
38000 
38001 
38003 class HPS_API Shader
38004 {
38005 public:
38008  enum class Parameterization
38009  {
38011  Cylinder,
38013  PhysicalReflection,
38015  Object,
38021  NaturalUV,
38023  ReflectionVector,
38025  SurfaceNormal,
38027  Sphere,
38029  UV,
38031  World
38032  };
38033 
38035  class HPS_API ImportOptionsKit : public Object
38036  {
38037  public:
38039  ImportOptionsKit();
38040 
38043  ImportOptionsKit(ImportOptionsKit const & in_kit);
38044 
38048  ImportOptionsKit(ImportOptionsKit && in_that);
38049 
38053  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38054 
38055  virtual ~ImportOptionsKit();
38056 
38057  HPS::Type ObjectType() const { return HPS::Type::ShaderImportOptionsKit; };
38058 
38061  void Set(ImportOptionsKit const & in_kit);
38062 
38065  void Show(ImportOptionsKit & out_kit) const;
38066 
38070  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
38071 
38074  bool Empty() const;
38075 
38079  bool Equals(ImportOptionsKit const & in_kit) const;
38080 
38084  bool operator==(ImportOptionsKit const & in_kit) const;
38085 
38089  bool operator!=(ImportOptionsKit const & in_kit) const;
38090 
38097  ImportOptionsKit & SetMultitexture(bool in_state);
38098 
38102  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38103 
38107  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
38108 
38112  ImportOptionsKit & UnsetMultitexture();
38113 
38116  ImportOptionsKit & UnsetParameterizationSource();
38117 
38120  ImportOptionsKit & UnsetTransformMatrix();
38121 
38124  ImportOptionsKit & UnsetEverything();
38125 
38131  bool ShowMultitexture(bool & out_state) const;
38132 
38136  bool ShowParameterizationSource(Parameterization & out_source) const;
38137 
38141  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38142  };
38143 
38145  class HPS_API File
38146  {
38147  public:
38153  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
38154 
38155  private:
38157  File();
38158  };
38159 
38160 private:
38162  Shader();
38163 };
38164 
38165 
38167 class HPS_API ShaderKit : public Object
38168 {
38169 public:
38171  ShaderKit();
38172 
38175  ShaderKit(ShaderKit const & in_kit);
38176 
38180  ShaderKit(ShaderKit && in_that);
38181 
38185  ShaderKit & operator=(ShaderKit && in_that);
38186 
38187  virtual ~ShaderKit();
38188 
38189  HPS::Type ObjectType() const { return HPS::Type::ShaderKit; };
38190 
38193  void Set(ShaderKit const & in_kit);
38194 
38197  void Show(ShaderKit & out_kit) const;
38198 
38202  ShaderKit & operator=(ShaderKit const & in_kit);
38203 
38206  bool Empty() const;
38207 
38211  bool Equals(ShaderKit const & in_kit) const;
38212 
38216  bool operator==(ShaderKit const & in_kit) const;
38217 
38221  bool operator!=(ShaderKit const & in_kit) const;
38222 
38226  ShaderKit & SetSource(char const * in_source);
38227 
38234  ShaderKit & SetMultitexture(bool in_state);
38235 
38239  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38240 
38244  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
38245 
38248  ShaderKit & UnsetSource();
38249 
38253  ShaderKit & UnsetMultitexture();
38254 
38257  ShaderKit & UnsetParameterizationSource();
38258 
38261  ShaderKit & UnsetTransformMatrix();
38262 
38265  ShaderKit & UnsetEverything();
38266 
38270  bool ShowSource(UTF8 & out_source) const;
38271 
38277  bool ShowMultitexture(bool & out_state) const;
38278 
38282  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
38283 
38287  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38288 };
38289 
38290 
38292 class HPS_API ShaderDefinition : public Definition
38293 {
38294 public:
38296  ShaderDefinition();
38297 
38302  ShaderDefinition(Definition const & in_that);
38303 
38306  ShaderDefinition(ShaderDefinition const & in_that);
38307 
38311  ShaderDefinition & operator=(ShaderDefinition const & in_that);
38312 
38316  ShaderDefinition(ShaderDefinition && in_that);
38317 
38321  ShaderDefinition & operator=(ShaderDefinition && in_that);
38322 
38323  ~ShaderDefinition();
38324 
38325  HPS::Type ObjectType() const { return HPS::Type::ShaderDefinition; };
38326 
38329  void Set(ShaderKit const & in_kit);
38330 
38333  void Show(ShaderKit & out_kit) const;
38334 };
38335 
38336 
38337 
38338 
38342 
38344 {
38345 public:
38348 
38352 
38357 
38362 
38363  virtual ~CutGeometryGatheringOptionsKit();
38364 
38365  HPS::Type ObjectType() const {return HPS::Type::CutGeometryGatheringOptionsKit;};
38366 
38370  static CutGeometryGatheringOptionsKit GetDefault();
38371 
38374  void Set(CutGeometryGatheringOptionsKit const & in_kit);
38375 
38378  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
38379 
38384 
38387  bool Empty() const;
38388 
38392  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
38393 
38397  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
38398 
38402  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
38403 
38404 
38408  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
38409 
38413  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
38414 
38419 
38420 
38423  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
38424 
38427  CutGeometryGatheringOptionsKit & UnsetOffset();
38428 
38431  CutGeometryGatheringOptionsKit & UnsetLevel();
38432 
38435  CutGeometryGatheringOptionsKit & UnsetEverything();
38436 
38437 
38441  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
38442 
38446  bool ShowOffset(size_t & out_offset) const;
38447 
38451  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
38452 };
38453 
38455 class HPS_API SearchOptionsKit : public Object
38456 {
38457 public:
38459  SearchOptionsKit();
38460 
38463  SearchOptionsKit(SearchOptionsKit const & in_kit);
38464 
38468  SearchOptionsKit(SearchOptionsKit && in_that);
38469 
38473  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
38474 
38475  virtual ~SearchOptionsKit();
38476 
38477  HPS::Type ObjectType() const {return HPS::Type::SearchOptionsKit;};
38478 
38482  static SearchOptionsKit GetDefault();
38483 
38486  void Set(SearchOptionsKit const & in_kit);
38487 
38490  void Show(SearchOptionsKit & out_kit) const;
38491 
38495  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
38496 
38499  bool Empty() const;
38500 
38504  bool Equals(SearchOptionsKit const & in_kit) const;
38505 
38509  bool operator==(SearchOptionsKit const & in_kit) const;
38510 
38514  bool operator!=(SearchOptionsKit const & in_kit) const;
38515 
38519  SearchOptionsKit & SetCriteria(Search::Type in_request);
38520 
38524  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
38525 
38529  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
38530 
38535  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
38536 
38540  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
38541 
38544  SearchOptionsKit & UnsetBehavior();
38545 
38548  SearchOptionsKit & UnsetCriteria();
38549 
38552  SearchOptionsKit & UnsetSearchSpace();
38553 
38556  SearchOptionsKit & UnsetEverything();
38557 
38561  bool ShowBehavior(Search::Behavior & out_behavior) const;
38562 
38566  bool ShowCriteria(SearchTypeArray & out_types) const;
38567 
38571  bool ShowSearchSpace(Search::Space & out_search_space) const;
38572 };
38573 
38577 class HPS_API TreeContext : public Object
38578 {
38579 public:
38582  TreeContext(bool in_create = true);
38583 
38586  TreeContext(TreeContext const & in_that);
38587 
38591  TreeContext(TreeContext && in_that);
38592 
38596  TreeContext & operator=(TreeContext && in_that);
38597 
38599  virtual ~TreeContext();
38600 
38601  HPS::Type ObjectType() const {return HPS::Type::TreeContext;};
38602 
38606  TreeContext & operator=(TreeContext const & in_that);
38607 
38611  bool Equals(TreeContext const & in_that) const;
38612 
38616  bool operator==(TreeContext const & in_that) const;
38617 
38621  bool operator!=(TreeContext const & in_that) const;
38622 
38623 };
38624 
38626 class HPS_API SelectionOptionsKit : public Object
38627 {
38628 public:
38631 
38634  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
38635 
38640 
38644  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
38645 
38646  virtual ~SelectionOptionsKit();
38647 
38648  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsKit;};
38649 
38653  static SelectionOptionsKit GetDefault();
38654 
38657  void Set(SelectionOptionsKit const & in_kit);
38658 
38661  void Show(SelectionOptionsKit & out_kit) const;
38662 
38666  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
38667 
38670  bool Empty() const;
38671 
38675  bool Equals(SelectionOptionsKit const & in_kit) const;
38676 
38680  bool operator==(SelectionOptionsKit const & in_kit) const;
38681 
38685  bool operator!=(SelectionOptionsKit const & in_kit) const;
38686 
38694  SelectionOptionsKit & SetProximity(float in_proximity);
38695 
38701  SelectionOptionsKit & SetLevel(Selection::Level in_level);
38702 
38707  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
38708 
38717  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
38718 
38726  SelectionOptionsKit & SetSorting(bool in_sorted);
38727 
38733  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
38734 
38740  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
38741 
38746  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
38747 
38752  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
38753 
38758  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
38759 
38766  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
38767 
38774  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
38775 
38782  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
38783 
38790  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
38791 
38794  SelectionOptionsKit & UnsetProximity();
38795 
38798  SelectionOptionsKit & UnsetLevel();
38799 
38802  SelectionOptionsKit & UnsetInternalLimit();
38803 
38806  SelectionOptionsKit & UnsetRelatedLimit();
38807 
38810  SelectionOptionsKit & UnsetSorting();
38811 
38814  SelectionOptionsKit & UnsetAlgorithm();
38815 
38818  SelectionOptionsKit & UnsetGranularity();
38819 
38822  SelectionOptionsKit & UnsetScope();
38823 
38826  SelectionOptionsKit & UnsetTreeContext();
38827 
38830  SelectionOptionsKit & UnsetExtentCullingRespected();
38831 
38834  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
38835 
38838  SelectionOptionsKit & UnsetFrustumCullingRespected();
38839 
38842  SelectionOptionsKit & UnsetVectorCullingRespected();
38843 
38844 
38847  SelectionOptionsKit & UnsetEverything();
38848 
38852  bool ShowProximity(float & out_proximity) const;
38853 
38857  bool ShowLevel(Selection::Level & out_level) const;
38858 
38862  bool ShowInternalLimit(size_t & out_limit) const;
38863 
38867  bool ShowRelatedLimit(size_t & out_limit) const;
38868 
38872  bool ShowSorting(bool & out_sorted) const;
38873 
38877  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38878 
38882  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38883 
38887  bool ShowScope(KeyPath & out_start_path) const;
38888 
38892  bool ShowTreeContext(TreeContext & out_tree_context) const;
38893 
38897  bool ShowExtentCullingRespected(bool & out_state) const;
38898 
38902  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38903 
38907  bool ShowFrustumCullingRespected(bool & out_state) const;
38908 
38912  bool ShowVectorCullingRespected(bool & out_state) const;
38913 };
38914 
38915 
38916 
38920 class HPS_API SelectionOptionsControl : public Control
38921 {
38922 public:
38925  explicit SelectionOptionsControl(WindowKey const & in_window);
38926 
38930 
38935 
38939  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
38940 
38942 
38943  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsControl;};
38944 
38948  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
38949 
38955  SelectionOptionsControl & SetProximity(float in_proximity);
38956 
38962  SelectionOptionsControl & SetLevel(Selection::Level in_level);
38963 
38970  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
38971 
38980  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
38981 
38989  SelectionOptionsControl & SetSorting(bool in_sorted);
38990 
38996  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
38997 
39003  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
39004 
39011  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
39012 
39019  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
39020 
39027  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
39028 
39035  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
39036 
39037  // there is no way to unset default values, intentionally
39038 
39042  bool ShowProximity(float & out_proximity) const;
39043 
39047  bool ShowLevel(Selection::Level & out_level) const;
39048 
39052  bool ShowInternalLimit(size_t & out_limit) const;
39053 
39057  bool ShowRelatedLimit(size_t & out_limit) const;
39058 
39062  bool ShowSorting(bool & out_sorted) const;
39063 
39067  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
39068 
39072  bool ShowGranularity(Selection::Granularity & out_granularity) const;
39073 
39077  bool ShowExtentCullingRespected(bool & out_state) const;
39078 
39082  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
39083 
39087  bool ShowFrustumCullingRespected(bool & out_state) const;
39088 
39092  bool ShowVectorCullingRespected(bool & out_state) const;
39093 
39094 private:
39097 };
39098 
39099 
39100 
39102 class HPS_API SelectionItem : public Object
39103 {
39104 public:
39106  SelectionItem();
39107 
39110  SelectionItem(SelectionItem const & in_that);
39111 
39115  SelectionItem(SelectionItem && in_that);
39116 
39120  SelectionItem & operator=(SelectionItem && in_that);
39121 
39122  virtual ~SelectionItem();
39123 
39124  HPS::Type ObjectType() const {return HPS::Type::SelectionItem;};
39125 
39128  void Set(SelectionItem const & in_that);
39129 
39133  SelectionItem & operator=(SelectionItem const & in_that);
39134 
39138  bool Equals(SelectionItem const & in_that) const;
39139 
39143  bool operator==(SelectionItem const & in_that) const;
39144 
39148  bool operator!=(SelectionItem const & in_that) const;
39149 
39153  bool ShowSelectionLevel(Selection::Level & out_level) const;
39154 
39158  bool ShowSelectedItem(Key & out_selection) const;
39159 
39163  bool ShowPath(KeyPath & out_path) const;
39164 
39168  bool ShowFaces(SizeTArray & out_faces) const;
39169 
39173  bool ShowVertices(SizeTArray & out_vertices) const;
39174 
39179  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
39180 
39184  bool ShowCharacters(SizeTArray & out_characters) const;
39185 
39189  bool ShowSelectionPosition(WindowPoint & out_location) const;
39190 
39194  bool ShowSelectionPosition(WorldPoint & out_location) const;
39195 
39196 };
39197 
39199 class HPS_API SelectionResultsIterator : public Object
39200 {
39201 public:
39204 
39209 
39214 
39218  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
39219 
39221 
39222  HPS::Type ObjectType() const {return HPS::Type::SelectionResultsIterator;}
39223 
39227  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
39228 
39231  void Set(SelectionResultsIterator const & in_that);
39232 
39234  void Next();
39235 
39238  SelectionResultsIterator & operator++();
39239 
39242  SelectionResultsIterator operator++(int in_val);
39243 
39246  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
39247 
39250  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
39251 
39252 
39255  bool IsValid() const;
39256 
39258  void Reset();
39259 
39262  SelectionItem GetItem() const;
39263 
39266  SelectionItem operator*() const;
39267 
39268 
39269 };
39270 
39274 class HPS_API SelectionResults : public Object
39275 {
39276 public:
39278  SelectionResults();
39279 
39282  SelectionResults(SelectionResults const & in_that);
39283 
39287  SelectionResults(SelectionResults && in_that);
39288 
39292  SelectionResults & operator=(SelectionResults && in_that);
39293 
39294  ~SelectionResults();
39295 
39296  HPS::Type ObjectType() const {return HPS::Type::SelectionResults;}
39297 
39300  void Assign(SelectionResults const & in_that);
39301 
39305  SelectionResults & operator=(SelectionResults const & in_that);
39306 
39310  bool Equals(SelectionResults const & in_that) const;
39311 
39315  bool operator==(SelectionResults const & in_that) const;
39316 
39320  bool operator!=(SelectionResults const & in_that) const;
39321 
39323  virtual void Reset();
39324 
39327  Selection::Level GetSelectionLevel() const;
39328 
39331  size_t GetCount() const;
39332 
39335  SelectionResultsIterator GetIterator() const;
39336 
39342  bool Union(SelectionResults const & in_that);
39343 
39348  bool Intersect(SelectionResults const & in_that);
39349 
39355  bool SymmetricDifference(SelectionResults const & in_that);
39356 
39361  bool Difference(SelectionResults const & in_that);
39362 
39365  void Copy(SelectionResults const & in_that);
39366 };
39367 
39370 class HPS_API SelectionControl : public Object
39371 {
39372 public:
39375  explicit SelectionControl(WindowKey const & in_window);
39376 
39379  SelectionControl(SelectionControl const & in_that);
39380 
39384  SelectionControl(SelectionControl && in_that);
39385 
39389  SelectionControl & operator=(SelectionControl && in_that);
39390 
39391  ~SelectionControl();
39392 
39393  HPS::Type ObjectType() const {return HPS::Type::SelectionControl;};
39394 
39398  SelectionControl & operator=(SelectionControl const & in_that);
39399 
39405  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39406 
39411  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
39412 
39418  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39419 
39424  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
39425 
39431  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39432 
39437  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
39438 
39445  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39446 
39452  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39453 
39459  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39460 
39465  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
39466 
39473  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39474 
39480  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39481 
39482 
39483  //Object space selections
39484 
39490  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39491 
39496  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
39497 
39503  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39504 
39509  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
39510 
39511 
39518  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39519 
39525  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
39526 
39527 
39534  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39535 
39541  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
39542 
39543 private:
39545  SelectionControl();
39546 };
39547 
39548 
39549 
39551 class HPS_API HighlightOptionsKit : public Object
39552 {
39553 public:
39556 
39559  HighlightOptionsKit(char const * in_style_name);
39560 
39564  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
39565 
39568  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
39569 
39574 
39578  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
39579 
39580  virtual ~HighlightOptionsKit();
39581 
39582  HPS::Type ObjectType() const {return HPS::Type::HighlightOptionsKit;};
39583 
39587  static HighlightOptionsKit GetDefault();
39588 
39591  void Set(HighlightOptionsKit const & in_kit);
39592 
39595  void Show(HighlightOptionsKit & out_kit) const;
39596 
39600  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
39601 
39604  bool Empty() const;
39605 
39609  bool Equals(HighlightOptionsKit const & in_kit) const;
39610 
39614  bool operator==(HighlightOptionsKit const & in_kit) const;
39615 
39619  bool operator!=(HighlightOptionsKit const & in_kit) const;
39620 
39621 
39625  HighlightOptionsKit & SetStyleName(char const * in_style_name);
39626 
39630  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
39631 
39638  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
39639 
39645  HighlightOptionsKit & SetNotification(bool in_state);
39646 
39647 
39650  HighlightOptionsKit & UnsetStyleName();
39651 
39654  HighlightOptionsKit & UnsetSecondaryStyleName();
39655 
39658  HighlightOptionsKit & UnsetOverlay();
39659 
39662  HighlightOptionsKit & UnsetNotification();
39663 
39666  HighlightOptionsKit & UnsetEverything();
39667 
39668 
39672  bool ShowStyleName(UTF8 & out_style_name) const;
39673 
39677  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
39678 
39682  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
39683 
39687  bool ShowNotification(bool & out_state) const;
39688 };
39689 
39692 class HPS_API HighlightControl : public Control
39693 {
39694 public:
39697  explicit HighlightControl(WindowKey const & in_window);
39698 
39701  HighlightControl(HighlightControl const & in_that);
39702 
39706  HighlightControl(HighlightControl && in_that);
39707 
39711  HighlightControl & operator=(HighlightControl && in_that);
39712 
39713  ~HighlightControl();
39714 
39715  HPS::Type ObjectType() const {return HPS::Type::HighlightControl;};
39716 
39720  HighlightControl & operator=(HighlightControl const & in_that);
39721 
39726  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
39727 
39732  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
39733 
39738  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
39739 
39744  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
39745 
39750  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
39751 
39756  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39757 
39762  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39763 
39768  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39769 
39774  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39775 
39780  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39781 
39785  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
39786 
39789  HighlightControl & UnhighlightEverything();
39790 
39791 private:
39793  HighlightControl();
39794 };
39795 
39797 class HPS_API UpdateOptionsKit : public Object
39798 {
39799 public:
39801  UpdateOptionsKit();
39802 
39805  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
39806 
39810  UpdateOptionsKit(UpdateOptionsKit && in_that);
39811 
39815  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
39816 
39817  virtual ~UpdateOptionsKit();
39818 
39819  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsKit;};
39820 
39824  static UpdateOptionsKit GetDefault();
39825 
39828  void Set(UpdateOptionsKit const & in_kit);
39829 
39832  void Show(UpdateOptionsKit & out_kit) const;
39833 
39837  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
39838 
39841  bool Empty() const;
39842 
39846  bool Equals(UpdateOptionsKit const & in_kit) const;
39847 
39851  bool operator==(UpdateOptionsKit const & in_kit) const;
39852 
39856  bool operator!=(UpdateOptionsKit const & in_kit) const;
39857 
39861  UpdateOptionsKit & SetUpdateControl(HPS::Window::UpdateControl in_control);
39862 
39866  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
39867 
39870  UpdateOptionsKit & UnsetUpdateControl();
39871 
39874  UpdateOptionsKit & UnsetTimeLimit();
39875 
39878  UpdateOptionsKit & UnsetEverything();
39879 
39880 
39884  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39885 
39889  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39890 
39891 };
39892 
39893 
39894 
39900 class HPS_API UpdateOptionsControl : public Control
39901 {
39902 public:
39905  explicit UpdateOptionsControl(WindowKey const & in_window);
39906 
39909  UpdateOptionsControl(UpdateOptionsControl const & in_that);
39910 
39915 
39919  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
39920 
39922 
39923  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsControl;};
39924 
39928  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
39929 
39933  UpdateOptionsControl & SetUpdateControl(HPS::Window::UpdateControl in_control);
39934 
39938  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
39939 
39942  UpdateOptionsControl & UnsetUpdateControl();
39943 
39946  UpdateOptionsControl & UnsetTimeLimit();
39947 
39950  UpdateOptionsControl & UnsetEverything();
39951 
39955  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39956 
39960  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39961 
39962 private:
39965 };
39966 
39969 class HPS_API World : public Object
39970 {
39971 public:
39975  World(char const * in_license);
39976 
39978  ~World();
39979 
39980  HPS::Type ObjectType() const {return HPS::Type::World;};
39981 
39986  World & SetMaterialLibraryDirectory(char const * in_directory);
39987 
39992  World & SetFontDirectory(char const * in_directory);
39993 
39999  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
40000 
40005  World & SetFontDirectories(UTF8Array const & in_directories);
40006 
40012  World & SetDriverConfigFile(char const * in_filename);
40013 
40019  World & SetExchangeLibraryDirectory(char const * in_directory);
40020 
40026  World & SetPublishResourceDirectory(char const * in_directory);
40027 
40032  World & SetParasolidSchemaDirectory(char const * in_directory);
40033 
40039  World & SetParasolidBodyshopDirectory(char const * in_directory);
40040 
40043  World & UnsetMaterialLibraryDirectory();
40044 
40047  World & UnsetFontDirectories();
40048 
40051  World & UnsetDriverConfigFile();
40052 
40055  World & UnsetExchangeLibraryDirectory();
40056 
40059  World & UnsetPublishResourceDirectory();
40060 
40063  World & UnsetParasolidSchemaDirectory();
40064 
40067  World & UnsetParasolidBodyshopDirectory();
40068 
40072  bool ShowLicense(UTF8 & out_license) const;
40073 
40077  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
40078 
40082  bool ShowFontDirectories(UTF8Array & out_directories) const;
40083 
40087  bool ShowDriverConfigFile(UTF8 & out_filename) const;
40088 
40092  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
40093 
40097  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
40098 
40102  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
40103 
40104 
40108  bool ShowParasolidBodyshopDirectory(UTF8 & out_directory) const;
40109 private:
40111  World();
40112 
40114  virtual void Reset() {}
40115 };
40116 
40117 
40133 class HPS_API EmergencyHandler
40134 {
40135 public:
40136 
40139 
40140  virtual ~EmergencyHandler();
40141 
40143  intptr_t GetClassID() const;
40144 
40147  virtual EmergencyHandler * Clone() const = 0;
40148 
40152  virtual void Handle(const char * message, HPS::Emergency::Code code) const = 0;
40153 
40154  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
40155  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
40156 };
40157 
40158 
40161 class HPS_API Database
40162 {
40163 public:
40168  static void Execute(bool in_once=true);
40169 
40172  static Time GetTime();
40173 
40175  static void Sleep(Time milliseconds);
40176 
40201  static void RelinquishMemory();
40202 
40203 
40229  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
40230 
40238  static void Reset();
40239 
40241  static void Synchronize();
40242 
40245  static WindowKeyArray GetWindowKeys();
40246 
40249  static SegmentKeyArray GetRootSegments();
40250 
40253  static PortfolioKeyArray GetPortfolios();
40254 
40259  static PortfolioKey const GetMaterialLibraryPortfolio();
40260 
40266  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
40267 
40272  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
40273 
40277  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
40278 
40282  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
40283 
40290  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
40291 
40297  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
40298 
40304  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
40305 
40310  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
40311 
40314  static SegmentKey CreateRootSegment();
40315 
40318  static PortfolioKey CreatePortfolio();
40319 
40322  static EventDispatcher CreateEventDispatcher();
40323 
40327  static EventDispatcher CreateEventDispatcher(char const * in_name);
40328 
40334  static size_t SelectByShell(ShellKit const & in_shell,
40335  SelectionOptionsKit const & in_options,
40336  SelectionResults & out_results);
40337 
40343  static size_t SelectByShell(ShellKey const & in_shell,
40344  SelectionOptionsKit const & in_options,
40345  SelectionResults & out_results);
40346 
40353  static size_t SelectByVolume(SimpleCuboid const & in_volume,
40354  SelectionOptionsKit const & in_options,
40355  SelectionResults & out_results);
40356 
40363  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
40364  SelectionOptionsKit const & in_options,
40365  SelectionResults & out_results);
40366 
40369  static EventDispatcher const & GetEventDispatcher();
40370 
40371 
40375  static bool GetInformationEventFilter(HPS::Info::Code in_code);
40376 
40380  static bool GetWarningEventFilter(HPS::Info::Code in_code);
40381 
40385  static bool GetErrorEventFilter(HPS::Info::Code in_code);
40386 
40391  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
40392 
40397  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
40398 
40403  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
40404 
40405 
40408  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
40409 
40411  static void UnsetEmergencyHandler();
40412 
40415  static size_t GetSoftMemoryLimit();
40416 
40420  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
40421 
40425  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
40426 
40427 private:
40429  Database();
40430 };
40431 
40432 
40436 
40437 
40438 
40440 class HPS_API EventDispatcher : public Object
40441 {
40442 public:
40445  EventDispatcher();
40446 
40449  EventDispatcher(EventDispatcher const & in_that);
40450 
40454  EventDispatcher(EventDispatcher && in_that);
40455 
40459  EventDispatcher & operator=(EventDispatcher && in_that);
40460 
40461  virtual ~EventDispatcher();
40462 
40463  HPS::Type ObjectType() const {return HPS::Type::EventDispatcher;};
40464 
40468  EventDispatcher & operator=(EventDispatcher const & in_that);
40469 
40473  bool Equals(EventDispatcher const & in_that) const;
40474 
40478  bool operator==(EventDispatcher const & in_that) const;
40479 
40483  bool operator!=(EventDispatcher const & in_that) const;
40484 
40489  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
40490 
40495  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
40496 
40501  bool UnSubscribe(EventHandler const & in_handler) const;
40502 
40506  bool UnSubscribe(intptr_t in_type) const;
40507 
40511  bool InjectEvent(Event const & in_event) const;
40512 
40517  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
40518 
40521  void Shutdown() const;
40522 
40525  bool IsShutdown() const;
40526 
40527 
40530  void SetName(char const * in_name) const;
40531 
40534  void ShowName(UTF8 & out_name) const;
40535 
40536 private:
40538  virtual void Reset() {}
40539 };
40540 
40541 
40544 class HPS_API EventHandler : public Object
40545 {
40546 public:
40548  EventHandler();
40549 
40552  EventHandler(EventHandler const & in_that);
40553 
40557  EventHandler(EventHandler && in_that);
40558 
40562  EventHandler & operator=(EventHandler && in_that);
40563 
40567  EventHandler & operator=(EventHandler const & in_that);
40568 
40569  virtual ~EventHandler();
40570 
40571  HPS::Type ObjectType() const {return HPS::Type::EventHandler;};
40572 
40577  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40578 
40583  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40584 
40588  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
40589 
40591  void UnSubscribeEverything() const;
40592 
40594  virtual void Reset() { UnSubscribeEverything(); }
40595 
40598  void Shutdown();
40599 
40602  enum class HandleResult
40603  {
40604  Handled,
40605  NotHandled
40606  };
40607 
40612  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
40613 };
40614 
40615 
40616 
40618 class HPS_API TimerTickEvent : public Event
40619 {
40620 public:
40623  {
40624  channel = GetClassID();
40625  consumable = false;
40626  }
40627 
40628 
40631  TimerTickEvent(Event const & in_event) : Event(in_event)
40632  {
40633  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
40634  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40635  }
40636 
40637  ~TimerTickEvent();
40638 
40641  Event * Clone() const
40642  {
40643  TimerTickEvent * new_event = new TimerTickEvent(*this);
40644  return new_event;
40645  }
40646 
40650  virtual bool Drop(Event const * in_that_event) const
40651  {
40652  HPS_UNREFERENCED(in_that_event);
40653  return true;
40654  }
40655 
40656  virtual intptr_t Freshen() const {
40657  return GetClassID();
40658  }
40659 };
40660 
40662 class HPS_API HighlightEvent : public Event
40663 {
40664 public:
40665  enum class Action
40666  {
40667  None = 0,
40668  Highlight,
40669  Unhighlight,
40670  };
40671 
40674  {
40675  channel = GetClassID();
40676  consumable = false;
40677  action = Action::None;
40678  }
40679 
40680  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
40681  : Event(), action(in_action), results(in_results), options(in_options)
40682  {
40683  channel = GetClassID();
40684  consumable = false;
40685  }
40686 
40689  HighlightEvent(Event const & in_event) : Event(in_event)
40690  {
40691  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
40692  {
40693  auto that = static_cast<HighlightEvent const &>(in_event);
40694  action = that.action;
40695  results = that.results;
40696  options = that.options;
40697  }
40698  else
40699  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40700  }
40701 
40702  ~HighlightEvent();
40703 
40706  Event * Clone() const
40707  {
40708  HighlightEvent * new_event = new HighlightEvent(*this);
40709  return new_event;
40710  }
40711 
40712  Action action;
40713  SelectionResults results;
40714  HighlightOptionsKit options;
40715 };
40716 
40718 class HPS_API InformationEvent : public Event
40719 {
40720 public:
40722  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40723 
40726  InformationEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40727 
40731  InformationEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40732 
40735  InformationEvent(Event const & in_event) : Event(in_event)
40736  {
40737  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
40738  {
40739  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
40740  message = event->message;
40741  code = event->code;
40742  }
40743  else
40744  {
40745  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40746  }
40747  }
40748 
40749  ~InformationEvent();
40750 
40753  Event * Clone() const
40754  {
40755  InformationEvent * new_event = new InformationEvent(*this);
40756  return new_event;
40757  }
40758 
40762  virtual bool Equals(InformationEvent const & in_that) const
40763  {
40764  return message == in_that.message && code == in_that.code;
40765  }
40766 
40770  virtual bool operator== (InformationEvent const & in_that) const
40771  {
40772  return Equals(in_that);
40773  }
40774 
40778  virtual bool operator!= (InformationEvent const & in_that) const
40779  {
40780  return !Equals(in_that);
40781  }
40782 
40785 };
40786 
40787 
40789 class HPS_API WarningEvent : public Event
40790 {
40791 public:
40793  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40794 
40797  WarningEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40798 
40802  WarningEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40803 
40806  WarningEvent(Event const & in_event) : Event(in_event)
40807  {
40808  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
40809  {
40810  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
40811  message = event->message;
40812  code = event->code;
40813  }
40814  else
40815  {
40816  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40817  }
40818  }
40819 
40820  ~WarningEvent();
40821 
40824  Event * Clone() const
40825  {
40826  WarningEvent * new_event = new WarningEvent(*this);
40827  return new_event;
40828  }
40829 
40833  virtual bool Equals(WarningEvent const & in_that) const
40834  {
40835  return message == in_that.message && code == in_that.code;
40836  }
40837 
40841  virtual bool operator== (WarningEvent const & in_that) const
40842  {
40843  return Equals(in_that);
40844  }
40845 
40849  virtual bool operator!= (WarningEvent const & in_that) const
40850  {
40851  return !Equals(in_that);
40852  }
40853 
40856 };
40857 
40858 
40860 class HPS_API ErrorEvent : public Event
40861 {
40862 public:
40864  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40865 
40868  ErrorEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40869 
40873  ErrorEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40874 
40877  ErrorEvent(Event const & in_event) : Event(in_event)
40878  {
40879  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
40880  {
40881  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
40882  message = event->message;
40883  code = event->code;
40884  }
40885  else
40886  {
40887  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40888  }
40889  }
40890 
40891  ~ErrorEvent();
40892 
40895  Event * Clone() const
40896  {
40897  ErrorEvent * new_event = new ErrorEvent(*this);
40898  return new_event;
40899  }
40900 
40904  virtual bool Equals(ErrorEvent const & in_that) const
40905  {
40906  return message == in_that.message && code == in_that.code;
40907  }
40908 
40912  virtual bool operator== (ErrorEvent const & in_that) const
40913  {
40914  return Equals(in_that);
40915  }
40916 
40920  virtual bool operator!= (ErrorEvent const & in_that) const
40921  {
40922  return !Equals(in_that);
40923  }
40924 
40927 };
40928 
40929 
40931 class HPS_API StandAloneWindowEvent : public Event
40932 {
40933 public:
40934 
40937  enum class Action
40938  {
40939  Unknown,
40940  Close,
40941  FocusIn,
40942  FocusOut,
40943  };
40944 
40946  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
40947 
40948 
40951  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
40952 
40955  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
40956  {
40957  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40958  {
40959  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
40960  action = event->action;
40961  }
40962  else
40963  {
40964  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40965  }
40966  }
40967 
40969 
40972  Event * Clone() const
40973  {
40974  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
40975  return new_event;
40976  }
40977 
40981  virtual bool Equals(StandAloneWindowEvent const & in_that) const
40982  {
40983  return action == in_that.action;
40984  }
40985 
40989  virtual bool operator== (StandAloneWindowEvent const & in_that) const
40990  {
40991  return Equals(in_that);
40992  }
40993 
40997  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
40998  {
40999  return !Equals(in_that);
41000  }
41001 
41003 };
41004 
41006 class HPS_API FocusLostEvent : public Event
41007 {
41008 public:
41011  Event()
41012  { channel = GetClassID(); }
41013 
41014  ~FocusLostEvent() {};
41015 
41018  Event * Clone() const
41019  {
41020  FocusLostEvent * new_event = new FocusLostEvent(*this);
41021  return new_event;
41022  }
41023 };
41024 
41025 
41027 class HPS_API UpdateCompletedEvent : public Event
41028 {
41029 public:
41031  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
41032 
41034  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
41035 
41038  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
41039  {
41040  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41041  {
41042  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
41043  update_time = event->update_time;
41044  }
41045  else
41046  {
41047  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41048  }
41049  }
41050 
41051  virtual ~UpdateCompletedEvent();
41052 
41055  Event * Clone() const
41056  {
41057  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
41058  return new_event;
41059  }
41060 
41061  Time update_time;
41062 };
41063 
41065 class HPS_API ImportStatusEvent : public Event
41066 {
41067 public:
41070  : Event()
41071  , import_status_message(HPS::UTF8())
41072  { channel = GetClassID(); }
41073 
41074  ImportStatusEvent(char const * in_message)
41075  : Event()
41076  , import_status_message(in_message)
41077  { channel = GetClassID(); }
41078 
41081  ImportStatusEvent(Event const & in_event) : Event(in_event)
41082  {
41083  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
41084  {
41085  auto event = static_cast<ImportStatusEvent const &>(in_event);
41086  import_status_message = event.import_status_message;
41087  }
41088  else
41089  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41090  }
41091 
41092  ~ImportStatusEvent() {};
41093 
41096  Event * Clone() const
41097  {
41098  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
41099  return new_event;
41100  }
41101 
41102  HPS::UTF8 import_status_message;
41103 };
41104 
41106 class HPS_API ModifierKeys
41107 {
41108 public:
41110  ModifierKeys() : modifiers(_key_none) {}
41111 
41115  bool Equals(ModifierKeys const & in_that) const
41116  {
41117  return modifiers == in_that.modifiers;
41118  }
41119 
41123  bool operator== (ModifierKeys const & in_that) const
41124  {
41125  return Equals(in_that);
41126  }
41127 
41131  bool operator!= (ModifierKeys const & in_that) const
41132  {
41133  return !Equals(in_that);
41134  }
41135 
41138  bool None() const { return modifiers == _key_none; }
41139 
41142  bool Shift() const { return (modifiers & _key_shift) != 0; }
41143 
41146  bool Control() const { return (modifiers & _key_control) != 0; }
41147 
41150  bool Alt() const { return (modifiers & _key_alt) != 0; }
41151 
41154  bool Meta() const { return (modifiers & _key_meta) != 0; }
41155 
41156 
41160  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41161 
41165  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
41166 
41167 
41170  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
41171 
41174  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
41175 
41178  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
41179 
41182  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
41183 
41187  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
41188  {
41189  ModifierKeys ret;
41190  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41191  return ret;
41192  }
41193 
41197  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
41198  {
41199  ModifierKeys ret;
41200  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41201  return ret;
41202  }
41203 
41207  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
41208 
41212  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
41213 
41214 
41217  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
41218 
41221  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
41222 
41225  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
41226 
41229  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
41230 
41231 protected:
41232 
41236  {
41237  _key_none = 0x0000,
41238  _key_shift = 0x0001,
41239  _key_control = 0x0002,
41240  _key_alt = 0x0004,
41241  _key_meta = 0x0008,
41242  };
41243 
41244  int modifiers;
41245 };
41246 
41247 
41250 class HPS_API InputEvent : public Event
41251 {
41252 public:
41253 
41255  InputEvent() : Event() { channel = GetClassID(); }
41256 
41259  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
41260 
41261  ~InputEvent();
41262 
41265  Event * Clone() const
41266  {
41267  InputEvent * new_event = new InputEvent(*this);
41268  return new_event;
41269  }
41270 
41274  virtual bool Equals(InputEvent const & in_that) const
41275  {
41276  return ModifierKeyState == in_that.ModifierKeyState;
41277  }
41278 
41282  virtual bool operator== (InputEvent const & in_that) const
41283  {
41284  return Equals(in_that);
41285  }
41286 
41290  virtual bool operator!= (InputEvent const & in_that) const
41291  {
41292  return !Equals(in_that);
41293  }
41294 
41298  {
41299  return ModifierKeyState;
41300  }
41301 
41303 };
41304 
41306 class HPS_API TouchEvent : public InputEvent
41307 {
41308 public:
41311  enum class Action
41312  {
41313  TouchDown,
41314  TouchUp,
41315  Move,
41316  };
41317 
41319  TouchEvent() : InputEvent() { channel = GetClassID(); }
41320 
41325  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
41326  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41327 
41333  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
41334  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41335 
41342  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
41343  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41344 
41345 
41348  TouchEvent(Event const & in_event) : InputEvent()
41349  {
41350  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
41351  {
41352  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
41353  channel = GetClassID();
41354  CurrentAction = event->CurrentAction;
41355  Touches = event->Touches;
41356  ModifierKeyState = event->ModifierKeyState;
41357  }
41358  else
41359  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
41360  }
41361 
41362  ~TouchEvent();
41363 
41364 
41367  Event * Clone() const
41368  {
41369  TouchEvent * new_event = new TouchEvent(*this);
41370  return new_event;
41371  }
41372 
41376  virtual bool Equals(TouchEvent const & in_that) const
41377  {
41378  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
41379  }
41380 
41384  virtual bool operator== (TouchEvent const & in_that) const
41385  {
41386  return Equals(in_that);
41387  }
41388 
41392  virtual bool operator!= (TouchEvent const & in_that) const
41393  {
41394  return !Equals(in_that);
41395  }
41396 
41400  virtual bool Drop(Event const * in_that_event) const
41401  {
41402  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
41403 
41404  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
41405  && Touches.size() == that_touch_event->Touches.size() )
41406  {
41407  TouchArray these_touches = Touches;
41408  TouchArray those_touches = that_touch_event->Touches;
41409 
41410  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41411  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41412 
41413  for (size_t i = 0 ; i < these_touches.size() ; i++)
41414  {
41415  if (these_touches[i].ID != those_touches[i].ID)
41416  return false;
41417  }
41418  return true;
41419  }
41420 
41421  return false;
41422  }
41423 
41427  void SetTouches(size_t in_touch_count, Touch const in_touches[])
41428  {
41429  Touches.assign(in_touches, in_touches + in_touch_count);
41430  }
41431 
41434  void SetTouches(HPS::TouchArray const & in_touches)
41435  {
41436  Touches = in_touches;
41437  }
41438 
41440  HPS::TouchArray Touches;
41441 
41442 private:
41448  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
41449  {
41450  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
41451  }
41452 };
41453 
41454 
41456 class HPS_API MouseButtons
41457 {
41458 public:
41460  MouseButtons() : buttons(_button_none) {}
41461 
41465  bool Equals(MouseButtons const & in_that) const
41466  {
41467  return buttons == in_that.buttons;
41468  }
41469 
41473  bool operator== (MouseButtons const & in_that) const
41474  {
41475  return Equals(in_that);
41476  }
41477 
41481  bool operator!= (MouseButtons const & in_that) const
41482  {
41483  return !Equals(in_that);
41484  }
41485 
41488  bool None() const { return buttons == _button_none; }
41489 
41492  bool Left() const { return (buttons & _button_left) != 0; }
41493 
41496  bool Right() const { return (buttons & _button_right) != 0; }
41497 
41500  bool Middle() const { return (buttons & _button_middle) != 0; }
41501 
41504  bool X1() const { return (buttons & _button_x1) != 0; }
41505 
41508  bool X2() const { return (buttons & _button_x2) != 0; }
41509 
41510 
41514  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41515 
41519  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
41520 
41523  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
41524 
41527  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
41528 
41531  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
41532 
41535  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
41536 
41539  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
41540 
41544  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
41545  {
41546  MouseButtons ret;
41547  ret.buttons = buttons | in_buttons_to_merge.buttons;
41548  return ret;
41549  }
41550 
41554  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
41555  {
41556  MouseButtons ret;
41557  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41558  return ret;
41559  }
41560 
41564  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
41565 
41569  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
41570 
41571 
41574  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
41575 
41578  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
41579 
41582  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
41583 
41586  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
41587 
41590  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
41591 
41592 protected:
41593 
41596  enum Buttons
41597  {
41598  _button_none = 0x0000,
41599  _button_left = 0x0001,
41600  _button_right = 0x0002,
41601  _button_middle = 0x0004,
41602  _button_x1 = 0x0008,
41603  _button_x2 = 0x0010
41604  };
41605 
41606  int buttons;
41607 };
41608 
41610 class HPS_API MouseEvent : public InputEvent
41611 {
41612 public:
41613 
41616  enum class Action
41617  {
41618  ButtonUp,
41619  ButtonDown,
41620  Move,
41621  Scroll,
41622  Enter,
41623  Leave
41624  };
41625 
41627  MouseEvent() : InputEvent() { channel = GetClassID(); }
41628 
41635  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
41636  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41637 
41645  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)
41646  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41647 
41650  MouseEvent(Event const & in_event) : InputEvent()
41651  {
41652  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
41653  {
41654  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
41655  channel = GetClassID();
41656  CurrentAction = event->CurrentAction;
41657  Location = event->Location;
41658  CurrentButton = event->CurrentButton;
41659  WheelDelta = event->WheelDelta;
41660  ClickCount = event->ClickCount;
41661  }
41662  else
41663  {
41664  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41665  }
41666  }
41667 
41668  ~MouseEvent();
41669 
41672  Event * Clone() const
41673  {
41674  MouseEvent * new_event = new MouseEvent(*this);
41675  return new_event;
41676  }
41677 
41681  virtual bool Equals(MouseEvent const & in_that) const
41682  {
41683  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
41684  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
41685  && Location == in_that.Location && ClickCount == in_that.ClickCount;
41686  }
41687 
41691  virtual bool operator== (MouseEvent const & in_that) const
41692  {
41693  return Equals(in_that);
41694  }
41695 
41699  virtual bool operator!= (MouseEvent const & in_that) const
41700  {
41701  return !Equals(in_that);
41702  }
41703 
41707  virtual bool Drop(Event const * in_that_event) const
41708  {
41709  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
41710 
41711  if (CurrentAction == that_mouse_event->CurrentAction &&
41712  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41713  CurrentButton == that_mouse_event->CurrentButton)
41714  return true;
41715 
41716  return false;
41717  }
41718 
41719  virtual intptr_t Freshen() const {
41720 
41721  if (CurrentAction == Action::Move)
41722  return GetClassID();
41723 
41724  return 0;
41725  }
41726 
41730  float WheelDelta;
41731  size_t ClickCount;
41732 };
41733 
41734 
41736 class HPS_API KeyboardEvent : public InputEvent
41737 {
41738 public:
41741  enum class Action
41742  {
41743  None,
41744  KeyDown,
41745  KeyUp
41746  };
41747 
41749  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
41750 
41755  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41756 
41762  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
41763  : InputEvent(in_modifiers), CurrentAction(in_action)
41764  {
41765  channel = GetClassID();
41766  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41767  }
41768 
41773  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
41774  : InputEvent(in_modifiers), CurrentAction(in_action)
41775  {
41776  channel = GetClassID();
41777  KeyboardCodes = in_keyboardcodes;
41778  }
41779 
41782  KeyboardEvent(Event const & in_event) : InputEvent()
41783  {
41784  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
41785  {
41786  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
41787  channel = GetClassID();
41788  KeyboardCodes = event->KeyboardCodes;
41789  CurrentAction = event->CurrentAction;
41790  }
41791  else
41792  {
41793  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41794  }
41795  }
41796 
41797  ~KeyboardEvent();
41798 
41801  Event * Clone() const
41802  {
41803  KeyboardEvent * new_event = new KeyboardEvent(*this);
41804  return new_event;
41805  }
41806 
41810  virtual bool Equals(KeyboardEvent const & in_that) const
41811  {
41812  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
41813  }
41814 
41818  virtual bool operator== (KeyboardEvent const & in_that) const
41819  {
41820  return Equals(in_that);
41821  }
41822 
41826  virtual bool operator!= (KeyboardEvent const & in_that) const
41827  {
41828  return !Equals(in_that);
41829  }
41830 
41834  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
41835  {
41836  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41837  }
41838 
41841  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
41842  {
41843  KeyboardCodes = in_keyboardcodes;
41844  }
41845 
41846  HPS::KeyboardCodeArray KeyboardCodes;
41848 };
41849 
41850 
41852 class HPS_API MouseState : public Object
41853 {
41854 public:
41856  MouseState();
41857 
41860  MouseState(MouseState const & in_that);
41861 
41865  MouseState(MouseState && in_that);
41866 
41870  MouseState & operator=(MouseState && in_that);
41871 
41872  ~MouseState();
41873 
41874  HPS::Type ObjectType() const {return HPS::Type::MouseState;};
41875 
41878  void Assign(MouseState const & in_that);
41879 
41883  MouseState & operator=(MouseState const & in_that);
41884 
41888  bool Equals(MouseState const & in_that) const;
41889 
41893  bool operator== (MouseState const & in_that) const;
41894 
41898  bool operator!= (MouseState const & in_that) const;
41899 
41904  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
41905 
41912  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
41913 
41916  HPS::MouseEvent GetActiveEvent() const;
41917 
41921  HPS::WindowKey GetEventSource() const;
41922 
41926  HPS::KeyArray GetEventPath() const;
41927 
41930  MouseButtons GetButtons() const;
41931 
41934  WindowPoint GetLocation() const;
41935 
41938  ModifierKeys GetModifierKeys() const;
41939 
41942  void SetActiveEvent(MouseEvent const & in_event);
41943 
41946  void SetEventPath(KeyArray const & in_path);
41947 
41950  void SetButtons(MouseButtons in_buttons);
41951 
41954  void SetLocation(WindowPoint const & in_point);
41955 
41958  void SetModifierKeys(ModifierKeys in_modifiers);
41959 };
41960 
41961 
41962 
41964 class HPS_API TouchState : public Object
41965 {
41966 public:
41968  TouchState();
41969 
41972  TouchState(TouchState const & in_that);
41973 
41977  TouchState(TouchState && in_that);
41978 
41982  TouchState & operator=(TouchState && in_that);
41983 
41984  ~TouchState();
41985 
41986  HPS::Type ObjectType() const {return HPS::Type::TouchState;};
41987 
41990  void Assign(TouchState const & in_that);
41991 
41995  TouchState & operator=(TouchState const & in_that);
41996 
42000  bool Equals(TouchState const & in_that) const;
42001 
42005  bool operator== (TouchState const & in_that) const;
42006 
42010  bool operator!= (TouchState const & in_that) const;
42011 
42017  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
42018 
42021  HPS::TouchEvent GetActiveEvent() const;
42022 
42026  HPS::WindowKey GetEventSource() const;
42027 
42031  HPS::KeyArray GetEventPath() const;
42032 
42035  size_t GetTouchCount() const;
42036 
42039  HPS::TouchArray GetTouches() const;
42040 
42043  ModifierKeys GetModifierKeys() const;
42044 
42047  void SetActiveEvent(TouchEvent const & in_event);
42048 
42051  void SetEventPath(KeyArray const & in_path);
42052 
42055  void SetTouches(TouchArray const & in_touches);
42056 
42059  void SetModifierKeys(ModifierKeys in_modifiers);
42060 };
42061 
42062 
42063 
42065 class HPS_API KeyboardState : public Object
42066 {
42067 public:
42069  KeyboardState();
42070 
42073  KeyboardState(KeyboardState const & in_that);
42074 
42078  KeyboardState(KeyboardState && in_that);
42079 
42083  KeyboardState & operator=(KeyboardState && in_that);
42084 
42085  ~KeyboardState();
42086 
42087  HPS::Type ObjectType() const {return HPS::Type::KeyboardState;};
42088 
42091  void Assign(KeyboardState const & in_that);
42092 
42096  KeyboardState & operator=(KeyboardState const & in_that);
42097 
42101  bool Equals(KeyboardState const & in_that) const;
42102 
42106  bool operator== (KeyboardState const & in_that) const;
42107 
42111  bool operator!= (KeyboardState const & in_that) const;
42112 
42118  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
42119 
42122  HPS::KeyboardEvent GetActiveEvent() const;
42123 
42127  HPS::WindowKey GetEventSource() const;
42128 
42132  HPS::KeyArray GetEventPath() const;
42133 
42136  size_t GetKeyboardCodeCount() const;
42137 
42140  HPS::KeyboardCodeArray GetKeyboardCodes() const;
42141 
42145  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
42146 
42149  ModifierKeys GetModifierKeys() const;
42150 
42153  void SetActiveEvent(KeyboardEvent const & in_event);
42154 
42157  void SetEventPath(KeyArray const & in_path);
42158 
42161  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
42162 
42165  void SetModifierKeys(ModifierKeys in_modifiers);
42166 };
42167 
42168 
42172 
42175 class HPS_API IONotifier : public Object
42176 {
42177 public:
42179  IONotifier();
42180 
42183  IONotifier(IONotifier const & in_that);
42184 
42188  IONotifier(IONotifier && in_that);
42189 
42193  IONotifier & operator=(IONotifier && in_that);
42194 
42195  virtual ~IONotifier();
42196 
42197  HPS::Type ObjectType() const {return HPS::Type::IONotifier;};
42198 
42202  IONotifier & operator=(IONotifier const & in_that);
42203 
42206  void Assign(IONotifier const & in_that);
42207 
42209  void Wait();
42210 
42213  IOResult Status() const;
42214 
42218  IOResult Status(float & out_percent_complete) const;
42219 
42223  void Cancel();
42224 };
42225 
42227 class HPS_API Stream
42228 {
42229 public:
42231  class HPS_API Toolkit : public Object
42232  {
42233  public:
42235  Toolkit();
42236 
42239  Toolkit(Toolkit const & in_toolkit);
42240 
42244  Toolkit(Toolkit && in_toolkit);
42245 
42249  Toolkit & operator=(Toolkit const & in_toolkit);
42250 
42254  Toolkit & operator=(Toolkit && in_toolkit);
42255 
42256  HPS::Type ObjectType() const { return HPS::Type::StreamToolkit; }
42257 
42259  virtual void Restart();
42260  };
42261 
42264  static Toolkit CreateToolkit();
42265 
42267  class HPS_API ImportOptionsKit : public Object
42268  {
42269  public:
42271  ImportOptionsKit();
42272 
42275  ImportOptionsKit(ImportOptionsKit const & in_kit);
42276 
42280  ImportOptionsKit(ImportOptionsKit && in_that);
42281 
42285  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42286 
42287  virtual ~ImportOptionsKit();
42288 
42289  HPS::Type ObjectType() const { return HPS::Type::StreamImportOptionsKit; };
42290 
42293  void Set(ImportOptionsKit const & in_kit);
42294 
42297  void Show(ImportOptionsKit & out_kit) const;
42298 
42302  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42303 
42306  bool Empty() const;
42307 
42311  bool Equals(ImportOptionsKit const & in_kit) const;
42312 
42316  bool operator==(ImportOptionsKit const & in_kit) const;
42317 
42321  bool operator!=(ImportOptionsKit const & in_kit) const;
42322 
42325  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42326 
42329  ImportOptionsKit & UnsetToolkit();
42330 
42334  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42335 
42340  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42341 
42344  ImportOptionsKit & UnsetSegment();
42345 
42349  bool ShowSegment(SegmentKey & out_segment) const;
42350 
42355  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
42356 
42359  ImportOptionsKit & UnsetAlternateRoot();
42360 
42364  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42365 
42370  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42371 
42374  ImportOptionsKit & UnsetPortfolio();
42375 
42379  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42380 
42383  ImportOptionsKit & UnsetEverything();
42384  };
42385 
42387  class HPS_API ImportResultsKit : public Object
42388  {
42389  public:
42391  ImportResultsKit();
42392 
42395  ImportResultsKit(ImportResultsKit const & in_kit);
42396 
42400  ImportResultsKit(ImportResultsKit && in_that);
42401 
42405  ImportResultsKit & operator=(ImportResultsKit && in_that);
42406 
42407  virtual ~ImportResultsKit();
42408 
42409  HPS::Type ObjectType() const { return HPS::Type::StreamImportResultsKit; };
42410 
42413  void Set(ImportResultsKit const & in_kit);
42414 
42417  void Show(ImportResultsKit & out_kit) const;
42418 
42422  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42423 
42426  bool Empty() const;
42427 
42431  bool Equals(ImportResultsKit const & in_kit) const;
42432 
42436  bool operator==(ImportResultsKit const & in_kit) const;
42437 
42441  bool operator!=(ImportResultsKit const & in_kit) const;
42442 
42447  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42448 
42452  ImportResultsKit & UnsetSegment();
42453 
42458  bool ShowSegment(SegmentKey & out_segment) const;
42459 
42464  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
42465 
42469  ImportResultsKit & UnsetAlternateRoot();
42470 
42476  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42477 
42482  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42483 
42487  ImportResultsKit & UnsetPortfolio();
42488 
42494  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42495 
42500  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
42501 
42505  ImportResultsKit & UnsetDefaultCamera();
42506 
42510  bool ShowDefaultCamera(CameraKit & out_camera) const;
42511 
42512 
42518  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
42519 
42523  ImportResultsKit & UnsetAlternateCameras();
42524 
42529  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
42530 
42531 
42534  ImportResultsKit & UnsetEverything();
42535  };
42536 
42538  class HPS_API ExportOptionsKit : public Object
42539  {
42540  public:
42542  ExportOptionsKit();
42543 
42546  ExportOptionsKit(ExportOptionsKit const & in_kit);
42547 
42551  ExportOptionsKit(ExportOptionsKit && in_that);
42552 
42556  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42557 
42561  static ExportOptionsKit GetDefault();
42562 
42563  virtual ~ExportOptionsKit();
42564 
42565  HPS::Type ObjectType() const { return HPS::Type::StreamExportOptionsKit; };
42566 
42569  void Set(ExportOptionsKit const & in_kit);
42570 
42573  void Show(ExportOptionsKit & out_kit) const;
42574 
42578  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42579 
42582  bool Empty() const;
42583 
42587  bool Equals(ExportOptionsKit const & in_kit) const;
42588 
42592  bool operator==(ExportOptionsKit const & in_kit) const;
42593 
42597  bool operator!=(ExportOptionsKit const & in_kit) const;
42598 
42601  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42602 
42610  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
42611 
42619  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
42620 
42626  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
42627 
42635  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
42636 
42644  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
42645 
42651  ExportOptionsKit & SetConnectivityCompression(bool in_state);
42652 
42658  ExportOptionsKit & SetSerializeTristrips(bool in_state);
42659 
42668  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
42669 
42672  ExportOptionsKit & UnsetToolkit();
42673 
42676  ExportOptionsKit & UnsetVertexCompression();
42677 
42680  ExportOptionsKit & UnsetNormalCompression();
42681 
42684  ExportOptionsKit & UnsetParameterCompression();
42685 
42688  ExportOptionsKit & UnsetColorCompression();
42689 
42692  ExportOptionsKit & UnsetIndexCompression();
42693 
42696  ExportOptionsKit & UnsetConnectivityCompression();
42697 
42700  ExportOptionsKit & UnsetImageCompression();
42701 
42704  ExportOptionsKit & UnsetSerializeTristrips();
42705 
42708  ExportOptionsKit & UnsetEverything();
42709 
42713  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42714 
42719  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
42720 
42725  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
42726 
42731  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
42732 
42737  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
42738 
42743  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
42744 
42748  bool ShowConnectivityCompression(bool & out_state) const;
42749 
42754  bool ShowImageCompression(bool & out_state, float & out_quality) const;
42755 
42759  bool ShowSerializeTristrips(bool & out_state) const;
42760  };
42761 
42764  class HPS_API ImportNotifier : public IONotifier
42765  {
42766  public:
42768  ImportNotifier();
42769 
42772  ImportNotifier(ImportNotifier const & in_that);
42773 
42778  ImportNotifier(IONotifier const & in_that);
42779 
42783  ImportNotifier(ImportNotifier && in_that);
42784 
42788  ImportNotifier & operator=(ImportNotifier && in_that);
42789 
42790  virtual ~ImportNotifier();
42791 
42792  HPS::Type ObjectType() const {return HPS::Type::StreamImportNotifier;};
42793 
42797  ImportNotifier & operator=(ImportNotifier const & in_that);
42798 
42801  void Assign(ImportNotifier const & in_that);
42802 
42806  ImportResultsKit GetResults() const;
42807  };
42808 
42811  class HPS_API ExportNotifier : public IONotifier
42812  {
42813  public:
42815  ExportNotifier();
42816 
42819  ExportNotifier(ExportNotifier const & in_that);
42820 
42825  ExportNotifier(IONotifier const & in_that);
42826 
42830  ExportNotifier(ExportNotifier && in_that);
42831 
42835  ExportNotifier & operator=(ExportNotifier && in_that);
42836 
42837  virtual ~ExportNotifier();
42838 
42839  HPS::Type ObjectType() const {return HPS::Type::StreamExportNotifier;};
42840 
42844  ExportNotifier & operator=(ExportNotifier const & in_that);
42845 
42848  void Assign(ExportNotifier const & in_that);
42849  };
42850 
42851 
42853  class HPS_API File
42854  {
42855  public:
42861  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42862 
42869  static ExportNotifier Export(const char * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
42870 
42877  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
42878 
42879  private:
42881  File();
42882  };
42883 private:
42885  Stream();
42886 };
42887 
42891 
42896 class HPS_API Hardcopy
42897 {
42898 public:
42899 
42901  enum class SizeUnits
42902  {
42903  Centimeters,
42904  Inches,
42905  };
42906 
42908  enum class ResolutionUnits
42909  {
42910  DPCM,
42911  DPI,
42912  DotsPerCentimeter = DPCM,
42913  DotsPerInch = DPI,
42914  };
42915 
42917  class HPS_API File
42918  {
42919  public:
42920 
42922  class HPS_API ExportOptionsKit : public Object
42923  {
42924  public:
42926  ExportOptionsKit();
42927 
42930  ExportOptionsKit(ExportOptionsKit const & in_kit);
42931 
42935  ExportOptionsKit(ExportOptionsKit && in_that);
42936 
42940  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42941 
42942  virtual ~ExportOptionsKit();
42943 
42944  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
42945 
42948  void Set(ExportOptionsKit const & in_kit);
42949 
42952  void Show(ExportOptionsKit & out_kit) const;
42953 
42957  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42958 
42961  bool Empty() const;
42962 
42966  bool Equals(ExportOptionsKit const & in_kit) const;
42967 
42971  bool operator==(ExportOptionsKit const & in_kit) const;
42972 
42976  bool operator!=(ExportOptionsKit const & in_kit) const;
42977 
42978 
42979 
42980 
42986  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
42987 
42995  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
42996 
42999  ExportOptionsKit & UnsetSize();
43000 
43001 
43002 
43008  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
43009 
43016  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
43017 
43020  ExportOptionsKit & UnsetResolution();
43021 
43022 
43023 
43026  bool ShowWYSIWYG(bool & out_onoff) const;
43027 
43039  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
43040 
43043  ExportOptionsKit & UnsetWYSIWYG();
43044 
43045 
43048  ExportOptionsKit & UnsetEverything();
43049 
43050 
43054  static ExportOptionsKit GetDefault();
43055  };
43056 
43058  enum class Driver
43059  {
43060  PDF,
43061  Postscript
43062  };
43063 
43069  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
43070  private:
43071  File();
43072  };
43073 
43074 #ifdef _MSC_VER
43075  class HPS_API GDI
43076  {
43077  public:
43078 
43080  class HPS_API ExportOptionsKit : public Object
43081  {
43082  public:
43084  ExportOptionsKit();
43085 
43088  ExportOptionsKit(ExportOptionsKit const & in_kit);
43089 
43093  ExportOptionsKit(ExportOptionsKit && in_that);
43094 
43098  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
43099 
43100  virtual ~ExportOptionsKit();
43101 
43102  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
43103 
43106  void Set(ExportOptionsKit const & in_kit);
43107 
43110  void Show(ExportOptionsKit & out_kit) const;
43111 
43115  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
43116 
43119  bool Empty() const;
43120 
43124  bool Equals(ExportOptionsKit const & in_kit) const;
43125 
43129  bool operator==(ExportOptionsKit const & in_kit) const;
43130 
43134  bool operator!=(ExportOptionsKit const & in_kit) const;
43135 
43136 
43137 
43138 
43142  bool ShowResolution(float & out_resolution) const;
43143 
43147  ExportOptionsKit & SetResolution(float in_resolution);
43148 
43151  ExportOptionsKit & UnsetResolution();
43152 
43153 
43154 
43155 
43158  bool ShowWYSIWYG(bool & out_onoff) const;
43159 
43163  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
43164 
43167  ExportOptionsKit & UnsetWYSIWYG();
43168 
43169 
43172  ExportOptionsKit & UnsetEverything();
43173  };
43174 
43181  static IOResult Export(intptr_t hdc, intptr_t attribdc, HPS::WindowKey const & window, ExportOptionsKit const & options);
43182 
43183  private:
43184  GDI();
43185  };
43186 #endif
43187 
43188 private:
43189  Hardcopy();
43190 };
43191 
43195 
43197 class HPS_API OBJ
43198 {
43199 public:
43200 
43202  class HPS_API ImportOptionsKit : public Object
43203  {
43204  public:
43206  ImportOptionsKit();
43207 
43210  ImportOptionsKit(ImportOptionsKit const & in_kit);
43211 
43215  ImportOptionsKit(ImportOptionsKit && in_that);
43216 
43220  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43221 
43222  virtual ~ImportOptionsKit();
43223 
43224  HPS::Type ObjectType() const { return HPS::Type::OBJImportOptionsKit; };
43225 
43228  void Set(ImportOptionsKit const & in_kit);
43229 
43232  void Show(ImportOptionsKit & out_kit) const;
43233 
43237  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43238 
43241  bool Empty() const;
43242 
43246  bool Equals(ImportOptionsKit const & in_kit) const;
43247 
43251  bool operator==(ImportOptionsKit const & in_kit) const;
43252 
43256  bool operator!=(ImportOptionsKit const & in_kit) const;
43257 
43262  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43263 
43266  ImportOptionsKit & UnsetSegment();
43267 
43271  bool ShowSegment(SegmentKey & out_segment) const;
43272 
43277  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43278 
43281  ImportOptionsKit & UnsetPortfolio();
43282 
43286  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43287 
43293  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43294 
43297  ImportOptionsKit & UnsetHandedness();
43298 
43302  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43303 
43306  ImportOptionsKit & UnsetEverything();
43307  };
43308 
43310  class HPS_API ImportResultsKit : public Object
43311  {
43312  public:
43314  ImportResultsKit();
43315 
43318  ImportResultsKit(ImportResultsKit const & in_kit);
43319 
43323  ImportResultsKit(ImportResultsKit && in_that);
43324 
43328  ImportResultsKit & operator=(ImportResultsKit && in_that);
43329 
43330  virtual ~ImportResultsKit();
43331 
43332  HPS::Type ObjectType() const { return HPS::Type::OBJImportResultsKit; };
43333 
43336  void Set(ImportResultsKit const & in_kit);
43337 
43340  void Show(ImportResultsKit & out_kit) const;
43341 
43345  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43346 
43349  bool Empty() const;
43350 
43354  bool Equals(ImportResultsKit const & in_kit) const;
43355 
43359  bool operator==(ImportResultsKit const & in_kit) const;
43360 
43364  bool operator!=(ImportResultsKit const & in_kit) const;
43365 
43370  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43371 
43375  ImportResultsKit & UnsetSegment();
43376 
43381  bool ShowSegment(SegmentKey & out_segment) const;
43382 
43387  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43388 
43392  ImportResultsKit & UnsetPortfolio();
43393 
43399  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43400 
43405  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43406 
43410  ImportResultsKit & UnsetHandedness();
43411 
43416  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43417 
43420  ImportResultsKit & UnsetEverything();
43421  };
43422 
43425  class HPS_API ImportNotifier : public IONotifier
43426  {
43427  public:
43429  ImportNotifier();
43430 
43433  ImportNotifier(ImportNotifier const & in_that);
43434 
43439  ImportNotifier(IONotifier const & in_that);
43440 
43444  ImportNotifier(ImportNotifier && in_that);
43445 
43449  ImportNotifier & operator=(ImportNotifier && in_that);
43450 
43451  virtual ~ImportNotifier();
43452 
43453  HPS::Type ObjectType() const {return HPS::Type::OBJImportNotifier;};
43454 
43458  ImportNotifier & operator=(ImportNotifier const & in_that);
43459 
43462  void Assign(ImportNotifier const & in_that);
43463 
43467  ImportResultsKit GetResults() const;
43468  };
43469 
43470 
43472  class HPS_API File
43473  {
43474  public:
43480  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43481 
43482  private:
43484  File();
43485  };
43486 private:
43488  OBJ();
43489 };
43490 
43494 
43496 class HPS_API STL
43497 {
43498 public:
43499 
43501  class HPS_API ImportOptionsKit : public Object
43502  {
43503  public:
43505  ImportOptionsKit();
43506 
43509  ImportOptionsKit(ImportOptionsKit const & in_kit);
43510 
43514  ImportOptionsKit(ImportOptionsKit && in_that);
43515 
43519  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43520 
43521  virtual ~ImportOptionsKit();
43522 
43523  HPS::Type ObjectType() const { return HPS::Type::STLImportOptionsKit; };
43524 
43527  void Set(ImportOptionsKit const & in_kit);
43528 
43531  void Show(ImportOptionsKit & out_kit) const;
43532 
43536  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43537 
43540  bool Empty() const;
43541 
43545  bool Equals(ImportOptionsKit const & in_kit) const;
43546 
43550  bool operator==(ImportOptionsKit const & in_kit) const;
43551 
43555  bool operator!=(ImportOptionsKit const & in_kit) const;
43556 
43560  static ImportOptionsKit GetDefault();
43561 
43566  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43567 
43575  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
43576 
43583  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
43584 
43585 
43588  ImportOptionsKit & UnsetSegment();
43589 
43592  ImportOptionsKit & UnsetOptimization();
43593 
43596  ImportOptionsKit & UnsetEverything();
43597 
43598 
43602  bool ShowSegment(SegmentKey & out_segment) const;
43603 
43608  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
43609  };
43610 
43612  class HPS_API ImportResultsKit : public Object
43613  {
43614  public:
43616  ImportResultsKit();
43617 
43620  ImportResultsKit(ImportResultsKit const & in_kit);
43621 
43625  ImportResultsKit(ImportResultsKit && in_that);
43626 
43630  ImportResultsKit & operator=(ImportResultsKit && in_that);
43631 
43632  virtual ~ImportResultsKit();
43633 
43634  HPS::Type ObjectType() const { return HPS::Type::STLImportResultsKit; };
43635 
43638  void Set(ImportResultsKit const & in_kit);
43639 
43642  void Show(ImportResultsKit & out_kit) const;
43643 
43647  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43648 
43651  bool Empty() const;
43652 
43656  bool Equals(ImportResultsKit const & in_kit) const;
43657 
43661  bool operator==(ImportResultsKit const & in_kit) const;
43662 
43666  bool operator!=(ImportResultsKit const & in_kit) const;
43667 
43672  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43673 
43677  ImportResultsKit & UnsetSegment();
43678 
43683  bool ShowSegment(SegmentKey & out_segment) const;
43684 
43687  ImportResultsKit & UnsetEverything();
43688  };
43689 
43692  class HPS_API ImportNotifier : public IONotifier
43693  {
43694  public:
43696  ImportNotifier();
43697 
43700  ImportNotifier(ImportNotifier const & in_that);
43701 
43706  ImportNotifier(IONotifier const & in_that);
43707 
43711  ImportNotifier(ImportNotifier && in_that);
43712 
43716  ImportNotifier & operator=(ImportNotifier && in_that);
43717 
43718  virtual ~ImportNotifier();
43719 
43720  HPS::Type ObjectType() const {return HPS::Type::STLImportNotifier;};
43721 
43725  ImportNotifier & operator=(ImportNotifier const & in_that);
43726 
43729  void Assign(ImportNotifier const & in_that);
43730 
43734  ImportResultsKit GetResults() const;
43735  };
43736 
43737 
43739  class HPS_API File
43740  {
43741  public:
43747  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43748 
43749  private:
43751  File();
43752  };
43753 private:
43755  STL();
43756 };
43757 
43758 }
43759 
43760 #ifdef _MSC_VER
43761 # pragma warning(pop)
43762 #endif
43763 
43764 #endif
43765 
43766 
HPS::Type ObjectType() const
Definition: hps.h:39980
Rotation
Definition: hps.h:1595
HPS::Type ObjectType() const
Definition: hps.h:26947
bool Empty() const
Definition: hps.h:6825
CameraPoint(Point const &in_point)
Definition: hps.h:5776
Alignment
Definition: hps.h:1528
HPS::Type ObjectType() const
Definition: hps.h:19333
Space
Definition: hps.h:561
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41728
Definition: hps.h:3259
Definition: hps.h:6015
Channel
Definition: hps.h:945
HPS::Type ObjectType() const
Definition: hps.h:24119
Handedness
Definition: hps.h:1276
Definition: hps.h:14200
Definition: hps.h:1051
Definition: hps.h:11983
ColorSource
Definition: hps.h:1921
HPS::Type ObjectType() const
Definition: hps.h:17070
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:41514
HPS::Type ObjectType() const
Definition: hps.h:36282
Event(intptr_t in_channel=0)
Definition: hps.h:6129
Definition: hps.h:18185
HPS::Type ObjectType() const
Definition: hps.h:43453
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:34686
HPS::Type ObjectType() const
Definition: hps.h:35889
bool operator==(Touch const &in_that) const
Definition: hps.h:6419
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:41535
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41170
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40926
InformationEvent(char const *in_message)
Definition: hps.h:40726
HPS::Type ObjectType() const
Definition: hps.h:34352
Definition: hps.h:8677
HPS::Type ObjectType() const
Definition: hps.h:21849
HPS::Type ObjectType() const
Definition: hps.h:23647
HPS::Type ObjectType() const
Definition: hps.h:24393
Action
Definition: hps.h:41311
Orientation
Definition: hps.h:537
Definition: hps.h:20664
Code
Definition: hps.h:134
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1331
Multiline strings will be left justfied.
Definition: hps.h:39797
HPS::Type ObjectType() const
Definition: hps.h:14954
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40981
HPS::Type ObjectType() const
Definition: hps.h:8611
HPS::Type ObjectType() const
Definition: hps.h:28175
Event * Clone() const
Definition: hps.h:40824
Definition: hps.h:13259
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:41645
Definition: hps.h:43197
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40612
ImportStatusEvent()
Definition: hps.h:41069
HPS::Type ObjectType() const
Definition: hps.h:21465
HPS::Type ObjectType() const
Definition: hps.h:36064
Definition: hps.h:13766
HPS::Type ObjectType() const
Definition: hps.h:25910
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41376
HPS::Type ObjectType() const
Definition: hps.h:30215
HPS::Type ObjectType() const
Definition: hps.h:25521
HPS::Type ObjectType() const
Definition: hps.h:11634
static MouseButtons ButtonX2()
Definition: hps.h:41590
Definition: hps.h:19767
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:40873
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41834
Definition: hps.h:43612
Definition: hps.h:37956
Definition: hps.h:19127
HPS::Type ObjectType() const
Definition: hps.h:37776
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5673
Definition: hps.h:1494
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5921
bool Middle() const
Definition: hps.h:41500
Definition: hps.h:467
Driver
Definition: hps.h:154
HPS::Type ObjectType() const
Definition: hps.h:41874
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2192
Definition: hps.h:35385
HPS::Type ObjectType() const
Definition: hps.h:39124
CappingLevel
Definition: hps.h:1727
Definition: hps.h:41736
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8692
HPS::Type ObjectType() const
Definition: hps.h:23374
HPS::Type ObjectType() const
Definition: hps.h:35817
Definition: hps.h:9386
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12772
HPS::Type ObjectType() const
Definition: hps.h:41986
HPS::Type ObjectType() const
Definition: hps.h:20509
Definition: hps.h:26534
HPS::Type ObjectType() const
Definition: hps.h:13789
InputEvent()
Definition: hps.h:41255
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5533
static MouseButtons ButtonRight()
Definition: hps.h:41578
HPS::Type ObjectType() const
Definition: hps.h:28960
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3858
Definition: hps.h:5573
Definition: hps.h:35652
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41773
static ModifierKeys KeyMeta()
Definition: hps.h:41229
HPS::Type ObjectType() const
Definition: hps.h:35552
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1505
Definition: hps.h:23540
HPS::Type ObjectType() const
Definition: hps.h:36931
Definition: hps.h:16666
HPS::Type ObjectType() const
Definition: hps.h:42839
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:41465
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3737
Definition: hps.h:35043
HPS::Type ObjectType() const
Definition: hps.h:19572
HPS::Type ObjectType() const
Definition: hps.h:39296
HPS::Type ObjectType() const
Definition: hps.h:23572
HPS::Type ObjectType() const
Definition: hps.h:35122
Definition: hps.h:22397
HPS::Type ObjectType() const
Definition: hps.h:16779
MouseButtons()
Definition: hps.h:41460
HPS::Type ObjectType() const
Definition: hps.h:38365
Definition: hps.h:20277
Time GetTimeStamp() const
Definition: hps.h:6151
Definition: hps.h:43739
void Left(bool in_state)
Definition: hps.h:41523
HPS::Type ObjectType() const
Definition: hps.h:22367
NormalizedPoint(Point const &in_point)
Definition: hps.h:5826
HPS::Type ObjectType() const
Definition: hps.h:23921
Event * Clone() const
Definition: hps.h:40641
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3786
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:41519
Renderer
Definition: hps.h:1576
HPS::Type ObjectType() const
Definition: hps.h:34088
Definition: hps.h:40133
KeyboardEvent()
Definition: hps.h:41749
HPS::Type ObjectType() const
Definition: hps.h:7338
Definition: hps.h:37743
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3979
ObjectPoint(Point const &in_point)
Definition: hps.h:5676
HPS::Type ObjectType() const
Definition: hps.h:17657
Definition: hps.h:33538
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:39900
Definition: hps.h:4367
Definition: hps.h:6634
Definition: hps.h:1325
Definition: hps.h:40662
Definition: hps.h:24361
Point_3D< F > min
Definition: hps.h:3721
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40955
static ModifierKeys KeyAlt()
Definition: hps.h:41225
bool IsConsumable() const
Definition: hps.h:6154
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:41762
Mobility
Definition: hps.h:194
HPS::Type ObjectType() const
Definition: hps.h:13282
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5874
Definition: hps.h:14637
InterpolationAlgorithm
Definition: hps.h:1511
Fill
Definition: hps.h:1912
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3774
Definition: hps.h:23815
Definition: hps.h:19310
HPS::Type ObjectType() const
Definition: hps.h:27452
HPS::Type ObjectType() const
Definition: hps.h:19150
char At(size_t in_index) const
Definition: hps.h:6868
Definition: hps.h:39969
Definition: hps.h:4393
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41165
HPS::Type ObjectType() const
Definition: hps.h:35944
Definition: hps.h:129
ReferenceFrame
Definition: hps.h:1543
Definition: hps.h:25878
Bloom Shape.
Definition: hps.h:42065
Definition: hps.h:3719
Definition: hps.h:3716
HPS::Type ObjectType() const
Definition: hps.h:16986
GreekingUnits
Definition: hps.h:1630
Definition: hps.h:18677
Definition: hps.h:7390
HPS::Type ObjectType() const
Definition: hps.h:12184
InnerConeUnits
Definition: hps.h:486
Definition: hps.h:26744
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5970
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:41586
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41031
Definition: hps.h:18396
Definition: hps.h:3406
OuterConeUnits
Definition: hps.h:472
Definition: hps.h:6401
void X2(bool in_state)
Definition: hps.h:41539
HPS::Type ObjectType() const
Definition: hps.h:18934
HPS::Type ObjectType() const
Definition: hps.h:40463
HPS::Type ObjectType() const
Definition: hps.h:39393
HPS::Type ObjectType() const
Definition: hps.h:14385
Definition: hps.h:14930
Definition: hps.h:1993
HPS::Type ObjectType() const
Definition: hps.h:33571
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41841
HPS::Type ObjectType() const
Definition: hps.h:26846
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41400
HPS::Type ObjectType() const
Definition: hps.h:12655
HPS::Type ObjectType() const
Definition: hps.h:25103
Definition: hps.h:441
HPS::Type ObjectType() const
Definition: hps.h:36395
Definition: hps.h:21827
Channel
Definition: hps.h:904
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40855
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:12007
Definition: hps.h:8562
Definition: hps.h:26824
Definition: hps.h:19549
HPS::Type ObjectType() const
Definition: hps.h:34708
Action
Definition: hps.h:40937
Event * Clone() const
Definition: hps.h:40753
HPS::Type ObjectType() const
Definition: hps.h:14223
Definition: hps.h:4642
HPS::Type ObjectType() const
Definition: hps.h:42565
HPS::Type ObjectType() const
Definition: hps.h:27553
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6434
Definition: hps.h:21255
Definition: hps.h:4524
HPS::Type ObjectType() const
Definition: hps.h:37894
HPS::Type ObjectType() const
Definition: hps.h:34225
Definition: hps.h:1384
Definition: hps.h:17867
Definition: hps.h:879
Definition: hps.h:5559
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41333
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:41160
Definition: hps.h:37861
Definition: hps.h:36042
Definition: hps.h:7380
HPS::Type ObjectType() const
Definition: hps.h:23124
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41810
HPS::Type ObjectType() const
Definition: hps.h:21390
WarningEvent(Event const &in_event)
Definition: hps.h:40806
Definition: hps.h:36954
HPS::Type ObjectType() const
Definition: hps.h:11510
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:41217
Definition: hps.h:149
HPS::Type ObjectType() const
Definition: hps.h:28686
Shape
Definition: hps.h:1073
bool IsValid() const
Definition: hps.h:6818
Definition: hps.h:20486
Definition: hps.h:1523
Cuboid_3D()
Definition: hps.h:3729
ErrorEvent(Event const &in_event)
Definition: hps.h:40877
size_t GetWStrLength() const
Definition: hps.h:6847
Event * Clone() const
Definition: hps.h:40706
HPS::Type ObjectType() const
Definition: hps.h:11101
AppendMode
Definition: hps.h:332
Definition: hps.h:8591
Definition: hps.h:25351
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:41504
Definition: hps.h:236
Definition: hps.h:41065
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3922
void Meta(bool in_state)
Definition: hps.h:41182
Definition: hps.h:6586
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6069
Definition: hps.h:26925
HPS::Type ObjectType() const
Definition: hps.h:14663
UpdateStatus
Definition: hps.h:164
HPS_INLINE bool IsValid() const
Definition: hps.h:3779
HPS::Type ObjectType() const
Definition: hps.h:38477
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:41002
Definition: hps.h:21055
Quality
Definition: hps.h:1057
ResolutionUnits
Definition: hps.h:42908
Event * Clone() const
Definition: hps.h:41265
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:41302
Definition: hps.h:4466
TimerTickEvent(Event const &in_event)
Definition: hps.h:40631
Component
Definition: hps.h:352
Definition: hps.h:43310
Definition: hps.h:5668
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6020
HPS::Type ObjectType() const
Definition: hps.h:12271
Definition: hps.h:12397
Default
Definition: hps.h:1885
HPS::Type ObjectType() const
Definition: hps.h:10731
Definition: hps.h:16963
Definition: hps.h:2132
Definition: hps.h:24809
InformationEvent()
Definition: hps.h:40722
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5065
Definition: hps.h:37695
Definition: hps.h:11610
Definition: hps.h:13846
Definition: hps.h:11077
Definition: hps.h:43692
bool Shift() const
Definition: hps.h:41142
SizeToleranceUnits
Definition: hps.h:1617
HPS::Type ObjectType() const
Definition: hps.h:38601
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:7418
Definition: hps.h:11343
Definition: hps.h:20832
Definition: hps.h:13952
HPS::Type ObjectType() const
Definition: hps.h:43224
HPS::Type ObjectType() const
Definition: hps.h:43332
MouseEvent()
Definition: hps.h:41627
Definition: hps.h:14023
HPS::Type ObjectType() const
Definition: hps.h:12112
Definition: hps.h:20039
Definition: hps.h:27196
Definition: hps.h:1067
HPS::Type ObjectType() const
Definition: hps.h:16688
Definition: hps.h:12305
Definition: hps.h:32345
HPS::Type ObjectType() const
Definition: hps.h:35167
Definition: hps.h:12631
static const float Infinity
Definition: hps.h:2187
InsetBehavior
Definition: hps.h:1817
HPS::Type ObjectType() const
Definition: hps.h:25029
Definition: hps.h:5642
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2200
HPS::Type ObjectType() const
Definition: hps.h:13677
HPS::Type ObjectType() const
Definition: hps.h:27146
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6433
HPS::Type ObjectType() const
Definition: hps.h:35357
HPS::Type ObjectType() const
Definition: hps.h:37621
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3901
Algorithm
Definition: hps.h:1445
Definition: hps.h:41964
Definition: hps.h:8627
Decimation
Definition: hps.h:1014
StaticModel
Definition: hps.h:1115
Definition: hps.h:38577
Granularity
Definition: hps.h:1366
Definition: hps.h:36852
DisplayLists
Definition: hps.h:1093
Definition: hps.h:10909
Search the current segment only.
Definition: hps.h:42811
Definition: hps.h:2646
Definition: hps.h:42538
Definition: hps.h:556
KeyboardEvent(Event const &in_event)
Definition: hps.h:41782
Definition: hps.h:21106
Definition: hps.h:35094
ClipOperation
Definition: hps.h:1305
HPS::Type ObjectType() const
Definition: hps.h:8948
Definition: hps.h:2559
Definition: hps.h:30182
Method
Definition: hps.h:1435
Definition: hps.h:36898
HPS::Type ObjectType() const
Definition: hps.h:26566
Definition: hps.h:42853
Parameterization
Definition: hps.h:959
Definition: hps.h:4284
Definition: hps.h:37149
Definition: hps.h:36368
FocusLostEvent()
Definition: hps.h:41010
CuttingLevel
Definition: hps.h:1736
Channel
Definition: hps.h:925
Definition: hps.h:9467
Definition: hps.h:43501
HandleResult
Definition: hps.h:40602
Definition: hps.h:39102
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5077
Definition: hps.h:5916
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40925
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:26062
Event * Clone() const
Definition: hps.h:41018
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41681
Definition: hps.h:42231
Definition: hps.h:41610
ErrorEvent()
Definition: hps.h:40864
Definition: hps.h:40931
Justification
Definition: hps.h:1551
The vertex colors applied to faces.
Definition: hps.h:6506
HPS::Type ObjectType() const
Definition: hps.h:14047
Definition: hps.h:35223
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5551
ErrorEvent(char const *in_message)
Definition: hps.h:40868
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41038
Definition: hps.h:41306
FrameSize
Definition: hps.h:205
Definition: hps.h:2147
Definition: hps.h:9277
Definition: hps.h:23625
Definition: hps.h:12089
Justification
Definition: hps.h:1853
Definition: hps.h:21583
HPS::Type ObjectType() const
Definition: hps.h:11832
Definition: hps.h:40440
Definition: hps.h:37904
HPS::Type ObjectType() const
Definition: hps.h:19791
Definition: hps.h:1690
Definition: hps.h:1471
HPS::Type ObjectType() const
Definition: hps.h:22198
bool None() const
Definition: hps.h:41488
Definition: hps.h:316
Definition: hps.h:1410
HPS::Type ObjectType() const
Definition: hps.h:8731
HPS::Type ObjectType() const
Definition: hps.h:36885
HPS::Type ObjectType() const
Definition: hps.h:35071
Definition: hps.h:17634
GreekingMode
Definition: hps.h:1642
HPS::Type ObjectType() const
Definition: hps.h:20301
Definition: hps.h:36260
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41846
Operation
Definition: hps.h:455
Definition: hps.h:1429
HPS::Type ObjectType() const
Definition: hps.h:37466
Type
Definition: hps.h:1999
WorldPoint(Point const &in_point)
Definition: hps.h:5726
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41440
Definition: hps.h:43472
HPS::Type ObjectType() const
Definition: hps.h:9930
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2479
Definition: hps.h:22597
HPS::Type ObjectType() const
Definition: hps.h:6665
Definition: hps.h:34837
Definition: hps.h:17939
TouchEvent(Event const &in_event)
Definition: hps.h:41348
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41434
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6950
Definition: hps.h:5048
Definition: hps.h:39370
Definition: hps.h:43496
Definition: hps.h:35324
Definition: hps.h:4223
Relation
Definition: hps.h:378
Action
Definition: hps.h:41741
ChannelMapping
Definition: hps.h:1028
HPS::Type ObjectType() const
Definition: hps.h:22716
Definition: hps.h:6763
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5568
HPS::Type ObjectType() const
Definition: hps.h:38943
HPS::Type ObjectType() const
Definition: hps.h:39582
Definition: hps.h:23899
Definition: hps.h:5769
HPS::Type ObjectType() const
Definition: hps.h:42256
bool Alt() const
Definition: hps.h:41150
Definition: hps.h:41456
ToleranceUnits
Definition: hps.h:361
Definition: hps.h:24678
Definition: hps.h:27420
HPS::Type ObjectType() const
Definition: hps.h:12582
SizeUnits
Definition: hps.h:1804
Type
Definition: hps.h:2016
HPS::Type ObjectType() const
Definition: hps.h:17786
The vertex colors applied to faces.
RelationTest
Definition: hps.h:388
Definition: hps.h:39274
Definition: hps.h:8656
Type
Definition: hps.h:323
HPS::Type ObjectType() const
Definition: hps.h:14807
Behavior
Definition: hps.h:570
Definition: hps.h:5719
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6740
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41847
Definition: hps.h:40618
HPS::Type ObjectType() const
Definition: hps.h:18700
Style Append Mode.
ImageFormat
Definition: hps.h:220
Definition: hps.h:38626
Definition: hps.h:25499
Definition: hps.h:41852
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5542
float blue
Definition: hps.h:4289
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:41006
Type
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:21129
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6968
PixelPoint(Point const &in_point)
Definition: hps.h:6072
HPS::Type ObjectType() const
Definition: hps.h:6194
HPS::Type ObjectType() const
Definition: hps.h:7057
Definition: hps.h:17762
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41707
Definition: hps.h:20968
Definition: hps.h:42764
HPS::Type ObjectType() const
Definition: hps.h:21726
HPS::Type ObjectType() const
Definition: hps.h:21606
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:35310
HPS::Type ObjectType() const
Definition: hps.h:28829
HPS::Type ObjectType() const
Definition: hps.h:24192
HPS::Type ObjectType() const
Definition: hps.h:39222
HPS::Type ObjectType() const
Definition: hps.h:20991
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41727
Event * Clone() const
Definition: hps.h:41096
Definition: hps.h:14347
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5071
Definition: hps.h:35911
Definition: hps.h:41027
HPS::Type ObjectType() const
Definition: hps.h:34622
HPS::Type ObjectType() const
Definition: hps.h:40571
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:42387
HPS::Type ObjectType() const
Definition: hps.h:15838
Definition: hps.h:1907
Definition: hps.h:31279
Infinite line which extends infinitely in both directions along a vector.
InformationEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40731
intptr_t GetChannel() const
Definition: hps.h:6148
HPS::Type ObjectType() const
Definition: hps.h:9301
Definition: hps.h:1344
Definition: hps.h:13653
Algorithm
Definition: hps.h:1358
HPS::Type ObjectType() const
Definition: hps.h:31301
HPS::Type ObjectType() const
Definition: hps.h:37937
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3846
Definition: hps.h:12559
Definition: hps.h:10707
Driver
Definition: hps.h:43058
Definition: hps.h:7009
Definition: hps.h:42175
SizeUnits
Definition: hps.h:1672
StandAloneWindowEvent()
Definition: hps.h:40946
HPS::Type ObjectType() const
Definition: hps.h:36464
HPS::Type ObjectType() const
Definition: hps.h:34460
ModifierKeys GetModifierKeys() const
Definition: hps.h:41297
Definition: hps.h:41106
Definition: hps.h:39551
Definition: hps.h:40789
HPS::Type ObjectType() const
Definition: hps.h:12420
HPS::Type ObjectType() const
Definition: hps.h:11251
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40833
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41635
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5514
HPS::Type ObjectType() const
Definition: hps.h:17497
Level
Definition: hps.h:1349
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:40762
bool X2() const
Definition: hps.h:41508
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41115
Definition: hps.h:34438
Definition: hps.h:43425
bool Left() const
Definition: hps.h:41492
void Control(bool in_state)
Definition: hps.h:41174
Definition: hps.h:21694
Definition: hps.h:2896
Definition: hps.h:17046
Definition: hps.h:41250
HPS::Type ObjectType() const
Definition: hps.h:42792
HPS::Type ObjectType() const
Definition: hps.h:18208
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:40854
The base class of all HPS exceptions.
Definition: hps.h:5506
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:41342
Event * Clone() const
Definition: hps.h:41672
Definition: hps.h:6115
HPS::Type ObjectType() const
Definition: hps.h:21278
Definition: hps.h:37393
InformationEvent(Event const &in_event)
Definition: hps.h:40735
Definition: hps.h:12834
void Invalidate()
Definition: hps.h:3791
Definition: hps.h:23092
Definition: hps.h:38920
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:5565
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41034
HPS::Type ObjectType() const
Definition: hps.h:33948
Definition: hps.h:6065
HPS::Type ObjectType() const
Definition: hps.h:39819
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6141
Definition: hps.h:403
char const * GetBytes() const
Definition: hps.h:6854
virtual intptr_t Freshen() const
Definition: hps.h:41719
Definition: hps.h:34319
HPS::Type ObjectType() const
Definition: hps.h:35419
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:41259
float green
Definition: hps.h:4288
Action
Definition: hps.h:41616
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1696
HPS::Type ObjectType() const
Definition: hps.h:10335
HPS::Type ObjectType() const
Definition: hps.h:27218
HPS::Type ObjectType() const
Definition: hps.h:24710
HPS::Type ObjectType() const
Definition: hps.h:24466
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10534
HPS::Type ObjectType() const
Definition: hps.h:37989
HPS::Type ObjectType() const
Definition: hps.h:24831
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5973
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41081
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5823
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6413
static const float NegativeInfinity
Definition: hps.h:2189
HighlightEvent(Event const &in_event)
Definition: hps.h:40689
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6959
SizeUnits
Definition: hps.h:1477
HPS::Type ObjectType() const
Definition: hps.h:12858
HPS::Type ObjectType() const
Definition: hps.h:20687
Definition: hps.h:21367
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41729
HPS::Type ObjectType() const
Definition: hps.h:10556
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5924
GatheringLevel
Definition: hps.h:1752
HPS::Type ObjectType() const
Definition: hps.h:29039
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:40784
Definition: hps.h:40544
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3758
Definition: hps.h:12454
FrameOptions
Definition: hps.h:214
HPS::Type ObjectType() const
Definition: hps.h:35260
Space
Definition: hps.h:8569
void Alt(bool in_state)
Definition: hps.h:41178
Definition: hps.h:7018
Buttons
Definition: hps.h:41596
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41754
HPS::Type ObjectType() const
Definition: hps.h:37193
Type
Definition: hps.h:258
bool operator!=(Touch const &in_that) const
Definition: hps.h:6427
Definition: hps.h:40161
Definition: hps.h:24087
Definition: hps.h:100
Type
Definition: hps.h:446
HPS::Type ObjectType() const
Definition: hps.h:42289
HPS::Type ObjectType() const
Definition: hps.h:43634
HPS::Type ObjectType() const
Definition: hps.h:43523
HPS::Type ObjectType() const
Definition: hps.h:33679
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5723
HPS::Type ObjectType() const
Definition: hps.h:9491
HPS::Type ObjectType() const
Definition: hps.h:43720
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6941
Definition: hps.h:23352
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41427
Definition: hps.h:35145
Definition: hps.h:1271
Event * Clone() const
Definition: hps.h:41367
void Middle(bool in_state)
Definition: hps.h:41531
Definition: hps.h:29017
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40904
Definition: hps.h:4793
Event * Clone() const
Definition: hps.h:40972
size_t GetLength() const
Definition: hps.h:6839
HPS::Type ObjectType() const
Definition: hps.h:21078
HPS::Type ObjectType() const
Definition: hps.h:26776
Type
Definition: hps.h:1134
Definition: hps.h:423
HPS::Type ObjectType() const
Definition: hps.h:9409
bool None() const
Definition: hps.h:41138
size_t ClickCount
The number of clicks received.
Definition: hps.h:41731
virtual intptr_t Freshen() const
Definition: hps.h:6145
void Reset()
Definition: hps.h:6834
HPS::Type ObjectType() const
Definition: hps.h:37723
HPS::Type ObjectType() const
Definition: hps.h:23847
Definition: hps.h:34192
HPS::Type ObjectType() const
Definition: hps.h:39923
Definition: hps.h:39199
SizeUnits
Definition: hps.h:1605
Event * Clone() const
Definition: hps.h:40895
MouseEvent(Event const &in_event)
Definition: hps.h:41650
bool Right() const
Definition: hps.h:41496
Definition: hps.h:2011
virtual bool Empty() const
Definition: hps.h:5606
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:41574
static MouseButtons ButtonMiddle()
Definition: hps.h:41582
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41325
HighlightEvent()
Definition: hps.h:40673
virtual HPS::Type ObjectType() const
Definition: hps.h:5602
Definition: hps.h:18910
HPS::Type ObjectType() const
Definition: hps.h:13870
Definition: hps.h:28669
Definition: hps.h:16757
Definition: hps.h:5818
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41439
Definition: hps.h:8702
Type
Definition: hps.h:581
virtual intptr_t Freshen() const
Definition: hps.h:40656
Background
Definition: hps.h:239
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3835
Definition: hps.h:42917
static ModifierKeys KeyControl()
Definition: hps.h:41221
HPS::Type ObjectType() const
Definition: hps.h:18420
Definition: hps.h:5524
HPS::Type ObjectType() const
Definition: hps.h:35674
Definition: hps.h:7312
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5871
HPS::Type ObjectType() const
Definition: hps.h:39715
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40951
Mode
Definition: hps.h:1717
Definition: hps.h:33318
Definition: hps.h:11228
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:40783
Event * Clone() const
Definition: hps.h:41055
Definition: hps.h:34054
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:33916
Type
Definition: hps.h:884
Definition: hps.h:346
Definition: hps.h:14784
Definition: hps.h:21442
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3823
Definition: hps.h:919
HPS::Type ObjectType() const
Definition: hps.h:12329
Definition: hps.h:35856
HPS::Type ObjectType() const
Definition: hps.h:32378
HPS::Type ObjectType() const
Definition: hps.h:17890
Definition: hps.h:42227
HPS::Type ObjectType() const
Definition: hps.h:37821
Definition: hps.h:35530
HPS::Type ObjectType() const
Definition: hps.h:42409
Definition: hps.h:5867
HPS::Type ObjectType() const
Definition: hps.h:42087
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3809
HPS::Type ObjectType() const
Definition: hps.h:36976
Definition: hps.h:35795
HPS::Type ObjectType() const
Definition: hps.h:12478
HPS::Type ObjectType() const
Definition: hps.h:17963
Definition: hps.h:24170
Mode
Definition: hps.h:1770
Definition: hps.h:8916
Event * Clone() const
Definition: hps.h:41801
Definition: hps.h:10311
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:6023
Transform
Definition: hps.h:1560
HPS::Type ObjectType() const
Definition: hps.h:37291
Definition: hps.h:11487
Definition: hps.h:8648
Definition: hps.h:40718
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:22050
Definition: hps.h:35278
Definition: hps.h:27531
Definition: hps.h:22335
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:38648
Definition: hps.h:26040
Definition: hps.h:939
ModifierKeys()
Definition: hps.h:41110
Definition: hps.h:25081
Definition: hps.h:1799
Definition: hps.h:22694
Definition: hps.h:28143
Preference
Definition: hps.h:1585
HPS::Type ObjectType() const
Definition: hps.h:25383
Capping
Definition: hps.h:526
Definition: hps.h:40860
HPS::Type ObjectType() const
Definition: hps.h:35492
TouchEvent()
Definition: hps.h:41319
Interpolation
Definition: hps.h:1003
HPS::Type ObjectType() const
Definition: hps.h:20062
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:41274
WarningEvent(char const *in_message)
Definition: hps.h:40797
HPS::Type ObjectType() const
Definition: hps.h:20855
Modifiers
Definition: hps.h:41235
Component
Definition: hps.h:518
Definition: hps.h:513
Definition: hps.h:9907
Definition: hps.h:37597
HPS::Type ObjectType() const
Definition: hps.h:35982
HPS::Type ObjectType() const
Definition: hps.h:6530
HPS::Type ObjectType() const
Definition: hps.h:22629
Definition: hps.h:17473
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4022
HPS::Type ObjectType() const
Definition: hps.h:42944
HPS::Type ObjectType() const
Definition: hps.h:22419
Definition: hps.h:3182
Format
Definition: hps.h:37154
WarningEvent()
Definition: hps.h:40793
Definition: hps.h:24997
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40650
Touch()
Definition: hps.h:6407
Definition: hps.h:12248
Definition: hps.h:35949
Component
Definition: hps.h:408
Definition: hps.h:33663
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:39692
Definition: hps.h:1129
float red
Definition: hps.h:4287
ClipSpace
Definition: hps.h:1313
Definition: hps.h:12160
Definition: hps.h:37788
Definition: hps.h:15815
Control & operator=(Control &&in_that)
Definition: hps.h:5659
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40802
HPS::Type ObjectType() const
Definition: hps.h:13975
Definition: hps.h:28938
SizeUnits
Definition: hps.h:42901
void Right(bool in_state)
Definition: hps.h:41527
virtual void Reset()
Definition: hps.h:40594
Definition: hps.h:11809
HPS::Type ObjectType() const
Definition: hps.h:11366
bool Meta() const
Definition: hps.h:41154
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4064
Definition: hps.h:35458
TimerTickEvent()
Definition: hps.h:40622
Definition: hps.h:38455
Definition: hps.h:37171
HPS::Type ObjectType() const
Definition: hps.h:22082
RenderingAlgorithm
Definition: hps.h:275
EmergencyHandler()
Definition: hps.h:40138
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5773
TouchID ID
TouchID for this Touch.
Definition: hps.h:6432
Definition: hps.h:36431
HPS::Type ObjectType() const
Definition: hps.h:10932
HPS::Type ObjectType() const
Definition: hps.h:33340
HPS::Type ObjectType() const
Definition: hps.h:8432
Definition: hps.h:42896
Definition: hps.h:6171
Definition: hps.h:24444
HandednessOptimization
Definition: hps.h:369
Definition: hps.h:6713
Projection
Definition: hps.h:1395
Control(Control &&in_that)
Definition: hps.h:5654
bool Control() const
Definition: hps.h:41146
Definition: hps.h:5432
HPS::Type ObjectType() const
Definition: hps.h:34859
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8681
Overlay
Definition: hps.h:1285
Definition: hps.h:28807
Definition: hps.h:5965
Definition: hps.h:37269
Definition: hps.h:43202
size_t GetHash() const
Status
Definition: hps.h:6121
Definition: hps.h:22176
HPS::Type ObjectType() const
Definition: hps.h:34989
HPS::Type ObjectType() const
Definition: hps.h:6612
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:41730
Definition: hps.h:37438
Definition: hps.h:42267
Definition: hps.h:27114
Definition: hps.h:2027
HPS::Type ObjectType() const
Definition: hps.h:42197