< Home

< Table of Contents

REFERENCE MANUAL

hps.h
1 
2 // Copyright (c) 1998-2014 by Tech Soft 3D, Inc.
3 //
4 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
5 // and considered a trade secret as defined under civil and criminal statutes.
6 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
7 // unauthorized use or misappropriation of its trade secrets. Use of this information
8 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
9 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
10 
11 #ifndef HPS_H
12 #define HPS_H
13 
14 #ifdef _MSC_VER
15 # ifndef STATIC_APP
16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
19 # else
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
22 # endif
23 # define HPS_TEMPLATE_API __declspec (dllexport)
24 # endif
25 # ifdef _WINDOWS_
26 # undef Ellipse
27 # undef Polyline
28 # undef Polygon
29 # undef Rectangle
30 # undef min
31 # undef max
32 # endif
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
35 #else
36 # include <limits.h>
37 # include <stddef.h>
38 # ifdef LINUX_SYSTEM
39 # ifndef STATIC_APP
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
43 # else
44 # define EXPIMP_TEMPLATE extern
45 # endif
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
47 # endif
48 # endif
49 #endif
50 #ifndef HPS_API
51 # define HPS_API
52 #endif
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
55 #endif
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
58 #endif
59 #ifndef ENUM_CLASS
60 # define ENUM_CLASS enum class
61 #endif
62 
63 #define NO_HPS_API
64 
65 #include <stdint.h>
66 #include <memory>
67 #include <vector>
68 #include <math.h>
69 #include <float.h>
70 #include <limits>
71 #include <stdexcept>
72 #include <algorithm>
73 #include <cstring>
74 
75 
76 
77 namespace HPSI
78 {
79  class Impl;
80  class KeyImpl;
81  class TicketImpl;
82  class EventDispatcherImpl;
83  class AbstractImage;
84 };
85 
86 namespace HPS
87 {
88 
89  // unimplemented
90 
91 
92 //Begin Info
94 class HPS_API Info
95 {
96 public:
99  enum class Code {
100  Unknown,
101  Exchange,
102  Publish,
103  Data,
104  Key,
105  Geometry,
106  Database,
107  Driver,
108  Internal,
109  Memory,
110  System,
111  Unsupported,
112  };
113 
114 private:
116  Info();
117 };
118 
119 
120 //Begin Info
122 class HPS_API Emergency
123 {
124 public:
127  enum class Code {
128  Unknown,
129  Fatal,
130  SoftMemoryLimit,
131  HardMemoryLimit,
132  };
133 
134 private:
136  Emergency();
137 };
138 
139 
140 //Begin Window
142 class HPS_API Window
143 {
144 public:
147  enum class Driver {
148  Default3D,
149  OpenGL,
150  OpenGL2,
151  DirectX9,
152  DirectX11,
153  };
154 
157  enum class UpdateStatus {
158  InProgress,
159  Completed,
160  TimedOut,
161  Interrupted,
162  Failed
163  };
164 
168  enum class UpdateControl {
169  DefaultUpdate,
170 
174  CompleteUpdate,
175 
176  RefreshUpdate,
177 
178  CompileOnlyUpdate,
179 
183  ExhaustiveUpdate,
184  };
185 
188  enum class Mobility
189  {
190  Locked,
191  Floating,
192  FixedRatio,
193  Free
194  };
195 
199  enum class FrameSize
200  {
201  Single,
202  Double
203  };
204 
208  enum class FrameOptions
209  {
210  Inset,
211  Overlay
212  };
213 
214 private:
216  Window();
217 };
218 
219 //Begin Subwindow
221 class HPS_API Subwindow
222 {
223 public:
224  enum class Background
225  {
226  SolidColor,
227  Image,
228  Cubemap,
229  Blend,
230  Transparent,
231  Interactive,
232 
233  GradientTopToBottom,
234  GradientBottomToTop,
235  GradientLeftToRight,
236  GradientRightToLeft,
237  GradientTopLeftToBottomRight,
238  GradientTopRightToBottomLeft,
239  GradientBottomLeftToTopRight,
240  GradientBottomRightToTopLeft,
241  };
242 
243  enum class Type
244  {
245  Standard,
246  Lightweight
247  };
248 
249  enum class Border
250  {
251  None,
252  Inset,
253  InsetBold,
254  Overlay,
255  OverlayBold
256  };
257 
258 
261  {
264  ZBuffer,
265 
271  HiddenLine,
272 
278  FastHiddenLine,
279 
292  Priority
293  };
294 
295 private:
296  Subwindow();
297 };
298 //End Subwindow
299 
301 class HPS_API Style
302 {
303 public:
304 
308  enum class Type
309  {
310  Segment,
311  Named
312  };
313 
317  enum class AppendMode
318  {
319  None,
320  And,
321  Or
322  };
323 
324 private:
325  Style();
326 };
327 
328 
329 //Begin Shell Attributes
331 class HPS_API Shell
332 {
333 public:
334 
337  enum class Component
338  {
339  Faces,
340  Edges,
341  Vertices
342  };
343 
344  /* \enum ToleranceUnits
345  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
346  enum class ToleranceUnits
347  {
348  ObjectSpace,
349  FeatureSizePercentage
350  };
351 
352  /* \enum HandednessOptimization
353  * Enumerates the shell optimization options with regards to handedness. */
355  {
356  None,
357  FixHandedness,
358  ReverseHandedness
359  };
360 
361  /* \enum RelationResults
362  * Enumerates the results of a shell relation computation. */
363  enum class Relation
364  {
365  On,
366  Off,
367  In,
368  Out
369  };
370 
371  /* \enum RelationTest
372  * Enumerates the test options for a shell relation computation. */
373  enum class RelationTest
374  {
375  Simple,
376  Enclosure,
377  Distance
378  };
379 
380 private:
382  Shell();
383 };
384 //End Shell Attributes
385 
386 //Begin Mesh Attributes
388 class HPS_API Mesh
389 {
390 public:
393  enum class Component
394  {
395  Faces,
396  Edges,
397  Vertices
398  };
399 
400 private:
402  Mesh();
403 };
404 //End Mesh Attributes
405 
406 //Begin InfiniteLine Attributes
408 class HPS_API InfiniteLine
409 {
410 public:
413  enum class Type
414  {
415  Line,
416  Ray
417  };
418 
419 private:
421  InfiniteLine();
422 };
423 //End InfiniteLine Attributes
424 
426 class HPS_API Trim
427 {
428 public:
431  enum class Type
432  {
433  Line,
434  Curve
435  };
436 
440  enum class Operation
441  {
442  Keep,
443  Remove
444  };
445 private:
447  Trim();
448 };
449 
450 //Begin Spotlight Attributes
452 class HPS_API Spotlight
453 {
454 public:
457  enum class OuterConeUnits
458  {
462  Degrees,
466  FieldRadius
467  };
468 
471  enum class InnerConeUnits
472  {
476  Degrees,
480  FieldRadius,
483  Percent
484  };
485 
486 
487 private:
489  Spotlight();
490 };
491 //End Spotlight Attributes
492 
493 
494 
495 
496 //Begin Cylinder Attributes
498 class HPS_API Cylinder
499 {
500 public:
503  enum class Component
504  {
505  Faces,
506  Edges,
507  };
508 
511  enum class Capping
512  {
513  None,
514  First,
515  Last,
516  Both
517  };
518 
522  enum class Orientation
523  {
524  Default,
525  DefaultRadii,
526  InvertRadii,
527  InvertRadiiOnly,
528  DefaultColors,
529  InvertColors,
530  InvertColorsOnly,
531  InvertAll
532  };
533 
534 private:
536  Cylinder();
537 };
538 
539 
541 class HPS_API Search
542 {
543 public:
546  enum class Space
547  {
548  SegmentOnly,
549  Subsegments,
550  SubsegmentsAndIncludes
551  };
552 
555  enum class Behavior
556  {
557  Exhaustive,
558  FirstMatch
559  };
560 
561 
562  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to 3DF HK types (if they map to HK types)
566  enum class Type : uint32_t {
567 
568  /* This enum classeration is divided into three parts.
569 
570  0xAABBBCCC
571 
572  The bits in A encode the most general category of the type (Geometry, Attribute).
573  The bits in B encode the subtype (Culling, TextAttribute). Attributes alone have these so far.
574  The bits in C encode the specific type (Shell, CullingVectorTolerance, TextAttributeSpacing).
575 
576  General category designators should have no bits in B or C.
577  Subtype category designators should have bits in A and B but not C.
578  Specific category designators should have bits in A and C and optionally B.
579 
580  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.
581  These types are kept in sync with the 3DF HK types by using Compile-time assets in hpsi.cpp.
582 
583  Geometry have no subtype. Most, 'Ordinary Geometry' map to a 3DF HK type.
584  The mutants or 'Special Geometry' (some lights and infinite ray) have no HK type to map to.
585 
586  Attributes come in a few forms.
587  The 'Simple Attributes' map to an HK type and have no subtypes -- they are what they are. ModellingMatrix, Camera, etc.
588  The 'Complex Attributes' have subtypes. A handful map to an HK type, but the majority are not.
589  */
590  None = 0x00000000,
591  Everything = 0x00ffffff,
592 
593  // Segment Stuff (Include & Segment map to HK types)
594  Include = 0x00000042,
595  Segment = 0x00000043,
596 
597  Includer = 0x00000100,
598 
599  // Geometry
600  Geometry = 0x10000000,
601 
602  // Ordinary Geometry (map to HK types) - (HK_* | Geometry)
603  CuttingSection = 0x10000026,
604  Shell = 0x10000028,
605  Mesh = 0x10000029,
606  Grid = 0x1000002a,
607  NURBSSurface = 0x1000002b,
608  Cylinder = 0x1000002d,
609  Sphere = 0x1000002e,
610  Polygon = 0x1000002f,
611  Circle = 0x10000030,
612  //unused = 0x10000031,
613  CircularWedge = 0x10000032,
614  Ellipse = 0x10000033,
615  Line = 0x10000034,
616  NURBSCurve = 0x10000037,
617  CircularArc = 0x10000038,
618  EllipticalArc = 0x10000039,
619  InfiniteLine = 0x1000003a,
620 // Image = 0x1000003b, N/A since images live in portfolios
621  Marker = 0x1000003c,
622  Text = 0x1000003e,
623  Reference = 0x10000040,
624 
625  // Special Geometry
626  DistantLight = 0x10000100,
627  Spotlight = 0x10000101,
628  InfiniteRay = 0x10000102,
629 
630  // Attributes
631  Attribute = 0x20000000,
632 
633  Priority = 0x20000001,
634 
635  // Simple Attributes (map to HK types)
636  Material = 0x2000000a,
637  Camera = 0x2000000e,
638  ModellingMatrix = 0x20000010,
639  UserData = 0x20000021,
640  TextureMatrix = 0x20000023,
641 
642  // Complex Attributes
643  Culling = 0x20001000,
644  CullingBackFace = 0x20001001,
645  CullingExtent = 0x20001002,
646  CullingVector = 0x20001003,
647  CullingVectorTolerance = 0x20001004,
648  CullingFrustum = 0x20001005,
649  CullingDeferralExtent = 0x20001006,
650 
651  CurveAttribute = 0x20002000,
652  CurveAttributeBudget = 0x20002001,
653  CurveAttributeContinuedBudget = 0x20002002,
654  CurveAttributeViewDependent = 0x20002003,
655  CurveAttributeMaximumDeviation = 0x20002004,
656  CurveAttributeMaximumAngle = 0x20002005,
657  CurveAttributeMaximumLength = 0x20002006,
658 
659  CylinderAttribute = 0x20003000,
660  CylinderAttributeTessellation = 0x20003001,
661  CylinderAttributeOrientation = 0x20003002,
662 
663  // EdgeAttributes map to HK types
664  EdgeAttribute = 0x20004000,
665  EdgeAttributePattern = 0x20004015,
666  EdgeAttributeWeight = 0x20004016,
667 
668  LightingAttribute = 0x20005000,
669  LightingAttributeInterpolation = 0x20005001,
670 
671  // LineAttributes map to HK types
672  LineAttribute = 0x20006000,
673  LineAttributePattern = 0x20006019,
674  LineAttributeWeight = 0x2000601a,
675 
676  // MarkerAttributes map to HK types
677  MarkerAttribute = 0x20007000,
678  MarkerAttributeSize = 0x2000701b,
679  MarkerAttributeSymbol = 0x2000701c,
680 
681  SurfaceAttribute = 0x20008000,
682  SurfaceAttributeBudget = 0x20008001,
683  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
684  SurfaceAttributeMaximumFacetAngle = 0x20008003,
685  SurfaceAttributeMaximumFacetWidth = 0x20008004,
686  SurfaceAttributeTrimCurveBudget = 0x20008005,
687  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
688 
689  Selectability = 0x20009000,
690  SelectabilityWindows = 0x20009001,
691  SelectabilityEdges = 0x20009002,
692  SelectabilityFaces = 0x20009003,
693  SelectabilityLights = 0x20009004,
694  SelectabilityLines = 0x20009005,
695  SelectabilityMarkers = 0x20009006,
696  SelectabilityVertices = 0x20009007,
697  SelectabilityText = 0x20009008,
698 
699  SphereAttribute = 0x2000a000,
700  SphereAttributeTessellation = 0x2000a001,
701 
702  Subwindow = 0x2000b000,
703  SubwindowEitherType = 0x2000b001,
704  SubwindowStandard = 0x2000b00d,
705  SubwindowLightweight = 0x2000b002,
706  SubwindowBackground = 0x2000b003,
707  SubwindowBorder = 0x2000b004,
708  SubwindowRenderingAlgorithm = 0x2000b005,
709 
710  // TextAttributeAlignment, Path, & Spacing map to HK types
711  TextAttribute = 0x2000c000,
712  TextAttributeAlignment = 0x2000c01d,
713  TextAttributeBold = 0x2000c002,
714  TextAttributeItalic = 0x2000c003,
715  TextAttributeOverline = 0x2000c004,
716  TextAttributeStrikethrough = 0x2000c005,
717  TextAttributeUnderline = 0x2000c006,
718  TextAttributeSlant = 0x2000c007,
719  TextAttributeLineSpacing = 0x2000c008,
720  TextAttributeRotation = 0x2000c00a,
721  TextAttributeExtraSpace = 0x2000c00b,
722  TextAttributeGreeking = 0x2000c00c,
723  TextAttributeSizeTolerance = 0x2000c00d,
724  TextAttributeSize = 0x2000c00e,
725  TextAttributeFont = 0x2000c00f,
726  TextAttributeTransform = 0x2000c010,
727  TextAttributeRenderer = 0x2000c011,
728  TextAttributePreference = 0x2000c012,
729  TextAttributePath = 0x2000c01f,
730  TextAttributeSpacing = 0x2000c020,
731 
732  Transparency = 0x2000d000,
733  TransparencyMethod = 0x2000d001,
734  TransparencyAlgorithm = 0x2000d002,
735  TransparencyDepthPeelingLayers = 0x2000d004,
736  TransparencyDepthPeelingMinimumArea = 0x2000d005,
737  TransparencyDepthWriting = 0x2000d006,
738 
739  Visibility = 0x2000e000,
740  VisibilityCuttingSections = 0x2000e001,
741  VisibilityCutEdges = 0x2000e002,
742  VisibilityCutFaces = 0x2000e003,
743  VisibilityWindows = 0x2000e004,
744  VisibilityText = 0x2000e005,
745  VisibilityLines = 0x2000e006,
746  VisibilityEdgeLights = 0x2000e007,
747  VisibilityMarkerLights = 0x2000e008,
748  VisibilityFaceLights = 0x2000e009,
749  VisibilityGenericEdges = 0x2000e00a,
750  VisibilityHardEdges = 0x2000e00b,
751  VisibilityAdjacentEdges = 0x2000e00c,
752  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
753  VisibilityShadowEmitting = 0x2000e00e,
754  VisibilityShadowReceiving = 0x2000e00f,
755  VisibilityShadowCasting = 0x2000e010,
756  VisibilityMarkers = 0x2000e011,
757  VisibilityVertices = 0x2000e012,
758  VisibilityFaces = 0x2000e013,
759  VisibilityPerimeterEdges = 0x2000e014,
760  VisibilityNonCulledEdges = 0x2000e015,
761  VisibilityMeshQuadEdges = 0x2000e016,
762 
763  VisualEffects = 0x2000f000,
764  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
765  VisualEffectsAntiAliasing = 0x2000f002,
766  VisualEffectsShadowMaps = 0x2000f003,
767  VisualEffectsSimpleShadow = 0x2000f004,
768  VisualEffectsSimpleShadowPlane = 0x2000f005,
769  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
770  VisualEffectsSimpleShadowColor = 0x2000f007,
771  VisualEffectsSimpleReflection = 0x2000f008,
772  VisualEffectsSimpleReflectionPlane = 0x2000f009,
773  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
774 
775  Performance = 0x20010000,
776  PerformanceDisplayLists = 0x20010001,
777  PerformanceStaticModel = 0x20010002,
778  StaticModelSegment = 0x40000043,
779 
780  // DrawingAttributeWorldHandedness map to HK types
781  DrawingAttribute = 0x20011000,
782  DrawingAttributePolygonHandedness = 0x20011001,
783  DrawingAttributeDepthRange = 0x20011002,
784  DrawingAttributeFaceDisplacement = 0x20011003,
785  DrawingAttributeGeneralDisplacement = 0x20011004,
786  DrawingAttributeVertexDisplacement = 0x20011005,
787  DrawingAttributeOverlay = 0x20011006,
788  DrawingAttributeDeferral = 0x20011007,
789  DrawingAttributeWorldHandedness = 0x20011018,
790  DrawingAttributeClipRegion = 0x20011019,
791 
792  HiddenLineAttribute = 0x20012000,
793  HiddenLineAttributeColor = 0x20012001,
794  HiddenLineAttributeDimFactor = 0x20012002,
795  HiddenLineAttributeFaceDisplacement = 0x20012003,
796  HiddenLineAttributeLinePattern = 0x20012005,
797  HiddenLineAttributeRenderFaces = 0x20012006,
798  HiddenLineAttributeRenderText = 0x20012007,
799  HiddenLineAttributeAlgorithm = 0x20012008,
800  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
801  HiddenLineAttributeVisibility = 0x2001200a,
802  HiddenLineAttributeWeight = 0x2001200b,
803  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
804 
805  SegmentStyle = 0x20013001,
806  NamedStyle = 0x20013002,
807  MaterialPalette = 0x20013003,
808  Portfolio = 0x20013004,
809 
810  ContourLine = 0x20014000,
811  ContourLineVisibility = 0x20014001,
812  ContourLinePosition = 0x20014002,
813  ContourLineColor = 0x20014003,
814  ContourLinePattern = 0x20014004,
815  ContourLineWeight = 0x20014005,
816  ContourLineLighting = 0x20014006,
817 
818  Condition = 0x20015000,
819 
820  Bounding = 0x20016000,
821  BoundingVolume = 0x20016001,
822  BoundingExclusion = 0x20016002,
823 
824  AttributeLock = 0x20017000,
825  AttributeLockSetting = 0x20017001,
826  AttributeLockSubsegmentOverride = 0x20017002,
827 
828  TransformMask = 0x20018000,
829  TransformMaskCamera = 0x20018001,
830  TransformMaskCameraTranslation = 0x20018002,
831  TransformMaskCameraScale = 0x20018003,
832  TransformMaskCameraOffset = 0x20018004,
833  TransformMaskCameraRotation = 0x20018005,
834  TransformMaskCameraPerspectiveScale = 0x20018006,
835  TransformMaskCameraProjection = 0x20018007,
836  TransformMaskModellingMatrix = 0x20018008,
837  TransformMaskModellingMatrixTranslation = 0x20018009,
838  TransformMaskModellingMatrixScale = 0x20018010,
839  TransformMaskModellingMatrixOffset = 0x20018011,
840  TransformMaskModellingMatrixRotation = 0x20018012,
841 
842  ColorInterpolation = 0x20019000,
843  ColorInterpolationFaceColor = 0x20019001,
844  ColorInterpolationEdgeColor = 0x20019002,
845  ColorInterpolationMarkerColor = 0x20019003,
846  ColorInterpolationFaceIndex = 0x20019004,
847  ColorInterpolationEdgeIndex = 0x20019005,
848  ColorInterpolationMarkerIndex = 0x20019006,
849 
850  CuttingSectionAttribute = 0x2001a000,
851  CuttingSectionAttributeCuttingLevel = 0x2001a001,
852  CuttingSectionAttributeCappingLevel = 0x2001a002,
853  CuttingSectionAttributeMaterialPreference = 0x2001a003,
854 
855  };
856  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to HK types (if they are map to HK types)
857 
858 private:
860  Search();
861 };
862 
864 class HPS_API Material
865 {
866 public:
869  enum class Type
870  {
871  InvalidMaterialIndex = -1,
872  Nothing = 0,
873  FullMaterial,
874  ExplicitRGBColor,
875  ExplicitRGBAColor,
876  MaterialIndex,
877  TextureName,
878  ModulatedTexture,
879  CubeMapName,
880  ModulatedCubeMap,
881  GlossValue,
882  DiffuseChannelAlpha
883 
884  };
885 
889  enum class Channel
890  {
891  DiffuseColor = 1,
892  DiffuseTexture = 2,
893  Specular = 3,
894  Emission = 4,
895  Transmission = 5,
896  Mirror = 6,
897  Bump = 7,
898  EnvironmentTexture = 8,
899  EnvironmentCubeMap = 9,
900  Gloss = 10
901  };
902 
904  class HPS_API Color
905  {
906  public:
910  enum class Channel
911  {
912  DiffuseColor = 1,
913  Specular = 3,
914  Emission = 4,
915  Mirror = 6
916  };
917 
918  private:
920  Color();
921  };
922 
924  class HPS_API Texture
925  {
926  public:
930  enum class Channel
931  {
932  DiffuseTexture = 2,
933  Specular = 3,
934  Emission = 4,
935  Transmission = 5,
936  Mirror = 6,
937  Bump = 7,
938  EnvironmentTexture = 8,
939  EnvironmentCubeMap = 9
940  };
941 
944  enum class Parameterization
945  {
947  Cylinder,
949  PhysicalReflection,
951  Object,
957  NaturalUV,
959  ReflectionVector,
961  SurfaceNormal,
963  Sphere,
965  UV,
967  World
968  };
969 
972  enum class Tiling
973  {
976  Clamp,
978  Repeat,
980  Reflect,
983  Trim
984  };
985 
988  enum class Interpolation
989  {
991  Bilinear,
992 
994  InterpolationOff
995  };
996 
999  enum class Decimation
1000  {
1003  Anisotropic,
1005  Mipmap,
1007  DecimationOff
1008  };
1009 
1013  enum class ChannelMapping
1014  {
1015  Red,
1016  Green,
1017  Blue,
1018  Alpha,
1019  Zero,
1020  One,
1021  Luminance
1022  };
1023 
1024  private:
1026  Texture();
1027  };
1028 private:
1030  Material();
1031 };
1032 
1033 class HPS_API PostProcessEffects
1034 {
1035 public:
1036  class HPS_API AmbientOcclusion
1037  {
1038  public:
1042  enum class Quality
1043  {
1044  Fastest,
1045  Nicest
1046  };
1047 
1048  private:
1049  AmbientOcclusion();
1050  };
1051 
1052  class HPS_API Bloom
1053  {
1054  public:
1058  enum class Shape
1059  {
1060  Star,
1061  Radial
1062  };
1063 
1064  private:
1065  Bloom();
1066  };
1067 
1068 private:
1069  PostProcessEffects() {}
1070 };
1071 
1072 class HPS_API Performance
1073 {
1074 public:
1078  enum class DisplayLists
1079  {
1081  NoDisplayLists,
1082 
1085  GeometryDisplayLists,
1086 
1089  SegmentDisplayLists
1090  };
1091 
1100  enum class StaticModel
1101  {
1102 
1103  NoStaticModel,
1104  AttributeStaticModel,
1105  AttributeSpatialStaticModel
1106  };
1107 
1108 
1109 private:
1110  Performance() {}
1111 };
1112 
1113 
1114 class HPS_API AttributeLock
1115 {
1116 public:
1117 
1119  enum class Type : uint32_t
1120  {
1121  Everything = 0x01000000,
1122 
1123  Visibility = 0x02000000,
1124 
1125  VisibilityCuttingSections,
1126  VisibilityCutEdges,
1127  VisibilityCutFaces,
1128  VisibilityWindows,
1129  VisibilityText,
1130  VisibilityLines,
1131  VisibilityEdgeLights,
1132  VisibilityMarkerLights,
1133  VisibilityFaceLights,
1134  VisibilityGenericEdges,
1135  VisibilityHardEdges,
1136  VisibilityAdjacentEdges,
1137  VisibilityInteriorSilhouetteEdges,
1138  VisibilityShadowEmitting,
1139  VisibilityShadowReceiving,
1140  VisibilityShadowCasting,
1141  VisibilityMarkers,
1142  VisibilityVertices,
1143  VisibilityFaces,
1144  VisibilityPerimeterEdges,
1145  VisibilityNonCulledEdges,
1146  VisibilityMeshQuadEdges,
1147  VisibilityCutGeometry,
1148  VisibilityEdges,
1149  VisibilityGeometry,
1150  VisibilityLights,
1151  VisibilityShadows,
1152 
1153  Material = 0x03000000,
1154 
1155  MaterialGeometry,
1156  MaterialCutGeometry,
1157 
1158  MaterialAmbientLightUpColor,
1159  MaterialAmbientLightDownColor,
1160  MaterialAmbientLightColor,
1161 
1162  MaterialWindowColor,
1163  MaterialWindowContrastColor,
1164 
1165  MaterialLightColor,
1166  MaterialLineColor,
1167  MaterialMarkerColor,
1168  MaterialTextColor,
1169  MaterialCutEdgeColor,
1170 
1171  MaterialVertex,
1172  MaterialVertexDiffuse,
1173  MaterialVertexDiffuseColor,
1174  MaterialVertexDiffuseAlpha,
1175  MaterialVertexDiffuseTexture,
1176  MaterialVertexSpecular,
1177  MaterialVertexMirror,
1178  MaterialVertexTransmission,
1179  MaterialVertexEmission,
1180  MaterialVertexEnvironment,
1181  MaterialVertexBump,
1182  MaterialVertexGloss,
1183 
1184  MaterialEdge,
1185  MaterialEdgeDiffuse,
1186  MaterialEdgeDiffuseColor,
1187  MaterialEdgeDiffuseAlpha,
1188  MaterialEdgeDiffuseTexture,
1189  MaterialEdgeSpecular,
1190  MaterialEdgeMirror,
1191  MaterialEdgeTransmission,
1192  MaterialEdgeEmission,
1193  MaterialEdgeEnvironment,
1194  MaterialEdgeBump,
1195  MaterialEdgeGloss,
1196 
1197  MaterialFace,
1198  MaterialFaceDiffuse,
1199  MaterialFaceDiffuseColor,
1200  MaterialFaceDiffuseAlpha,
1201  MaterialFaceDiffuseTexture,
1202  MaterialFaceSpecular,
1203  MaterialFaceMirror,
1204  MaterialFaceTransmission,
1205  MaterialFaceEmission,
1206  MaterialFaceEnvironment,
1207  MaterialFaceBump,
1208  MaterialFaceGloss,
1209 
1210  MaterialBackFace,
1211  MaterialBackFaceDiffuse,
1212  MaterialBackFaceDiffuseColor,
1213  MaterialBackFaceDiffuseAlpha,
1214  MaterialBackFaceDiffuseTexture,
1215  MaterialBackFaceSpecular,
1216  MaterialBackFaceMirror,
1217  MaterialBackFaceTransmission,
1218  MaterialBackFaceEmission,
1219  MaterialBackFaceEnvironment,
1220  MaterialBackFaceBump,
1221  MaterialBackFaceGloss,
1222 
1223  MaterialFrontFace,
1224  MaterialFrontFaceDiffuse,
1225  MaterialFrontFaceDiffuseColor,
1226  MaterialFrontFaceDiffuseAlpha,
1227  MaterialFrontFaceDiffuseTexture,
1228  MaterialFrontFaceSpecular,
1229  MaterialFrontFaceMirror,
1230  MaterialFrontFaceTransmission,
1231  MaterialFrontFaceEmission,
1232  MaterialFrontFaceEnvironment,
1233  MaterialFrontFaceBump,
1234  MaterialFrontFaceGloss,
1235 
1236  MaterialCutFace,
1237  MaterialCutFaceDiffuse,
1238  MaterialCutFaceDiffuseColor,
1239  MaterialCutFaceDiffuseAlpha,
1240  MaterialCutFaceDiffuseTexture,
1241  MaterialCutFaceSpecular,
1242  MaterialCutFaceMirror,
1243  MaterialCutFaceTransmission,
1244  MaterialCutFaceEmission,
1245  MaterialCutFaceEnvironment,
1246  MaterialCutFaceBump,
1247  MaterialCutFaceGloss,
1248 
1249  Camera = 0x04000000,
1250  };
1251 
1252 private:
1253  AttributeLock() {}
1254 };
1255 
1256 class HPS_API Drawing
1257 {
1258 public:
1261  enum class Handedness
1262  {
1263  NoHandedness,
1264  Left,
1265  Right
1266  };
1267 
1270  enum class Overlay
1271  {
1273  NoOverlay,
1276  NormalOverlay,
1279  OverlayWithZValues,
1280 
1285  InPlace,
1286  };
1287 
1290  enum class ClipOperation
1291  {
1292  Keep,
1293  Remove,
1294  };
1295 
1298  enum class ClipSpace
1299  {
1300  Window,
1301  World,
1302  Object,
1303  };
1304 
1305 private:
1306  Drawing() {}
1307 };
1308 
1309 
1310 class HPS_API HiddenLine
1311 {
1312 public:
1316  enum class Algorithm
1317  {
1318  None,
1319  ZBuffer,
1320  ZSort,
1321  };
1322 
1323 private:
1324  HiddenLine() {}
1325 };
1326 
1327 
1329 class HPS_API Selection
1330 {
1331 public:
1334  enum class Level
1335  {
1336  Segment,
1337  Entity,
1338  Subentity,
1339  };
1340 
1343  enum class Algorithm
1344  {
1345  Visual,
1346  Analytic
1347  };
1348 
1351  enum class Granularity
1352  {
1353  General,
1354  Detailed
1355  };
1356 
1357 private:
1359  Selection();
1360 };
1361 
1362 
1366 
1367 //Begin Camera
1369 class HPS_API Camera
1370 {
1371 public:
1380  enum class Projection {
1381  Default=1,
1382  Perspective,
1383  Orthographic,
1384  Stretched,
1385  };
1388 private:
1389  Camera();
1390 };
1391 
1392 
1393 //Begin Selectability
1395 class HPS_API Selectability
1396 {
1397 public:
1401  enum class Value
1402  {
1403  Off=0,
1404  On,
1405  ForcedOn
1406  };
1407 
1408 private:
1409  Selectability();
1410 };
1411 
1412 // Begin Transparency
1414 class HPS_API Transparency
1415 {
1416 public:
1420  enum class Method
1421  {
1422  Off,
1423  Blended,
1424  ScreenDoor
1425  };
1426 
1430  enum class Algorithm
1431  {
1432  NoSorting,
1433  Painters,
1434  ZSortNicest,
1435  ZSortFastest,
1436  DepthPeeling
1437  };
1438 
1442  enum class AreaUnits
1443  {
1444  Percent,
1445  Pixels
1446  };
1447 
1448 private:
1449  Transparency() {}
1450 };
1451 
1452 
1453 
1454 //Begin Marker Attributes
1456 class HPS_API Marker
1457 {
1458 public:
1462  enum class SizeUnits
1463  {
1464  ScaleFactor,
1465  ObjectSpace,
1466  SubscreenRelative,
1467  WindowRelative,
1468  WorldSpace,
1469  Points,
1470  Pixels
1471 
1472  };
1473 private:
1474  Marker();
1475 };
1476 
1477 //Begin Sphere Attributes
1479 class HPS_API Sphere
1480 {
1481 public:
1482 
1483 private:
1484  Sphere();
1485 };
1486 
1487 
1488 //Begin Lighting Attributes
1490 class HPS_API Lighting
1491 {
1492 public:
1497  {
1498  Phong,
1499  Gouraud,
1500  Flat
1501  };
1502 
1503 private:
1504  Lighting();
1505 };
1506 
1508 class HPS_API Text
1509 {
1510 public:
1513  enum class Alignment
1514  {
1515  TopLeft,
1516  CenterLeft,
1517  BottomLeft,
1518  TopCenter,
1519  Center,
1520  BottomCenter,
1521  TopRight,
1522  CenterRight,
1523  BottomRight
1524  };
1525 
1528  enum class ReferenceFrame
1529  {
1530  WorldAligned,
1531  PathAligned
1532  };
1533 
1536  enum class Justification
1537  {
1538  LeftJustified,
1539  RightJustified,
1540  CenterJustified
1541  };
1542 
1545  enum class Transform
1546  {
1548  Transformable,
1551  NonTransformable,
1553  CharacterPositionOnly,
1556  CharacterPositionAdjusted
1557  };
1558 
1561  enum class Renderer
1562  {
1563  DefaultRenderer,
1564  DriverRenderer,
1565  TruetypeRenderer,
1566  };
1567 
1570  enum class Preference
1571  {
1572  Default,
1573  Vector,
1574  Raster,
1575  Exterior
1576  };
1577 
1580  enum class Rotation
1581  {
1582  NoRotation,
1583  Rotate,
1584  FollowPath
1585  };
1586 
1587 
1590  enum class SizeUnits
1591  {
1592  ObjectSpace,
1593  SubscreenRelative,
1594  WindowRelative,
1595  WorldSpace,
1596  Points,
1597  Pixels
1598  };
1599 
1603  {
1604  ObjectSpace,
1605  SubscreenRelative,
1606  WindowRelative,
1607  WorldSpace,
1608  Points,
1609  Pixels,
1610  Percent
1611  };
1612 
1615  enum class GreekingUnits
1616  {
1617  ObjectSpace,
1618  SubscreenRelative,
1619  WindowRelative,
1620  WorldSpace,
1621  Points,
1622  Pixels
1623  };
1624 
1627  enum class GreekingMode
1628  {
1629  Nothing,
1630  Lines,
1631  Box
1632  };
1633 
1636  enum class RegionAlignment
1637  {
1638  RegionTop,
1639  RegionCenter,
1640  RegionBottom
1641  };
1642 
1643 private:
1645  Text();
1646 };
1647 
1648 // Begin Line Attributes
1649 
1651 class HPS_API Line
1652 {
1653 public:
1657  enum class SizeUnits
1658  {
1659  ScaleFactor,
1660  ObjectSpace,
1661  SubscreenRelative,
1662  WindowRelative,
1663  WorldSpace,
1664  Points,
1665  Pixels
1666  };
1667 private:
1668  Line();
1669 };
1670 
1671 
1672 // Begin Edge Attributes
1673 
1675 class HPS_API Edge
1676 {
1677 public:
1681  enum class SizeUnits
1682  {
1683  ScaleFactor,
1684  ObjectSpace,
1685  SubscreenRelative,
1686  WindowRelative,
1687  WorldSpace,
1688  Points,
1689  Pixels
1690  };
1691 private:
1692  Edge();
1693 };
1694 
1695 
1697 class HPS_API CuttingSection
1698 {
1699 public:
1702  enum class Mode
1703  {
1704  None,
1705  Round,
1706  Square,
1707  Plane
1708  };
1709 
1712  enum class CappingLevel
1713  {
1714  Entity,
1715  Segment,
1716  SegmentTree
1717  };
1718 
1721  enum class CuttingLevel
1722  {
1723  Global,
1724  Local,
1725  };
1726 
1730  {
1731  Explicit,
1732  Implicit,
1733  };
1734 
1737  enum class GatheringLevel
1738  {
1739  Segment,
1740  SegmentTree
1741  };
1742 
1743 private:
1745  CuttingSection();
1746 };
1747 
1749 class HPS_API ContourLine
1750 {
1751 public:
1755  enum class Mode
1756  {
1757  Repeating,
1758  Explicit,
1759  };
1760 
1761 private:
1762  ContourLine();
1763 };
1764 
1767 enum class IOResult
1768 {
1769  Success,
1770  Failure,
1771  FileNotFound,
1772  UnableToOpenFile,
1773  InvalidOptions,
1774  InvalidSegment,
1775  InProgress,
1776  Canceled,
1777  UnableToLoadLibraries,
1778  VersionIncompatibility,
1779  InitializationFailed,
1780  UnsupportedFormat,
1781 };
1782 
1784 class HPS_API LinePattern
1785 {
1786 public:
1789  enum class SizeUnits
1790  {
1791  ObjectSpace,
1792  SubscreenRelative,
1793  WindowRelative,
1794  WorldSpace,
1795  Points,
1796  Pixels,
1797  ScaleFactor
1798  };
1799 
1802  enum class InsetBehavior
1803  {
1804  Overlap,
1805  Trim,
1806  Inline
1807  };
1808 
1812  enum class Join
1813  {
1814  MitreJoin,
1815  RoundJoin,
1816  BevelJoin
1817  };
1818 
1821  enum class Cap
1822  {
1825  ButtCap,
1828  SquareCap,
1831  RoundCap,
1833  MitreCap
1834  };
1835 
1838  enum class Justification
1839  {
1842  Center,
1844  Stretch
1845  };
1846 
1849  enum class Modifier
1850  {
1851  GlyphName,
1852  Enumerated
1853  };
1854 
1855 
1870  enum class Default
1871  {
1872  Solid,
1873  DashDot,
1874  Dashed,
1875  Dotted,
1876  Dash2Dot,
1877  Dash3Dot,
1878  LongDash,
1879  LongDashShortDash,
1880  LongDash2ShortDash,
1881  FineDot,
1882  };
1883 
1884 private:
1886  LinePattern();
1887 };
1888 
1889 
1890 //Begin Glyphs
1892 class HPS_API Glyph
1893 {
1894 public:
1897  enum class Fill
1898  {
1899  Unfilled,
1900  ContinuousFill,
1901  NewFill
1902  };
1903 
1906  enum class ColorSource
1907  {
1908  Normal,
1909  Explicit,
1910  Indexed
1911  };
1912 
1916  enum class Default
1917  {
1918  Circle,
1919  CircleWithDot,
1920  CircleWithPlus,
1921  CircleWithTimes,
1922  CircleWithCircle,
1923  SolidCircle,
1924  Dot,
1925  Plus,
1926  Times,
1927  Splat,
1928  Box,
1929  BoxWithDot,
1930  BoxWithTimes,
1931  SolidBox,
1932  Diamond,
1933  DiamondWithDot,
1934  DiamondWithPlus,
1935  SolidDiamond,
1936  TriangleUp,
1937  TriangleUpWithDot,
1938  SolidTriangleUp,
1939  TriangleDown,
1940  TriangleDownWithDot,
1941  SolidTriangleDown,
1942  TriangleRight,
1943  TriangleRightWithDot,
1944  SolidTriangleRight,
1945  TriangleLeft,
1946  TriangleLeftWithDot,
1947  SolidTriangleLeft,
1948  TriangleUpV,
1949  SolidTriangleUpV,
1950  TriangleDownV,
1951  SolidTriangleDownV,
1952  TriangleRightV,
1953  SolidTriangleRightV,
1954  TriangleLeftV,
1955  SolidTriangleLeftV,
1956  LetterY,
1957  LetterZ,
1958  CircleLetterY,
1959  CircleLetterZ,
1960  VerticalBar,
1961  HorizontalBar,
1962  SlantLeft,
1963  SlantRight,
1964  WidePlus,
1965  SolidWidePlus,
1966  WideTimes,
1967  SolidWideTimes,
1968  Pound,
1969  };
1970 
1971 private:
1973  Glyph();
1974 };
1975 
1976 
1978 class HPS_API Bounding
1979 {
1980 public:
1984  enum class Type
1985  {
1986  None,
1987  Sphere,
1988  Cuboid
1989  };
1990 
1991 private:
1992  Bounding() {}
1993 };
1994 
1996 class HPS_API Grid
1997 {
1998 public:
2001  enum class Type
2002  {
2003  Quadrilateral,
2004  Radial
2005  };
2006 
2007 private:
2008  Grid();
2009 };
2010 
2011 
2012 
2013 #ifdef _MSC_VER
2014 # ifndef HPS_INLINE
2015 # define HPS_INLINE __forceinline
2016 # endif
2017 #else
2018 # define HPS_INLINE inline
2019 #endif
2020 
2021 #ifndef HPS_UNREFERENCED
2022 #define HPS_UNREFERENCED(param) ((void)(param))
2023 #endif
2024 
2025 
2026 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2027 
2028 template<typename T>
2029 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2030 {
2031  return degrees * (T)(PI / 180.0);
2032 }
2033 
2034 template<typename T>
2035 HPS_INLINE T Radians_To_Degrees(T const & radians)
2036 {
2037  return radians * (T)(180.0 / PI);
2038 }
2039 
2040 template<typename T>
2041 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2042  T a = Degrees_To_Radians(angle);
2043  cosine = cos(a);
2044  sine = sin(a);
2045 }
2046 
2047 template<typename T>
2048 HPS_INLINE T Cos(T const & angle) {
2049  return cos (Degrees_To_Radians(angle));
2050 }
2051 
2052 template<typename T>
2053 HPS_INLINE T Sin(T const & angle) {
2054  return sin (Degrees_To_Radians(angle));
2055 }
2056 
2057 template<typename T>
2058 HPS_INLINE T ACos(T const & x) {
2059  if (x > 1)
2060  return 0;
2061  if (x < -1)
2062  return 180;
2063  return Radians_To_Degrees(acos(x));
2064 }
2065 
2066 template<typename T>
2067 HPS_INLINE T ATan2(T const & y, T const & x) {
2068  if (x == 0 && y == 0)
2069  return 0;
2070  return Radians_To_Degrees(atan2(y, x));
2071 }
2072 
2073 
2074 template <typename F> struct Float_Traits {};
2075 template <> struct Float_Traits<float> {
2076  typedef double Alternative;
2077  static const int Type = 1;
2078  static float Epsilon () { return 1.0e-30f; }
2079 };
2080 template <> struct Float_Traits<double> {
2081  typedef float Alternative;
2082  static const int Type = 2;
2083  static double Epsilon () { return 1.0e-300; }
2084 };
2085 
2086 
2087 
2089 class HPS_API Float {
2090 private:
2091  enum Parts {
2092 # if HOOPS_BIGENDIAN
2093  High, Low
2094 # else
2095  Low, High
2096 # endif
2097  };
2098 
2099  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2100  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2101  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2102  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2103  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2104 
2105  static HPS_INLINE bool is_nan(int32_t const & v) {
2106  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2107  return exp == 0x7F800000 && mantissa != 0;
2108  }
2109  static HPS_INLINE bool is_nan(uint32_t const & v) {
2110  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2111  return exp == 0x7F800000 && mantissa != 0;
2112  }
2113  static HPS_INLINE bool is_nan(int32_t const * v) {
2114  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2115  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2116  }
2117  static HPS_INLINE bool is_nan(uint32_t const * v) {
2118  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2119  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2120  }
2121 
2122  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2123  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2124  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2125  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2126 public:
2127 
2129  static const float Infinity;
2131  static const float NegativeInfinity;
2132 
2134  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2135  static HPS_INLINE bool IsInfinite(double const & a) {
2136  uint32_t v[2];
2137  memcpy (v, &a, sizeof(double));
2138  return is_infinite (v);
2139  }
2140 
2142  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2143  static HPS_INLINE bool IsNAN(double const & a) {
2144  uint32_t v[2];
2145  memcpy (v, &a, sizeof(double));
2146  return is_nan (v);
2147  }
2148 
2150  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2151  static HPS_INLINE bool IsAbnormal(double const & a) {
2152  uint32_t v[2];
2153  memcpy (v, &a, sizeof(double));
2154  return is_special (v);
2155  }
2156 
2159  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2160  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2161 
2162 #ifndef HOOPS_DEFINED
2163  template <typename Alloc>
2164  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2165  {
2166  if (a.size() != b.size())
2167  return false;
2168 
2169  auto it1 = a.begin();
2170  auto it2 = b.begin();
2171  auto const end = a.end();
2172  for ( ; it1 != end; ++it1, ++it2)
2173  {
2174  if (!Equals(*it1, *it2, tolerance))
2175  return false;
2176  }
2177  return true;
2178  }
2179 #endif
2180 
2181  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2182  return extract_uint32_t(a) & 0x80000000;
2183  }
2184  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2185  uint32_t v[2];
2186  memcpy (v, &a, sizeof(double));
2187  return v[High] & 0x80000000;
2188  }
2189 
2190  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2191  uint32_t v = extract_uint32_t(a);
2192  v &= 0x7FFFFFFF;
2193  v |= sign_bit;
2194  inject_uint32_t(a, v);
2195  }
2196  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2197  uint32_t v[2];
2198  memcpy (v, &a, sizeof(double));
2199  v[High] &= 0x7FFFFFFF;
2200  v[High] |= sign_bit;
2201  memcpy (&a, v, sizeof(double));
2202  }
2203 
2204 
2205  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2206  uint32_t v = extract_uint32_t(a);
2207 
2208  v &= 0x7FFFFFFF;
2209  if (v < 0x3B800000)
2210  return 0;
2211 
2212  v--;
2213 
2214  uint32_t exp = v >> 23;
2215  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2216 
2217  return (unsigned char) (man >> (16 + 126 - exp));
2218  }
2219 
2220  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2221  uint32_t v = extract_uint32_t(a);
2222 
2223  v &= 0x7FFFFFFF;
2224  if (v < 0x3B800000)
2225  return 0;
2226 
2227  v--;
2228 
2229  uint32_t exp = v >> 23;
2230  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2231 
2232  uint32_t x = (man >> (16 + 126 - exp));
2233 
2234  return (unsigned char) ((x * (mix+1)) >> 8);
2235  }
2236 
2237 
2238  static HPS_INLINE bool match(float const & a, float const & b) {
2239  uint32_t va = extract_uint32_t(a);
2240  uint32_t vb = extract_uint32_t(b);
2241 
2242  if (((va | vb) & 0x7FFFFFFF) == 0)
2243  return true;
2244 
2245  return va == vb;
2246  }
2247  static HPS_INLINE bool match(double const & a, double const & b) {
2248  return a == b;
2249  }
2250 
2251 
2252  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2253  uint32_t va = extract_uint32_t(a);
2254  uint32_t vb = extract_uint32_t(b);
2255 
2256  uint32_t a_sign = va & 0x80000000;
2257  uint32_t b_sign = vb & 0x80000000;
2258 
2259  (int32_t&)a_sign >>= 31;
2260  (int32_t&)b_sign >>= 31;
2261 
2262  uint32_t mash = (a_sign&b_sign);
2263 
2264  va ^= mash;
2265  vb ^= mash;
2266 
2267  if ((int32_t&)vb < (int32_t&)va)
2268  memcpy(&a, &b, sizeof(float));
2269  }
2270  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2271  if (b < a)
2272  a = b;
2273  }
2274 
2275  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2276  uint32_t va = extract_uint32_t(a);
2277  uint32_t vb = extract_uint32_t(b);
2278 
2279  uint32_t a_sign = va & 0x80000000;
2280  uint32_t b_sign = vb & 0x80000000;
2281 
2282  (int32_t&)a_sign >>= 31;
2283  (int32_t&)b_sign >>= 31;
2284 
2285  uint32_t mash = (a_sign&b_sign);
2286 
2287  va ^= mash;
2288  vb ^= mash;
2289 
2290  if ((int32_t&)vb > (int32_t&)va)
2291  memcpy(&a, &b, sizeof(float));
2292  }
2293  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2294  if (b > a)
2295  a = b;
2296  }
2297 
2298 
2299  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2300  uint32_t i;
2301  memcpy(&i, &a, sizeof(float));
2302  return i;
2303  }
2304 
2305  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2306  memcpy(&a, &i, sizeof(float));
2307  }
2308 
2309  static HPS_INLINE float C2F(unsigned char x) {
2310  //return (float)x * (1.0f/255.0f);
2311  return char_to_float[x];
2312  }
2313 
2314 
2315  // SSE convenience functions
2316  static HPS_INLINE void pack_4(float const & f, float * m) {
2317  memcpy(&m[0], &f, sizeof(float));
2318  memcpy(&m[1], &f, sizeof(float));
2319  memcpy(&m[2], &f, sizeof(float));
2320  memcpy(&m[3], &f, sizeof(float));
2321  }
2322 
2323  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2324  memcpy(&m[0], &f0, sizeof(float));
2325  memcpy(&m[1], &f1, sizeof(float));
2326  memcpy(&m[2], &f2, sizeof(float));
2327  memcpy(&m[3], &f3, sizeof(float));
2328  }
2329 
2330  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2331  memcpy(f0, m, sizeof(float)*4);
2332  }
2333 
2334  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2335  memcpy(&f0, &m[0], sizeof(float));
2336  memcpy(&f1, &m[1], sizeof(float));
2337  memcpy(&f2, &m[2], sizeof(float));
2338  memcpy(&f3, &m[3], sizeof(float));
2339  }
2340 
2341 private:
2342  static const float char_to_float[256];
2343 
2344  Float();
2345 };
2346 
2347 
2349 
2350 
2351 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2352 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2353 
2354 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2355 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2356 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2357 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2358 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2359 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2360 
2361 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2362 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2363 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); }
2364 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); }
2365 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); }
2366 
2367 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2368 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2369 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); }
2370 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); }
2371 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); }
2372 
2373 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; }
2374 
2375 
2376 template <> HPS_INLINE float Abs<float> (float const & a) {
2377  uint32_t v = Float::extract_uint32_t(a);
2378  v &= 0x7FFFFFFF;
2379  float f;
2380  Float::inject_uint32_t(f,v);
2381  return f;
2382 }
2383 
2384 template <> HPS_INLINE int Sign<float> (float const & a) {
2385  uint32_t v = Float::extract_uint32_t(a);
2386 
2387  if ((v & 0x7FFFFFFF) == 0)
2388  return 0;
2389 
2390  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2391 }
2392 
2393 template <> HPS_INLINE int Compare<float> (float const & a, float const & b) {
2394  int a_sign = Sign(a);
2395  int b_sign = Sign(b);
2396 
2397  if (a_sign != b_sign)
2398  return Compare(a_sign, b_sign);
2399 
2400  uint32_t v = Float::extract_uint32_t(a);
2401  uint32_t u = Float::extract_uint32_t(b);
2402 
2403  return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2404 }
2405 
2406 template <> HPS_INLINE float const & Min<float> (float const & a, float const & b) {
2407  if (Compare(a,b)>0)
2408  return b;
2409  return a;
2410 }
2411 
2412 template <> HPS_INLINE float const & Max<float> (float const & a, float const & b) {
2413  if (Compare(a,b)>0)
2414  return a;
2415  return b;
2416 }
2417 
2418 
2420 
2421 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2422  int32_t va = Float::extract_uint32_t(a);
2423  int32_t vb = Float::extract_uint32_t(b);
2424 
2425  if (is_special(va) || is_special(vb)) {
2426  if (is_infinite(va) || is_infinite(vb))
2427  return va == vb; // final check is for sign bits same
2428  if (is_nan(va) || is_nan(vb))
2429  return false;
2430  }
2431 
2432  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2433  if ((va & 0x7FFFFFFF) == 0)
2434  return (vb & 0x7FFFFFFF) < close_to_zero;
2435  else if ((vb & 0x7FFFFFFF) == 0)
2436  return (va & 0x7FFFFFFF) < close_to_zero;
2437 
2438  uint32_t sign_mask = va ^ vb;
2439  (int32_t &)sign_mask >>= 31;
2440 
2441  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2442  int32_t v1 = tolerance + diff;
2443  int32_t v2 = tolerance - diff;
2444  return (v1|v2) >= 0;
2445 }
2446 
2447 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2448  int32_t va[2], vb[2];
2449  memcpy (va, &a, sizeof(double));
2450  memcpy (vb, &b, sizeof(double));
2451 
2452  if (is_special(va) || is_special(vb)) {
2453  if (is_infinite(va) || is_infinite(vb))
2454  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2455  if (is_nan(va) || is_nan(vb))
2456  return false;
2457  }
2458 
2459  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2460  return Abs(a - b) < 0.000000000000005;
2461 
2462  if (extract_sign_bit(a) != extract_sign_bit(b))
2463  return a == b;
2464 
2465  if (va[High] != vb[High])
2466  return false;
2467 
2468  return Abs(va[Low] - vb[Low]) <= tolerance;
2469 }
2470 
2472 
2473 
2474 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2475 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2476 
2477 template <typename T>
2478 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2479  while (count-- > 0)
2480  if (Is_Abnormal (*t++))
2481  return true;
2482  return false;
2483 }
2484 
2485 template <typename T>
2486 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2487  return count >= 0 && Is_Abnormal((size_t)count, t);
2488 }
2489 
2490 
2492 
2493 
2494 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2495 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2496 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2497 template <typename F> class HPS_TEMPLATE_API Point_2D;
2498 
2499 
2500 template <typename F>
2501 class HPS_TEMPLATE_API Point_3D {
2502  public:
2503  F x;
2504  F y;
2505  F z;
2506 
2507  Point_3D () {}
2508  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2509 
2510  template <typename D>
2511  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2512 
2513  explicit Point_3D (Vector_3D<F> const & v);
2514  explicit Point_3D (Vector_2D<F> const & v);
2515  explicit Point_3D (Point_2D<F> const & that);
2516 
2517  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2518 
2519  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2520  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2521 
2522  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2523  return Float::Equals(x, p.x, in_tolerance) &&
2524  Float::Equals(y, p.y, in_tolerance) &&
2525  Float::Equals(z, p.z, in_tolerance);
2526  }
2527 
2528 
2529  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2530  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2531  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2532  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2533 
2534  F & operator[] (size_t i) { return (&x)[i]; }
2535  F const & operator[] (size_t i) const { return (&x)[i]; }
2536 
2537  Point_3D & operator+= (Vector_3D<F> const & v);
2538  Point_3D & operator-= (Vector_3D<F> const & v);
2539  Point_3D & operator*= (Vector_3D<F> const & v);
2540  Point_3D & operator/= (Vector_3D<F> const & v);
2541  Point_3D const operator* (Vector_3D<F> const & v) const;
2542  Point_3D const operator/ (Vector_3D<F> const & v) const;
2543 
2544  Point_3D & operator+= (Vector_2D<F> const & v);
2545  Point_3D & operator-= (Vector_2D<F> const & v);
2546  Point_3D & operator*= (Vector_2D<F> const & v);
2547  Point_3D & operator/= (Vector_2D<F> const & v);
2548  Point_3D const operator* (Vector_2D<F> const & v) const;
2549  Point_3D const operator/ (Vector_2D<F> const & v) const;
2550 
2551  Vector_3D<F> const operator- (Point_3D const & p) const;
2552 
2553  Point_3D const operator+ (Vector_3D<F> const & v) const;
2554  Point_3D const operator- (Vector_3D<F> const & v) const;
2555 
2556  Point_3D const operator+ (Vector_2D<F> const & v) const;
2557  Point_3D const operator- (Vector_2D<F> const & v) const;
2558 
2559  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2560  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2561 };
2562 
2563 typedef Point_3D<float> Point;
2564 typedef Point_3D<double> DPoint;
2565 
2566 
2567 
2568 template <typename F, typename S>
2569 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)); }
2570 
2571 template <typename F>
2572 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2573  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2574 }
2575 
2576 template <typename F>
2577 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2578  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);
2579 }
2580 
2581 template <typename F>
2582 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2583  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2584 }
2585 
2586 
2587 template <typename F>
2588 class HPS_TEMPLATE_API Point_2D {
2589 public:
2590  F x;
2591  F y;
2592 
2593  Point_2D () {}
2594  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2595 
2596  template <typename D>
2597  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2598 
2599  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2600  explicit Point_2D (Vector_2D<F> const & v);
2601 
2602  Point_2D const operator- () const { return Point_2D (-x, -y); }
2603 
2604  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2605  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2606 
2607  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2608  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2609  }
2610 
2611 
2612  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2613  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2614  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2615  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2616 
2617  F & operator[] (size_t i) { return (&x)[i]; }
2618  F const & operator[] (size_t i) const { return (&x)[i]; }
2619 
2620  Point_2D & operator+= (Vector_2D<F> const & v);
2621  Point_2D & operator-= (Vector_2D<F> const & v);
2622  Point_2D & operator*= (Vector_2D<F> const & v);
2623  Point_2D & operator/= (Vector_2D<F> const & v);
2624  Point_2D const operator* (Vector_2D<F> const & v) const;
2625  Point_2D const operator/ (Vector_2D<F> const & v) const;
2626 
2627  Vector_2D<F> const operator- (Point_2D const & p) const;
2628 
2629  Point_2D const operator+ (Vector_2D<F> const & v) const;
2630  Point_2D const operator- (Vector_2D<F> const & v) const;
2631 
2632  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2633  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2634 };
2635 
2636 typedef Point_2D<float> Point2D;
2637 typedef Point_2D<double> DPoint2D;
2638 
2639 template <typename F>
2640 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2641 
2642 template <typename F, typename S>
2643 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)); }
2644 
2645 template <typename F>
2646 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2647  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2648 }
2649 
2650 template <typename F>
2651 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2652  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);
2653 }
2654 
2655 template <typename F>
2656 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2657  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2658 }
2659 
2660 
2661 template <typename F>
2662 class HPS_TEMPLATE_API Vector_3D {
2663  public:
2664  F x;
2665  F y;
2666  F z;
2667 
2668  Vector_3D () {}
2669  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2670  template <typename D>
2671  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2672  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2673  explicit Vector_3D(Plane_3D<F> const & p);
2674 
2675  explicit Vector_3D (Vector_2D<F> const & that);
2676 
2677  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2678 
2679  bool operator== (Vector_3D const & v) const {
2680  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2681  }
2682  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2683 
2684  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2685  return Float::Equals(x, v.x, in_tolerance) &&
2686  Float::Equals(y, v.y, in_tolerance) &&
2687  Float::Equals(z, v.z, in_tolerance);
2688  }
2689 
2690  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2691  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2692  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2693  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2694 
2695  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2696  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2697  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2698  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2699 
2700  F & operator[] (size_t i) { return (&x)[i]; }
2701  F const & operator[] (size_t i) const { return (&x)[i]; }
2702 
2703  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2704 
2705  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2706 
2707  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2708 
2709  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2710 
2711  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2712  if (check_range) {
2713  F range = Max (Abs (x), Abs (y), Abs (z));
2714  if (range > F(1.0e10))
2715  operator/= (range);
2716  }
2717 
2718  F len = (F)Length();
2719  if (len > epsilon)
2720  operator/= (len);
2721  else
2722  *this = Zero();
2723  return *this;
2724  }
2725  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2726 
2727  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2728  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2729 
2730  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2731 
2732  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2733  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2734  }
2735 
2736 
2737  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2738  return Vector_3D (x * v.x, y * v.y, z * v.z);
2739  }
2740 
2741  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2742  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2743  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2744  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2745  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2746 };
2747 
2748 typedef Vector_3D<float> Vector;
2749 typedef Vector_3D<double> DVector;
2750 
2751 
2752 template <typename F, typename S>
2753 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)); }
2754 
2755 template <typename F>
2756 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2757  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2758 }
2759 
2760 
2761 template <typename F>
2762 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2763 
2764 template <typename F>
2765 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; }
2766 template <typename F>
2767 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; }
2768 
2769 template <typename F>
2770 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); }
2771 
2772 template <typename F>
2773 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); }
2774 template <typename F>
2775 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); }
2776 
2777 template <typename F>
2778 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; }
2779 template <typename F>
2780 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; }
2781 template <typename F>
2782 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); }
2783 template <typename F>
2784 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); }
2785 
2786 
2787 
2788 template <typename F>
2789 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2790  return a + (b - a) * t;
2791 }
2792 
2793 template <typename F>
2794 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2795  return Vector_3D<F>(a + (b - a) * t).Normalize();
2796 }
2797 
2798 
2799 
2800 template <typename F>
2801 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2802  return (p2 - p1).Length();
2803 }
2804 
2805 template <typename F>
2806 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2807  return (p2 - p1).LengthSquared();
2808 }
2809 
2810 template <typename F>
2811 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2812  F p = static_cast<F>((c - b).LengthSquared());
2813  F q = static_cast<F>((c - a).LengthSquared());
2814  F r = static_cast<F>((b - a).LengthSquared());
2815 
2816  return Point_3D<F>(
2817  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2818  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2819 }
2820 
2821 
2822 
2823 template <typename F>
2824 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2825  bool success = true;
2826  for (size_t i = 0; i < count; ++i) {
2827  if (vectors->Normalize() == Vector_3D<F>::Zero())
2828  success = false;
2829  vectors++;
2830  }
2831  return success;
2832 }
2833 
2834 
2835 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2836 
2837 template <typename F>
2838 class HPS_TEMPLATE_API Vector_2D {
2839 public:
2840  F x;
2841  F y;
2842 
2843  Vector_2D () {}
2844  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2845  template <typename D>
2846  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2847 
2848  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2849  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2850  explicit Vector_2D (Plane_2D<F> const & p);
2851 
2852  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2853 
2854  bool operator== (Vector_2D const & v) const {
2855  return Float::match(x, v.x) && Float::match(y, v.y);
2856  }
2857  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2858 
2859  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2860  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2861  }
2862 
2863  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2864  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2865  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2866  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2867 
2868  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2869  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
2870  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
2871  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
2872 
2873  F & operator[] (size_t i) { return (&x)[i]; }
2874  F const & operator[] (size_t i) const { return (&x)[i]; }
2875 
2876  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2877 
2878  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
2879 
2880  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2881  if (check_range) {
2882  F range = Max (Abs (x), Abs (y));
2883  if (range > F(1.0e10))
2884  operator/= (range);
2885  }
2886 
2887  F len = (F)Length();
2888  if (len > epsilon)
2889  operator/= (len);
2890  else
2891  *this = Zero();
2892  return *this;
2893  }
2894  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2895 
2896  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
2897  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
2898 
2899  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
2900 
2901 
2902  HPS_INLINE float Cross (Vector_2D const & v) const {
2903  return x * v.y - y * v.x;
2904  }
2905 
2906  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
2907  return Vector_2D (x * v.x, y * v.y);
2908  }
2909 
2910  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
2911  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
2912 
2913  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
2914  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
2915 };
2916 
2917 typedef Vector_2D<float> Vector2D;
2919 
2920 template <typename F, typename S>
2921 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)); }
2922 
2923 template <typename F>
2924 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
2925  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2926 }
2927 
2928 
2929 template <typename F>
2930 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
2931 
2932 template <typename F>
2933 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
2934 
2935 template <typename F>
2936 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
2937 template <typename F>
2938 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
2939 
2940 template <typename F>
2941 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); }
2942 template <typename F>
2943 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); }
2944 
2945 template <typename F>
2946 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
2947 template <typename F>
2948 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
2949 
2950 template <typename F>
2951 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); }
2952 template <typename F>
2953 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); }
2954 
2955 
2956 template <typename F>
2957 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
2958 template <typename F>
2959 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
2960 
2961 template <typename F>
2962 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); }
2963 
2964 template <typename F>
2965 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); }
2966 template <typename F>
2967 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); }
2968 
2969 template <typename F>
2970 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
2971 template <typename F>
2972 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
2973 template <typename F>
2974 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); }
2975 template <typename F>
2976 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); }
2977 
2978 
2979 
2980 
2981 
2982 template <typename F>
2983 class HPS_TEMPLATE_API Plane_3D {
2984  public:
2985  F a;
2986  F b;
2987  F c;
2988  F d;
2989 
2990  Plane_3D () {}
2991  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
2992  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
2993  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)) {}
2994  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)) {}
2995  template <typename D>
2996  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
2997 
2998  Plane_3D (size_t count, Point_3D<F> const * points) {
2999  if (count >= 3) {
3000  // The 3 coefficients A, B, and C are proportional to the areas of the
3001  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3002 
3003  // run around the polygon, collecting trapezoidal areas
3004  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3005 
3006  // take care of the swing point first
3007  Point_3D<F> const * p0 = &points[count-1];
3008 
3010  Vector_3D<F> normal = Vector_3D<F>::Zero();
3011 
3012  for (size_t i=0; i<count; ++i) {
3013  Point_3D<F> const * p1 = &points[i];
3014 
3015  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3016  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3017  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3018 
3019  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3020 
3021  p0 = p1;
3022  }
3023 
3024  // ("should" always be != 0)
3025  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3026  /* finish finding the average */
3027  double inv_count = 1.0 / (double)count;
3028  ctr *= inv_count;
3029 
3030  *this = Plane_3D(normal, Point_3D<F>(ctr));
3031  return;
3032  }
3033  }
3034 
3035  *this = Plane_3D::Zero();
3036  }
3037 
3038 
3039  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3040 
3041  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3042  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3043 
3044  F & operator[] (size_t i) { return (&a)[i]; }
3045  F const & operator[] (size_t i) const { return (&a)[i]; }
3046 
3047  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3048  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3049  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3050  }
3051 
3052  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3053  F len = (F)Vector_3D<F>(*this).Length();
3054  if (len > epsilon)
3055  operator/= (len);
3056  else
3057  *this = Zero();
3058  return *this;
3059  }
3060 
3061  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3062  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3063  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3064 
3065  if (val1 >= eps) {
3066  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3067  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3068  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3069  }
3070  else
3071  return p1;
3072  }
3073 
3074  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3075  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3076  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3077 
3078  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));
3079  }
3080 
3081  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3082 
3083 
3084  private:
3085  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3086  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3087  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3088  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3089 };
3090 
3091 typedef Plane_3D<float> Plane;
3092 typedef Plane_3D<double> DPlane;
3093 
3094 
3095 template <typename F>
3096 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3097  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3098 }
3099 
3100 
3101 template <typename F>
3102 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3103  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3104 }
3105 template <typename F>
3106 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3107  return plane * point;
3108 }
3109 
3110 template <typename F>
3111 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3112  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);
3113 }
3114 
3115 template <typename F>
3116 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3117 
3118 
3119 
3120 
3121 
3122 
3123 template <typename F>
3124 class HPS_TEMPLATE_API Plane_2D {
3125 public:
3126  F a;
3127  F b;
3128  F c;
3129 
3130  Plane_2D () {}
3131  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3132  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3133  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)) {}
3134  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)) {}
3135  template <typename D>
3136  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3137 
3138  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3139 
3140  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3141  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3142 
3143  F & operator[] (size_t i) { return (&a)[i]; }
3144  F const & operator[] (size_t i) const { return (&a)[i]; }
3145 
3146  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3147  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3148  }
3149 
3150  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3151  F len = (F)Vector_2D<F>(*this).Length();
3152  if (len > epsilon)
3153  operator/= (len);
3154  else
3155  *this = Zero();
3156  return *this;
3157  }
3158 
3159  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3160 
3161 
3162 private:
3163  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3164  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3165  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3166  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3167 };
3168 
3169 typedef Plane_2D<float> Plane2D;
3170 typedef Plane_2D<double> DPlane2D;
3171 
3172 
3173 template <typename F>
3174 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3175  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3176 }
3177 
3178 
3179 template <typename F>
3180 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3181  return plane.a * point.x + plane.b * point.y + plane.c;
3182 }
3183 template <typename F>
3184 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3185  return plane * point;
3186 }
3187 
3188 template <typename F>
3189 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3190  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);
3191 }
3192 
3193 template <typename F>
3194 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3195 
3196 
3197 
3198 
3199 struct Rectangle;
3200 
3201 struct HPS_API IntRectangle {
3202  int left;
3203  int right;
3204  int bottom;
3205  int top;
3206 
3207  IntRectangle()
3208  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3209  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3210 
3211  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3212  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3213 
3214  IntRectangle(IntRectangle const & that)
3215  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3216 
3217  explicit IntRectangle(Rectangle const & that);
3218 
3219  bool operator==(IntRectangle const & rect) const {
3220  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3221  }
3222 
3223  bool operator!=(IntRectangle const & rect) const {
3224  return !(*this == rect);
3225  }
3226 
3227  HPS_INLINE int PixelWidth() const {
3228  return right - left + 1;
3229  }
3230 
3231  HPS_INLINE int PixelHeight() const {
3232  return top - bottom + 1;
3233  }
3234 
3235  HPS_INLINE int Width() const {
3236  return right - left;
3237  }
3238 
3239  HPS_INLINE int Height() const {
3240  return top - bottom;
3241  }
3242 
3243  HPS_INLINE int Area() const {
3244  return Width() * Height();
3245  }
3246 
3247  HPS_INLINE Point2D Center() const {
3248  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3249  }
3250 
3251  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3252  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3253  }
3254 
3255  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3256  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3257  }
3258 
3259  HPS_INLINE IntRectangle & Expand(int border) {
3260  left -= border;
3261  right += border;
3262  bottom -= border;
3263  top += border;
3264  return *this;
3265  }
3266 
3267  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3268  left -= rect.left;
3269  right += rect.right;
3270  bottom -= rect.bottom;
3271  top += rect.top;
3272  return *this;
3273  }
3274 
3275  HPS_INLINE IntRectangle & Contract(int border) {
3276  left += border;
3277  right -= border;
3278  bottom += border;
3279  top -= border;
3280  return *this;
3281  }
3282 
3283  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3284  left += rect.left;
3285  right -= rect.right;
3286  bottom += rect.bottom;
3287  top -= rect.top;
3288  return *this;
3289  }
3290 
3291  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3292  left = Max(left, rect.left);
3293  right = Min(right, rect.right);
3294  bottom = Max(bottom, rect.bottom);
3295  top = Min(top, rect.top);
3296  return *this;
3297  }
3298 
3299  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3300  left = Min(left, rect.left);
3301  right = Max(right, rect.right);
3302  bottom = Min(bottom, rect.bottom);
3303  top = Max(top, rect.top);
3304  return *this;
3305  }
3306 
3307 
3308  static HPS_INLINE IntRectangle Invalid() {
3309  return IntRectangle();
3310  }
3311 
3312  static HPS_INLINE IntRectangle Zero() {
3313  return IntRectangle(0, 0, 0, 0);
3314  }
3315 
3316 };
3317 
3318 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3319  IntRectangle temp = a;
3320  return temp.Expand(border);
3321 }
3322 
3323 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3324  IntRectangle temp = a;
3325  return temp.Expand(border);
3326 }
3327 
3328 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3329  IntRectangle temp = a;
3330  return temp.Contract(border);
3331 }
3332 
3333 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3334  IntRectangle temp = a;
3335  return temp.Contract(border);
3336 }
3337 
3338 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3339  IntRectangle temp = a;
3340  return temp.Intersect(b);
3341 }
3342 
3343 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3344  IntRectangle temp = a;
3345  return temp.Union(b);
3346 }
3347 
3348 struct HPS_API Rectangle {
3349  float left;
3350  float right;
3351  float bottom;
3352  float top;
3353 
3354  Rectangle()
3355  : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3356  bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3357 
3358  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3359  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3360 
3361  Rectangle(Rectangle const & that)
3362  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3363 
3364  explicit Rectangle(IntRectangle const & that)
3365  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3366 
3367  HPS_INLINE Rectangle(size_t count, Point const * points) {
3368  left = points->x;
3369  right = points->x;
3370  top = points->y;
3371  bottom = points->y;
3372  --count;
3373  if (count > 0) {
3374  ++points;
3375  Merge(count, points);
3376  }
3377  }
3378 
3379  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3380  left = points->x;
3381  right = points->x;
3382  top = points->y;
3383  bottom = points->y;
3384  --count;
3385  if (count > 0) {
3386  ++points;
3387  Merge(count, points);
3388  }
3389  }
3390 
3391  HPS_INLINE float Width() const {
3392  return right - left;
3393  }
3394 
3395  HPS_INLINE float Height() const {
3396  return top - bottom;
3397  }
3398 
3399  HPS_INLINE float Area() const {
3400  return Width() * Height();
3401  }
3402 
3403  HPS_INLINE Point2D Center() const {
3404  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3405  }
3406 
3407  HPS_INLINE void Merge(size_t count, Point const * points) {
3408 
3409  while (count > 1) {
3410  if (Compare(points[0].x, points[1].x)>0) {
3411  Float::replace_if_smaller(left, points[1].x);
3412  Float::replace_if_larger(right, points[0].x);
3413  }
3414  else {
3415  Float::replace_if_smaller(left, points[0].x);
3416  Float::replace_if_larger(right, points[1].x);
3417  }
3418 
3419  if (Compare(points[0].y, points[1].y)>0) {
3420  Float::replace_if_smaller(bottom, points[1].y);
3421  Float::replace_if_larger(top, points[0].y);
3422  }
3423  else {
3424  Float::replace_if_smaller(bottom, points[0].y);
3425  Float::replace_if_larger(top, points[1].y);
3426  }
3427 
3428  points += 2;
3429  count -= 2;
3430  }
3431 
3432  if (count > 0)
3433  Merge(*points);
3434  }
3435 
3436  HPS_INLINE void Merge(Point const & point) {
3437  Float::replace_if_smaller(left, point.x);
3438  Float::replace_if_smaller(bottom, point.y);
3439  Float::replace_if_larger(right, point.x);
3440  Float::replace_if_larger(top, point.y);
3441  }
3442 
3443  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3444 
3445  while (count > 1) {
3446  if (Compare(points[0].x, points[1].x)>0) {
3447  Float::replace_if_smaller(left, points[1].x);
3448  Float::replace_if_larger(right, points[0].x);
3449  }
3450  else {
3451  Float::replace_if_smaller(left, points[0].x);
3452  Float::replace_if_larger(right, points[1].x);
3453  }
3454 
3455  if (Compare(points[0].y, points[1].y)>0) {
3456  Float::replace_if_smaller(bottom, points[1].y);
3457  Float::replace_if_larger(top, points[0].y);
3458  }
3459  else {
3460  Float::replace_if_smaller(bottom, points[0].y);
3461  Float::replace_if_larger(top, points[1].y);
3462  }
3463 
3464  points += 2;
3465  count -= 2;
3466  }
3467 
3468  if (count > 0)
3469  Merge(*points);
3470  }
3471 
3472  HPS_INLINE void Merge(Point2D const & point) {
3473  Float::replace_if_smaller(left, point.x);
3474  Float::replace_if_smaller(bottom, point.y);
3475  Float::replace_if_larger(right, point.x);
3476  Float::replace_if_larger(top, point.y);
3477  }
3478 
3479  bool operator==(Rectangle const & rect) const {
3480  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3481  }
3482 
3483  bool operator!=(Rectangle const & rect) const {
3484  return !(*this == rect);
3485  }
3486 
3487  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3488  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3489  }
3490 
3491  HPS_INLINE bool Contains(Point const & contained) const {
3492  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3493  }
3494 
3495  HPS_INLINE bool Contains(Point2D const & contained) const {
3496  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3497  }
3498 
3499  HPS_INLINE bool Contains(Rectangle const & rect) {
3500  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3501  }
3502 
3503  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3504  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3505  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3506  }
3507 
3508  HPS_INLINE Rectangle & Expand(float border) {
3509  left -= border;
3510  right += border;
3511  bottom -= border;
3512  top += border;
3513  return *this;
3514  }
3515 
3516  HPS_INLINE Rectangle & Expand(int border) {
3517  Expand((float)border);
3518  return *this;
3519  }
3520 
3521  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3522  left -= rect.left;
3523  right += rect.right;
3524  bottom -= rect.bottom;
3525  top += rect.top;
3526  return *this;
3527  }
3528 
3529  HPS_INLINE Rectangle & Contract(int border) {
3530  left += border;
3531  right -= border;
3532  bottom += border;
3533  top -= border;
3534  return *this;
3535  }
3536 
3537  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3538  left += rect.left;
3539  right -= rect.right;
3540  bottom += rect.bottom;
3541  top -= rect.top;
3542  return *this;
3543  }
3544 
3545  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3546  left = Max(left, rect.left);
3547  right = Min(right, rect.right);
3548  bottom = Max(bottom, rect.bottom);
3549  top = Min(top, rect.top);
3550  return *this;
3551  }
3552 
3553  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3554  left = Min(left, rect.left);
3555  right = Max(right, rect.right);
3556  bottom = Min(bottom, rect.bottom);
3557  top = Max(top, rect.top);
3558  return *this;
3559  }
3560 
3561  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3562  float scale = (scope.right - scope.left) * 0.5f;
3563  float trans = (scope.right + scope.left) * 0.5f;
3564 
3565  left = left * scale + trans;
3566  right = right * scale + trans;
3567 
3568  scale = (scope.top - scope.bottom) * 0.5f;
3569  trans = (scope.top + scope.bottom) * 0.5f;
3570 
3571  bottom = bottom * scale + trans;
3572  top = top * scale + trans;
3573  return *this;
3574  }
3575 
3576  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3577  float tmp = 2.0f/(scope.right - scope.left);
3578  right = (right - scope.left) * tmp - 1.0f;
3579  left = (left - scope.left) * tmp - 1.0f;
3580 
3581  tmp = 2.0f/(scope.top - scope.bottom);
3582  top = (top - scope.bottom) * tmp - 1.0f;
3583  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3584  return *this;
3585  }
3586 
3587  static HPS_INLINE Rectangle FullScope() {
3588  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3589  }
3590 
3591  static HPS_INLINE Rectangle InvalidScope() {
3592  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3593  }
3594 
3595  static HPS_INLINE Rectangle Zero() {
3596  return Rectangle(0, 0, 0, 0);
3597  }
3598 
3599 };
3600 
3601 
3602 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3603  IntRectangle temp;
3604  temp.left = Floor (a.left);
3605  temp.right = Floor (a.right);
3606  temp.bottom = Floor (a.bottom);
3607  temp.top = Floor (a.top);
3608  return temp;
3609 }
3610 
3611 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3612  Rectangle temp = a;
3613  return temp.Expand(border);
3614 }
3615 
3616 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3617  Rectangle temp = a;
3618  return temp.Expand(border);
3619 }
3620 
3621 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3622  Rectangle temp = a;
3623  return temp.Contract(border);
3624 }
3625 
3626 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3627  Rectangle temp = a;
3628  return temp.Contract(border);
3629 }
3630 
3631 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3632  Rectangle temp = a;
3633  return temp.Intersect(b);
3634 }
3635 
3636 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3637  Rectangle temp = a;
3638  return temp.Union(b);
3639 }
3640 
3641 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3642  Rectangle temp = a;
3643  return temp.Inscribe_Scope(scope);
3644 }
3645 
3646 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3647  Rectangle temp = a;
3648  return temp.Circumscribe_Scope(scope);
3649 }
3650 
3651 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3652  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3653 
3654 
3655 
3656 
3657 template <typename F>
3658 struct Sphere_3D;
3659 
3660 template <typename F>
3661 struct HPS_TEMPLATE_API Cuboid_3D {
3666 
3667 
3671  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3672 
3673  template <typename D>
3674 
3679  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3680 
3681 
3686  Cuboid_3D (Sphere_3D<F> const & that);
3687 
3693  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3694 
3700  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3701  if (count == 0) {
3702  min = Limit_Point();
3703  max = -Limit_Point();
3704  return;
3705  }
3706  min = max = *points++;
3707  --count;
3708  if (count>0)
3709  Merge(count, points);
3710  }
3711 
3716  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3717 
3721  HPS_INLINE bool IsValid() const {
3722  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3723  }
3724 
3728  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3729 
3733  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3734 
3739  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3740 
3745  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3746 
3751  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3752  points[0] = Point_3D<F> (min.x, min.y, min.z);
3753  points[1] = Point_3D<F> (min.x, min.y, max.z);
3754  points[2] = Point_3D<F> (min.x, max.y, min.z);
3755  points[3] = Point_3D<F> (min.x, max.y, max.z);
3756  points[4] = Point_3D<F> (max.x, min.y, min.z);
3757  points[5] = Point_3D<F> (max.x, min.y, max.z);
3758  points[6] = Point_3D<F> (max.x, max.y, min.z);
3759  points[7] = Point_3D<F> (max.x, max.y, max.z);
3760  }
3761 
3765  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3766 
3770  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3771 
3777  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3778  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3779  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3780  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3781  }
3782 
3788  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3789  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3790  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3791  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3792  }
3793 
3800  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3801  //ASSERT (0 <= dimension && dimension <= 2);
3802  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3803  }
3804 
3812  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3813  //ASSERT (0 <= dimension && dimension <= 2);
3814  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3815  }
3816 
3823  bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const;
3824 
3830  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3831  Float::replace_if_smaller(min.x, cuboid.min.x);
3832  Float::replace_if_smaller(min.y, cuboid.min.y);
3833  Float::replace_if_smaller(min.z, cuboid.min.z);
3834  Float::replace_if_larger(max.x, cuboid.max.x);
3835  Float::replace_if_larger(max.y, cuboid.max.y);
3836  Float::replace_if_larger(max.z, cuboid.max.z);
3837  }
3838 
3844  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
3845 
3851  HPS_INLINE void Merge(Point_3D<F> const & point) {
3852  Float::replace_if_smaller(min.x, point.x);
3853  Float::replace_if_smaller(min.y, point.y);
3854  Float::replace_if_smaller(min.z, point.z);
3855  Float::replace_if_larger(max.x, point.x);
3856  Float::replace_if_larger(max.y, point.y);
3857  Float::replace_if_larger(max.z, point.z);
3858  }
3859 
3866  void Merge(size_t count, Point_3D<F> const * points) {
3867  while (count > 1) {
3868  if (Compare(points[0].x, points[1].x)>0) {
3869  Float::replace_if_smaller(min.x, points[1].x);
3870  Float::replace_if_larger(max.x, points[0].x);
3871  }
3872  else {
3873  Float::replace_if_smaller(min.x, points[0].x);
3874  Float::replace_if_larger(max.x, points[1].x);
3875  }
3876 
3877  if (Compare(points[0].y, points[1].y)>0) {
3878  Float::replace_if_smaller(min.y, points[1].y);
3879  Float::replace_if_larger(max.y, points[0].y);
3880  }
3881  else {
3882  Float::replace_if_smaller(min.y, points[0].y);
3883  Float::replace_if_larger(max.y, points[1].y);
3884  }
3885 
3886  if (Compare(points[0].z, points[1].z)>0) {
3887  Float::replace_if_smaller(min.z, points[1].z);
3888  Float::replace_if_larger(max.z, points[0].z);
3889  }
3890  else {
3891  Float::replace_if_smaller(min.z, points[0].z);
3892  Float::replace_if_larger(max.z, points[1].z);
3893  }
3894 
3895  points += 2;
3896  count -= 2;
3897  }
3898 
3899  if (count > 0)
3900  Merge(*points);
3901  }
3902 
3908  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
3909  return (contained.min.x >= min.x &&
3910  contained.min.y >= min.y &&
3911  contained.min.z >= min.z &&
3912  contained.max.x <= max.x &&
3913  contained.max.y <= max.y &&
3914  contained.max.z <= max.z);
3915  }
3916 
3922  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
3923  return (contained.x >= min.x &&
3924  contained.y >= min.y &&
3925  contained.z >= min.z &&
3926  contained.x <= max.x &&
3927  contained.y <= max.y &&
3928  contained.z <= max.z);
3929  }
3930 
3937  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
3938  return (contained.x >= min.x - epsilon &&
3939  contained.y >= min.y - epsilon &&
3940  contained.z >= min.z - epsilon &&
3941  contained.x <= max.x + epsilon &&
3942  contained.y <= max.y + epsilon &&
3943  contained.z <= max.z + epsilon);
3944  }
3945 
3951  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
3952  Float::replace_if_larger(min.x, cuboid.min.x);
3953  Float::replace_if_larger(min.y, cuboid.min.y);
3954  Float::replace_if_larger(min.z, cuboid.min.z);
3955  Float::replace_if_smaller(max.x, cuboid.max.x);
3956  Float::replace_if_smaller(max.y, cuboid.max.y);
3957  Float::replace_if_smaller(max.z, cuboid.max.z);
3958  return *this;
3959  }
3960 
3966  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
3967  Float::replace_if_smaller(min.x, cuboid.min.x);
3968  Float::replace_if_smaller(min.y, cuboid.min.y);
3969  Float::replace_if_smaller(min.z, cuboid.min.z);
3970  Float::replace_if_larger(max.x, cuboid.max.x);
3971  Float::replace_if_larger(max.y, cuboid.max.y);
3972  Float::replace_if_larger(max.z, cuboid.max.z);
3973  return *this;
3974  }
3975 
3981  HPS_INLINE Cuboid_3D & Expand(F border) {
3982  Vector_3D<F> delta (border, border, border);
3983  min -= delta;
3984  max += delta;
3985  return *this;
3986  }
3987 
3993  HPS_INLINE Cuboid_3D & Contract(F border) {
3994  Vector_3D<F> delta (border, border, border);
3995  min += delta;
3996  max -= delta;
3997  return *this;
3998  }
3999 
4000  private:
4001  HPS_INLINE static Point_3D<F> Limit_Point () {
4002  F const limit = std::numeric_limits<F>::max();
4003  return Point_3D<F> (limit, limit, limit);
4004  }
4005 };
4006 
4007 typedef Cuboid_3D<float> SimpleCuboid;
4008 typedef Cuboid_3D<double> DSimpleCuboid;
4009 
4010 
4011 template <typename F>
4012 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4013  Cuboid_3D<F> temp = a;
4014  return temp.Intersect(b);
4015 }
4016 
4017 template <typename F>
4018 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4019  Cuboid_3D<F> temp = a;
4020  return temp.Union(b);
4021 }
4022 
4023 template <typename F>
4024 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4025  Cuboid_3D<F> temp = a;
4026  return temp.Expand(border);
4027 }
4028 
4029 template <typename F>
4030 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4031  Cuboid_3D<F> temp = a;
4032  return temp.Contract(border);
4033 }
4034 
4035 
4036 
4037 template <typename F>
4038 struct HPS_TEMPLATE_API Sphere_3D {
4039  Point_3D<F> center;
4040  F radius;
4041 
4042  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4043 
4044  template <typename D>
4045  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4046 
4047  Sphere_3D (Cuboid_3D<F> const & cuboid) :
4048  center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4049 
4050  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4051 
4052  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4053  Cuboid_3D<F> cuboid(count, points);
4054  center = Midpoint(cuboid.min, cuboid.max);
4055  Engulf (count, points);
4056  }
4057 
4058  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4059  Engulf (count, points);
4060  }
4061 
4062  HPS_INLINE bool IsValid() const {
4063  return radius >= 0;
4064  }
4065 
4066  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4067 
4068  void Invalidate() {radius = -1;}
4069 
4070  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4071  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4072 
4073  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4074 
4075  HPS_INLINE void Merge(Point_3D<F> const & point) {
4076  Vector_3D<F> dir = point - center;
4077  F distance = (F)dir.Length();
4078 
4079  if (distance > radius) {
4080  F t = F(0.5) * (distance - radius);
4081  center += t * dir.Normalize();
4082  radius += t;
4083  }
4084  }
4085 
4086  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4087 
4088  for (size_t i = 0; i < count; ++i) {
4089  Vector_3D<F> dir = *points - center;
4090  F distance = (F)dir.Length();
4091 
4092  if (distance > radius) {
4093  F t = F(0.5) * (distance - radius);
4094  center += t * dir.Normalize();
4095  radius += t;
4096  }
4097 
4098  ++points;
4099  }
4100  }
4101 
4102  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4103  Vector_3D<F> dir = sphere.center - center;
4104  F distance = (F)dir.Length();
4105 
4106  if (distance + sphere.radius > radius) {
4107  if (distance + radius > sphere.radius) {
4108  F t = F(0.5 * (sphere.radius + distance - radius));
4109  center += t * dir.Normalize();
4110  radius += t;
4111  }
4112  else {
4113  center = sphere.center;
4114  radius = sphere.radius;
4115  }
4116  }
4117  }
4118 
4119  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4120 
4121 private:
4122  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4123  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4124  for (size_t i = 0; i < count; ++i) {
4125  double dsq = (*points++ - center).LengthSquared();
4126  if ((F)dsq > radius * radius)
4127  radius = (F)sqrt(dsq);
4128  }
4129  }
4130 };
4131 
4132 typedef Sphere_3D<float> SimpleSphere;
4133 typedef Sphere_3D<double> DSimpleSphere;
4134 
4135 
4136 template <typename F>
4137 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4138  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4139  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4140 }
4141 
4142 
4143 
4144 
4145 class RGB24Color;
4146 class RGBA32Color;
4147 class RGBAS32Color;
4148 class RGBAColor;
4149 
4150 class HPS_API RGBColor {
4151 public:
4152  float red;
4153  float green;
4154  float blue;
4155 
4156  HPS_INLINE RGBColor () {}
4157  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4158  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4159  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4160  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4161  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4162  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4163 
4164  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4165  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4166  float Distance(RGBColor const & other_color) const;
4167  HPS_INLINE bool IsValid() const {
4168  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4169  }
4170 
4171  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4172  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4173 
4174  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4175  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4176 
4177  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4178  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4179  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4180  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4181  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4182  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4183 
4184  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4185  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4186  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4187  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4188  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4189  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4190  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4191  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4192 
4193  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4194  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4195  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4196 
4197  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4198  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4199  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4200 
4201  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4202  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4203  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4204 };
4205 
4206 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4207 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4208 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4209 
4210 
4211 class HPS_API RGBAColor {
4212 public:
4213 
4214  float red;
4215  float green;
4216  float blue;
4217  float alpha;
4219  HPS_INLINE RGBAColor () {}
4220  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4221  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4222 
4223  HPS_INLINE RGBAColor (RGBColor const & c) {
4224  memcpy(this, &c, sizeof(RGBColor)); //-V512
4225  alpha = 1.0f;
4226  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4227  }
4228  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4229  memcpy(this, &c, sizeof(RGBColor));
4230  memcpy(&alpha, &a, sizeof(float));
4231  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4232  }
4233  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4234  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4235 
4236  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4237  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4238  HPS_INLINE bool IsValid() const {
4239  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4240  }
4241 
4248  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4249 
4256  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4257 
4258  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4259  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4260  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4261  }
4262 
4263  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4264  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4265  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4266  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4267  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4268  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4269 
4270  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4271  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4272  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4273  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4274  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4275  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4276  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4277  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4278 
4279  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4280  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4281  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4282  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4283  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4284  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4285 
4286  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4287  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4288  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4289  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4290 };
4291 
4292 
4293 
4295 public:
4296  enum Order {
4297  Order_ABGR,
4298  Order_RGBA,
4299  Order_BGRA
4300  };
4301 
4302 #ifdef _MSC_VER
4303  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4304  unsigned char b, g, r, a;
4305 #endif
4306 
4307 #ifdef __linux__
4308  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4309  unsigned char r, g, b, a;
4310 #endif
4311 
4312 #ifdef __APPLE_CC__
4313  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4314  unsigned char r, g, b, a;
4315 #endif
4316 };
4317 
4318 
4319 
4321 public:
4322 
4323  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4324  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4325  r = gray;
4326  g = gray;
4327  b = gray;
4328  a = aa;
4329  }
4330  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4331  r = rr;
4332  g = gg;
4333  b = bb;
4334  a = aa;
4335  }
4336  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4337 
4338  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4339  {
4340  r = Float::unit_to_byte(c.red);
4341  g = Float::unit_to_byte(c.green);
4342  b = Float::unit_to_byte(c.blue);
4343  a = 255;
4344  }
4345 
4346  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4347 
4348  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4349 
4350  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4351  {
4352  r = Float::unit_to_byte(c.red);
4353  g = Float::unit_to_byte(c.green);
4354  b = Float::unit_to_byte(c.blue);
4355  a = Float::unit_to_byte(alpha);
4356  }
4357  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4358  {
4359  r = Float::unit_to_byte(c.red);
4360  g = Float::unit_to_byte(c.green);
4361  b = Float::unit_to_byte(c.blue);
4362  a = aa;
4363  }
4364  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4365  {
4366  r = Float::unit_to_byte(c.red);
4367  g = Float::unit_to_byte(c.green);
4368  b = Float::unit_to_byte(c.blue);
4369  a = Float::unit_to_byte(c.alpha);
4370  }
4371  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4372  {
4373  r = Float::unit_to_byte(c.red);
4374  g = Float::unit_to_byte(c.green);
4375  b = Float::unit_to_byte(c.blue);
4376  a = Float::unit_to_byte_scaled(c.alpha, mix);
4377  }
4378 
4379  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4380  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4381  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4382 
4383  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4384  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4385 
4386  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4387  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4388  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4389 
4390  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4391 };
4392 
4394 public:
4395  unsigned char r;
4396  unsigned char g;
4397  unsigned char b;
4398  unsigned char a;
4399 
4400  HPS_INLINE RGBA32Color () {}
4401  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4402  : r (gray), g (gray), b (gray), a (aa) {}
4403  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4404  : r (rr), g (gg), b (bb), a (aa) {}
4405  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4406  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4407  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4408  r = Float::unit_to_byte(c.red);
4409  g = Float::unit_to_byte(c.green);
4410  b = Float::unit_to_byte(c.blue);
4411  a = 255;
4412  }
4413  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4414  r = Float::unit_to_byte(c.red);
4415  g = Float::unit_to_byte(c.green);
4416  b = Float::unit_to_byte(c.blue);
4417  a = Float::unit_to_byte(alpha);
4418  }
4419  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4420  r = Float::unit_to_byte(c.red);
4421  g = Float::unit_to_byte(c.green);
4422  b = Float::unit_to_byte(c.blue);
4423  a = aa;
4424  }
4425  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4426  r = Float::unit_to_byte(c.red);
4427  g = Float::unit_to_byte(c.green);
4428  b = Float::unit_to_byte(c.blue);
4429  a = Float::unit_to_byte(c.alpha);
4430  }
4431  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4432  r = Float::unit_to_byte(c.red);
4433  g = Float::unit_to_byte(c.green);
4434  b = Float::unit_to_byte(c.blue);
4435  a = Float::unit_to_byte_scaled(c.alpha, mix);
4436  }
4437 
4438  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4439  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4440 
4441  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4442  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4443 
4444  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4445  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4446 
4447  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4448 };
4449 
4450 
4452 {
4453 public:
4454  unsigned char r;
4455  unsigned char g;
4456  unsigned char b;
4457 
4458  HPS_INLINE RGB24Color () {}
4459  explicit HPS_INLINE RGB24Color (unsigned char gray)
4460  : r (gray), g (gray), b (gray) {}
4461  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4462  : r (rr), g (gg), b (bb) {}
4463  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4464  r = Float::unit_to_byte(c.red);
4465  g = Float::unit_to_byte(c.green);
4466  b = Float::unit_to_byte(c.blue);
4467  }
4468 
4469  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4470  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4471 
4472  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4473  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4474 };
4475 
4476 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4477  red = Float::C2F(c32.r);
4478  green = Float::C2F(c32.g);
4479  blue = Float::C2F(c32.b);
4480 }
4481 
4482 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4483  red = Float::C2F(c32.r);
4484  green = Float::C2F(c32.g);
4485  blue = Float::C2F(c32.b);
4486 }
4487 
4488 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4489  red = c.red;
4490  green = c.green;
4491  blue = c.blue;
4492 }
4493 
4494 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4495  red = Float::C2F(c24.r);
4496  green = Float::C2F(c24.g);
4497  blue = Float::C2F(c24.b);
4498 }
4499 
4500 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4501 {
4502  r = c.r;
4503  g = c.g;
4504  b = c.b;
4505  a = 255;
4506 }
4507 
4508 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4509 {
4510  r = c.r;
4511  g = c.g;
4512  b = c.b;
4513  a = c.a;
4514 }
4515 
4516 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4517  red = Float::C2F(c32.r);
4518  green = Float::C2F(c32.g);
4519  blue = Float::C2F(c32.b);
4520  alpha = Float::C2F(c32.a);
4521 }
4522 
4523 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4524  red = Float::C2F(c32.r);
4525  green = Float::C2F(c32.g);
4526  blue = Float::C2F(c32.b);
4527  alpha = Float::C2F(c32.a);
4528 }
4529 
4530 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4531  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4532 }
4533 
4534 
4535 
4536 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4537  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4538 }
4539 
4540 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4541  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);
4542 }
4543 
4544 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4545  return RGBAS32Color(
4546  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4547  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4548  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4549  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4550 }
4551 
4552 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4553  return RGBA32Color(
4554  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4555  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4556  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4557  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4558 }
4559 
4560 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4561  return RGB24Color(
4562  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4563  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4564  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4565 }
4566 
4567 
4568 
4569 class HPS_API Quaternion {
4570 public:
4571  float w;
4572  float x;
4573  float y;
4574  float z;
4575 
4576  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4577 
4578  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) { }
4579 
4580  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4581 
4582  Quaternion const & Normalize() {
4583  float mag = Norm();
4584 
4585  if (mag > 0) {
4586  w /= mag;
4587  x /= mag;
4588  y /= mag;
4589  z /= mag;
4590  }
4591  return *this;
4592  }
4593 
4594 
4595  Quaternion operator* (Quaternion const & in_right) const {
4596  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4597  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4598  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4599  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4600  }
4601 
4602  Quaternion operator* (float in_right) const {
4603  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4604  }
4605 
4606  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4607  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4608  }
4609 
4610  Quaternion operator/ (float in_right) const {
4611  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4612  }
4613 
4614  Quaternion operator- (Quaternion const & in_right) const {
4615  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4616  }
4617 
4618  Quaternion operator+ (Quaternion const & in_right) const {
4619  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4620  }
4621 
4622  inline float Norm() const {
4623  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4624  }
4625 
4626 
4627  Quaternion Log() const {
4628  Quaternion ret;
4629  float mag_q = Norm();
4630  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4631 
4632  ret.w = static_cast<float>(log(mag_q));
4633 
4634  if (mag_V > 0) {
4635  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4636 
4637  ret.x = x * scale;
4638  ret.y = y * scale;
4639  ret.z = z * scale;
4640  }
4641  else
4642  ret.x = ret.y = ret.z = 0;
4643 
4644  return ret;
4645  }
4646 
4647  Quaternion Exp() const {
4648  Quaternion ret;
4649  float ea = static_cast<float>(exp(w));
4650  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4651  float scale = ea * sin(mag_V) / mag_V;
4652 
4653  ret.w = ea * cos(mag_V);
4654  ret.x = scale * x;
4655  ret.y = scale * y;
4656  ret.z = scale * z;
4657 
4658  return ret;
4659  }
4660 
4661  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4662  Quaternion ret = *this + in_fraction * (in_right - *this);
4663  return ret.Normalize();
4664  }
4665 
4666 
4667  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4668  Quaternion q3;
4669  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4670 
4671  if (in_shortest_path_only && dot < 0) {
4672  dot = -dot;
4673  q3 = -1 * in_right;
4674  }
4675  else
4676  q3 = in_right;
4677 
4678  if (dot > -0.95f && dot < 0.95f) {
4679  float angle = static_cast<float>(acos(dot));
4680  float sina = static_cast<float>(sin(angle));
4681  float sinat = static_cast<float>(sin(angle*in_fraction));
4682  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4683 
4684  return (*this * sinaomt + q3 * sinat) / sina;
4685  }
4686  else //if the angle is small, we use linear interpolation
4687  return Lerp(q3, in_fraction);
4688  }
4689 
4690 
4691  /*
4692  Spherical cubic interpolation between two Quaternions
4693  \param in_right The Quaternion for interpolation.
4694  \param in_control1 The first control point.
4695  \param in_control2 The second control point.
4696  \param in_fraction Interpolation distance (0 - 1).
4697  \return Result of interpolation.
4698  */
4699  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4700  Quaternion q1 = Slerp(in_right , in_fraction, false);
4701  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4702 
4703  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4704  }
4705 
4712  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4713  Quaternion qni(-x, -y, -z, w);
4714 
4715  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4716  }
4717 
4718 };
4719 
4720 typedef unsigned char byte;
4721 typedef signed char sbyte;
4722 typedef intptr_t WindowHandle;
4723 typedef double Time;
4724 typedef int64_t TouchID;
4725 typedef intptr_t PlatformData;
4726 
4727 /*
4728 HPS Lexicon:
4729 
4730 Concept Class -- A class that contains only enums and possibly static functions. The
4731  constructor is usually private because they are not intended to be instantiated.
4732 
4733 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4734  database objects is subject to locking to prevent threading deadlocks. (2) The class
4735  of the same name, offering static functions to initiate operations that take place
4736  within the database.
4737 
4738 Key -- A reference counted smart pointer to an object in the database. The
4739 
4740 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4741  option group, or other type. Modifying a kit has no effect on the database unless
4742  and until it is applied. Kits should generally be passed by reference because they
4743  are potentially very large and copying them can be arduous.
4744 
4745 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4746  pointers should generally be passed by value to ensure the reference count is
4747  correct.
4748 
4749 User Space -- The external space occupied by all user code. User space objects are not
4750  in the database and are not subject to locking.
4751 
4752 */
4753 
4757 class SegmentKey;
4758 class AttributesControl;
4759 class LineKit;
4760 class LineKey;
4761 class TextKey;
4762 class TextKit;
4763 class Key;
4764 class VisibilityControl;
4765 class CameraControl;
4766 class SelectabilityControl;
4767 class TransparencyKit;
4768 class TransparencyControl;
4769 class CullingKit;
4770 class CullingControl;
4771 class GlyphKit;
4772 class MarkerAttributeControl;
4773 class GlyphDefinition;
4774 class GeometryInsertControl;
4775 class GlyphElement;
4776 class TextAttributeControl;
4777 class TextAttributeKit;
4778 class LineAttributeKit;
4779 class LineAttributeControl;
4780 class EdgeAttributeKit;
4781 class EdgeAttributeControl;
4782 class CurveAttributeKit;
4783 class CurveAttributeControl;
4784 class GlyphPoint;
4785 class MatrixKit;
4786 class ModellingMatrixControl;
4787 class TextureMatrixControl;
4788 class TextureDefinition;
4789 class MaterialMappingKit;
4790 class MaterialMappingControl;
4791 class MaterialKit;
4792 class MarkerKit;
4793 class MarkerKey;
4794 class DistantLightKit;
4795 class DistantLightKey;
4796 class CuttingSectionKit;
4797 class CuttingSectionKey;
4798 class CuttingSectionAttributeKit;
4799 class CuttingSectionAttributeControl;
4800 class CylinderAttributeKit;
4801 class CylinderAttributeControl;
4802 class Cylinder;
4803 class CylinderKey;
4804 class CylinderKit;
4805 class SphereKey;
4806 class SphereKit;
4807 class SphereAttributeKit;
4808 class SphereAttributeControl;
4809 class PolygonKit;
4810 class PolygonKey;
4811 class CircleKey;
4812 class CircleKit;
4813 class CircularArcKey;
4814 class CircularArcKit;
4815 class CircularWedgeKey;
4816 class CircularWedgeKit;
4817 class IncludeKey;
4818 class InfiniteLineKey;
4819 class InfiniteLineKit;
4820 class SpotlightKey;
4821 class SpotlightKit;
4822 class NURBSCurveKey;
4823 class NURBSCurveKit;
4824 class NURBSSurfaceKey;
4825 class NURBSSurfaceKit;
4826 class TrimKit;
4827 class TrimElement;
4828 class EllipseKey;
4829 class EllipseKit;
4830 class EllipticalArcKey;
4831 class EllipticalArcKit;
4832 class ShellKit;
4833 class ShellKey;
4834 class Shell;
4835 class MeshKit;
4836 class MeshKey;
4837 class WindowKey;
4838 class Database;
4839 class NURBSSurfaceAttributeKit;
4840 class NURBSSurfaceAttributeControl;
4841 class Driver;
4842 class Search;
4843 class PerformanceKit;
4844 class PerformanceControl;
4845 class HiddenLineAttributeKit;
4846 class HiddenLineAttributeControl;
4847 class DrawingAttributeKit;
4848 class DrawingAttributeControl;
4849 class PortfolioKey;
4850 class Selection;
4851 class SelectionOptionsKit;
4852 class SelectionResults;
4853 class SelectionItem;
4854 class SelectionControl;
4855 class HighlightControl;
4856 class HighlightOptionsKit;
4857 class ImageDefinition;
4858 class ImageKit;
4859 class TextureDefinition;
4860 class TextureOptionsKit;
4861 class NamedStyleDefinition;
4862 class MaterialPaletteDefinition;
4863 class GlyphDefinition;
4864 class LinePatternOptionsKit;
4865 class LinePatternDefinition;
4866 class LinePatternKit;
4867 class LinePatternElement;
4868 class LinePatternParallelKit;
4869 class CubeMapDefinition;
4870 class ShaderKit;
4871 class ShaderDefinition;
4872 class EmergencyHandler;
4873 class EventDispatcher;
4874 class EventHandler;
4875 class Event;
4876 class StandAloneWindowKey;
4877 class StandAloneWindowOptionsKit;
4878 class ApplicationWindowKey;
4879 class ApplicationWindowOptionsKit;
4880 class OffScreenWindowKey;
4881 class OffScreenWindowOptionsKit;
4882 class LightingAttributeControl;
4883 class VisualEffectsControl;
4884 class PostProcessEffectsControl;
4885 class SelectionOptionsControl;
4886 class ObjectPoint;
4887 class WorldPoint;
4888 class CameraPoint;
4889 class NormalizedPoint;
4890 class ScreenRangePoint;
4891 class InnerWindowPoint;
4892 class InnerPixelPoint;
4893 class WindowPoint;
4894 class PixelPoint;
4895 class VisibilityKit;
4896 class CameraKit;
4897 class SelectabilityKit;
4898 class MarkerAttributeKit;
4899 class LightingAttributeKit;
4900 class VisualEffectsKit;
4901 class PostProcessEffectsKit;
4902 class Portfolio;
4903 class SubwindowControl;
4904 class SubwindowKit;
4905 class World;
4906 class DebuggingControl;
4907 class DebuggingKit;
4908 class KeyPath;
4909 class ContourLineKit;
4910 class ContourLineControl;
4911 class UTF8;
4912 class StyleControl;
4913 class PortfolioControl;
4914 class Condition;
4915 class ConditionControl;
4916 class WindowInfoKit;
4917 class WindowInfoControl;
4918 class FontInfoState;
4919 class FontInfoControl;
4920 class SearchOptionsKit;
4921 class AttributeLockControl;
4922 class AttributeLockKit;
4923 class ReferenceKey;
4924 class StyleKey;
4925 class BoundingKit;
4926 class BoundingControl;
4927 class TransformMaskKit;
4928 class TransformMaskControl;
4929 class ColorInterpolationKit;
4930 class ColorInterpolationControl;
4931 class UpdateOptionsKit;
4932 class UpdateOptionsControl;
4933 class GeometryKey;
4934 class TreeContext;
4935 class ShellRelationOptionsKit;
4936 class ShellRelationResultsKit;
4937 class GridKit;
4938 class GridKey;
4939 class CutGeometryGatheringOptionsKit;
4940 
4944 
4945 
4948 class HPS_API GlyphPoint
4949 {
4950 public:
4951 
4953  GlyphPoint();
4954 
4959  GlyphPoint(sbyte in_x, sbyte in_y);
4960 
4965  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
4966 
4971  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
4972 
4977  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
4978 
4979  sbyte x;
4980  sbyte y;
4981 };
4982 
4985 enum class Type : uint32_t
4986 {
4987  None = 0x00000000,
4988  GenericMask = 0xffffff00,
4989 
4990  World = 0x00000001,
4991  UTF8 = 0x00000002,
4992  EventDispatcher = 0x00000003,
4993  EventHandler = 0x00000004,
4994  EventNotifier = 0x00000005,
4995  UpdateNotifier = 0x00000006,
4996  SearchResults = 0x00000008,
4997  FontSearchResults = 0x00000009,
4998  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
4999  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5000  SelectionResults = 0x0000000c,
5001  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5002  SelectionItem = 0x0000000e,
5003  TreeContext = 0x0000000f,
5004 
5005  IONotifier = 0x04000100,
5006  StreamImportNotifier = 0x04000101,
5007  STLImportNotifier = 0x04000102,
5008  OBJImportNotifier = 0x04000103,
5009  ExchangeImportNotifier = 0x04000104,
5010  SketchupImportNotifier = 0x04000105,
5011  ParasolidImportNotifier = 0x04000106,
5012  ExchangeTranslationNotifier = 0x04000107,
5013 
5014  Kit = 0x01000000,
5015  MarkerKit = 0x01000010,
5016  SphereAttributeKit = 0x01000011,
5017  TextAttributeKit = 0x01000012,
5018  TransparencyKit = 0x01000013,
5019  VisibilityKit = 0x01000014,
5020  VisualEffectsKit = 0x01000015,
5021  CuttingSectionAttributeKit = 0x01000016,
5022  CircleKit = 0x01000017,
5023  CircularArcKit = 0x01000018,
5024  CircularWedgeKit = 0x01000019,
5025  CuttingSectionKit = 0x0100001a,
5026  CylinderKit = 0x0100001b,
5027  DistantLightKit = 0x0100001c,
5028  EllipseKit = 0x0100001d,
5029  EllipticalArcKit = 0x0100001e,
5030  InfiniteLineKit = 0x0100001f,
5031  LineKit = 0x01000020,
5032  NURBSCurveKit = 0x01000021,
5033  MeshKit = 0x01000022,
5034  NURBSSurfaceKit = 0x01000023,
5035  PolygonKit = 0x01000024,
5036  SphereKit = 0x01000025,
5037  SpotlightKit = 0x01000026,
5038  ShellKit = 0x01000027,
5039  TextKit = 0x01000028,
5040  MaterialKit = 0x01000029,
5041  TrimKit = 0x0100002a,
5042  TextureOptionsKit = 0x0100002c,
5043  LinePatternKit = 0x0100002d,
5044  GlyphKit = 0x0100002e,
5045  ImageKit = 0x0100002f,
5046  LinePatternOptionsKit = 0x01000030,
5047  CameraKit = 0x01000031,
5048  BoundingKit = 0x01000032,
5049  CullingKit = 0x01000033,
5050  CurveAttributeKit = 0x01000034,
5051  CylinderAttributeKit = 0x01000035,
5052  EdgeAttributeKit = 0x01000036,
5053  LightingAttributeKit = 0x01000037,
5054  LineAttributeKit = 0x01000038,
5055  MarkerAttributeKit = 0x01000039,
5056  MaterialMappingKit = 0x0100003a,
5057  MatrixKit = 0x0100003b,
5058  NURBSSurfaceAttributeKit = 0x0100003c,
5059  PostProcessEffectsKit = 0x0100003d,
5060  SelectabilityKit = 0x0100003e,
5061  SelectionOptionsKit = 0x0100003f,
5062  StandAloneWindowOptionsKit = 0x01000040,
5063  OffScreenWindowOptionsKit = 0x01000041,
5064  ApplicationWindowOptionsKit = 0x01000042,
5065  HighlightOptionsKit = 0x01000043,
5066  LinePatternParallelKit = 0x01000044,
5067  SubwindowKit = 0x01000045,
5068  PerformanceKit = 0x01000046,
5069  HiddenLineAttributeKit = 0x01000047,
5070  DrawingAttributeKit = 0x01000048,
5071  ShaderKit = 0x01000049,
5072  DebuggingKit = 0x0100004a,
5073  ContourLineKit = 0x0100004b,
5074  StreamImportOptionsKit = 0x0100004c,
5075  StreamImportResultsKit = 0x0100004d,
5076  StreamExportOptionsKit = 0x0100004e,
5077  StreamExportResultsKit = 0x0100004f,
5078  WindowInfoKit = 0x01000050,
5079  ImageImportOptionsKit = 0x01000051,
5080  SearchOptionsKit = 0x01000052,
5081  ShaderImportOptionsKit = 0x01000053,
5082  HardcopyExportOptionsKit = 0x01000055,
5083  AttributeLockKit = 0x01000056,
5084  TransformMaskKit = 0x01000057,
5085  ColorInterpolationKit = 0x01000058,
5086  UpdateOptionsKit = 0x01000059,
5087  ImageExportOptionsKit = 0x0100005a,
5088  OBJImportOptionsKit = 0x0100005b,
5089  OBJImportResultsKit = 0x0100005c,
5090  STLImportOptionsKit = 0x0100005d,
5091  STLImportResultsKit = 0x0100005e,
5092  ShellOptimizationOptionsKit = 0x0100005f,
5093  ShellRelationOptionsKit = 0x01000060,
5094  ShellRelationResultsKit = 0x01000061,
5095  GridKit = 0x01000062,
5096  CutGeometryGatheringOptionsKit = 0x01000063,
5097 
5098 
5099  LinePatternElement = 0x03000000,
5100  SolidLinePatternElement = 0x03000001,
5101  BlankLinePatternElement = 0x03000002,
5102  GlyphLinePatternElement = 0x03000003,
5103 
5104  GlyphElement = 0x05000000,
5105  DotGlyphElement = 0x05000001,
5106  LineGlyphElement = 0x05000002,
5107  EllipseGlyphElement = 0x05000003,
5108  CircularArcGlyphElement = 0x05000004,
5109  InfiniteLineGlyphElement = 0x05000005,
5110 
5111  TrimElement = 0x07000000,
5112 
5113  Condition = 0x09000000,
5114  NOTCondition = 0x09000001,
5115  ANDCondition = 0x09000002,
5116  ORCondition = 0x09000003,
5117  XORCondition = 0x09000004,
5118 
5119  MouseState = 0x01001001,
5120  TouchState = 0x01001002,
5121  KeyboardState = 0x01001003,
5122  FontInfoState = 0x01001004,
5123 
5124  KeyPath = 0x01000F01,
5125 
5126  Key = 0x10000000,
5127  IncludeKey = 0x10000001,
5128  PortfolioKey = 0x10000002,
5129  StyleKey = 0x10000003,
5130 
5131  SegmentKey = 0x10200000,
5132  WindowKey = 0x10600000,
5133  StandAloneWindowKey = 0x10600001,
5134  OffScreenWindowKey = 0x10600002,
5135  ApplicationWindowKey = 0x10600003,
5136 
5137  GeometryKey = 0x10100000,
5138  ReferenceKey = 0x10100001,
5139  CircleKey = 0x10100002,
5140  CircularArcKey = 0x10100003,
5141  CircularWedgeKey = 0x10100004,
5142  CuttingSectionKey = 0x10100005,
5143  CylinderKey = 0x10100006,
5144  EllipseKey = 0x10100007,
5145  EllipticalArcKey = 0x10100008,
5146  InfiniteLineKey = 0x10100009,
5147  LineKey = 0x1010000a,
5148  DistantLightKey = 0x1010000b,
5149  SpotlightKey = 0x1010000c,
5150  MarkerKey = 0x1010000d,
5151  MeshKey = 0x1010000e,
5152  NURBSCurveKey = 0x1010000f,
5153  NURBSSurfaceKey = 0x10100010,
5154  PolygonKey = 0x10100011,
5155  ShellKey = 0x10100012,
5156  SphereKey = 0x10100013,
5157  TextKey = 0x10100014,
5158  GridKey = 0x10100015,
5159 
5160  Definition = 0x20000000,
5161  NamedStyleDefinition = 0x20000001,
5162  TextureDefinition = 0x20000002,
5163  LinePatternDefinition = 0x20000003,
5164  GlyphDefinition = 0x20000004,
5165  CubeMapDefinition = 0x20000005,
5166  ImageDefinition = 0x20000006,
5167  MaterialPaletteDefinition = 0x20000007,
5168  ShaderDefinition = 0x20000008,
5169 
5170  Control = 0x50000000,
5171  CameraControl = 0x50000001,
5172  SelectabilityControl = 0x50000002,
5173  MarkerAttributeControl = 0x50000003,
5174  SphereAttributeControl = 0x50000004,
5175  LightingAttributeControl = 0x50000005,
5176  CylinderAttributeControl = 0x50000006,
5177  TextAttributeControl = 0x50000007,
5178  LineAttributeControl = 0x50000008,
5179  EdgeAttributeControl = 0x50000009,
5180  CurveAttributeControl = 0x5000000a,
5181  ModellingMatrixControl = 0x5000000b,
5182  TextureMatrixControl = 0x5000000c,
5183  CullingControl = 0x5000000d,
5184  TransparencyControl = 0x5000000e,
5185  MaterialMappingControl = 0x5000000f,
5186  NURBSSurfaceAttributeControl = 0x50000010,
5187  PostProcessEffectsControl = 0x50000011,
5188  BoundingControl = 0x50000012,
5189  VisualEffectsControl = 0x50000013,
5190  SelectionOptionsControl = 0x50000014,
5191  HighlightOptionsControl = 0x50000015,
5192  DefinitionControl = 0x50000016,
5193  SelectionControl = 0x50000017,
5194  HighlightControl = 0x50000018,
5195  StandAloneWindowOptionsControl = 0x50000019,
5196  OffScreenWindowOptionsControl = 0x5000001a,
5197  ApplicationWindowOptionsControl = 0x5000001b,
5198  VisibilityControl = 0x5000001c,
5199  SubwindowControl = 0x5000001d,
5200  PerformanceControl = 0x5000001e,
5201  HiddenLineAttributeControl = 0x5000001f,
5202  DrawingAttributeControl = 0x50000020,
5203  DebuggingControl = 0x50000021,
5204  ContourLineControl = 0x50000022,
5205  StyleControl = 0x50000023,
5206  ConditionControl = 0x50000024,
5207  PortfolioControl = 0x50000025,
5208  WindowInfoControl = 0x50000026,
5209  AttributeLockControl = 0x50000027,
5210  TransformMaskControl = 0x50000028,
5211  ColorInterpolationControl = 0x50000029,
5212  UpdateOptionsControl = 0x50000030,
5213  CuttingSectionAttributeControl = 0x50000031,
5214 
5215  LibraryMask = 0x80FF0000,
5216 
5217  Sprocket = 0x80000000,
5218  Canvas = 0x80000001,
5219  Layout = 0x80000002,
5220  View = 0x80000003,
5221  Model = 0x80000004,
5222  Operator = 0x80000005,
5223  SprocketPath = 0x80000007,
5224 
5225  SprocketControl = 0xD0000000,
5226  OperatorControl = 0xD0000008,
5227  NavigationCubeControl = 0xD0000009,
5228  AxisTriadControl = 0xD000000A,
5229 
5230  Metadata = 0x80001000,
5231  IntegerMetadata = 0x80001001,
5232  UnsignedIntegerMetadata = 0x80001002,
5233  DoubleMetadata = 0x80001003,
5234  StringMetadata = 0x80001004,
5235  TimeMetadata = 0x80001005,
5236  BooleanMetadata = 0x80001006,
5237 
5238  Component = 0x80000200,
5239  Filter = 0x80000600,
5240  Capture = 0x80000a00,
5241  CADModel = 0x80000300,
5242  ComponentPath = 0x81001000,
5243 
5244  ExchangeMask = 0x80020000,
5245  ExchangeComponent = 0x80021200,
5246  ExchangeFilter = 0x80020601,
5247  ExchangeCapture = 0x80020a01,
5248  ExchangeCADModel = 0x80020301,
5249  ExchangeConfiguration = 0x81020001,
5250  ExchangeImportOptionsKit = 0x81020002,
5251  ExchangeExportACISOptionsKit = 0x81020003,
5252  ExchangeExportIGESOptionsKit = 0x81020004,
5253  ExchangeExportJTOptionsKit = 0x81020005,
5254  ExchangeExportParasolidOptionsKit = 0x81020006,
5255  ExchangeExportPRCOptionsKit = 0x81020007,
5256  ExchangeExportSTEPOptionsKit = 0x81020008,
5257  ExchangeExportSTLOptionsKit = 0x81020009,
5258  ExchangeExportU3DOptionsKit = 0x8102000a,
5259  ExchangeExportXMLOptionsKit = 0x8102000b,
5260  ExchangeTessellationOptionsKit = 0x8102000c,
5261  ExchangeSheet = 0x8002120d,
5262 
5263  PublishMask = 0x80040000,
5264  PublishDocumentKit = 0x81040001,
5265  PublishPageKit = 0x81040002,
5266  PublishTemplateKit = 0x81040003,
5267  PublishAnnotationKit = 0x81040004,
5268  PublishArtworkKit = 0x81040005,
5269  PublishViewKit = 0x81040006,
5270  PublishTextKit = 0x81040007,
5271  PublishImageKit = 0x81040008,
5272  PublishTableKit = 0x81040009,
5273  PublishExportOptionsKit = 0x8104000a,
5274  PublishLinkKit = 0x8104000b,
5275  PublishButtonKit = 0x8104000c,
5276  PublishTextFieldKit = 0x8104000d,
5277  PublishSlideTableKit = 0x8104000e,
5278  PublishCheckBoxKit = 0x8104000f,
5279  PublishRadioButtonKit = 0x81040010,
5280  PublishListBoxKit = 0x81040011,
5281  PublishDropDownListKit = 0x81040012,
5282  PublishSignatureFieldKit = 0x81040013,
5283 
5284  PublishDocumentKey = 0x80040001,
5285  PublishPageControl = 0x80040002,
5286 
5287  SceneTree = 0x80008001,
5288  SceneTreeItem = 0x80008002,
5289 
5290  ComponentTree = 0x80008003,
5291  ComponentTreeItem = 0x80008004,
5292 
5293  SketchupMask = 0x80100000,
5294  SketchupImportOptionsKit = 0x81100001,
5295  SketchupImportResultsKit = 0x81100002,
5296 
5297  ParasolidMask = 0x80200000,
5298  ParasolidComponent = 0x80201201,
5299  ParasolidCADModel = 0x80200302,
5300  ParasolidImportOptionsKit = 0x81200003,
5301  ParasolidFacetTessellationKit = 0x81200004,
5302  ParasolidLineTessellationKit = 0x81200005,
5303  ParasolidExportOptionsKit = 0x81200006,
5304 
5305  IONotifierData = 0x84000200,
5306  StreamImportNotifierData = 0x84000201,
5307  STLImportNotifierData = 0x84000202,
5308  OBJImportNotifierData = 0x84000203,
5309  ExchangeImportNotifierData = 0x84020204,
5310  SketchupImportNotifierData = 0x84100205,
5311  ParasolidImportNotifierData = 0x84200206,
5312  ExchangeTranslationNotifierData = 0x84020207,
5313 };
5314 
5316 class HPS_API Memory
5317 {
5318 public:
5324  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5325 
5326 
5331  static void Free(void * in_pointer);
5332 
5333 private:
5335  Memory();
5336 };
5337 
5338 
5340 template <typename T>
5341 class NO_HPS_API Allocator
5342 {
5343 public:
5344  typedef T value_type;
5345  typedef value_type * pointer;
5346  typedef value_type const * const_pointer;
5347  typedef value_type & reference;
5348  typedef value_type const & const_reference;
5349  typedef size_t size_type;
5350  typedef ptrdiff_t difference_type;
5351 
5352 
5353  Allocator() {}
5354  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5355  ~Allocator() {}
5356 
5357  template <typename U> Allocator(Allocator<U> const &) {}
5358 
5359  template <typename U>
5360  struct rebind
5361  {
5362  typedef Allocator<U> other;
5363  };
5364 
5365 
5366  pointer address(reference x) const { return &x; }
5367  const_pointer address(const_reference x) const { return &x; }
5368 
5369  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5370  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5371 
5372 #if defined(_MSC_VER) || defined (__APPLE__)
5373  void construct(pointer p, const_reference x) { new(p) T(x); }
5374 #else
5375  template<typename U, typename... Args>
5376  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5377 #endif
5378  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5379 
5380  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5381 };
5382 
5383 template <typename T, typename U>
5384 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5385 
5386 template <typename T, typename U>
5387 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5388 
5390 class Exception : public std::runtime_error
5391 {
5392 public:
5393  Exception(char const * in_info) : std::runtime_error(in_info) { }
5394 };
5395 
5396 
5399 {
5400 public:
5401  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5402  Exception(in_info) {}
5403 };
5404 
5405 
5409 {
5410 public:
5411  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5412  Exception(in_info) {}
5413 };
5414 
5415 
5418 {
5419 public:
5420  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5421  Exception(in_info) {}
5422 };
5423 
5424 
5427 {
5428 public:
5429  InvalidLicenseException(char const * in_info) :
5430  Exception(in_info) {}
5431 };
5432 
5433 
5436 {
5437 public:
5438  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5439  Exception(in_info) {}
5440 };
5441 
5443 class IOException : public Exception
5444 {
5445 public:
5449  IOException(char const * in_info, IOResult in_result)
5450  : Exception(in_info), result(in_result) {}
5451 
5452  IOResult result;
5453 };
5454 
5455 
5457 class HPS_API Object
5458 {
5459 public:
5460 
5461  Object();
5462 
5463  virtual ~Object();
5464 
5465  Object & operator=(Object const & other_object);
5466 
5470  Object(Object && in_that);
5471 
5472 
5476  Object & operator=(Object && in_that);
5477 
5481  Type Type() const;
5482 
5486  virtual Type ObjectType() const { return Type::None; }
5487 
5490  virtual bool Empty() const {return (impl_ == 0);};
5491 
5493  virtual void Reset();
5494 
5498  bool HasType(Type in_mask) const;
5499 
5502  intptr_t GetClassID() const;
5503 
5507  intptr_t GetInstanceID() const;
5508 
5509  template <typename T>
5510  static intptr_t ClassID()
5511  {
5512  static const intptr_t ret = T().GetClassID();
5513  return ret;
5514  }
5515 private:
5516 
5517  friend class HPSI::Impl;
5518  friend class HPSI::KeyImpl;
5519  friend class HPSI::TicketImpl;
5520 
5521  HPSI::Impl * impl_;
5522 };
5523 
5524 
5526 class HPS_API Control : public Object
5527 {
5528  Type ObjectType() const {return Type::Control;}
5529 
5530 
5531 
5532 protected:
5533  Control() {}
5534 
5538  Control(Control && in_that) : Object(std::move(in_that)) {}
5539 
5543  Control & operator=(Control && in_that)
5544  {
5545  this->Object::operator=(std::move(in_that));
5546  return *this;
5547  }
5548 };
5549 
5550 
5552 class HPS_API ObjectPoint : public Point
5553 {
5554 public:
5555 
5557  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5558 
5560  ObjectPoint(Point const & in_point):Point(in_point){}
5561 
5563  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5564 
5566  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5567 
5569  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5570 
5572  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5573 
5575  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5576 
5578  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5579 
5581  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5582 
5584  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5585 
5587  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5588 
5589 private:
5590 
5591  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5592  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5593  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5594  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5595  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5596  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5597  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5598  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5599 
5600 };
5601 
5603 class HPS_API WorldPoint : public Point
5604 {
5605 public:
5607  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5608 
5610  WorldPoint(Point const & in_point):Point(in_point){}
5611 
5613  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5614 
5616  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5617 
5619  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5620 
5622  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5623 
5625  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5626 
5628  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5629 
5631  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5632 
5634  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5635 
5637  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5638 
5639 private:
5640 
5641  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5642  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5643  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5644  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5645  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5646  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5647  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5648  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5649 
5650 };
5651 
5653 class HPS_API CameraPoint : public Point
5654 {
5655 public:
5657  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5658 
5660  CameraPoint(Point const & in_point):Point(in_point){}
5661 
5663  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5664 
5666  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5667 
5669  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5670 
5672  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5673 
5675  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5676 
5678  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5679 
5681  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5682 
5684  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5685 
5687  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5688 
5689 private:
5690  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5691  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5692  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5693  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5694  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5695  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5696  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5697  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5698 
5699 };
5700 
5702 class HPS_API NormalizedPoint : public Point
5703 {
5704 public:
5705 
5707  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5708 
5710  NormalizedPoint(Point const & in_point):Point(in_point){}
5711 
5713  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5714 
5716  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5717 
5719  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5720 
5722  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5723 
5725  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5726 
5728  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5729 
5731  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5732 
5734  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5735 
5737  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5738 
5739 private:
5740  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5741  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5742  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5743  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5744  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5745  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5746  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5747  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5748 };
5749 
5751 class HPS_API ScreenRangePoint : public Point
5752 {
5753 public:
5755  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5756 
5758  ScreenRangePoint(Point const & in_point):Point(in_point){}
5759 
5761  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5762 
5764  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5765 
5767  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5768 
5770  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5771 
5773  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5774 
5776  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5777 
5779  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5780 
5782  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5783 
5785  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5786 
5787 private:
5788  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5789  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5790  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5791  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5792  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5793  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5794  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5795  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5796 
5797 };
5798 
5800 class HPS_API InnerWindowPoint : public Point
5801 {
5802 public:
5803 
5805  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5806 
5808  InnerWindowPoint(Point const & in_point):Point(in_point){}
5809 
5811  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5812 
5814  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5815 
5817  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5818 
5820  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5821 
5823  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5824 
5826  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5827 
5829  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5830 
5832  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5833 
5835  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5836 
5837 private:
5838  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5839  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5840  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5841  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5842  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5843  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5844  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5845  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5846 };
5847 
5849 class HPS_API InnerPixelPoint : public Point
5850 {
5851 public:
5852 
5854  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5855 
5857  InnerPixelPoint(Point const & in_point):Point(in_point){}
5858 
5860  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5861 
5863  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5864 
5866  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5867 
5869  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5870 
5872  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5873 
5875  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5876 
5878  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5879 
5881  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5882 
5884  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
5885 
5886 private:
5887  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5888  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5889  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5890  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5891  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5892  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5893  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5894  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5895 
5896 };
5897 
5899 class HPS_API WindowPoint : public Point
5900 {
5901 public:
5902 
5904  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5905 
5907  WindowPoint(Point const & in_point):Point(in_point){}
5908 
5910  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5911 
5913  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5914 
5916  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5917 
5919  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5920 
5922  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5923 
5925  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5926 
5928  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5929 
5931  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5932 
5934  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5935 
5936 private:
5937  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5938  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5939  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5940  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5941  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5942  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5943  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5944  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5945 };
5946 
5947 
5949 class HPS_API PixelPoint : public Point
5950 {
5951 public:
5953  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5954 
5956  PixelPoint(Point const & in_point):Point(in_point){}
5957 
5959  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5960 
5962  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5963 
5965  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5966 
5968  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5969 
5971  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5972 
5974  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5975 
5977  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5978 
5980  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5981 
5983  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
5984 
5985 private:
5986  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5987  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5988  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5989  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5990  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5991  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5992  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5993  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5994 
5995 };
5996 
5999 class HPS_API Event
6000 {
6001 public:
6005  enum class Status
6006  {
6007  InProgress,
6008  Completed,
6009  Failed
6010  };
6011 
6013  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6014 
6015  virtual ~Event();
6016 
6018  intptr_t GetClassID() const;
6019 
6022  virtual Event * Clone() const=0;
6023 
6025  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6026 
6029  virtual intptr_t Freshen() const { return 0; }
6030 
6032  intptr_t GetChannel() const { return channel; }
6033 
6035  Time GetTimeStamp() const { return time_stamp; }
6036 
6038  bool IsConsumable() const { return consumable; }
6039 
6040  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6041  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6042 
6043 protected:
6044  intptr_t channel;
6045  bool consumable;
6046 
6047 private:
6048  friend class HPSI::EventDispatcherImpl;
6049  Time time_stamp;
6050 };
6051 
6052 
6055 class HPS_API EventNotifier : public Object
6056 {
6057 public:
6058 
6060  EventNotifier();
6061 
6064  EventNotifier(EventNotifier const & in_that);
6065 
6069  EventNotifier(EventNotifier && in_that);
6070 
6074  EventNotifier & operator=(EventNotifier && in_that);
6075 
6076  virtual ~EventNotifier();
6077 
6078  Type ObjectType() const {return Type::EventNotifier;};
6079 
6083  EventNotifier & operator=(EventNotifier const & in_that);
6084 
6087  virtual void Assign(EventNotifier const & in_that);
6088 
6090  void Wait() const;
6091 
6094  Event::Status Status() const;
6095 };
6096 
6098 enum class KeyboardCode
6099 {
6100  None = 0,
6101 
6102  Backspace = 8,
6103  Tab = 9,
6104  Clear = 11,
6105  Return = 13,
6106  Shift = 16,
6107  Control = 17,
6108  Alt = 18,
6109  Pause = 19,
6110  Escape = 27,
6111 
6112  Space = 32,
6113  ExclamationMark,
6114  DoubleQuote,
6115  Number,
6116  Dollar,
6117  Percent,
6118  Ampersand,
6119  SingleQuote,
6120  OpenParen,
6121  CloseParen,
6122 
6123  Asterisk,
6124  Plus,
6125  Comma,
6126  Hyphen,
6127  Period,
6128  Slash,
6129 
6130  D0,
6131  D1,
6132  D2,
6133  D3,
6134  D4,
6135  D5,
6136  D6,
6137  D7,
6138  D8,
6139  D9,
6140 
6141  Colon,
6142  Semicolon,
6143  LessThan,
6144  Equal,
6145  GreaterThan,
6146  QuestionMark,
6147  AtSymbol,
6148 
6149  A,
6150  B,
6151  C,
6152  D,
6153  E,
6154  F,
6155  G,
6156  H,
6157  I,
6158  J,
6159  K,
6160  L,
6161  M,
6162  N,
6163  O,
6164  P,
6165  Q,
6166  R,
6167  S,
6168  T,
6169  U,
6170  V,
6171  W,
6172  X,
6173  Y,
6174  Z,
6175 
6176  OpenBrackets,
6177  Backslash,
6178  CloseBrackets,
6179  Caret,
6180  Underscore,
6181  Backtick,
6182 
6183  a,
6184  b,
6185  c,
6186  d,
6187  e,
6188  f,
6189  g,
6190  h,
6191  i,
6192  j,
6193  k,
6194  l,
6195  m,
6196  n,
6197  o,
6198  p,
6199  q,
6200  r,
6201  s,
6202  t,
6203  u,
6204  v,
6205  w,
6206  x,
6207  y,
6208  z,
6209 
6210  OpenBrace,
6211  VerticalBar,
6212  ClosingBrace,
6213  Tilde,
6214  Delete,
6215 
6216  Insert=1024,
6217  Home,
6218  End,
6219  PageUp,
6220  PageDown,
6221 
6222  Help,
6223 
6224  Left,
6225  Up,
6226  Right,
6227  Down,
6228 
6229  NumPad0,
6230  NumPad1,
6231  NumPad2,
6232  NumPad3,
6233  NumPad4,
6234  NumPad5,
6235  NumPad6,
6236  NumPad7,
6237  NumPad8,
6238  NumPad9,
6239 
6240  F1,
6241  F2,
6242  F3,
6243  F4,
6244  F5,
6245  F6,
6246  F7,
6247  F8,
6248  F9,
6249  F10,
6250  F11,
6251  F12,
6252  F13,
6253  F14,
6254  F15,
6255  F16,
6256  F17,
6257  F18,
6258  F19,
6259  F20,
6260  F21,
6261  F22,
6262  F23,
6263  F24,
6264 
6265  // these are not implemented
6266 // CapsLock, //!< The Caps Lock key.
6267 //
6268 // NumLock, //!< The Num Lock key.
6269 // ScrollLock, //!< The Scroll Lock key.
6270 // LeftShift, //!< The left Shift key.
6271 // RightShift, //!< The right Shift key.
6272 // LeftCtrl, //!< The left CTRL key.
6273 // RightCtrl, //!< The right CTRL key.
6274 // LeftAlt, //!< The left ALT key.
6275 // RightAlt, //!< The right ALT key.
6276 //
6277 // Select, //!< The Select key.
6278 // Print, //!< The Print key.
6279 // Execute, //!< The Execute key.
6280 // PrintScreen, //!< The Print Screen key.
6281 };
6282 
6283 
6285 class NO_HPS_API Touch
6286 {
6287 public:
6288 
6291  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6292 
6297  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6298  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6299 
6303  inline bool operator==(Touch const & in_that) const
6304  {
6305  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6306  }
6307 
6311  inline bool operator!=(Touch const & in_that) const
6312  {
6313  return !(*this == in_that);
6314  }
6315 
6316  TouchID ID;
6318  size_t TapCount;
6319 };
6320 
6321 
6322 typedef std::vector<Point, Allocator<Point> > PointArray;
6323 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6324 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6325 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6326 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6327 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6328 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6329 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6330 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6331 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6332 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6333 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6334 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6335 typedef std::vector<int, Allocator<int> > IntArray;
6336 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6337 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6338 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6339 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6340 typedef std::vector<float, Allocator<float> > FloatArray;
6341 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6342 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6343 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6344 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6345 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6346 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6347 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6348 typedef std::vector<bool, Allocator<bool> > BoolArray;
6349 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6350 typedef std::vector<Key, Allocator<Key> > KeyArray;
6351 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6352 typedef std::vector<char, Allocator<char> > CharArray;
6353 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6354 typedef std::vector<byte, Allocator<byte> > ByteArray;
6355 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6356 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6357 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6358 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6359 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6360 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6361 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6362 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6363 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6364 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6365 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6366 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6367 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6368 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6369 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6370 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6371 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6372 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6373 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6374 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6375 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6376 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6377 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6378 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6379 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6380 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6381 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6382 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6383 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6384 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6385 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6386 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6387 
6388 
6390 class HPS_API SearchResultsIterator : public Object
6391 {
6392 public:
6393 
6396 
6400  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6401 
6406 
6410  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6411 
6413 
6414  Type ObjectType() const {return Type::SearchResultsIterator;}
6415 
6420  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6421 
6426  void Set(SearchResultsIterator const & in_search_results_iterator);
6427 
6429  void Next();
6430 
6433  SearchResultsIterator & operator++();
6434 
6437  SearchResultsIterator operator++(int in_val);
6438 
6441  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6442 
6445  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6446 
6450  bool IsValid() const;
6451 
6453  void Reset();
6454 
6458  Key GetItem() const;
6459 
6462  Key operator*() const;
6463 
6466  SearchTypeArray GetResultTypes() const;
6467 };
6468 
6470 class HPS_API SearchResults : public Object
6471 {
6472 public:
6474  SearchResults();
6475 
6478  SearchResults(SearchResults const & in_search_results);
6479 
6483  SearchResults(SearchResults && in_that);
6484 
6488  SearchResults & operator=(SearchResults && in_that);
6489 
6491  virtual void Reset();
6492 
6494  ~SearchResults();
6495 
6496  Type ObjectType() const {return Type::SearchResults;}
6497 
6501  void Assign(SearchResults const & in_search_results);
6502 
6506  SearchResults & operator=(SearchResults const & in_search_results);
6507 
6510  size_t GetCount() const;
6511 
6514  SearchResultsIterator GetIterator() const;
6515 };
6516 
6518 class HPS_API FontSearchResultsIterator : public Object
6519 {
6520 public:
6521 
6524 
6528  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6529 
6534 
6539  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6540 
6541 
6545  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6546 
6548 
6549  Type ObjectType() const {return Type::FontSearchResultsIterator;}
6550 
6551 
6556  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6557 
6559  void Next();
6560 
6563  FontSearchResultsIterator & operator++();
6564 
6567  FontSearchResultsIterator operator++(int in_val);
6568 
6571  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6572 
6575  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6576 
6580  bool IsValid() const;
6581 
6583  void Reset();
6584 
6588  FontInfoState GetItem() const;
6589 
6592  FontInfoState operator*() const;
6593 
6594 };
6595 
6597 class HPS_API FontSearchResults : public Object
6598 {
6599 public:
6600 
6603 
6606  FontSearchResults(FontSearchResults const & in_search_results);
6607 
6612 
6616  FontSearchResults & operator=(FontSearchResults && in_that);
6617 
6619  virtual void Reset();
6620 
6622  ~FontSearchResults();
6623 
6624  Type ObjectType() const {return Type::FontSearchResults;}
6625 
6629  void Assign(FontSearchResults const & in_search_results);
6630 
6631 
6635  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6636 
6639  size_t GetCount() const;
6640 
6643  FontSearchResultsIterator GetIterator() const;
6644 };
6645 
6647 class HPS_API UTF8
6648 {
6649 public:
6650 
6652  UTF8();
6653 
6655  ~UTF8();
6656 
6663  UTF8(char const * in_string, char const * in_locale = 0);
6664 
6667  UTF8(wchar_t const * in_string);
6668 
6671  UTF8(UTF8 const & in_that);
6672 
6675  UTF8(UTF8 && in_that);
6676 
6680  UTF8 & Assign(UTF8 && in_utf8);
6681 
6684  inline UTF8 & operator= (UTF8 && in_utf8)
6685  {
6686  return Assign(std::move(in_utf8));
6687  }
6688 
6693  size_t ToWStr(wchar_t * out_wide_string) const;
6694 
6698  size_t ToWStr(WCharArray & out_wide_string) const;
6699 
6702  inline bool IsValid() const
6703  {
6704  return (_length > 0);
6705  }
6706 
6709  inline bool Empty() const
6710  {
6711  return (_length == 0);
6712  }
6713 
6715  void Clear();
6716 
6718  void Reset() { Clear(); }
6719 
6723  inline size_t GetLength() const
6724  {
6725  return _length;
6726  }
6727 
6731  inline size_t GetWStrLength() const
6732  {
6733  return ToWStr(0);
6734  }
6735 
6738  inline char const * GetBytes() const
6739  {
6740  return _text;
6741  }
6742 
6745  inline operator char const * () const
6746  {
6747  return _text;
6748  }
6749 
6752  char At(size_t in_index) const
6753  {
6754  if(!IsValid())
6755  throw InvalidObjectException();
6756  else if(in_index >= _length)
6757  throw IndexOutOfRangeException();
6758  else
6759  return _text[in_index];
6760  }
6761 
6765  UTF8 & Assign(UTF8 const & in_utf8);
6766 
6770  inline UTF8 & operator= (UTF8 const & in_utf8)
6771  {
6772  return Assign(in_utf8);
6773  }
6774 
6778  UTF8 & operator+= (UTF8 const & in_utf8);
6779 
6783  UTF8 & operator+= (char const * in_utf8);
6784 
6788  UTF8 operator+ (UTF8 const & in_utf8) const;
6789 
6793  UTF8 operator+ (char const * in_utf8) const;
6794 
6798  bool operator== (UTF8 const & in_utf8) const;
6799 
6803  bool operator!= (UTF8 const & in_utf8) const
6804  {
6805  return !(*this == in_utf8);
6806  }
6807 
6811  bool operator== (char const * in_utf8) const;
6812 
6816  bool operator!= (char const * in_utf8) const
6817  {
6818  return !(*this == in_utf8);
6819  }
6820 
6825  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
6826  {
6827  return in_right == in_left;
6828  }
6829 
6834  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
6835  {
6836  return in_right != in_left;
6837  }
6838 
6843  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
6844  {
6845  return in_right == UTF8(in_left);
6846  }
6847 
6852  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
6853  {
6854  return in_right != UTF8(in_left);
6855  }
6856 
6861  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
6862  {
6863  return UTF8(in_left) + in_right;
6864  }
6865 
6870  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
6871  {
6872  return UTF8(in_left) + in_right;
6873  }
6874 
6875 
6878  size_t GetHash() const;
6879 
6880 private:
6881 
6882  size_t internal_encode(wchar_t const * in_wide_string);
6883  size_t internal_decode(wchar_t * out_wide_string) const;
6884 
6885  char * _text;
6886  size_t _length;
6887  mutable size_t _hash_key;
6888  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
6889  char _buffer[_buffer_size];
6890 };
6891 
6893 struct UTF8Hasher {
6894  inline size_t operator()(const UTF8 & in_utf8) const
6895  {
6896  return in_utf8.GetHash();
6897  }
6898 };
6899 
6902 class HPS_API Condition : public Object
6903 {
6904 public:
6905 
6907  Condition();
6908 
6911  Condition(char const * in_utf8);
6912 
6915  Condition(Condition const & in_that);
6916 
6920  Condition(Condition && in_that);
6921 
6925  Condition & operator=(Condition && in_that);
6926 
6927  Type ObjectType() const { return Type::Condition; }
6928 
6933  bool ShowCondition(UTF8 & out_condition) const;
6934 
6939  bool ShowOperands(ConditionArray & out_operands) const;
6940 
6944  Condition & operator=(Condition const & in_that);
6945 
6949  bool Equals(Condition const & in_that) const;
6950 
6954  bool operator==(Condition const & in_that) const;
6955 
6959  bool operator!=(Condition const & in_that) const;
6960 
6964  Condition OR(Condition const & in_operand2) const;
6965 
6969  Condition XOR(Condition const & in_operand2) const;
6970 
6974  Condition AND(Condition const & in_operand2) const;
6975 
6976 
6979  Condition operator !() const;
6980 
6984  Condition operator ||(Condition const & in_operand2) const;
6985 
6989  Condition operator ^(Condition const & in_operand2) const;
6990 
6994  Condition operator &&(Condition const & in_operand2) const;
6995 
6996 
7000  static Condition NOT(Condition const & in_operand);
7001 
7006  static Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7007 
7008 
7013  static Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7014 
7019  static Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7020 
7021  friend HPS_API Condition NOT(Condition const & in_operand);
7022  friend HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7023  friend HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7024  friend HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7025 };
7026 
7027 
7031 HPS_API Condition NOT(Condition const & in_operand);
7032 
7037 HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7038 
7043 HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7044 
7049 HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7050 
7051 
7052 
7053 
7058 class HPS_API Key : public Object
7059 {
7060 public:
7061 
7063  Key();
7064 
7066  Key(Key const & in_that);
7067 
7069  explicit Key(Control const & in_control);
7070 
7074  Key(Key && in_that);
7075 
7079  Key & operator=(Key && in_that);
7080 
7082  virtual ~Key();
7083 
7084  Type ObjectType() const {return Type::Key;};
7085 
7087  bool HasOwner() const;
7088 
7090  SegmentKey Up() const;
7091 
7093  SegmentKey Owner() const;
7094 
7096  void Delete();
7097 
7099  void MoveTo(SegmentKey const & in_new_owner);
7100 
7103  Key CopyTo(SegmentKey const & in_destination) const;
7104 
7106  Key & operator=(Key const & in_that);
7107 
7109  virtual void Assign(Key const & in_that);
7110 
7112  bool Equals(Key const & in_that) const;
7113 
7115  bool operator!= (Key const & in_that) const;
7116 
7118  bool operator== (Key const & in_that) const;
7119 
7122  size_t GetHash() const;
7123 };
7124 
7126 struct KeyHasher {
7127  inline size_t operator()(const Key & in_key) const
7128  {
7129  return in_key.GetHash();
7130  }
7131 };
7132 
7133 
7136 class HPS_API SegmentKey : public Key
7137 {
7138 public:
7140  SegmentKey();
7141 
7143  SegmentKey(SegmentKey const & in_that);
7144 
7146  SegmentKey & operator=(SegmentKey const & other);
7147 
7151  SegmentKey(SegmentKey && in_that);
7152 
7156  SegmentKey & operator=(SegmentKey && in_that);
7157 
7159  explicit SegmentKey(Key const & in_that);
7160 
7162  ~SegmentKey();
7163 
7164  Type ObjectType() const {return Type::SegmentKey;};
7165 
7167  UTF8 Name() const;
7168 
7171  SegmentKey & SetName(char const * in_name);
7172 
7175  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7176 
7179  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7180 
7182  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7183 
7185  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7186 
7188  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7189 
7190 
7191 
7193  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7194 
7196  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7197 
7199  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7200 
7201 
7203  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7204 
7206  size_t Find(SearchOptionsKit const & in_options) const;
7207 
7208 
7211  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7212 
7216  IncludeKey IncludeSegment(SegmentKey const & in_seg, Condition const & in_condition);
7217 
7218 
7224  ReferenceKey ReferenceGeometry(Key const & in_key);
7225 
7233  ReferenceKey ReferenceGeometry(Key const & in_key, Condition const & in_condition);
7234 
7235 
7237  size_t ShowSubsegments() const;
7238 
7240  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7241 
7245  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7246 
7250  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7251 
7255  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7256 
7260  size_t ShowStylers(StyleKeyArray & out_styles) const;
7261 
7265  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7266 
7270  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7271 
7272 
7273 
7275  StyleControl GetStyleControl();
7276 
7278  StyleControl const GetStyleControl() const;
7279 
7280 
7282  PortfolioControl GetPortfolioControl();
7283 
7285  PortfolioControl const GetPortfolioControl() const;
7286 
7287 
7289  SegmentKey & SetCondition(char const * in_condition);
7290 
7292  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7293 
7295  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7296 
7298  SegmentKey & UnsetConditions();
7299 
7301  bool ShowConditions(UTF8Array & out_conditions) const;
7302 
7304  ConditionControl GetConditionControl();
7305 
7307  ConditionControl const GetConditionControl() const;
7308 
7309 
7311  SegmentKey & SetMaterialPalette(char const * in_name);
7312 
7314  SegmentKey & UnsetMaterialPalette();
7315 
7317  bool ShowMaterialPalette(UTF8 & out_name) const;
7318 
7319 
7326  SegmentKey & SetPriority(int in_priority);
7327 
7330  SegmentKey & UnsetPriority();
7331 
7335  bool ShowPriority(int & out_priority) const;
7336 
7337 
7343  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7344 
7349  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7350 
7354  SegmentKey & UnsetUserData(intptr_t in_index);
7355 
7360  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7361 
7365  SegmentKey & UnsetUserData(IntPtrTArray const & in_indices);
7366 
7369  SegmentKey & UnsetAllUserData();
7370 
7372  size_t ShowUserDataCount() const;
7373 
7377  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7378 
7383  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7384 
7385 
7387  LineKey InsertLine(LineKit const & in_kit);
7388 
7390  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7391 
7393  LineKey InsertLine(PointArray const & in_pts);
7394 
7396  LineKey InsertLine(Point const & pt1, Point const & pt2);
7397 
7398 
7400  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7401 
7403  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);
7404 
7406  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7407 
7409  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7410 
7411 
7416  SphereKey InsertSphere(SphereKit const & in_kit);
7417 
7425  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));
7426 
7428  CircleKey InsertCircle(CircleKit const & in_kit);
7429 
7431  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7432 
7434  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7435 
7436 
7438  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7439 
7441  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7442 
7443 
7445  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7446 
7448  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7449 
7450 
7452  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7453 
7455  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7456 
7457 
7459  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7460 
7462  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float start, float end);
7463 
7464 
7466  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7467 
7469  PolygonKey InsertPolygon(PointArray const & in_pts);
7470 
7472  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7473 
7474 
7476  ShellKey InsertShell(ShellKit const & in_kit);
7477 
7479  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7480 
7482  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7483 
7484 
7486  MeshKey InsertMesh(MeshKit const & in_kit);
7487 
7489  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7490 
7492  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7493 
7494 
7496  MarkerKey InsertMarker(Point const & in_position);
7497 
7499  MarkerKey InsertMarker(MarkerKit const & in_kit);
7500 
7501 
7503  DistantLightKey InsertDistantLight(Vector const & in_direction);
7504 
7506  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7507 
7508 
7510  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7511 
7513  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7514 
7516  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7517 
7519  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7520 
7521 
7523  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7524 
7526  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7527 
7528 
7530  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7531 
7533  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7534 
7535 
7537  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7538 
7540  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);
7541 
7543  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);
7544 
7545 
7547  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7548 
7550  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);
7551 
7553  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[]);
7554 
7556  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);
7557 
7559  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[]);
7560 
7561 
7563  TextKey InsertText(TextKit const & in_kit);
7564 
7570  TextKey InsertText(Point const & in_position, char const * in_text);
7571 
7572 
7573 
7575  GridKey InsertGrid(GridKit const & in_kit);
7576 
7578  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);
7579 
7580 
7581 
7589  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7590 
7598  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7599 
7607  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7608 
7616  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7617 
7625  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7626 
7634  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7635 
7640  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7641 
7646  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7647 
7652  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7653 
7658  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7659 
7664  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7665 
7670  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7671 
7672 
7674  SegmentKey & SetAttributeLocks(AttributeLockKit const & in_kit);
7675 
7677  SegmentKey & UnsetAttributeLocks();
7678 
7682  bool ShowAttributeLocks(AttributeLockKit & out_kit) const;
7683 
7685  AttributeLockControl GetAttributeLockControl();
7686 
7688  AttributeLockControl const GetAttributeLockControl() const;
7689 
7690 
7692  SegmentKey & SetBoundings(BoundingKit const & in_kit);
7693 
7695  SegmentKey & UnsetBoundings();
7696 
7700  bool ShowBoundings(BoundingKit & out_kit) const;
7701 
7703  BoundingControl GetBoundingControl();
7704 
7706  BoundingControl const GetBoundingControl() const;
7707 
7708 
7710  SegmentKey & SetCamera(CameraKit const & in_kit);
7711 
7713  SegmentKey & UnsetCamera();
7714 
7716  bool ShowCamera(CameraKit & out_kit) const;
7717 
7719  CameraControl GetCameraControl();
7720 
7722  CameraControl const GetCameraControl() const;
7723 
7725  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
7726 
7728  SegmentKey & UnsetColorInterpolation();
7729 
7731  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
7732 
7734  ColorInterpolationControl GetColorInterpolationControl();
7735 
7737  ColorInterpolationControl const GetColorInterpolationControl() const;
7738 
7739 
7741  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
7742 
7744  SegmentKey & UnsetContourLine();
7745 
7747  bool ShowContourLine(ContourLineKit & out_kit) const;
7748 
7750  ContourLineControl GetContourLineControl();
7751 
7753  ContourLineControl const GetContourLineControl() const;
7754 
7755 
7757  SegmentKey & SetCulling(CullingKit const & in_kit);
7758 
7760  SegmentKey & UnsetCulling();
7761 
7765  bool ShowCulling(CullingKit & out_kit) const;
7766 
7768  CullingControl GetCullingControl();
7769 
7771  CullingControl const GetCullingControl() const;
7772 
7773 
7775  SegmentKey & SetCurveAttributes(CurveAttributeKit const & in_kit);
7776 
7778  SegmentKey & UnsetCurveAttributes();
7779 
7781  bool ShowCurveAttributes(CurveAttributeKit & out_kit) const;
7782 
7784  CurveAttributeControl GetCurveAttributeControl();
7785 
7787  CurveAttributeControl const GetCurveAttributeControl() const;
7788 
7789 
7791  SegmentKey & SetCuttingSectionAttributes(CuttingSectionAttributeKit const & in_kit);
7792 
7794  SegmentKey & UnsetCuttingSectionAttributes();
7795 
7797  bool ShowCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
7798 
7800  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
7801 
7803  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
7804 
7805 
7807  SegmentKey & SetCylinderAttributes(CylinderAttributeKit const & in_kit);
7808 
7810  SegmentKey & UnsetCylinderAttributes();
7811 
7813  bool ShowCylinderAttributes(CylinderAttributeKit & out_kit) const;
7814 
7816  CylinderAttributeControl GetCylinderAttributeControl();
7817 
7819  CylinderAttributeControl const GetCylinderAttributeControl() const;
7820 
7821 
7823  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
7824 
7826  SegmentKey & UnsetDrawingAttribute();
7827 
7829  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
7830 
7832  DrawingAttributeControl GetDrawingAttributeControl();
7833 
7835  DrawingAttributeControl const GetDrawingAttributeControl() const;
7836 
7837 
7839  SegmentKey & SetEdgeAttributes(EdgeAttributeKit const & in_kit);
7840 
7842  SegmentKey & UnsetEdgeAttributes();
7843 
7845  bool ShowEdgeAttributes(EdgeAttributeKit & out_kit) const;
7846 
7848  EdgeAttributeControl GetEdgeAttributeControl();
7849 
7851  EdgeAttributeControl const GetEdgeAttributeControl() const;
7852 
7853 
7855  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
7856 
7858  SegmentKey & UnsetHiddenLineAttribute();
7859 
7861  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
7862 
7864  HiddenLineAttributeControl GetHiddenLineAttributeControl();
7865 
7867  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
7868 
7869 
7871  SegmentKey & SetLightingAttributes(LightingAttributeKit const & in_kit);
7872 
7874  SegmentKey & UnsetLightingAttributes();
7875 
7877  bool ShowLightingAttributes(LightingAttributeKit & out_kit) const;
7878 
7880  LightingAttributeControl GetLightingAttributeControl();
7881 
7883  LightingAttributeControl const GetLightingAttributeControl() const;
7884 
7885 
7887  SegmentKey & SetLineAttributes(LineAttributeKit const & in_kit);
7888 
7890  SegmentKey & UnsetLineAttributes();
7891 
7893  bool ShowLineAttributes(LineAttributeKit & out_kit) const;
7894 
7896  LineAttributeControl GetLineAttributeControl();
7897 
7899  LineAttributeControl const GetLineAttributeControl() const;
7900 
7901 
7903  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
7904 
7906  SegmentKey & UnsetMaterialMapping();
7907 
7909  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
7910 
7912  MaterialMappingControl GetMaterialMappingControl();
7913 
7915  MaterialMappingControl const GetMaterialMappingControl() const;
7916 
7917 
7919  SegmentKey & SetMarkerAttributes(MarkerAttributeKit const & in_kit);
7920 
7922  SegmentKey & UnsetMarkerAttributes();
7923 
7925  bool ShowMarkerAttributes(MarkerAttributeKit & out_kit) const;
7926 
7928  MarkerAttributeControl GetMarkerAttributeControl();
7929 
7931  MarkerAttributeControl const GetMarkerAttributeControl() const;
7932 
7933 
7935  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
7936 
7938  SegmentKey & UnsetModellingMatrix();
7939 
7941  bool ShowModellingMatrix(MatrixKit & out_kit) const;
7942 
7944  ModellingMatrixControl GetModellingMatrixControl();
7945 
7947  ModellingMatrixControl const GetModellingMatrixControl() const;
7948 
7949 
7951  SegmentKey & SetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit const & in_kit);
7952 
7954  SegmentKey & UnsetNURBSSurfaceAttributes();
7955 
7957  bool ShowNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
7958 
7960  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
7961 
7963  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
7964 
7965 
7967  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
7968 
7970  SegmentKey & UnsetPerformance();
7971 
7973  bool ShowPerformance(PerformanceKit & out_kit) const;
7974 
7976  PerformanceControl GetPerformanceControl();
7977 
7979  PerformanceControl const GetPerformanceControl() const;
7980 
7981 
7983  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
7984 
7986  SegmentKey & UnsetSelectability();
7987 
7991  bool ShowSelectability(SelectabilityKit & out_kit) const;
7992 
7994  SelectabilityControl GetSelectabilityControl();
7995 
7997  SelectabilityControl const GetSelectabilityControl() const;
7998 
7999 
8001  SegmentKey & SetSphereAttributes(SphereAttributeKit const & in_kit);
8002 
8004  SegmentKey & UnsetSphereAttributes();
8005 
8009  bool ShowSphereAttributes(SphereAttributeKit & out_kit) const;
8010 
8012  SphereAttributeControl GetSphereAttributeControl();
8013 
8015  SphereAttributeControl const GetSphereAttributeControl() const;
8016 
8017 
8019  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8020 
8022  SegmentKey & UnsetSubwindow();
8023 
8027  bool ShowSubwindow(SubwindowKit & out_kit) const;
8028 
8030  SubwindowControl GetSubwindowControl();
8031 
8033  SubwindowControl const GetSubwindowControl() const;
8034 
8035 
8037  SegmentKey & SetTextAttributes(TextAttributeKit const & in_kit);
8038 
8040  SegmentKey & UnsetTextAttributes();
8041 
8043  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
8044 
8046  TextAttributeControl GetTextAttributeControl();
8047 
8049  TextAttributeControl const GetTextAttributeControl() const;
8050 
8051 
8053  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8054 
8056  SegmentKey & UnsetTextureMatrix();
8057 
8061  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8062 
8064  TextureMatrixControl GetTextureMatrixControl();
8065 
8067  TextureMatrixControl const GetTextureMatrixControl() const;
8068 
8070  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8071 
8073  SegmentKey & UnsetTransformMask();
8074 
8078  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8079 
8081  TransformMaskControl GetTransformMaskControl();
8082 
8084  TransformMaskControl const GetTransformMaskControl() const;
8085 
8086 
8088  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8089 
8091  SegmentKey & UnsetTransparency();
8092 
8096  bool ShowTransparency(TransparencyKit & out_kit) const;
8097 
8099  TransparencyControl GetTransparencyControl();
8100 
8102  TransparencyControl const GetTransparencyControl() const;
8103 
8104 
8106  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8107 
8109  SegmentKey & UnsetVisibility();
8110 
8114  bool ShowVisibility(VisibilityKit & out_kit) const;
8115 
8117  VisibilityControl GetVisibilityControl();
8118 
8120  VisibilityControl const GetVisibilityControl() const;
8121 
8122 
8124  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8125 
8127  SegmentKey & UnsetVisualEffects();
8128 
8132  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8133 
8135  VisualEffectsControl GetVisualEffectsControl();
8136 
8138  VisualEffectsControl const GetVisualEffectsControl() const;
8139 
8140 };
8141 
8142 
8144 class HPS_API Coordinate
8145 {
8146 public:
8147 
8151  enum class Space
8152  {
8153  Object,
8154  World,
8155  Camera,
8156  Normalized,
8157  ScreenRange,
8158  InnerWindow,
8159  InnerPixel,
8160  Window,
8161  Pixel,
8162  };
8163 
8164 private:
8165  Coordinate();
8166 };
8167 
8168 
8169 
8170 
8173 class HPS_API UpdateNotifier : public Object
8174 {
8175 public:
8176 
8177  UpdateNotifier();
8178 
8179  UpdateNotifier(UpdateNotifier const & in_that);
8180 
8184  UpdateNotifier(UpdateNotifier && in_that);
8185 
8189  UpdateNotifier & operator=(UpdateNotifier && in_that);
8190 
8191  virtual ~UpdateNotifier();
8192 
8193  Type ObjectType() const {return Type::UpdateNotifier;};
8194 
8196  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8197 
8199  void Assign(UpdateNotifier const & in_that);
8200 
8201  void Wait() const;
8202 
8203  Window::UpdateStatus Status() const;
8204 
8205 };
8206 
8207 
8211 class HPS_API WindowKey : public SegmentKey
8212 {
8213 public:
8214 
8216  WindowKey();
8217 
8219  WindowKey(WindowKey const & in_window);
8220 
8222  WindowKey & operator=(WindowKey const & other);
8223 
8227  WindowKey(WindowKey && in_that);
8228 
8232  WindowKey & operator=(WindowKey && in_that);
8233 
8235  WindowKey(Key const & in_key);
8236 
8238  ~WindowKey();
8239 
8240  Type ObjectType() const {return Type::WindowKey;};
8241 
8243  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8244 
8246  size_t FindFonts(FontSearchResults & out_results) const;
8247 
8249  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8250 
8252  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8253 
8255  PostProcessEffectsControl GetPostProcessEffectsControl();
8256 
8258  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8259 
8260 
8262  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8263 
8267  bool ShowDebugging(DebuggingKit & out_kit) const;
8268 
8270  DebuggingControl GetDebuggingControl();
8271 
8273  DebuggingControl const GetDebuggingControl() const;
8274 
8276  WindowInfoControl const GetWindowInfoControl() const;
8277 
8278  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8279 
8281  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8282 
8284  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8285 
8287  WindowKey & SetUpdateOptions(UpdateOptionsKit const & in_kit);
8288 
8290  bool ShowUpdateOptions(UpdateOptionsKit & out_kit) const;
8291 
8292 
8294  SelectionOptionsControl GetSelectionOptionsControl();
8295 
8297  SelectionOptionsControl const GetSelectionOptionsControl() const;
8298 
8299 
8301  SelectionControl GetSelectionControl();
8302 
8304  SelectionControl const GetSelectionControl() const;
8305 
8307  HighlightControl GetHighlightControl();
8308 
8310  HighlightControl const GetHighlightControl() const;
8311 
8313  UpdateOptionsControl GetUpdateOptionsControl();
8314 
8316  UpdateOptionsControl const GetUpdateOptionsControl() const;
8317 
8319  void Update();
8320 
8325  void Update(UpdateOptionsKit const & in_kit);
8326 
8341  void Update(Window::UpdateControl in_control, Time in_time_limit=-1);
8342 
8346  UpdateNotifier UpdateWithNotifier();
8347 
8351  UpdateNotifier UpdateWithNotifier(UpdateOptionsKit const & in_kit);
8352 
8358  UpdateNotifier UpdateWithNotifier(Window::UpdateControl in_control, Time in_time_limit=-1);
8359 
8361  EventDispatcher & GetEventDispatcher();
8362 
8364  EventDispatcher const & GetEventDispatcher() const;
8365 
8369  bool ShowSnapshot(ImageKit & out_kit) const;
8370 
8371 private:
8372 
8374  SegmentKey & UnsetAttributeLocks();
8375  SegmentKey & UnsetCamera();
8376  SegmentKey & UnsetColorInterpolation();
8377  SegmentKey & UnsetContourLine();
8378  SegmentKey & UnsetCulling();
8379  SegmentKey & UnsetCurveAttributes();
8380  SegmentKey & UnsetCuttingSectionAttributes();
8381  SegmentKey & UnsetCylinderAttributes();
8382  SegmentKey & UnsetDrawingAttribute();
8383  SegmentKey & UnsetEdgeAttributes();
8384  SegmentKey & UnsetHiddenLineAttribute();
8385  SegmentKey & UnsetLightingAttributes();
8386  SegmentKey & UnsetLineAttributes();
8387  SegmentKey & UnsetMaterialMapping();
8388  SegmentKey & UnsetMarkerAttributes();
8389  SegmentKey & UnsetModellingMatrix();
8390  SegmentKey & UnsetNURBSSurfaceAttributes();
8391  SegmentKey & UnsetPerformance();
8392  SegmentKey & UnsetSelectability();
8393  SegmentKey & UnsetSphereAttributes();
8394  SegmentKey & UnsetSubwindow();
8395  SegmentKey & UnsetTextAttributes();
8396  SegmentKey & UnsetTextureMatrix();
8397  SegmentKey & UnsetTransformMask();
8398  SegmentKey & UnsetTransparency();
8399  SegmentKey & UnsetVisibility();
8400  SegmentKey & UnsetVisualEffects();
8401 
8403  void MoveTo(SegmentKey const & in_new_owner);
8404 
8406  Key CopyTo(SegmentKey const & in_destination) const;
8407 };
8408 
8409 
8410 
8413 class HPS_API KeyPath : public Object
8414 {
8415 public:
8416 
8418  KeyPath();
8419 
8422  KeyPath(KeyArray const & in_path);
8423 
8427  KeyPath(size_t in_path_count, Key const in_path []);
8428 
8430  KeyPath(KeyPath const & in_that);
8431 
8435  KeyPath(KeyPath && in_that);
8436 
8440  KeyPath & operator=(KeyPath && in_that);
8441 
8443  virtual ~KeyPath();
8444 
8445  Type ObjectType() const { return Type::KeyPath; }
8446 
8450  KeyPath & operator+=(Key const & in_key);
8451 
8455  KeyPath & operator+=(KeyPath const & in_key_path);
8456 
8460  KeyPath & operator+=(KeyArray const & in_key_array);
8461 
8465  KeyPath & Append(Key const & in_key);
8466 
8470  KeyPath & Append(KeyPath const & in_key_path);
8471 
8475  KeyPath & Append(KeyArray const & in_key_array);
8476 
8480  KeyPath & operator=(KeyPath const & in_that);
8481 
8485  KeyPath & operator=(KeyArray const & in_path);
8486 
8489  void Set(KeyPath const & in_that);
8490 
8494  bool Equals(KeyPath const & in_that) const;
8495 
8499  bool operator!= (KeyPath const & in_that) const;
8500 
8504  bool operator== (KeyPath const & in_that) const;
8505 
8506 
8510  KeyPath & SetKeys(KeyArray const & in_keys);
8511 
8516  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
8517 
8518 
8521  KeyPath & UnsetKeys();
8522 
8523 
8526  bool ShowKeys(KeyArray & out_keys) const;
8527 
8528 
8535  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8536 
8543  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
8544 
8550  bool ComputeTextExtent(const char* in_text, float & out_xfrac, float & out_yfrac) const;
8551 
8552 
8558  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, MatrixKit & out_matrix) const;
8559 
8560 
8563  bool ShowNetVisibility(VisibilityKit & out_kit) const;
8564 
8567  bool ShowNetBounding(BoundingKit & out_kit) const;
8568 
8571  bool ShowNetCamera(CameraKit & out_kit) const;
8572 
8575  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
8576 
8579  bool ShowNetContourLine(ContourLineKit & out_kit) const;
8580 
8583  bool ShowNetPerformance(PerformanceKit & out_kit) const;
8584 
8587  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8588 
8591  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
8592 
8595  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
8596 
8599  bool ShowNetMarkerAttributes(MarkerAttributeKit & out_kit) const;
8600 
8603  bool ShowNetSphereAttributes(SphereAttributeKit & out_kit) const;
8604 
8607  bool ShowNetLightingAttributes(LightingAttributeKit & out_kit) const;
8608 
8611  bool ShowNetCylinderAttributes(CylinderAttributeKit & out_kit) const;
8612 
8615  bool ShowNetCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
8616 
8619  bool ShowNetTextAttributes(TextAttributeKit & out_kit) const;
8620 
8623  bool ShowNetLineAttributes(LineAttributeKit & out_kit) const;
8624 
8627  bool ShowNetEdgeAttributes(EdgeAttributeKit & out_kit) const;
8628 
8631  bool ShowNetCurveAttributes(CurveAttributeKit & out_kit) const;
8632 
8635  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
8636 
8639  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
8640 
8643  bool ShowNetCulling(CullingKit & out_kit) const;
8644 
8647  bool ShowNetTransparency(TransparencyKit & out_kit) const;
8648 
8651  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
8652 
8655  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
8656 
8659  bool ShowNetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
8660 
8663  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
8664 
8667  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
8668 
8671  bool ShowNetAttributeLocks(AttributeLockKit & out_kit) const;
8672 
8675  bool ShowNetConditions(UTF8Array & out_conditions) const;
8676 
8682  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
8683 
8684 };
8685 
8686 
8691 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
8692 {
8693  return KeyPath().Append(in_lhs).Append(in_rhs);
8694 }
8695 
8700 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
8701 {
8702  return KeyPath().Append(in_lhs).Append(in_rhs);
8703 }
8704 
8709 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
8710 {
8711  return KeyPath().Append(in_lhs).Append(in_rhs);
8712 }
8713 
8718 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
8719 {
8720  return KeyPath().Append(in_lhs).Append(in_rhs);
8721 }
8722 
8727 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
8728 {
8729  return KeyPath().Append(in_lhs).Append(in_rhs);
8730 }
8731 
8736 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
8737 {
8738  return KeyPath().Append(in_lhs).Append(in_rhs);
8739 }
8740 
8745 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
8746 {
8747  return KeyPath().Append(in_lhs).Append(in_rhs);
8748 }
8749 
8754 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
8755 {
8756  return KeyPath().Append(in_lhs).Append(in_rhs);
8757 }
8758 
8763 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
8764 {
8765  return KeyPath().Append(in_lhs).Append(in_rhs);
8766 }
8767 
8768 
8772 
8774 class HPS_API BoundingKit : public Object
8775 {
8776 public:
8777 
8779  BoundingKit();
8780 
8783  BoundingKit(BoundingKit const & in_kit);
8784 
8788  BoundingKit(BoundingKit && in_that);
8789 
8793  BoundingKit & operator=(BoundingKit && in_that);
8794 
8796  virtual ~BoundingKit();
8797 
8798  Type ObjectType() const {return Type::BoundingKit;};
8799 
8803  static BoundingKit GetDefault();
8804 
8807  void Set(BoundingKit const & in_kit);
8808 
8811  void Show(BoundingKit & out_kit) const;
8812 
8816  BoundingKit & operator=(BoundingKit const & in_kit);
8817 
8820  bool Empty() const;
8821 
8825  bool Equals(BoundingKit const & in_kit) const;
8826 
8830  bool operator==(BoundingKit const & in_kit) const;
8831 
8835  bool operator!=(BoundingKit const & in_kit) const;
8836 
8837 
8841  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
8842 
8846  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
8847 
8851  BoundingKit & SetExclusion(bool in_exclude);
8852 
8853 
8856  BoundingKit & UnsetVolume();
8857 
8860  BoundingKit & UnsetExclusion();
8861 
8864  BoundingKit & UnsetEverything();
8865 
8866 
8871  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
8872 
8876  bool ShowExclusion(bool & out_exclusion) const;
8877 
8878 };
8879 
8880 
8883 class HPS_API BoundingControl : public Control
8884 {
8885 public:
8886 
8888  explicit BoundingControl(SegmentKey & in_seg);
8889 
8891  BoundingControl(BoundingControl const & in_that);
8892 
8896  BoundingControl(BoundingControl && in_that);
8897 
8901  BoundingControl & operator=(BoundingControl && in_that);
8902 
8904  ~BoundingControl();
8905 
8906  Type ObjectType() const {return Type::BoundingControl;};
8907 
8909  BoundingControl & operator=(BoundingControl const & in_that);
8910 
8915  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
8916 
8920  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
8921 
8925  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
8926 
8930  BoundingControl & SetExclusion(bool in_exclusion);
8931 
8932 
8935  BoundingControl & UnsetVolume();
8936 
8939  BoundingControl & UnsetExclusion();
8940 
8943  BoundingControl & UnsetEverything();
8944 
8945 
8950  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
8951 
8955  bool ShowExclusion(bool & out_exclusion) const;
8956 
8957 private:
8959  BoundingControl();
8960 };
8961 
8962 
8964 class HPS_API VisibilityKit : public Object
8965 {
8966 public:
8967 
8969  VisibilityKit();
8970 
8973  VisibilityKit(VisibilityKit const & in_kit);
8974 
8978  VisibilityKit(VisibilityKit && in_that);
8979 
8983  VisibilityKit & operator=(VisibilityKit && in_that);
8984 
8986  virtual ~VisibilityKit();
8987 
8988  Type ObjectType() const {return Type::VisibilityKit;};
8989 
8993  static VisibilityKit GetDefault();
8994 
8997  void Set(VisibilityKit const & in_kit);
8998 
9001  void Show(VisibilityKit & out_kit) const;
9002 
9006  VisibilityKit & operator=(VisibilityKit const & in_kit);
9007 
9010  bool Empty() const;
9011 
9015  bool Equals(VisibilityKit const & in_kit) const;
9016 
9020  bool operator==(VisibilityKit const & in_kit) const;
9021 
9025  bool operator!=(VisibilityKit const & in_kit) const;
9026 
9027 
9031  VisibilityKit & SetCuttingSections(bool in_state);
9032 
9036  VisibilityKit & SetCutEdges(bool in_state);
9037 
9041  VisibilityKit & SetCutFaces(bool in_state);
9042 
9046  VisibilityKit & SetWindows(bool in_state);
9047 
9051  VisibilityKit & SetText(bool in_state);
9052 
9056  VisibilityKit & SetLines(bool in_state);
9057 
9061  VisibilityKit & SetEdgeLights(bool in_state);
9062 
9066  VisibilityKit & SetMarkerLights(bool in_state);
9067 
9071  VisibilityKit & SetFaceLights(bool in_state);
9072 
9076  VisibilityKit & SetGenericEdges(bool in_state);
9077 
9081  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9082 
9086  VisibilityKit & SetAdjacentEdges(bool in_state);
9087 
9091  VisibilityKit & SetHardEdges(bool in_state);
9092 
9096  VisibilityKit & SetMeshQuadEdges(bool in_state);
9097 
9101  VisibilityKit & SetNonCulledEdges(bool in_state);
9102 
9106  VisibilityKit & SetPerimeterEdges(bool in_state);
9107 
9111  VisibilityKit & SetFaces(bool in_state);
9112 
9116  VisibilityKit & SetVertices(bool in_state);
9117 
9121  VisibilityKit & SetMarkers(bool in_state);
9122 
9126  VisibilityKit & SetShadowCasting(bool in_state);
9127 
9131  VisibilityKit & SetShadowReceiving(bool in_state);
9132 
9136  VisibilityKit & SetShadowEmitting(bool in_state);
9137 
9138 
9142  VisibilityKit & SetCutGeometry(bool in_state);
9143 
9147  VisibilityKit & SetEdges(bool in_state);
9148 
9152  VisibilityKit & SetGeometry(bool in_state);
9153 
9157  VisibilityKit & SetLights(bool in_state);
9158 
9162  VisibilityKit & SetShadows(bool in_state);
9163 
9167  VisibilityKit & SetEverything(bool in_state);
9168 
9169 
9172  VisibilityKit & UnsetCuttingSections();
9173 
9176  VisibilityKit & UnsetCutEdges();
9177 
9180  VisibilityKit & UnsetCutFaces();
9181 
9184  VisibilityKit & UnsetWindows();
9185 
9188  VisibilityKit & UnsetText();
9189 
9192  VisibilityKit & UnsetLines();
9193 
9196  VisibilityKit & UnsetEdgeLights();
9197 
9200  VisibilityKit & UnsetMarkerLights();
9201 
9204  VisibilityKit & UnsetFaceLights();
9205 
9208  VisibilityKit & UnsetGenericEdges();
9209 
9212  VisibilityKit & UnsetInteriorSilhouetteEdges();
9213 
9216  VisibilityKit & UnsetAdjacentEdges();
9217 
9220  VisibilityKit & UnsetHardEdges();
9221 
9224  VisibilityKit & UnsetMeshQuadEdges();
9225 
9228  VisibilityKit & UnsetNonCulledEdges();
9229 
9232  VisibilityKit & UnsetPerimeterEdges();
9233 
9236  VisibilityKit & UnsetFaces();
9237 
9240  VisibilityKit & UnsetVertices();
9241 
9244  VisibilityKit & UnsetMarkers();
9245 
9248  VisibilityKit & UnsetShadowCasting();
9249 
9252  VisibilityKit & UnsetShadowReceiving();
9253 
9256  VisibilityKit & UnsetShadowEmitting();
9257 
9258 
9261  VisibilityKit & UnsetCutGeometry();
9262 
9265  VisibilityKit & UnsetEdges();
9266 
9269  VisibilityKit & UnsetGeometry();
9270 
9273  VisibilityKit & UnsetLights();
9274 
9277  VisibilityKit & UnsetShadows();
9278 
9281  VisibilityKit & UnsetEverything();
9282 
9283 
9287  bool ShowCuttingSections(bool & out_state) const;
9288 
9292  bool ShowCutEdges(bool & out_state) const;
9293 
9297  bool ShowCutFaces(bool & out_state) const;
9298 
9302  bool ShowWindows(bool & out_state) const;
9303 
9307  bool ShowText(bool & out_state) const;
9308 
9312  bool ShowLines(bool & out_state) const;
9313 
9317  bool ShowEdgeLights(bool & out_state) const;
9318 
9322  bool ShowMarkerLights(bool & out_state) const;
9323 
9327  bool ShowFaceLights(bool & out_state) const;
9328 
9332  bool ShowGenericEdges(bool & out_state) const;
9333 
9337  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9338 
9342  bool ShowAdjacentEdges(bool & out_state) const;
9343 
9347  bool ShowHardEdges(bool & out_state) const;
9348 
9352  bool ShowMeshQuadEdges(bool & out_state) const;
9353 
9357  bool ShowNonCulledEdges(bool & out_state) const;
9358 
9362  bool ShowPerimeterEdges(bool & out_state) const;
9363 
9367  bool ShowFaces(bool & out_state) const;
9368 
9372  bool ShowVertices(bool & out_state) const;
9373 
9377  bool ShowMarkers(bool & out_state) const;
9378 
9382  bool ShowShadowCasting(bool & out_state) const;
9383 
9387  bool ShowShadowReceiving(bool & out_state) const;
9388 
9392  bool ShowShadowEmitting(bool & out_state) const;
9393 };
9394 
9395 
9401 class HPS_API VisibilityControl : public Control
9402 {
9403 public:
9404 
9406  explicit VisibilityControl(SegmentKey & in_seg);
9407 
9409  VisibilityControl(VisibilityControl const & in_that);
9410 
9415 
9419  VisibilityControl & operator=(VisibilityControl && in_that);
9420 
9422  ~VisibilityControl();
9423 
9424  Type ObjectType() const {return Type::VisibilityControl;};
9425 
9427  VisibilityControl & operator=(VisibilityControl const & in_that);
9428 
9429 
9433  VisibilityControl & SetCuttingSections(bool in_state);
9434 
9438  VisibilityControl & SetCutEdges(bool in_state);
9439 
9443  VisibilityControl & SetCutFaces(bool in_state);
9444 
9448  VisibilityControl & SetWindows(bool in_state);
9449 
9453  VisibilityControl & SetText(bool in_state);
9454 
9458  VisibilityControl & SetLines(bool in_state);
9459 
9463  VisibilityControl & SetEdgeLights(bool in_state);
9464 
9468  VisibilityControl & SetMarkerLights(bool in_state);
9469 
9473  VisibilityControl & SetFaceLights(bool in_state);
9474 
9478  VisibilityControl & SetGenericEdges(bool in_state);
9479 
9483  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
9484 
9488  VisibilityControl & SetAdjacentEdges(bool in_state);
9489 
9493  VisibilityControl & SetHardEdges(bool in_state);
9494 
9498  VisibilityControl & SetMeshQuadEdges(bool in_state);
9499 
9503  VisibilityControl & SetNonCulledEdges(bool in_state);
9504 
9508  VisibilityControl & SetPerimeterEdges(bool in_state);
9509 
9513  VisibilityControl & SetFaces(bool in_state);
9514 
9518  VisibilityControl & SetVertices(bool in_state);
9519 
9523  VisibilityControl & SetMarkers(bool in_state);
9524 
9528  VisibilityControl & SetShadowCasting(bool in_state);
9529 
9533  VisibilityControl & SetShadowReceiving(bool in_state);
9534 
9538  VisibilityControl & SetShadowEmitting(bool in_state);
9539 
9540 
9544  VisibilityControl & SetCutGeometry(bool in_state);
9545 
9549  VisibilityControl & SetEdges(bool in_state);
9550 
9554  VisibilityControl & SetGeometry(bool in_state);
9555 
9559  VisibilityControl & SetLights(bool in_state);
9560 
9564  VisibilityControl & SetShadows(bool in_state);
9565 
9569  VisibilityControl & SetEverything(bool in_state);
9570 
9571 
9574  VisibilityControl & UnsetCuttingSections();
9575 
9578  VisibilityControl & UnsetCutEdges();
9579 
9582  VisibilityControl & UnsetCutFaces();
9583 
9586  VisibilityControl & UnsetWindows();
9587 
9590  VisibilityControl & UnsetText();
9591 
9594  VisibilityControl & UnsetLines();
9595 
9598  VisibilityControl & UnsetEdgeLights();
9599 
9602  VisibilityControl & UnsetMarkerLights();
9603 
9606  VisibilityControl & UnsetFaceLights();
9607 
9610  VisibilityControl & UnsetGenericEdges();
9611 
9614  VisibilityControl & UnsetInteriorSilhouetteEdges();
9615 
9618  VisibilityControl & UnsetAdjacentEdges();
9619 
9622  VisibilityControl & UnsetHardEdges();
9623 
9626  VisibilityControl & UnsetMeshQuadEdges();
9627 
9630  VisibilityControl & UnsetNonCulledEdges();
9631 
9634  VisibilityControl & UnsetPerimeterEdges();
9635 
9638  VisibilityControl & UnsetFaces();
9639 
9642  VisibilityControl & UnsetVertices();
9643 
9646  VisibilityControl & UnsetMarkers();
9647 
9650  VisibilityControl & UnsetShadowCasting();
9651 
9654  VisibilityControl & UnsetShadowReceiving();
9655 
9658  VisibilityControl & UnsetShadowEmitting();
9659 
9660 
9663  VisibilityControl & UnsetCutGeometry();
9664 
9667  VisibilityControl & UnsetEdges();
9668 
9671  VisibilityControl & UnsetGeometry();
9672 
9675  VisibilityControl & UnsetLights();
9676 
9679  VisibilityControl & UnsetShadows();
9680 
9683  VisibilityControl & UnsetEverything();
9684 
9685 
9689  bool ShowCuttingSections(bool & out_state) const;
9690 
9694  bool ShowCutEdges(bool & out_state) const;
9695 
9699  bool ShowCutFaces(bool & out_state) const;
9700 
9704  bool ShowWindows(bool & out_state) const;
9705 
9709  bool ShowText(bool & out_state) const;
9710 
9714  bool ShowLines(bool & out_state) const;
9715 
9719  bool ShowEdgeLights(bool & out_state) const;
9720 
9724  bool ShowMarkerLights(bool & out_state) const;
9725 
9729  bool ShowFaceLights(bool & out_state) const;
9730 
9734  bool ShowGenericEdges(bool & out_state) const;
9735 
9739  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9740 
9744  bool ShowAdjacentEdges(bool & out_state) const;
9745 
9749  bool ShowHardEdges(bool & out_state) const;
9750 
9754  bool ShowMeshQuadEdges(bool & out_state) const;
9755 
9759  bool ShowNonCulledEdges(bool & out_state) const;
9760 
9764  bool ShowPerimeterEdges(bool & out_state) const;
9765 
9769  bool ShowFaces(bool & out_state) const;
9770 
9774  bool ShowVertices(bool & out_state) const;
9775 
9779  bool ShowMarkers(bool & out_state) const;
9780 
9784  bool ShowShadowCasting(bool & out_state) const;
9785 
9789  bool ShowShadowReceiving(bool & out_state) const;
9790 
9794  bool ShowShadowEmitting(bool & out_state) const;
9795 
9796 private:
9799 };
9800 
9801 
9802 
9805 class HPS_API CameraKit : public Object
9806 {
9807 public:
9808 
9810  CameraKit();
9811 
9814  CameraKit(const CameraKit & in_kit);
9815 
9819  CameraKit(CameraKit && in_that);
9820 
9824  CameraKit & operator=(CameraKit && in_that);
9825 
9827  virtual ~CameraKit();
9828 
9829  Type ObjectType() const {return Type::CameraKit;};
9830 
9834  static CameraKit GetDefault();
9835 
9838  void Set(CameraKit const & in_kit);
9839 
9842  void Show(CameraKit & out_kit) const;
9843 
9847  CameraKit & operator=(CameraKit const & in_kit);
9848 
9851  bool Empty() const;
9852 
9856  bool Equals(CameraKit const & in_kit) const;
9857 
9861  bool operator==(CameraKit const & in_kit) const;
9862 
9866  bool operator!=(CameraKit const & in_kit) const;
9867 
9871  CameraKit & SetUpVector(Vector const & in_up);
9872 
9876  CameraKit & SetPosition(Point const & in_position);
9877 
9881  CameraKit & SetTarget(Point const & in_target);
9882 
9889  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
9890 
9896  CameraKit & SetField(float in_width, float in_height);
9897 
9907  CameraKit & SetNearLimit(float const in_limit);
9908 
9911  CameraKit & UnsetUpVector();
9912 
9915  CameraKit & UnsetPosition();
9916 
9919  CameraKit & UnsetTarget();
9920 
9923  CameraKit & UnsetProjection();
9924 
9927  CameraKit & UnsetField();
9928 
9931  CameraKit & UnsetNearLimit();
9932 
9935  CameraKit & UnsetEverything();
9936 
9937 
9941  bool ShowUpVector(Vector & out_up) const;
9942 
9946  bool ShowPosition(Point & out_position) const;
9947 
9951  bool ShowTarget(Point & out_target) const;
9952 
9956  bool ShowProjection(Camera::Projection & out_type) const;
9957 
9963  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
9964 
9968  bool ShowWidth(float & out_width) const;
9969 
9973  bool ShowHeight(float & out_height) const;
9974 
9979  bool ShowField(float & out_width, float & out_height) const;
9980 
9984  bool ShowNearLimit(float & out_near_limit) const;
9985 
9992  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
9993 
10000  CameraKit & Orbit(float in_theta, float in_phi);
10001 
10008  CameraKit & Pan(float in_theta, float in_phi);
10009 
10015  CameraKit & Roll(float in_theta);
10016 
10022  CameraKit & Zoom(float in_zoom);
10023 };
10024 
10028 class HPS_API CameraControl : public Control
10029 {
10030 public:
10032  explicit CameraControl(SegmentKey & in_seg);
10033 
10035  CameraControl(CameraControl const & in_that);
10036 
10040  CameraControl(CameraControl && in_that);
10041 
10045  CameraControl & operator=(CameraControl && in_that);
10046 
10048  ~CameraControl();
10049 
10050  Type ObjectType() const {return Type::CameraControl;};
10051 
10053  CameraControl & operator=(CameraControl const & in_that);
10054 
10055 
10060  CameraControl & SetUpVector(Vector const & in_up);
10061 
10066  CameraControl & SetPosition(Point const & in_position);
10067 
10072  CameraControl & SetTarget(Point const & in_target);
10073 
10080  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10081 
10087  CameraControl & SetField(float in_width, float in_height);
10088 
10099  CameraControl & SetNearLimit(float in_double);
10100 
10104  CameraControl & UnsetEverything();
10105 
10106 
10110  bool ShowUpVector(Vector & out_up) const;
10111 
10115  bool ShowPosition(Point & out_position) const;
10116 
10120  bool ShowTarget(Point & out_target) const;
10121 
10125  bool ShowProjection(Camera::Projection & out_type) const;
10126 
10132  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10133 
10137  bool ShowWidth(float & out_width) const;
10138 
10142  bool ShowHeight(float & out_height) const;
10143 
10148  bool ShowField(float & out_width, float & out_height) const;
10149 
10153  bool ShowNearLimit(float & out_width) const;
10154 
10161  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10162 
10169  CameraControl & Orbit(float in_theta, float in_phi);
10170 
10177  CameraControl & Pan(float in_theta, float in_phi);
10178 
10184  CameraControl & Roll(float in_theta);
10185 
10191  CameraControl & Zoom(float in_zoom);
10192 
10193 private:
10195  CameraControl();
10196 };
10197 
10198 
10199 
10201 class HPS_API SelectabilityKit : public Object
10202 {
10203 public:
10204 
10206  SelectabilityKit();
10207 
10210  SelectabilityKit(SelectabilityKit const & in_kit);
10211 
10215  SelectabilityKit(SelectabilityKit && in_that);
10216 
10220  SelectabilityKit & operator=(SelectabilityKit && in_that);
10221 
10223  virtual ~SelectabilityKit();
10224 
10225  Type ObjectType() const {return Type::SelectabilityKit;};
10226 
10230  static SelectabilityKit GetDefault();
10231 
10234  void Set(SelectabilityKit const & in_kit);
10235 
10238  void Show(SelectabilityKit & out_kit) const;
10239 
10243  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10244 
10247  bool Empty() const;
10248 
10252  bool Equals(SelectabilityKit const & in_kit) const;
10253 
10257  bool operator==(SelectabilityKit const & in_kit) const;
10258 
10262  bool operator!=(SelectabilityKit const & in_kit) const;
10263 
10264 
10268  SelectabilityKit & SetWindows(Selectability::Value in_val);
10269 
10273  SelectabilityKit & SetEdges(Selectability::Value in_val);
10274 
10278  SelectabilityKit & SetFaces(Selectability::Value in_val);
10279 
10283  SelectabilityKit & SetLights(Selectability::Value in_val);
10284 
10288  SelectabilityKit & SetLines(Selectability::Value in_val);
10289 
10293  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10294 
10298  SelectabilityKit & SetVertices(Selectability::Value in_val);
10299 
10303  SelectabilityKit & SetText(Selectability::Value in_val);
10304 
10308  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10309 
10313  SelectabilityKit & SetEverything(Selectability::Value in_val);
10314 
10315 
10318  SelectabilityKit & UnsetWindows();
10319 
10322  SelectabilityKit & UnsetEdges();
10323 
10326  SelectabilityKit & UnsetFaces();
10327 
10330  SelectabilityKit & UnsetLights();
10331 
10334  SelectabilityKit & UnsetLines();
10335 
10338  SelectabilityKit & UnsetMarkers();
10339 
10342  SelectabilityKit & UnsetVertices();
10343 
10346  SelectabilityKit & UnsetText();
10347 
10350  SelectabilityKit & UnsetGeometry();
10351 
10354  SelectabilityKit & UnsetEverything();
10355 
10356 
10360  bool ShowWindows(Selectability::Value & out_val) const;
10361 
10365  bool ShowEdges(Selectability::Value & out_val) const;
10366 
10370  bool ShowFaces(Selectability::Value & out_val) const;
10371 
10375  bool ShowLights(Selectability::Value & out_val) const;
10376 
10380  bool ShowLines(Selectability::Value & out_val) const;
10381 
10385  bool ShowMarkers(Selectability::Value & out_val) const;
10386 
10390  bool ShowVertices(Selectability::Value & out_val) const;
10391 
10395  bool ShowText(Selectability::Value & out_val) const;
10396 };
10397 
10403 class HPS_API SelectabilityControl : public Control
10404 {
10405 public:
10406 
10408  explicit SelectabilityControl(SegmentKey & in_seg);
10409 
10411  SelectabilityControl(SelectabilityControl const & in_that);
10412 
10417 
10421  SelectabilityControl & operator=(SelectabilityControl && in_that);
10422 
10425 
10426  Type ObjectType() const {return Type::SelectabilityControl;};
10427 
10429  SelectabilityControl & operator=(SelectabilityControl const & in_that);
10430 
10431 
10435  SelectabilityControl & SetWindows(Selectability::Value in_val);
10436 
10440  SelectabilityControl & SetEdges(Selectability::Value in_val);
10441 
10445  SelectabilityControl & SetFaces(Selectability::Value in_val);
10446 
10450  SelectabilityControl & SetLights(Selectability::Value in_val);
10451 
10455  SelectabilityControl & SetLines(Selectability::Value in_val);
10456 
10460  SelectabilityControl & SetMarkers(Selectability::Value in_val);
10461 
10465  SelectabilityControl & SetVertices(Selectability::Value in_val);
10466 
10470  SelectabilityControl & SetText(Selectability::Value in_val);
10471 
10475  SelectabilityControl & SetGeometry(Selectability::Value in_val);
10476 
10480  SelectabilityControl & SetEverything(Selectability::Value in_val);
10481 
10482 
10485  SelectabilityControl & UnsetWindows();
10486 
10489  SelectabilityControl & UnsetEdges();
10490 
10493  SelectabilityControl & UnsetFaces();
10494 
10497  SelectabilityControl & UnsetLights();
10498 
10501  SelectabilityControl & UnsetLines();
10502 
10505  SelectabilityControl & UnsetMarkers();
10506 
10509  SelectabilityControl & UnsetVertices();
10510 
10513  SelectabilityControl & UnsetText();
10514 
10517  SelectabilityControl & UnsetGeometry();
10518 
10521  SelectabilityControl & UnsetEverything();
10522 
10523 
10527  bool ShowWindows(Selectability::Value & out_val) const;
10528 
10532  bool ShowEdges(Selectability::Value & out_val) const;
10533 
10537  bool ShowFaces(Selectability::Value & out_val) const;
10538 
10542  bool ShowLights(Selectability::Value & out_val) const;
10543 
10547  bool ShowLines(Selectability::Value & out_val) const;
10548 
10552  bool ShowMarkers(Selectability::Value & out_val) const;
10553 
10557  bool ShowVertices(Selectability::Value & out_val) const;
10558 
10562  bool ShowText(Selectability::Value & out_val) const;
10563 
10564 private:
10567 };
10568 
10569 
10571 class HPS_API TransparencyKit : public Object
10572 {
10573 public:
10574 
10576  TransparencyKit();
10577 
10580  TransparencyKit(TransparencyKit const & in_kit);
10581 
10585  TransparencyKit(TransparencyKit && in_that);
10586 
10590  TransparencyKit & operator=(TransparencyKit && in_that);
10591 
10593  virtual ~TransparencyKit();
10594 
10595  Type ObjectType() const {return Type::TransparencyKit;};
10596 
10600  static TransparencyKit GetDefault();
10601 
10604  void Set(TransparencyKit const & in_kit);
10605 
10608  void Show(TransparencyKit & out_kit) const;
10609 
10613  TransparencyKit & operator=(TransparencyKit const & in_kit);
10614 
10617  bool Empty() const;
10618 
10622  bool Equals(TransparencyKit const & in_kit) const;
10623 
10627  bool operator==(TransparencyKit const & in_kit) const;
10628 
10632  bool operator!=(TransparencyKit const & in_kit) const;
10633 
10634 
10638  TransparencyKit & SetMethod(Transparency::Method in_style);
10639 
10643  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
10644 
10649  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
10650 
10656  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
10657 
10662  TransparencyKit & SetDepthWriting(bool in_state);
10663 
10664 
10667  TransparencyKit & UnsetMethod();
10668 
10671  TransparencyKit & UnsetAlgorithm();
10672 
10675  TransparencyKit & UnsetDepthPeelingLayers();
10676 
10679  TransparencyKit & UnsetDepthPeelingMinimumArea();
10680 
10683  TransparencyKit & UnsetDepthWriting();
10684 
10687  TransparencyKit & UnsetEverything();
10688 
10689 
10693  bool ShowMethod(Transparency::Method & out_style) const;
10694 
10698  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
10699 
10703  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
10704 
10709  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
10710 
10714  bool ShowDepthWriting(bool & out_state) const;
10715 };
10716 
10722 class HPS_API TransparencyControl : public Control
10723 {
10724 public:
10725 
10727  explicit TransparencyControl(SegmentKey & in_seg);
10728 
10730  TransparencyControl(TransparencyControl const & in_that);
10731 
10736 
10740  TransparencyControl & operator=(TransparencyControl && in_that);
10741 
10744 
10745  Type ObjectType() const {return Type::TransparencyControl;};
10746 
10748  TransparencyControl & operator=(TransparencyControl const & in_that);
10749 
10753  TransparencyControl & SetMethod(Transparency::Method in_style);
10754 
10758  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
10759 
10764  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
10765 
10771  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
10772 
10777  TransparencyControl & SetDepthWriting(bool in_state);
10778 
10779 
10782  TransparencyControl & UnsetMethod();
10783 
10786  TransparencyControl & UnsetAlgorithm();
10787 
10790  TransparencyControl & UnsetDepthPeelingLayers();
10791 
10794  TransparencyControl & UnsetDepthPeelingMinimumArea();
10795 
10798  TransparencyControl & UnsetDepthWriting();
10799 
10802  TransparencyControl & UnsetEverything();
10803 
10804 
10808  bool ShowMethod(Transparency::Method & out_style) const;
10809 
10813  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
10814 
10818  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
10819 
10824  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
10825 
10829  bool ShowDepthWriting(bool & out_state) const;
10830 
10831 private:
10834 };
10835 
10837 class HPS_API ColorInterpolationKit : public Object
10838 {
10839 public:
10840 
10843 
10846 
10851 
10855  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
10856 
10858  virtual ~ColorInterpolationKit();
10859 
10860  Type ObjectType() const {return Type::ColorInterpolationKit;};
10861 
10862  static ColorInterpolationKit GetDefault();
10863 
10865  void Set(ColorInterpolationKit const & in_kit);
10866 
10868  void Show(ColorInterpolationKit & out_kit) const;
10869 
10871  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
10872 
10874  bool Empty() const;
10875 
10877  bool Equals(ColorInterpolationKit const & in_kit) const;
10878 
10880  bool operator==(ColorInterpolationKit const & in_kit) const;
10881 
10883  bool operator!=(ColorInterpolationKit const & in_kit) const;
10884 
10885 
10889  ColorInterpolationKit & SetFaceColor(bool in_state);
10890 
10894  ColorInterpolationKit & SetEdgeColor(bool in_state);
10895 
10899  ColorInterpolationKit & SetVertexColor(bool in_state);
10900 
10904  ColorInterpolationKit & SetFaceIndex(bool in_state);
10905 
10909  ColorInterpolationKit & SetEdgeIndex(bool in_state);
10910 
10914  ColorInterpolationKit & SetVertexIndex(bool in_state);
10915 
10916 
10919  ColorInterpolationKit & UnsetFaceColor();
10920 
10923  ColorInterpolationKit & UnsetEdgeColor();
10924 
10927  ColorInterpolationKit & UnsetVertexColor();
10928 
10931  ColorInterpolationKit & UnsetFaceIndex();
10932 
10935  ColorInterpolationKit & UnsetEdgeIndex();
10936 
10939  ColorInterpolationKit & UnsetVertexIndex();
10940 
10943  ColorInterpolationKit & UnsetEverything();
10944 
10945 
10949  bool ShowFaceColor(bool & out_state) const;
10950 
10954  bool ShowEdgeColor(bool & out_state) const;
10955 
10959  bool ShowVertexColor(bool & out_state) const;
10960 
10964  bool ShowFaceIndex(bool & out_state) const;
10965 
10969  bool ShowEdgeIndex(bool & out_state) const;
10970 
10974  bool ShowVertexIndex(bool & out_state) const;
10975 };
10976 
10977 
10981 class HPS_API ColorInterpolationControl : public Control
10982 {
10983 public:
10984 
10986  explicit ColorInterpolationControl(SegmentKey & in_seg);
10987 
10990 
10995 
10999  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11000 
11003 
11004  Type ObjectType() const {return Type::ColorInterpolationControl;};
11005 
11006 
11010  ColorInterpolationControl & SetFaceColor(bool in_state);
11011 
11015  ColorInterpolationControl & SetEdgeColor(bool in_state);
11016 
11020  ColorInterpolationControl & SetVertexColor(bool in_state);
11021 
11025  ColorInterpolationControl & SetFaceIndex(bool in_state);
11026 
11030  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11031 
11035  ColorInterpolationControl & SetVertexIndex(bool in_state);
11036 
11037 
11040  ColorInterpolationControl & UnsetFaceColor();
11041 
11044  ColorInterpolationControl & UnsetEdgeColor();
11045 
11048  ColorInterpolationControl & UnsetVertexColor();
11049 
11052  ColorInterpolationControl & UnsetFaceIndex();
11053 
11056  ColorInterpolationControl & UnsetEdgeIndex();
11057 
11060  ColorInterpolationControl & UnsetVertexIndex();
11061 
11064  ColorInterpolationControl & UnsetEverything();
11065 
11066 
11070  bool ShowFaceColor(bool & out_state) const;
11071 
11075  bool ShowEdgeColor(bool & out_state) const;
11076 
11080  bool ShowVertexColor(bool & out_state) const;
11081 
11085  bool ShowFaceIndex(bool & out_state) const;
11086 
11090  bool ShowEdgeIndex(bool & out_state) const;
11091 
11095  bool ShowVertexIndex(bool & out_state) const;
11096 
11097 private:
11100 };
11101 
11102 
11104 class HPS_API CullingKit : public Object
11105 {
11106 public:
11107 
11109  CullingKit();
11110 
11113  CullingKit(CullingKit const & in_kit);
11114 
11118  CullingKit(CullingKit && in_that);
11119 
11123  CullingKit & operator=(CullingKit && in_that);
11124 
11126  virtual ~CullingKit();
11127 
11128  Type ObjectType() const {return Type::CullingKit;};
11129 
11133  static CullingKit GetDefault();
11134 
11137  void Set(CullingKit const & in_kit);
11138 
11141  void Show(CullingKit & out_kit) const;
11142 
11146  CullingKit & operator=(CullingKit const & in_kit);
11147 
11150  bool Empty() const;
11151 
11155  bool Equals(CullingKit const & in_kit) const;
11156 
11160  bool operator==(CullingKit const & in_kit) const;
11161 
11165  bool operator!=(CullingKit const & in_kit) const;
11166 
11171  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11172 
11177  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11178 
11183  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11184 
11189  CullingKit & SetExtent(unsigned int in_pixels);
11190 
11194  CullingKit & SetBackFace(bool in_state);
11195 
11202  CullingKit & SetVector(bool in_state, Vector const & in_vector, float in_tolerance_degrees);
11203 
11210  CullingKit & SetVector(Vector const & in_vector, float in_tolerance_degrees);
11211 
11218  CullingKit & SetVector(bool in_state, Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11219 
11225  CullingKit & SetVector(Vector const & in_vector);
11226 
11230  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11231 
11235  CullingKit & SetFrustum(bool in_state);
11236 
11239  CullingKit & UnsetDeferralExtent();
11240 
11243  CullingKit & UnsetExtent();
11244 
11247  CullingKit & UnsetBackFace();
11248 
11251  CullingKit & UnsetVector();
11252 
11255  CullingKit & UnsetVectorTolerance();
11256 
11259  CullingKit & UnsetFrustum();
11260 
11263  CullingKit & UnsetEverything();
11264 
11269  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11270 
11275  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11276 
11280  bool ShowBackFace(bool & out_state) const;
11281 
11287  bool ShowVector(bool & out_state, Vector & out_vector) const;
11288 
11292  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11293 
11297  bool ShowFrustum(bool & out_state) const;
11298 };
11299 
11303 class HPS_API CullingControl : public Control
11304 {
11305 public:
11306 
11308  explicit CullingControl(SegmentKey & in_seg);
11309 
11311  CullingControl(CullingControl const & in_that);
11312 
11314  ~CullingControl();
11315 
11319  CullingControl(CullingControl && in_that);
11320 
11324  CullingControl & operator=(CullingControl && in_that);
11325 
11326  Type ObjectType() const {return Type::CullingControl;};
11327 
11329  CullingControl & operator=(CullingControl const & in_that);
11330 
11337  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11338 
11345  CullingControl & SetDeferralExtent(unsigned int in_pixels);
11346 
11351  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
11352 
11357  CullingControl & SetExtent(unsigned int in_pixels);
11358 
11363  CullingControl & SetBackFace(bool in_state);
11364 
11371  CullingControl & SetVector(bool in_state, Vector const & in_vector, float in_tolerance_degrees);
11372 
11379  CullingControl & SetVector(Vector const & in_vector, float in_tolerance_degrees);
11380 
11387  CullingControl & SetVector(bool in_state, Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11388 
11394  CullingControl & SetVector(Vector const & in_vector);
11395 
11399  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
11400 
11404  CullingControl & SetFrustum(bool in_state);
11405 
11408  CullingControl & UnsetDeferralExtent();
11409 
11412  CullingControl & UnsetExtent();
11413 
11416  CullingControl & UnsetBackFace();
11417 
11420  CullingControl & UnsetVector();
11421 
11424  CullingControl & UnsetVectorTolerance();
11425 
11428  CullingControl & UnsetFrustum();
11429 
11432  CullingControl & UnsetEverything();
11433 
11438  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11439 
11444  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11445 
11449  bool ShowBackFace(bool & out_state) const;
11450 
11456  bool ShowVector(bool & out_state, Vector & out_vector) const;
11457 
11461  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11462 
11466  bool ShowFrustum(bool & out_state) const;
11467 
11468 private:
11470  CullingControl();
11471 };
11472 
11473 
11474 
11475 
11477 class HPS_API MarkerAttributeKit : public Object
11478 {
11479 public:
11480 
11483 
11486  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
11487 
11492 
11496  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
11497 
11499  virtual ~MarkerAttributeKit();
11500 
11501  Type ObjectType() const {return Type::MarkerAttributeKit;};
11502 
11506  static MarkerAttributeKit GetDefault();
11507 
11510  void Set(MarkerAttributeKit const & in_kit);
11511 
11514  void Show(MarkerAttributeKit & out_kit) const;
11515 
11519  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
11520 
11523  bool Empty() const;
11524 
11528  bool Equals(MarkerAttributeKit const & in_kit) const;
11529 
11533  bool operator==(MarkerAttributeKit const & in_kit) const;
11534 
11538  bool operator!=(MarkerAttributeKit const & in_kit) const;
11539 
11540 
11544  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
11545 
11550  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
11551 
11552 
11555  MarkerAttributeKit & UnsetSymbol();
11556 
11559  MarkerAttributeKit & UnsetSize();
11560 
11563  MarkerAttributeKit & UnsetEverything();
11564 
11565 
11569  bool ShowSymbol(UTF8 & out_glyph_name) const;
11570 
11575  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
11576 };
11577 
11583 class HPS_API MarkerAttributeControl : public Control
11584 {
11585 public:
11586 
11588  explicit MarkerAttributeControl(SegmentKey & in_seg);
11589 
11592 
11597 
11601  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
11602 
11605 
11606  Type ObjectType() const {return Type::MarkerAttributeControl;};
11607 
11609  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
11610 
11614  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
11615 
11620  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
11621 
11622 
11625  MarkerAttributeControl & UnsetSymbol();
11626 
11629  MarkerAttributeControl & UnsetSize();
11630 
11633  MarkerAttributeControl & UnsetEverything();
11634 
11635 
11639  bool ShowSymbol(UTF8 & out_glyph_name) const;
11640 
11645  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
11646 
11647 private:
11650 };
11651 
11652 
11654 class HPS_API SphereAttributeKit : public Object
11655 {
11656 public:
11657 
11660 
11663  SphereAttributeKit(SphereAttributeKit const & in_kit);
11664 
11669 
11673  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
11674 
11676  virtual ~SphereAttributeKit();
11677 
11678  Type ObjectType() const {return Type::SphereAttributeKit;};
11679 
11683  static SphereAttributeKit GetDefault();
11684 
11687  void Set(SphereAttributeKit const & in_kit);
11688 
11691  void Show(SphereAttributeKit & out_kit) const;
11692 
11696  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
11697 
11700  bool Empty() const;
11701 
11705  bool Equals(SphereAttributeKit const & in_kit) const;
11706 
11710  bool operator==(SphereAttributeKit const & in_kit) const;
11711 
11715  bool operator!=(SphereAttributeKit const & in_kit) const;
11716 
11717 
11721  SphereAttributeKit & SetTessellation(size_t in_facets);
11722 
11723 
11726  SphereAttributeKit & UnsetTessellation();
11727 
11730  SphereAttributeKit & UnsetEverything();
11731 
11732 
11736  bool ShowTessellation(size_t & out_facets) const;
11737 };
11738 
11739 
11742 class HPS_API SphereAttributeControl : public Control
11743 {
11744 public:
11745 
11747  explicit SphereAttributeControl(SegmentKey const & in_seg);
11748 
11751 
11756 
11760  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
11761 
11764 
11765  Type ObjectType() const {return Type::SphereAttributeControl;};
11766 
11768  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
11769 
11770 
11775  SphereAttributeControl & SetTessellation(size_t in_facets);
11776 
11777 
11780  SphereAttributeControl & UnsetTessellation();
11781 
11784  SphereAttributeControl & UnsetEverything();
11785 
11786 
11790  bool ShowTessellation(size_t & out_facets) const;
11791 
11792 private:
11795 };
11796 
11797 
11799 class HPS_API LightingAttributeKit : public Object
11800 {
11801 public:
11802 
11805 
11809 
11814 
11818  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
11819 
11821  virtual ~LightingAttributeKit();
11822 
11823  Type ObjectType() const {return Type::LightingAttributeKit;};
11824 
11828  static LightingAttributeKit GetDefault();
11829 
11832  void Set(LightingAttributeKit const & in_kit);
11833 
11836  void Show(LightingAttributeKit & out_kit) const;
11837 
11841  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
11842 
11845  bool Empty() const;
11846 
11850  bool Equals(LightingAttributeKit const & in_kit) const;
11851 
11855  bool operator==(LightingAttributeKit const & in_kit) const;
11856 
11860  bool operator!=(LightingAttributeKit const & in_kit) const;
11861 
11862 
11866  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
11867 
11868 
11871  LightingAttributeKit & UnsetInterpolationAlgorithm();
11872 
11875  LightingAttributeKit & UnsetEverything();
11876 
11877 
11881  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
11882 };
11883 
11884 
11885 
11891 class HPS_API LightingAttributeControl : public Control
11892 {
11893 public:
11894 
11896  explicit LightingAttributeControl(SegmentKey & in_seg);
11897 
11900 
11905 
11909  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
11910 
11913 
11914  Type ObjectType() const {return Type::LightingAttributeControl;};
11915 
11917  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
11918 
11919 
11923  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
11924 
11925 
11928  LightingAttributeControl & UnsetInterpolationAlgorithm();
11929 
11932  LightingAttributeControl & UnsetEverything();
11933 
11934 
11938  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
11939 
11940 private:
11943 };
11944 
11945 
11946 
11948 class HPS_API CylinderAttributeKit : public Object
11949 {
11950 public:
11951 
11954 
11958 
11963 
11967  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
11968 
11970  virtual ~CylinderAttributeKit();
11971 
11972  Type ObjectType() const {return Type::CylinderAttributeKit;};
11973 
11977  static CylinderAttributeKit GetDefault();
11978 
11981  void Set(CylinderAttributeKit const & in_kit);
11982 
11985  void Show(CylinderAttributeKit & out_kit) const;
11986 
11990  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
11991 
11994  bool Empty() const;
11995 
11999  bool Equals(CylinderAttributeKit const & in_kit) const;
12000 
12004  bool operator==(CylinderAttributeKit const & in_kit) const;
12005 
12009  bool operator!=(CylinderAttributeKit const & in_kit) const;
12010 
12011 
12015  CylinderAttributeKit & SetTessellation(size_t in_facets);
12016 
12021  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12022 
12023 
12026  CylinderAttributeKit & UnsetTessellation();
12027 
12030  CylinderAttributeKit & UnsetOrientation();
12031 
12034  CylinderAttributeKit & UnsetEverything();
12035 
12036 
12040  bool ShowTessellation(size_t & out_facets) const;
12041 
12045  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12046 };
12047 
12048 
12049 
12053 class HPS_API CylinderAttributeControl : public Control
12054 {
12055 public:
12056 
12058  explicit CylinderAttributeControl(SegmentKey & in_seg);
12059 
12062 
12067 
12071  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12072 
12075 
12076  Type ObjectType() const {return Type::CylinderAttributeControl;};
12077 
12079  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12080 
12081 
12085  CylinderAttributeControl & SetTessellation(size_t in_facets);
12086 
12091  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12092 
12093 
12096  CylinderAttributeControl & UnsetTessellation();
12097 
12100  CylinderAttributeControl & UnsetOrientation();
12101 
12104  CylinderAttributeControl & UnsetEverything();
12105 
12106 
12110  bool ShowTessellation(size_t & out_facets) const;
12111 
12115  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12116 
12117 private:
12120 };
12121 
12122 
12123 
12125 class HPS_API CuttingSectionAttributeKit : public Object
12126 {
12127 public:
12128 
12131 
12135 
12140 
12145 
12147  virtual ~CuttingSectionAttributeKit();
12148 
12149  Type ObjectType() const {return Type::CuttingSectionAttributeKit;};
12150 
12154  static CuttingSectionAttributeKit GetDefault();
12155 
12158  void Set(CuttingSectionAttributeKit const & in_kit);
12159 
12162  void Show(CuttingSectionAttributeKit & out_kit) const;
12163 
12167  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12168 
12171  bool Empty() const;
12172 
12176  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12177 
12181  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12182 
12186  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12187 
12188 
12192  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12193 
12197  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12198 
12202  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12203 
12204 
12207  CuttingSectionAttributeKit & UnsetCuttingLevel();
12208 
12211  CuttingSectionAttributeKit & UnsetCappingLevel();
12212 
12215  CuttingSectionAttributeKit & UnsetMaterialPreference();
12216 
12219  CuttingSectionAttributeKit & UnsetEverything();
12220 
12221 
12225  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12226 
12230  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12231 
12235  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12236 };
12237 
12238 
12239 
12244 {
12245 public:
12246 
12248  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12249 
12252 
12257 
12262 
12265 
12266  Type ObjectType() const {return Type::CuttingSectionAttributeControl;};
12267 
12270 
12271 
12276 
12281 
12285  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12286 
12287 
12290  CuttingSectionAttributeControl & UnsetCuttingLevel();
12291 
12294  CuttingSectionAttributeControl & UnsetCappingLevel();
12295 
12298  CuttingSectionAttributeControl & UnsetMaterialPreference();
12299 
12302  CuttingSectionAttributeControl & UnsetEverything();
12303 
12304 
12308  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12309 
12313  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12314 
12318  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12319 
12320 private:
12323 };
12324 
12325 
12326 
12328 class HPS_API TextAttributeKit : public Object
12329 {
12330 public:
12331 
12333  TextAttributeKit();
12334 
12337  TextAttributeKit(TextAttributeKit const & in_kit);
12338 
12342  TextAttributeKit(TextAttributeKit && in_that);
12343 
12347  TextAttributeKit & operator=(TextAttributeKit && in_that);
12348 
12350  virtual ~TextAttributeKit();
12351 
12352  Type ObjectType() const {return Type::TextAttributeKit;};
12353 
12357  static TextAttributeKit GetDefault();
12358 
12361  void Set(TextAttributeKit const & in_kit);
12362 
12365  void Show(TextAttributeKit & out_kit) const;
12366 
12370  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
12371 
12374  bool Empty() const;
12375 
12379  bool Equals(TextAttributeKit const & in_kit) const;
12380 
12384  bool operator==(TextAttributeKit const & in_kit) const;
12385 
12389  bool operator!=(TextAttributeKit const & in_kit) const;
12390 
12391 
12398 
12403  TextAttributeKit & SetBold(bool in_state);
12404 
12409  TextAttributeKit & SetItalic(bool in_state);
12410 
12414  TextAttributeKit & SetOverline(bool in_state);
12415 
12419  TextAttributeKit & SetStrikethrough(bool in_state);
12420 
12424  TextAttributeKit & SetUnderline(bool in_state);
12425 
12431  TextAttributeKit & SetSlant(float in_angle);
12432 
12437  TextAttributeKit & SetLineSpacing(float in_multiplier);
12438 
12443  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12444 
12449  TextAttributeKit & SetRotation(float in_angle);
12450 
12456  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12457 
12463  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12464 
12471  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12472 
12479 
12489  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12490 
12500  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
12501 
12506  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
12507 
12514  TextAttributeKit & SetFont(char const * in_name);
12515 
12519  TextAttributeKit & SetTransform(Text::Transform in_trans);
12520 
12524  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
12525 
12530  TextAttributeKit & SetPreference(Text::Preference in_pref);
12531 
12539  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
12540 
12545  TextAttributeKit & SetPath(Vector const & in_path);
12546 
12554  TextAttributeKit & SetSpacing(float in_multiplier);
12555 
12556 
12559  TextAttributeKit & UnsetAlignment();
12560 
12563  TextAttributeKit & UnsetBold();
12564 
12567  TextAttributeKit & UnsetItalic();
12568 
12571  TextAttributeKit & UnsetOverline();
12572 
12575  TextAttributeKit & UnsetStrikethrough();
12576 
12579  TextAttributeKit & UnsetUnderline();
12580 
12583  TextAttributeKit & UnsetSlant();
12584 
12587  TextAttributeKit & UnsetLineSpacing();
12588 
12591  TextAttributeKit & UnsetRotation();
12592 
12595  TextAttributeKit & UnsetExtraSpace();
12596 
12599  TextAttributeKit & UnsetGreeking();
12600 
12603  TextAttributeKit & UnsetSizeTolerance();
12604 
12607  TextAttributeKit & UnsetSize();
12608 
12611  TextAttributeKit & UnsetFont();
12612 
12615  TextAttributeKit & UnsetTransform();
12616 
12619  TextAttributeKit & UnsetRenderer();
12620 
12623  TextAttributeKit & UnsetPreference();
12624 
12627  TextAttributeKit & UnsetPath();
12628 
12631  TextAttributeKit & UnsetSpacing();
12632 
12635  TextAttributeKit & UnsetEverything();
12636 
12637 
12643  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
12644 
12648  bool ShowBold(bool & out_state) const;
12649 
12653  bool ShowItalic(bool & out_state) const;
12654 
12658  bool ShowOverline(bool & out_state) const;
12659 
12663  bool ShowStrikethrough(bool & out_state) const;
12664 
12668  bool ShowUnderline(bool & out_state) const;
12669 
12673  bool ShowSlant(float & out_angle) const;
12674 
12678  bool ShowLineSpacing(float & out_multiplier) const;
12679 
12684  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
12685 
12691  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
12692 
12699  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
12700 
12706  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
12707 
12712  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
12713 
12717  bool ShowFont(UTF8 & out_name) const;
12718 
12722  bool ShowTransform(Text::Transform & out_trans) const;
12723 
12727  bool ShowRenderer(Text::Renderer & out_rend) const;
12728 
12735  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
12736 
12740  bool ShowPath(Vector & out_path) const;
12741 
12745  bool ShowSpacing(float & out_multiplier) const;
12746 };
12747 
12753 class HPS_API TextAttributeControl : public Control
12754 {
12755 public:
12756 
12758  explicit TextAttributeControl(SegmentKey & in_seg);
12759 
12761  TextAttributeControl(TextAttributeControl const & in_that);
12762 
12767 
12771  TextAttributeControl & operator=(TextAttributeControl && in_that);
12772 
12775 
12776  Type ObjectType() const {return Type::TextAttributeControl;};
12777 
12779  TextAttributeControl & operator=(TextAttributeControl const & in_that);
12780 
12781 
12788 
12793  TextAttributeControl & SetBold(bool in_state);
12794 
12799  TextAttributeControl & SetItalic(bool in_state);
12800 
12804  TextAttributeControl & SetOverline(bool in_state);
12805 
12809  TextAttributeControl & SetStrikethrough(bool in_state);
12810 
12814  TextAttributeControl & SetUnderline(bool in_state);
12815 
12821  TextAttributeControl & SetSlant(float in_angle);
12822 
12827  TextAttributeControl & SetLineSpacing(float in_multiplier);
12828 
12833  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12834 
12839  TextAttributeControl & SetRotation(float in_angle);
12840 
12846  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12847 
12853  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12854 
12861  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12862 
12869 
12879  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12880 
12890  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
12891 
12896  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
12897 
12904  TextAttributeControl & SetFont(char const * in_name);
12905 
12909  TextAttributeControl & SetTransform(Text::Transform in_trans);
12910 
12914  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
12915 
12920  TextAttributeControl & SetPreference(Text::Preference in_pref);
12921 
12929  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
12930 
12935  TextAttributeControl & SetPath(Vector const & in_path);
12936 
12944  TextAttributeControl & SetSpacing(float in_multiplier);
12945 
12946 
12949  TextAttributeControl & UnsetAlignment();
12950 
12953  TextAttributeControl & UnsetBold();
12954 
12957  TextAttributeControl & UnsetItalic();
12958 
12961  TextAttributeControl & UnsetOverline();
12962 
12965  TextAttributeControl & UnsetStrikethrough();
12966 
12969  TextAttributeControl & UnsetUnderline();
12970 
12973  TextAttributeControl & UnsetSlant();
12974 
12977  TextAttributeControl & UnsetLineSpacing();
12978 
12981  TextAttributeControl & UnsetRotation();
12982 
12985  TextAttributeControl & UnsetExtraSpace();
12986 
12989  TextAttributeControl & UnsetGreeking();
12990 
12993  TextAttributeControl & UnsetSizeTolerance();
12994 
12997  TextAttributeControl & UnsetSize();
12998 
13001  TextAttributeControl & UnsetFont();
13002 
13005  TextAttributeControl & UnsetTransform();
13006 
13009  TextAttributeControl & UnsetRenderer();
13010 
13013  TextAttributeControl & UnsetPreference();
13014 
13017  TextAttributeControl & UnsetPath();
13018 
13021  TextAttributeControl & UnsetSpacing();
13022 
13025  TextAttributeControl & UnsetEverything();
13026 
13027 
13033  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13034 
13038  bool ShowBold(bool & out_state) const;
13039 
13043  bool ShowItalic(bool & out_state) const;
13044 
13048  bool ShowOverline(bool & out_state) const;
13049 
13053  bool ShowStrikethrough(bool & out_state) const;
13054 
13058  bool ShowUnderline(bool & out_state) const;
13059 
13063  bool ShowSlant(float & out_angle) const;
13064 
13068  bool ShowLineSpacing(float & out_multiplier) const;
13069 
13074  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13075 
13081  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13082 
13089  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13090 
13096  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13097 
13102  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13103 
13107  bool ShowFont(UTF8 & out_name) const;
13108 
13112  bool ShowTransform(Text::Transform & out_trans) const;
13113 
13117  bool ShowRenderer(Text::Renderer & out_rend) const;
13118 
13125  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13126 
13130  bool ShowPath(Vector & out_path) const;
13131 
13135  bool ShowSpacing(float & out_multiplier) const;
13136 
13137 private:
13140 };
13141 
13142 
13143 
13144 
13145 
13147 class HPS_API LineAttributeKit : public Object
13148 {
13149 public:
13150 
13152  LineAttributeKit();
13153 
13156  LineAttributeKit(LineAttributeKit const & in_kit);
13157 
13161  LineAttributeKit(LineAttributeKit && in_that);
13162 
13166  LineAttributeKit & operator=(LineAttributeKit && in_that);
13167 
13169  virtual ~LineAttributeKit();
13170 
13171  Type ObjectType() const {return Type::LineAttributeKit;};
13172 
13176  static LineAttributeKit GetDefault();
13177 
13180  void Set(LineAttributeKit const & in_kit);
13181 
13184  void Show(LineAttributeKit & out_kit) const;
13185 
13189  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13190 
13193  bool Empty() const;
13194 
13198  bool Equals(LineAttributeKit const & in_kit) const;
13199 
13203  bool operator==(LineAttributeKit const & in_kit) const;
13204 
13208  bool operator!=(LineAttributeKit const & in_kit) const;
13209 
13210 
13214  LineAttributeKit & SetPattern(char const * in_name);
13215 
13220  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13221 
13226  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13227 
13228 
13231  LineAttributeKit & UnsetPattern();
13232 
13235  LineAttributeKit & UnsetWeight();
13236 
13239  LineAttributeKit & UnsetEverything();
13240 
13241 
13246  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13247 
13252  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13253 };
13254 
13260 class HPS_API LineAttributeControl : public Control
13261 {
13262 public:
13263 
13265  explicit LineAttributeControl(SegmentKey & in_seg);
13266 
13268  LineAttributeControl(LineAttributeControl const & in_that);
13269 
13274 
13278  LineAttributeControl & operator=(LineAttributeControl && in_that);
13279 
13282 
13283  Type ObjectType() const {return Type::LineAttributeControl;};
13284 
13286  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13287 
13288 
13292  LineAttributeControl & SetPattern(char const * in_pattern);
13293 
13298  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13299 
13304  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13305 
13306 
13309  LineAttributeControl & UnsetPattern();
13310 
13313  LineAttributeControl & UnsetWeight();
13314 
13317  LineAttributeControl & UnsetEverything();
13318 
13319 
13324  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13325 
13330  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13331 
13332 private:
13335 };
13336 
13337 
13338 
13340 class HPS_API EdgeAttributeKit : public Object
13341 {
13342 public:
13343 
13345  EdgeAttributeKit();
13346 
13349  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
13350 
13354  EdgeAttributeKit(EdgeAttributeKit && in_that);
13355 
13359  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
13360 
13362  virtual ~EdgeAttributeKit();
13363 
13364  Type ObjectType() const {return Type::EdgeAttributeKit;};
13365 
13369  static EdgeAttributeKit GetDefault();
13370 
13373  void Set(EdgeAttributeKit const & in_kit);
13374 
13377  void Show(EdgeAttributeKit & out_kit) const;
13378 
13382  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
13383 
13386  bool Empty() const;
13387 
13391  bool Equals(EdgeAttributeKit const & in_kit) const;
13392 
13396  bool operator==(EdgeAttributeKit const & in_kit) const;
13397 
13401  bool operator!=(EdgeAttributeKit const & in_kit) const;
13402 
13403 
13407  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
13408 
13413  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13414 
13415 
13418  EdgeAttributeKit & UnsetPattern();
13419 
13422  EdgeAttributeKit & UnsetWeight();
13423 
13426  EdgeAttributeKit & UnsetEverything();
13427 
13428 
13432  bool ShowPattern(UTF8 & out_pattern_name) const;
13433 
13438  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13439 };
13440 
13446 class HPS_API EdgeAttributeControl : public Control
13447 {
13448 public:
13449 
13451  explicit EdgeAttributeControl(SegmentKey & in_seg);
13452 
13454  EdgeAttributeControl(EdgeAttributeControl const & in_that);
13455 
13460 
13464  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
13465 
13468 
13469  Type ObjectType() const {return Type::EdgeAttributeControl;};
13470 
13472  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
13473 
13477  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
13478 
13483  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13484 
13485 
13488  EdgeAttributeControl & UnsetPattern();
13489 
13492  EdgeAttributeControl & UnsetWeight();
13493 
13496  EdgeAttributeControl & UnsetEverything();
13497 
13498 
13502  bool ShowPattern(UTF8 & out_pattern_name) const;
13503 
13508  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13509 
13510 private:
13513 };
13514 
13515 
13517 class HPS_API CurveAttributeKit : public Object
13518 {
13519 public:
13520 
13523 
13526  CurveAttributeKit(CurveAttributeKit const & in_kit);
13527 
13532 
13536  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
13537 
13539  virtual ~CurveAttributeKit();
13540 
13541  Type ObjectType() const {return Type::CurveAttributeKit;};
13542 
13546  static CurveAttributeKit GetDefault();
13547 
13550  void Set(CurveAttributeKit const & in_kit);
13551 
13554  void Show(CurveAttributeKit & out_kit) const;
13555 
13559  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
13560 
13563  bool Empty() const;
13564 
13568  bool Equals(CurveAttributeKit const & in_kit) const;
13569 
13573  bool operator==(CurveAttributeKit const & in_kit) const;
13574 
13578  bool operator!=(CurveAttributeKit const & in_kit) const;
13579 
13580  //Set
13581  CurveAttributeKit & SetBudget(size_t in_budget);
13582 
13589  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
13590 
13597  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
13598 
13599 
13606  CurveAttributeKit & SetViewDependent(bool in_state);
13607 
13611  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
13612 
13617  CurveAttributeKit & SetMaximumAngle(float in_degrees);
13618 
13623  CurveAttributeKit & SetMaximumLength(float in_length);
13624 
13625 
13628  CurveAttributeKit & UnsetBudget();
13629 
13632  CurveAttributeKit & UnsetContinuedBudget();
13633 
13636  CurveAttributeKit & UnsetViewDependent();
13637 
13640  CurveAttributeKit & UnsetMaximumDeviation();
13641 
13644  CurveAttributeKit & UnsetMaximumAngle();
13645 
13648  CurveAttributeKit & UnsetMaximumLength();
13649 
13652  CurveAttributeKit & UnsetEverything();
13653 
13654 
13658  bool ShowBudget(size_t & out_budget) const;
13659 
13664  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
13665 
13669  bool ShowViewDependent(bool & out_state) const;
13670 
13675  bool ShowMaximumDeviation(float & out_deviation) const;
13676 
13681  bool ShowMaximumAngle(float & out_degrees) const;
13682 
13687  bool ShowMaximumLength(float & out_length) const;
13688 };
13689 
13690 
13694 class HPS_API CurveAttributeControl : public Control
13695 {
13696 public:
13697 
13699  explicit CurveAttributeControl(SegmentKey & in_seg);
13700 
13703 
13708 
13712  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
13713 
13716 
13717  Type ObjectType() const {return Type::CurveAttributeControl;};
13718 
13720  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
13721 
13725  CurveAttributeControl & SetBudget(size_t in_budget);
13726 
13733  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
13734 
13741  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
13742 
13749  CurveAttributeControl & SetViewDependent(bool in_state);
13750 
13754  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
13755 
13760  CurveAttributeControl & SetMaximumAngle(float in_degrees);
13761 
13766  CurveAttributeControl & SetMaximumLength(float in_length);
13767 
13768 
13771  CurveAttributeControl & UnsetBudget();
13772 
13775  CurveAttributeControl & UnsetContinuedBudget();
13776 
13779  CurveAttributeControl & UnsetViewDependent();
13780 
13783  CurveAttributeControl & UnsetMaximumDeviation();
13784 
13787  CurveAttributeControl & UnsetMaximumAngle();
13788 
13791  CurveAttributeControl & UnsetMaximumLength();
13792 
13795  CurveAttributeControl & UnsetEverything();
13796 
13797 
13801  bool ShowBudget(size_t & out_budget) const;
13802 
13807  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
13808 
13812  bool ShowViewDependent(bool & out_state) const;
13813 
13818  bool ShowMaximumDeviation(float & out_deviation) const;
13819 
13824  bool ShowMaximumAngle(float & out_degrees) const;
13825 
13830  bool ShowMaximumLength(float & out_length) const;
13831 
13832 private:
13835 };
13836 
13837 
13838 
13839 
13841 class HPS_API MatrixKit : public Object
13842 {
13843 public:
13844 
13846  MatrixKit();
13847 
13850  MatrixKit(MatrixKit const & in_kit);
13851 
13855  MatrixKit(MatrixKit && in_that);
13856 
13860  MatrixKit & operator=(MatrixKit && in_that);
13861 
13865  MatrixKit(FloatArray const & in_matrix_source);
13866 
13870  MatrixKit(float const in_matrix_source []);
13871 
13874  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
13875 
13877  virtual ~MatrixKit();
13878 
13879  Type ObjectType() const {return Type::MatrixKit;};
13880 
13883  static MatrixKit GetDefault();
13884 
13887  void Set(MatrixKit const & in_kit);
13888 
13891  void Show(MatrixKit & out_kit) const;
13892 
13896  MatrixKit & operator=(MatrixKit const & in_kit);
13897 
13900  bool Empty() const;
13901 
13905  bool Equals(MatrixKit const & in_kit) const;
13906 
13910  bool operator==(MatrixKit const & in_kit) const;
13911 
13915  bool operator!=(MatrixKit const & in_kit) const;
13916 
13922  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
13923 
13928  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
13929 
13933  MatrixKit & SetElements(FloatArray const & in_matrix);
13934 
13939  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
13940 
13941 
13944  MatrixKit & UnsetEverything();
13945 
13946 
13952  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
13953 
13958  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
13959 
13963  bool ShowElements(FloatArray & out_matrix) const;
13964 
13968  bool ShowDeterminant(float & out_determinant) const;
13969 
13973  bool ShowInverse(MatrixKit & out_matrix) const;
13974 
13979  bool ShowAdjoint(MatrixKit & out_matrix) const;
13980 
13981 
13987  MatrixKit & Rotate(float in_x, float in_y, float in_z);
13988 
13993  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
13994 
14000  MatrixKit & Translate(float in_x, float in_y, float in_z);
14001 
14007  MatrixKit & Scale(float in_x, float in_y, float in_z);
14008 
14012  MatrixKit & Concatenate(MatrixKit const & in_kit);
14013 
14016  MatrixKit & Normalize();
14017 
14020  MatrixKit & Invert();
14021 
14025  MatrixKit & Adjoint();
14026 
14027 
14031  MatrixKit Multiply(MatrixKit const & in_right) const;
14032 
14036  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14037 
14041  MatrixKit Multiply(float in_scalar) const;
14042 
14046  MatrixKit const & MultiplyAndAssign(float in_scalar);
14047 
14051  MatrixKit operator*(MatrixKit const & in_right) const;
14052 
14056  MatrixKit const & operator*=(MatrixKit const & in_right);
14057 
14061  MatrixKit operator*(float in_scalar) const;
14062 
14066  MatrixKit const & operator*=(float in_scalar);
14067 
14068 
14072  Point Transform(Point const & in_source) const;
14073 
14077  PointArray Transform(PointArray const & in_source) const;
14078 
14083  PointArray Transform(size_t in_count, Point const in_source []) const;
14084 
14088  Vector Transform(Vector const & in_source) const;
14089 
14093  VectorArray Transform(VectorArray const & in_source) const;
14094 
14099  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14100 
14104  Plane Transform(Plane const & in_source) const;
14105 
14109  PlaneArray Transform(PlaneArray const & in_source) const;
14110 
14115  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14116 };
14117 
14121 class HPS_API ModellingMatrixControl : public Control
14122 {
14123 public:
14124 
14126  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14127 
14129  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14130 
14133 
14138 
14142  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14143 
14146 
14147  Type ObjectType() const {return Type::ModellingMatrixControl;};
14148 
14150  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14151 
14157  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14158 
14163  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14164 
14168  ModellingMatrixControl & SetElements(FloatArray const & in_matrix);
14169 
14174  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14175 
14176 
14179  ModellingMatrixControl & UnsetEverything();
14180 
14181 
14187  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14188 
14193  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14194 
14198  bool ShowElements(FloatArray & out_matrix) const;
14199 
14203  bool ShowDeterminant(float & out_determinant) const;
14204 
14208  bool ShowInverse(MatrixKit & out_matrix) const;
14209 
14214  bool ShowAdjoint(MatrixKit & out_matrix) const;
14215 
14221  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14222 
14227  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14228 
14234  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14235 
14241  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14242 
14246  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14247 
14250  ModellingMatrixControl & Normalize();
14251 
14254  ModellingMatrixControl & Invert();
14255 
14259  ModellingMatrixControl & Adjoint();
14260 
14261 private:
14264 };
14265 
14268 class HPS_API TextureMatrixControl : public Control
14269 {
14270 public:
14271 
14273  explicit TextureMatrixControl(SegmentKey & in_seg);
14274 
14276  TextureMatrixControl(const TextureMatrixControl & in_that);
14277 
14282 
14286  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
14287 
14290 
14291  Type ObjectType() const {return Type::TextureMatrixControl;};
14292 
14294  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
14295 
14296 
14302  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14303 
14308  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14309 
14313  TextureMatrixControl & SetElements(FloatArray const & in_matrix);
14314 
14319  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14320 
14321 
14324  TextureMatrixControl & UnsetEverything();
14325 
14326 
14332  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14333 
14338  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14339 
14343  bool ShowElements(FloatArray & out_matrix) const;
14344 
14348  bool ShowDeterminant(float & out_determinant) const;
14349 
14353  bool ShowInverse(MatrixKit & out_matrix) const;
14354 
14359  bool ShowAdjoint(MatrixKit & out_matrix) const;
14360 
14366  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
14367 
14372  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14373 
14379  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
14380 
14386  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
14387 
14391  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
14392 
14395  TextureMatrixControl & Normalize();
14396 
14399  TextureMatrixControl & Invert();
14400 
14404  TextureMatrixControl & Adjoint();
14405 
14406 private:
14409 };
14410 
14411 
14414 class HPS_API MaterialMappingKit : public Object
14415 {
14416 public:
14417 
14420 
14423  MaterialMappingKit(MaterialMappingKit const & in_kit);
14424 
14429 
14433  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
14434 
14436  ~MaterialMappingKit();
14437 
14438  Type ObjectType() const {return Type::MaterialMappingKit;};
14439 
14443  static MaterialMappingKit GetDefault();
14444 
14447  void Set(MaterialMappingKit const & in_kit);
14448 
14451  void Show(MaterialMappingKit & out_kit) const;
14452 
14456  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
14457 
14460  bool Empty() const;
14461 
14465  bool Equals(MaterialMappingKit const & in_kit) const;
14466 
14470  bool operator==(MaterialMappingKit const & in_kit) const;
14471 
14475  bool operator!=(MaterialMappingKit const & in_kit) const;
14476 
14477  //Set
14478 
14482  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
14483 
14489  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
14490 
14491 
14495  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
14496 
14502  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
14503 
14509  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14510 
14515  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
14516 
14523  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14524 
14533  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);
14534 
14538  MaterialMappingKit & SetBackFaceGloss(float in_value);
14539 
14543  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
14544 
14549  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
14550 
14556  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14557 
14562  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
14563 
14570  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14571 
14580  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);
14581 
14585  MaterialMappingKit & SetFrontFaceGloss(float in_value);
14586 
14590  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
14591 
14596  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
14597 
14598 
14602  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
14603 
14609  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
14610 
14616  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14617 
14622  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
14623 
14630  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14631 
14640  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);
14641 
14645  MaterialMappingKit & SetCutFaceGloss(float in_value);
14646 
14650  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
14651 
14656  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
14657 
14662  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
14663 
14669  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14670 
14677  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14678 
14687  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);
14688 
14692  MaterialMappingKit & SetEdgeGloss(float in_value);
14693 
14697  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
14698 
14703  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
14704 
14709  MaterialMappingKit & SetFaceAlpha(float in_alpha);
14710 
14716  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14717 
14724  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14725 
14734  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);
14735 
14739  MaterialMappingKit & SetFaceGloss(float in_value);
14740 
14744  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
14745 
14750  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
14751 
14755  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
14756 
14757 
14758 
14759 
14760 
14764  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
14765 
14771  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
14772 
14773 
14777  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
14778 
14784  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
14785 
14786 
14790  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
14791 
14797  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
14798 
14799 
14803  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
14804 
14810  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
14811 
14816  MaterialMappingKit & SetVertexAlpha(float in_alpha);
14817 
14823  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14824 
14831  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14832 
14841  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);
14842 
14846  MaterialMappingKit & SetVertexGloss(float in_value);
14847 
14851  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
14852 
14857  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
14858 
14862  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
14863 
14864 
14868  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
14869 
14875  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
14876 
14877 
14881  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
14882 
14888  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
14889 
14890  //Aggregate Sets
14891 
14895  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
14896 
14901  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
14902 
14903 
14907  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
14908 
14914  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
14915 
14916 
14917  //Unset
14918 
14921  MaterialMappingKit & UnsetAmbientLightUpColor();
14922 
14923 
14926  MaterialMappingKit & UnsetAmbientLightDownColor();
14927 
14928 
14931  MaterialMappingKit & UnsetBackFaceMaterial();
14932 
14935  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
14936 
14939  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
14940 
14943  MaterialMappingKit & UnsetFrontFaceMaterial();
14944 
14947  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
14948 
14951  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
14952 
14953 
14954 
14957  MaterialMappingKit & UnsetCutEdgeColor();
14958 
14959 
14962  MaterialMappingKit & UnsetCutFaceMaterial();
14963 
14966  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
14967 
14970  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
14971 
14972 
14975  MaterialMappingKit & UnsetEdgeMaterial();
14976 
14979  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
14980 
14983  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
14984 
14985 
14988  MaterialMappingKit & UnsetFaceMaterial();
14989 
14992  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
14993 
14996  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
14997 
14998 
15001  MaterialMappingKit & UnsetLightColor();
15002 
15003 
15006  MaterialMappingKit & UnsetLineColor();
15007 
15008 
15011  MaterialMappingKit & UnsetMarkerColor();
15012 
15013 
15016  MaterialMappingKit & UnsetTextColor();
15017 
15018 
15021  MaterialMappingKit & UnsetVertexMaterial();
15022 
15025  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15026 
15029  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15030 
15031 
15034  MaterialMappingKit & UnsetWindowColor();
15035 
15036 
15039  MaterialMappingKit & UnsetWindowContrastColor();
15040 
15041 
15042  //Aggregate Unsets
15043 
15046  MaterialMappingKit & UnsetCutGeometryColor();
15047 
15050  MaterialMappingKit & UnsetAmbientLightColor();
15051 
15054  MaterialMappingKit & UnsetEverything();
15055 
15056 
15057  //Show
15058 
15064  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15065 
15071  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15072 
15073 
15081  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15082 
15091  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;
15092 
15098  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15099 
15100 
15108  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15109 
15118  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;
15119 
15125  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15126 
15127 
15128 
15134  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15135 
15136 
15144  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15145 
15154  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;
15155 
15161  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15162 
15163 
15171  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15172 
15181  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;
15182 
15188  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15189 
15190 
15198  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15199 
15208  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;
15209 
15215  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15216 
15217 
15223  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15224 
15225 
15231  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15232 
15233 
15239  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15240 
15241 
15247  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15248 
15249 
15257  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15258 
15267  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;
15268 
15274  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15275 
15276 
15282  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15283 
15284 
15290  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15291 };
15292 
15293 
15299 class HPS_API MaterialMappingControl : public Control
15300 {
15301 public:
15302 
15304  explicit MaterialMappingControl(SegmentKey & in_seg);
15305 
15308 
15313 
15317  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
15318 
15321 
15322  Type ObjectType() const {return Type::MaterialMappingControl;};
15323 
15325  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
15326 
15327  //Set
15328 
15332  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15333 
15339  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
15340 
15341 
15345  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15346 
15352  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
15353 
15358  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
15359 
15365  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15366 
15373  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15374 
15383  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);
15384 
15388  MaterialMappingControl & SetBackFaceGloss(float in_value);
15389 
15393  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
15394 
15399  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
15400 
15401 
15406  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
15407 
15413  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15414 
15421  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15422 
15431  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);
15432 
15436  MaterialMappingControl & SetFrontFaceGloss(float in_value);
15437 
15441  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
15442 
15447  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
15448 
15449 
15453  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15454 
15460  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
15461 
15466  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
15467 
15473  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15474 
15481  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15482 
15491  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);
15492 
15496  MaterialMappingControl & SetCutFaceGloss(float in_value);
15497 
15501  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
15502 
15507  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
15508 
15513  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
15514 
15520  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15521 
15528  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15529 
15538  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);
15539 
15543  MaterialMappingControl & SetEdgeGloss(float in_value);
15544 
15548  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
15549 
15554  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
15555 
15561  MaterialMappingControl & SetFaceAlpha(float in_alpha);
15562 
15569  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15570 
15577  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15578 
15587  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);
15588 
15592  MaterialMappingControl & SetFaceGloss(float in_value);
15593 
15597  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
15598 
15603  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
15604 
15608  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
15609 
15610 
15614  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
15615 
15621  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
15622 
15623 
15627  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
15628 
15634  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
15635 
15636 
15640  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
15641 
15647  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
15648 
15649 
15653  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
15654 
15660  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
15661 
15662 
15667  MaterialMappingControl & SetVertexAlpha(float in_alpha);
15668 
15669 
15675  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15676 
15683  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15684 
15693  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);
15694 
15698  MaterialMappingControl & SetVertexGloss(float in_value);
15699 
15703  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
15704 
15709  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
15710 
15714  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
15715 
15716 
15720  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
15721 
15727  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
15728 
15729 
15733  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15734 
15740  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
15741 
15742  //Aggregate Sets
15743 
15747  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15748 
15753  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
15754 
15755 
15759  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15760 
15766  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
15767 
15768 
15769  //Unset
15770 
15773  MaterialMappingControl & UnsetAmbientLightUpColor();
15774 
15775 
15778  MaterialMappingControl & UnsetAmbientLightDownColor();
15779 
15780 
15783  MaterialMappingControl & UnsetFrontFaceMaterial();
15784 
15787  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
15788 
15791  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15792 
15793 
15796  MaterialMappingControl & UnsetBackFaceMaterial();
15797 
15800  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
15801 
15804  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15805 
15806 
15809  MaterialMappingControl & UnsetCutEdgeColor();
15810 
15811 
15814  MaterialMappingControl & UnsetCutFaceMaterial();
15815 
15818  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
15819 
15822  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15823 
15824 
15827  MaterialMappingControl & UnsetEdgeMaterial();
15828 
15831  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
15832 
15835  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15836 
15837 
15840  MaterialMappingControl & UnsetFaceMaterial();
15841 
15844  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
15845 
15848  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15849 
15850 
15853  MaterialMappingControl & UnsetLightColor();
15854 
15855 
15858  MaterialMappingControl & UnsetLineColor();
15859 
15860 
15863  MaterialMappingControl & UnsetMarkerColor();
15864 
15865 
15868  MaterialMappingControl & UnsetTextColor();
15869 
15870 
15873  MaterialMappingControl & UnsetVertexMaterial();
15874 
15877  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
15878 
15881  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15882 
15883 
15886  MaterialMappingControl & UnsetWindowColor();
15887 
15888 
15891  MaterialMappingControl & UnsetWindowContrastColor();
15892 
15893 
15894  //Aggregate Unsets
15895 
15898  MaterialMappingControl & UnsetCutGeometryColor();
15899 
15902  MaterialMappingControl & UnsetAmbientLightColor();
15903 
15906  MaterialMappingControl & UnsetEverything();
15907 
15908 
15909  //Show
15910 
15916  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15917 
15918 
15924  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15925 
15926 
15934  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15935 
15944  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;
15945 
15951  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15952 
15953 
15961  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15962 
15971  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;
15972 
15978  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15979 
15980 
15986  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15987 
15988 
15996  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15997 
16006  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;
16007 
16013  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16014 
16015 
16023  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16024 
16033  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;
16034 
16040  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16041 
16042 
16050  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16051 
16060  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;
16061 
16067  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16068 
16069 
16075  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16076 
16077 
16083  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16084 
16085 
16091  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16092 
16093 
16099  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16100 
16101 
16109  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16110 
16119  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;
16120 
16126  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16127 
16128 
16134  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16135 
16136 
16142  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16143 
16144 private:
16146 };
16147 
16148 
16151 class HPS_API PortfolioControl : public Control
16152 {
16153 public:
16155  explicit PortfolioControl(SegmentKey & in_seg);
16156 
16158  PortfolioControl(PortfolioControl const & in_that);
16159 
16163  PortfolioControl(PortfolioControl && in_that);
16164 
16168  PortfolioControl & operator=(PortfolioControl && in_that);
16169 
16171  ~PortfolioControl();
16172 
16173  Type ObjectType() const { return Type::PortfolioControl; };
16174 
16176  PortfolioControl & operator=(PortfolioControl const & in_that);
16177 
16179  size_t GetCount() const;
16180 
16181 
16186  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16187 
16190  bool Pop();
16191 
16195  bool Pop(PortfolioKey & out_portfolio);
16196 
16197 
16201  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16202 
16206  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16207 
16212  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16213 
16214 
16217  PortfolioControl & UnsetTop();
16218 
16221  PortfolioControl & UnsetEverything();
16222 
16223 
16227  bool ShowTop(PortfolioKey & out_portfolio) const;
16228 
16232  bool Show(PortfolioKeyArray & out_portfolios) const;
16233 
16234 private:
16235  PortfolioControl();
16236 };
16237 
16238 
16239 
16242 class HPS_API StyleControl : public Control
16243 {
16244 public:
16246  explicit StyleControl(SegmentKey & in_seg);
16247 
16249  StyleControl(StyleControl const & in_that);
16250 
16254  StyleControl(StyleControl && in_that);
16255 
16259  StyleControl & operator=(StyleControl && in_that);
16260 
16262  ~StyleControl();
16263 
16264  Type ObjectType() const { return Type::StyleControl; };
16265 
16267  StyleControl & operator=(StyleControl const & in_that);
16268 
16270  size_t GetCount() const;
16271 
16272 
16274  StyleKey PushNamed(char const * in_style_name);
16275 
16277  StyleKey PushNamed(char const * in_style_name, Condition const & in_condition);
16278 
16280  StyleKey AppendNamed(char const * in_style_name, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16281 
16285  StyleKey PushSegment(SegmentKey const & in_style_source);
16286 
16290  StyleKey PushSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16291 
16294  StyleKey AppendSegment(SegmentKey const & in_style_source, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16295 
16296 
16297 
16300  bool Pop();
16301 
16308  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition);
16309 
16313  void Flush(SegmentKey const & in_style_source);
16314 
16321  void Flush(SegmentKey const & in_style_source, Condition const & in_condition);
16322 
16326  void Flush(char const * in_style_name);
16327 
16334  void Flush(char const * in_style_name, Condition const & in_condition);
16335 
16336 
16339  StyleKey SetNamed(char const * in_style_name);
16340 
16344  StyleKey SetNamed(char const * in_style_name, Condition const & in_condition);
16345 
16346 
16349  StyleKey SetSegment(SegmentKey const & in_style_source);
16350 
16354  StyleKey SetSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16355 
16356 
16362  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionArray const & in_conditions);
16363 
16368  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
16369 
16376  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[]);
16377 
16378 
16379 
16381  void UnsetTop();
16382 
16384  void UnsetAllSegment();
16385 
16387  void UnsetAllNamed();
16388 
16390  void UnsetEverything();
16391 
16392 
16399  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition) const;
16400 
16404  bool ShowTop(StyleKey & out_style) const;
16405 
16412  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions) const;
16413 
16417  bool Show(StyleKeyArray & out_styles) const;
16418 
16423  bool ShowAllSegment(SegmentKeyArray & out_segments, ConditionArray & out_conditions) const;
16424 
16428  bool ShowAllSegment(StyleKeyArray & out_styles) const;
16429 
16434  bool ShowAllNamed(UTF8Array & out_names, ConditionArray & out_conditions) const;
16435 
16439  bool ShowAllNamed(StyleKeyArray & out_styles) const;
16440 
16441 private:
16442  StyleControl();
16443 };
16444 
16445 
16448 class HPS_API ConditionControl : public Control
16449 {
16450 public:
16452  explicit ConditionControl(SegmentKey & in_seg);
16453 
16455  ConditionControl(ConditionControl const & in_that);
16456 
16460  ConditionControl(ConditionControl && in_that);
16461 
16465  ConditionControl & operator=(ConditionControl && in_that);
16466 
16468  ~ConditionControl();
16469 
16470 
16471  Type ObjectType() const { return Type::ConditionControl; };
16472 
16474  ConditionControl & operator=(ConditionControl const & in_that);
16475 
16478  size_t GetCount() const;
16479 
16483  ConditionControl & AddCondition(char const * in_condition);
16484 
16485 
16489  ConditionControl & SetCondition(char const * in_condition);
16490 
16494  ConditionControl & SetConditions(UTF8Array const & in_conditions);
16495 
16500  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
16501 
16502 
16506  ConditionControl & UnsetCondition(char const * in_condition);
16507 
16510  ConditionControl & UnsetEverything();
16511 
16512 
16516  bool ShowCondition(char const * in_condition) const;
16517 
16521  bool ShowConditions(UTF8Array & out_conditions) const;
16522 
16523 private:
16525  ConditionControl();
16526 };
16527 
16528 
16531 class HPS_API MaterialKit : public Object
16532 {
16533 public:
16534 
16536  MaterialKit();
16537 
16540  MaterialKit(MaterialKit const & in_kit);
16541 
16545  MaterialKit(MaterialKit && in_that);
16546 
16550  MaterialKit & operator=(MaterialKit && in_that);
16551 
16553  ~MaterialKit();
16554 
16555  Type ObjectType() const {return Type::MaterialKit;};
16556 
16559  void Set(MaterialKit const & in_kit);
16560 
16563  void Show(MaterialKit & out_kit) const;
16564 
16568  MaterialKit & operator=(MaterialKit const & in_kit);
16569 
16572  bool Empty() const;
16573 
16577  bool Equals(MaterialKit const & in_kit) const;
16578 
16582  bool operator==(MaterialKit const & in_kit) const;
16583 
16587  bool operator!=(MaterialKit const & in_kit) const;
16588 
16589 
16590  //Set
16591 
16595  MaterialKit & SetDiffuse(RGBColor const & in_color);
16596 
16600  MaterialKit & SetDiffuse(RGBAColor const & in_color);
16601 
16605  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
16606 
16610  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
16611 
16616  MaterialKit & SetDiffuseAlpha(float in_alpha);
16617 
16624  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
16625 
16633  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
16634 
16639  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
16640 
16646  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
16647 
16654  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
16655 
16663  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
16664 
16665 
16669  MaterialKit & SetShader(char const * in_shader_name);
16670 
16671 
16672 
16676  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
16677 
16681  MaterialKit & SetSpecular(char const * in_texture_name);
16682 
16687  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
16688 
16689 
16690 
16694  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
16695 
16699  MaterialKit & SetMirror(char const * in_texture_name);
16700 
16705  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
16706 
16707 
16708 
16712  MaterialKit & SetTransmission(char const * in_texture_name);
16713 
16718  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
16719 
16720 
16721 
16725  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
16726 
16730  MaterialKit & SetEmission(char const * in_texture_name);
16731 
16736  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
16737 
16738 
16739 
16743  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
16744 
16749  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
16750 
16754  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
16755 
16760  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
16761 
16764  MaterialKit & SetEnvironmentTexture();
16765 
16766 
16770  MaterialKit & SetBump(char const * in_texture_name);
16771 
16772 
16773 
16780  MaterialKit & SetGloss(float in_gloss);
16781 
16784  MaterialKit & UnsetDiffuseColorRGB();
16785 
16788  MaterialKit & UnsetDiffuseColor();
16789 
16792  MaterialKit & UnsetDiffuseAlpha();
16793 
16796  MaterialKit & UnsetDiffuseTexture();
16797 
16801  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
16802 
16805  MaterialKit & UnsetShader();
16806 
16809  MaterialKit & UnsetSpecular();
16810 
16813  MaterialKit & UnsetMirror();
16814 
16817  MaterialKit & UnsetTransmission();
16818 
16821  MaterialKit & UnsetEmission();
16822 
16825  MaterialKit & UnsetEnvironment();
16826 
16829  MaterialKit & UnsetBump();
16830 
16833  MaterialKit & UnsetGloss();
16834 
16837  MaterialKit & UnsetEverything();
16838 
16839 
16842  bool ShowDiffuse() const;
16843 
16847  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
16848 
16852  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
16853 
16857  bool ShowDiffuseAlpha(float & out_alpha) const;
16858 
16865  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16866 
16874  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16875 
16882  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
16883 
16887  bool ShowShader(UTF8 & out_shader_name) const;
16888 
16897  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16898 
16907  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16908 
16909 
16910 
16919  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16920 
16921 
16930  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16931 
16932 
16941  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16942 
16943 
16947  bool ShowBump(UTF8 & out_texture_name) const;
16948 
16953  bool ShowGloss(float & out_gloss) const;
16954 };
16955 
16956 
16958 class HPS_API NURBSSurfaceAttributeKit : public Object
16959 {
16960 public:
16961 
16964 
16968 
16973 
16977  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
16978 
16980  virtual ~NURBSSurfaceAttributeKit();
16981 
16982  Type ObjectType() const {return Type::NURBSSurfaceAttributeKit;};
16983 
16987  static NURBSSurfaceAttributeKit GetDefault();
16988 
16991  void Set(NURBSSurfaceAttributeKit const & in_kit);
16992 
16995  void Show(NURBSSurfaceAttributeKit & out_kit) const;
16996 
17000  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17001 
17004  bool Empty() const;
17005 
17009  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17010 
17014  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17015 
17019  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17020 
17021 
17025  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17026 
17031  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17032 
17036  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17037 
17041  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17042 
17046  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17047 
17052  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17053 
17054 
17057  NURBSSurfaceAttributeKit & UnsetBudget();
17058 
17061  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17062 
17065  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17066 
17069  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17070 
17073  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17074 
17077  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17078 
17081  NURBSSurfaceAttributeKit & UnsetEverything();
17082 
17086  bool ShowBudget(size_t & out_budget) const;
17087 
17091  bool ShowMaximumDeviation(float & out_deviation) const;
17092 
17096  bool ShowMaximumAngle(float & out_degrees) const;
17097 
17101  bool ShowMaximumWidth(float & out_width) const;
17102 
17106  bool ShowTrimBudget(size_t & out_budget) const;
17107 
17111  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17112 };
17113 
17120 {
17121 public:
17122 
17124  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17125 
17128 
17133 
17138 
17141 
17142  Type ObjectType() const {return Type::NURBSSurfaceAttributeControl;};
17143 
17145  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17146 
17150  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17151 
17156  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17157 
17161  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17162 
17166  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17167 
17171  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17172 
17177  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17178 
17179 
17182  NURBSSurfaceAttributeControl & UnsetBudget();
17183 
17186  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17187 
17190  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17191 
17194  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17195 
17198  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17199 
17202  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17203 
17206  NURBSSurfaceAttributeControl & UnsetEverything();
17207 
17208 
17212  bool ShowBudget(size_t & out_budget) const;
17213 
17217  bool ShowMaximumDeviation(float & out_deviation) const;
17218 
17222  bool ShowMaximumAngle(float & out_degrees) const;
17223 
17227  bool ShowMaximumWidth(float & out_width) const;
17228 
17232  bool ShowTrimBudget(size_t & out_budget) const;
17233 
17237  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17238 
17239 private:
17242 };
17243 
17244 
17245 
17247 class HPS_API PerformanceKit : public Object
17248 {
17249 public:
17250 
17252  PerformanceKit();
17253 
17256  PerformanceKit(PerformanceKit const & in_kit);
17257 
17261  PerformanceKit(PerformanceKit && in_that);
17262 
17266  PerformanceKit & operator=(PerformanceKit && in_that);
17267 
17269  virtual ~PerformanceKit();
17270 
17271  Type ObjectType() const {return Type::PerformanceKit;};
17272 
17276  static PerformanceKit GetDefault();
17277 
17280  void Set(PerformanceKit const & in_kit);
17281 
17284  void Show(PerformanceKit & out_kit) const;
17285 
17289  PerformanceKit & operator=(PerformanceKit const & in_kit);
17290 
17293  bool Empty() const;
17294 
17298  bool Equals(PerformanceKit const & in_kit) const;
17299 
17303  bool operator==(PerformanceKit const & in_kit) const;
17304 
17308  bool operator!=(PerformanceKit const & in_kit) const;
17309 
17310 
17315 
17320  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
17321 
17322 
17325  PerformanceKit & UnsetDisplayLists();
17326 
17329  PerformanceKit & UnsetStaticModel();
17330 
17333  PerformanceKit & UnsetEverything();
17334 
17338  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17339 
17343  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17344 };
17345 
17346 
17352 class HPS_API PerformanceControl : public Control
17353 {
17354 public:
17355 
17357  explicit PerformanceControl(SegmentKey & in_seg);
17358 
17360  PerformanceControl(PerformanceControl const & in_that);
17361 
17366 
17370  PerformanceControl & operator=(PerformanceControl && in_that);
17371 
17373  ~PerformanceControl();
17374 
17375  Type ObjectType() const {return Type::PerformanceControl;};
17376 
17378  PerformanceControl & operator=(PerformanceControl const & in_that);
17379 
17380 
17385 
17390  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
17391 
17392 
17395  PerformanceControl & UnsetDisplayLists();
17396 
17399  PerformanceControl & UnsetStaticModel();
17400 
17403  PerformanceControl & UnsetEverything();
17404 
17405 
17409  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17410 
17414  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17415 
17416 private:
17419 };
17420 
17421 
17422 
17424 class HPS_API HiddenLineAttributeKit : public Object
17425 {
17426 public:
17427 
17430 
17434 
17439 
17443  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
17444 
17446  virtual ~HiddenLineAttributeKit();
17447 
17448  Type ObjectType() const {return Type::HiddenLineAttributeKit;};
17449 
17453  static HiddenLineAttributeKit GetDefault();
17454 
17457  void Set(HiddenLineAttributeKit const & in_kit);
17458 
17461  void Show(HiddenLineAttributeKit & out_kit) const;
17462 
17466  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
17467 
17470  bool Empty() const;
17471 
17475  bool Equals(HiddenLineAttributeKit const & in_kit) const;
17476 
17480  bool operator==(HiddenLineAttributeKit const & in_kit) const;
17481 
17485  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
17486 
17487 
17491  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
17492 
17498  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
17499 
17509  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
17510 
17514  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
17515 
17519  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
17520 
17524  HiddenLineAttributeKit & SetRenderText(bool in_state);
17525 
17530  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
17531 
17537  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
17538 
17542  HiddenLineAttributeKit & SetVisibility(bool in_state);
17543 
17548  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
17549 
17555  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
17556 
17557 
17560  HiddenLineAttributeKit & UnsetColor();
17561 
17564  HiddenLineAttributeKit & UnsetDimFactor();
17565 
17568  HiddenLineAttributeKit & UnsetFaceDisplacement();
17569 
17572  HiddenLineAttributeKit & UnsetLinePattern();
17573 
17576  HiddenLineAttributeKit & UnsetRenderFaces();
17577 
17580  HiddenLineAttributeKit & UnsetRenderText();
17581 
17584  HiddenLineAttributeKit & UnsetAlgorithm();
17585 
17588  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
17589 
17592  HiddenLineAttributeKit & UnsetVisibility();
17593 
17596  HiddenLineAttributeKit & UnsetWeight();
17597 
17600  HiddenLineAttributeKit & UnsetTransparencyCutoff();
17601 
17604  HiddenLineAttributeKit & UnsetEverything();
17605 
17606 
17610  bool ShowColor(RGBAColor & out_color) const;
17611 
17615  bool ShowDimFactor(float & out_zero_to_one) const;
17616 
17620  bool ShowFaceDisplacement(float & out_buckets) const;
17621 
17625  bool ShowLinePattern(UTF8 & out_pattern) const;
17626 
17630  bool ShowRenderFaces(bool & out_state) const;
17631 
17635  bool ShowRenderText(bool & out_state) const;
17636 
17640  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
17641 
17645  bool ShowSilhouetteCleanup(bool & out_state) const;
17646 
17650  bool ShowVisibility(bool & out_state) const;
17651 
17656  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
17657 
17661  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
17662 };
17663 
17664 
17670 class HPS_API HiddenLineAttributeControl : public Control
17671 {
17672 public:
17673 
17675  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
17676 
17679 
17684 
17689 
17692 
17693  Type ObjectType() const {return Type::HiddenLineAttributeControl;};
17694 
17696  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
17697 
17701  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
17702 
17708  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
17709 
17719  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
17720 
17724  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
17725 
17729  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
17730 
17734  HiddenLineAttributeControl & SetRenderText(bool in_state);
17735 
17740  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
17741 
17747  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
17748 
17752  HiddenLineAttributeControl & SetVisibility(bool in_state);
17753 
17758  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
17759 
17765  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
17766 
17767 
17770  HiddenLineAttributeControl & UnsetColor();
17771 
17774  HiddenLineAttributeControl & UnsetDimFactor();
17775 
17778  HiddenLineAttributeControl & UnsetFaceDisplacement();
17779 
17782  HiddenLineAttributeControl & UnsetLinePattern();
17783 
17786  HiddenLineAttributeControl & UnsetRenderFaces();
17787 
17790  HiddenLineAttributeControl & UnsetRenderText();
17791 
17794  HiddenLineAttributeControl & UnsetAlgorithm();
17795 
17798  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
17799 
17802  HiddenLineAttributeControl & UnsetVisibility();
17803 
17806  HiddenLineAttributeControl & UnsetWeight();
17807 
17810  HiddenLineAttributeControl & UnsetTransparencyCutoff();
17811 
17814  HiddenLineAttributeControl & UnsetEverything();
17815 
17816 
17820  bool ShowColor(RGBAColor & out_color) const;
17821 
17825  bool ShowDimFactor(float & out_zero_to_one) const;
17826 
17830  bool ShowFaceDisplacement(float & out_buckets) const;
17831 
17835  bool ShowLinePattern(UTF8 & out_pattern) const;
17836 
17840  bool ShowRenderFaces(bool & out_state) const;
17841 
17845  bool ShowRenderText(bool & out_state) const;
17846 
17850  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
17851 
17855  bool ShowSilhouetteCleanup(bool & out_state) const;
17856 
17860  bool ShowVisibility(bool & out_state) const;
17861 
17866  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
17867 
17871  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
17872 
17873 private:
17876 };
17877 
17878 
17879 
17881 class HPS_API DrawingAttributeKit : public Object
17882 {
17883 public:
17884 
17887 
17890  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
17891 
17896 
17900  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
17901 
17903  virtual ~DrawingAttributeKit();
17904 
17905  Type ObjectType() const {return Type::DrawingAttributeKit;};
17906 
17910  static DrawingAttributeKit GetDefault();
17911 
17914  void Set(DrawingAttributeKit const & in_kit);
17915 
17918  void Show(DrawingAttributeKit & out_kit) const;
17919 
17923  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
17924 
17927  bool Empty() const;
17928 
17932  bool Equals(DrawingAttributeKit const & in_kit) const;
17933 
17937  bool operator==(DrawingAttributeKit const & in_kit) const;
17938 
17942  bool operator!=(DrawingAttributeKit const & in_kit) const;
17943 
17959  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
17960 
17966  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
17967 
17980  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
17981 
17988  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
17989 
17994  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
17995 
18002  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18003 
18008  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18009 
18016  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18017 
18022  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18023 
18027  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18028 
18033  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18034 
18040  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18041 
18048  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);
18049 
18055  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18056 
18059  DrawingAttributeKit & UnsetPolygonHandedness();
18060 
18063  DrawingAttributeKit & UnsetWorldHandedness();
18064 
18067  DrawingAttributeKit & UnsetDepthRange();
18068 
18071  DrawingAttributeKit & UnsetFaceDisplacement();
18072 
18075  DrawingAttributeKit & UnsetGeneralDisplacement();
18076 
18079  DrawingAttributeKit & UnsetVertexDisplacement();
18080 
18083  DrawingAttributeKit & UnsetOverlay();
18084 
18087  DrawingAttributeKit & UnsetDeferral();
18088 
18091  DrawingAttributeKit & UnsetClipRegion();
18092 
18095  DrawingAttributeKit & UnsetEverything();
18096 
18100  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18101 
18105  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18106 
18111  bool ShowDepthRange(float & out_near, float & out_far) const;
18112 
18117  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18118 
18123  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18124 
18129  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18130 
18134  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18135 
18139  bool ShowDeferral(int & out_defer_batch) const;
18140 
18146  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18147 
18148 };
18149 
18150 
18162 class HPS_API DrawingAttributeControl : public Control
18163 {
18164 public:
18165 
18167  explicit DrawingAttributeControl(SegmentKey & in_seg);
18168 
18171 
18176 
18180  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18181 
18184 
18185  Type ObjectType() const {return Type::DrawingAttributeControl;};
18186 
18188  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18189 
18199  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18200 
18206  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18207 
18220  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18221 
18228  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18229 
18234  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18235 
18242  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18243 
18248  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
18249 
18256  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
18257 
18262  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
18263 
18267  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
18268 
18274  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18275 
18282  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);
18283 
18289  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18290 
18295  DrawingAttributeControl & SetDeferral(int in_deferral);
18298  DrawingAttributeControl & UnsetPolygonHandedness();
18299 
18302  DrawingAttributeControl & UnsetWorldHandedness();
18303 
18306  DrawingAttributeControl & UnsetDepthRange();
18307 
18310  DrawingAttributeControl & UnsetFaceDisplacement();
18311 
18314  DrawingAttributeControl & UnsetGeneralDisplacement();
18315 
18318  DrawingAttributeControl & UnsetVertexDisplacement();
18319 
18322  DrawingAttributeControl & UnsetOverlay();
18323 
18326  DrawingAttributeControl & UnsetDeferral();
18327 
18330  DrawingAttributeControl & UnsetClipRegion();
18331 
18334  DrawingAttributeControl & UnsetEverything();
18335 
18336 
18340  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18341 
18345  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18346 
18351  bool ShowDepthRange(float & out_x, float & out_y) const;
18352 
18357  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18358 
18363  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18364 
18369  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18370 
18374  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18375 
18379  bool ShowDeferral(int & out_defer_batch) const;
18380 
18386  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & ou_operation);
18387 
18388 private:
18391 };
18392 
18393 
18395 class HPS_API PostProcessEffectsKit : public Object
18396 {
18397 public:
18398 
18401 
18405 
18410 
18414  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
18415 
18417  virtual ~PostProcessEffectsKit();
18418 
18419  Type ObjectType() const {return Type::PostProcessEffectsKit;};
18420 
18424  static PostProcessEffectsKit GetDefault();
18425 
18428  void Set(PostProcessEffectsKit const & in_kit);
18429 
18432  void Show(PostProcessEffectsKit & out_kit) const;
18433 
18437  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
18438 
18441  bool Empty() const;
18442 
18446  bool Equals(PostProcessEffectsKit const & in_kit) const;
18447 
18451  bool operator==(PostProcessEffectsKit const & in_kit) const;
18452 
18456  bool operator!=(PostProcessEffectsKit const & in_kit) const;
18457 
18458 
18466  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18467 
18474  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18475 
18482  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18483 
18489  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
18490 
18497  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
18498 
18504  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
18505 
18513  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
18514 
18521  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
18522 
18530  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
18531 
18538  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
18539 
18542  PostProcessEffectsKit & UnsetAmbientOcclusion();
18543 
18546  PostProcessEffectsKit & UnsetBloom();
18547 
18550  PostProcessEffectsKit & UnsetDepthOfField();
18551 
18554  PostProcessEffectsKit & UnsetSilhouetteEdges();
18555 
18558  PostProcessEffectsKit & UnsetEyeDomeLighting();
18559 
18562  PostProcessEffectsKit & UnsetEverything();
18563 
18564 
18571  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
18572 
18579  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
18580 
18587  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
18588 
18596  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
18597 
18605  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
18606 };
18607 
18608 
18612 class HPS_API PostProcessEffectsControl : public Control
18613 {
18614 public:
18615 
18617  explicit PostProcessEffectsControl(WindowKey & in_seg);
18618 
18621 
18626 
18630  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
18631 
18634 
18635  Type ObjectType() const {return Type::PostProcessEffectsControl;};
18636 
18638  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
18639 
18640 
18648  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18649 
18656  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18657 
18664  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18665 
18671  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
18672 
18679  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
18680 
18686  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
18687 
18695  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
18696 
18703  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
18704 
18711  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
18712 
18719  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
18720 
18721 
18724  PostProcessEffectsControl & UnsetAmbientOcclusion();
18725 
18728  PostProcessEffectsControl & UnsetBloom();
18729 
18732  PostProcessEffectsControl & UnsetDepthOfField();
18733 
18736  PostProcessEffectsControl & UnsetSilhouetteEdges();
18737 
18740  PostProcessEffectsControl & UnsetEyeDomeLighting();
18741 
18744  PostProcessEffectsControl & UnsetEverything();
18745 
18746 
18753  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
18754 
18761  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
18762 
18769  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
18770 
18778  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
18779 
18787  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
18788 
18789 private:
18792 };
18793 
18795 class HPS_API TransformMaskKit : public Object
18796 {
18797 public:
18798 
18800  TransformMaskKit();
18801 
18803  TransformMaskKit(TransformMaskKit const & in_kit);
18804 
18808  TransformMaskKit(TransformMaskKit && in_that);
18809 
18813  TransformMaskKit & operator=(TransformMaskKit && in_that);
18814 
18816  virtual ~TransformMaskKit();
18817 
18818  Type ObjectType() const {return Type::TransformMaskKit;};
18819 
18820  static TransformMaskKit GetDefault();
18821 
18823  void Set(TransformMaskKit const & in_kit);
18824 
18826  void Show(TransformMaskKit & out_kit) const;
18827 
18829  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
18830 
18832  bool Empty() const;
18833 
18835  bool Equals(TransformMaskKit const & in_kit) const;
18836 
18838  bool operator==(TransformMaskKit const & in_kit) const;
18839 
18841  bool operator!=(TransformMaskKit const & in_kit) const;
18842 
18843 
18847  TransformMaskKit & SetCameraRotation(bool in_state);
18848 
18852  TransformMaskKit & SetCameraScale(bool in_state);
18853 
18857  TransformMaskKit & SetCameraTranslation(bool in_state);
18858 
18862  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
18863 
18867  TransformMaskKit & SetCameraProjection(bool in_state);
18868 
18872  TransformMaskKit & SetCameraOffset(bool in_state);
18873 
18877  TransformMaskKit & SetCameraNearLimit(bool in_state);
18878 
18882  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
18883 
18887  TransformMaskKit & SetModellingMatrixScale(bool in_state);
18888 
18892  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
18893 
18897  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
18898 
18899 
18903  TransformMaskKit & SetCameraEverything(bool in_state);
18904 
18908  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
18909 
18913  TransformMaskKit & SetEverything(bool in_state);
18914 
18915 
18918  TransformMaskKit & UnsetCameraRotation();
18919 
18922  TransformMaskKit & UnsetCameraScale();
18923 
18926  TransformMaskKit & UnsetCameraTranslation();
18927 
18930  TransformMaskKit & UnsetCameraPerspectiveScale();
18931 
18934  TransformMaskKit & UnsetCameraProjection();
18935 
18938  TransformMaskKit & UnsetCameraOffset();
18939 
18942  TransformMaskKit & UnsetCameraNearLimit();
18943 
18946  TransformMaskKit & UnsetCameraEverything();
18947 
18950  TransformMaskKit & UnsetModellingMatrixRotation();
18951 
18954  TransformMaskKit & UnsetModellingMatrixScale();
18955 
18958  TransformMaskKit & UnsetModellingMatrixTranslation();
18959 
18962  TransformMaskKit & UnsetModellingMatrixOffset();
18963 
18966  TransformMaskKit & UnsetModellingMatrixEverything();
18967 
18970  TransformMaskKit & UnsetEverything();
18971 
18972 
18976  bool ShowCameraRotation(bool & out_state) const;
18977 
18981  bool ShowCameraScale(bool & out_state) const;
18982 
18986  bool ShowCameraTranslation(bool & out_state) const;
18987 
18991  bool ShowCameraPerspectiveScale(bool & out_state) const;
18992 
18996  bool ShowCameraProjection(bool & out_state) const;
18997 
19001  bool ShowCameraOffset(bool & out_state) const;
19002 
19006  bool ShowCameraNearLimit(bool & out_state) const;
19007 
19011  bool ShowModellingMatrixRotation(bool & out_state) const;
19012 
19016  bool ShowModellingMatrixScale(bool & out_state) const;
19017 
19021  bool ShowModellingMatrixTranslation(bool & out_state) const;
19022 
19026  bool ShowModellingMatrixOffset(bool & out_state) const;
19027 };
19028 
19029 
19034 class HPS_API TransformMaskControl : public Control
19035 {
19036 public:
19037 
19039  explicit TransformMaskControl(SegmentKey & in_seg);
19040 
19042  TransformMaskControl(TransformMaskControl const & in_that);
19043 
19048 
19052  TransformMaskControl & operator=(TransformMaskControl && in_that);
19053 
19056 
19057  Type ObjectType() const {return Type::TransformMaskControl;};
19058 
19059 
19063  TransformMaskControl & SetCameraRotation(bool in_state);
19064 
19068  TransformMaskControl & SetCameraScale(bool in_state);
19069 
19073  TransformMaskControl & SetCameraTranslation(bool in_state);
19074 
19078  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19079 
19083  TransformMaskControl & SetCameraProjection(bool in_state);
19084 
19088  TransformMaskControl & SetCameraOffset(bool in_state);
19089 
19093  TransformMaskControl & SetCameraNearLimit(bool in_state);
19094 
19098  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19099 
19103  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19104 
19108  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19109 
19113  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19114 
19115 
19119  TransformMaskControl & SetCameraEverything(bool in_state);
19120 
19124  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19125 
19129  TransformMaskControl & SetEverything(bool in_state);
19130 
19131 
19134  TransformMaskControl & UnsetCameraRotation();
19135 
19138  TransformMaskControl & UnsetCameraScale();
19139 
19142  TransformMaskControl & UnsetCameraTranslation();
19143 
19146  TransformMaskControl & UnsetCameraPerspectiveScale();
19147 
19150  TransformMaskControl & UnsetCameraProjection();
19151 
19154  TransformMaskControl & UnsetCameraOffset();
19155 
19158  TransformMaskControl & UnsetCameraNearLimit();
19159 
19162  TransformMaskControl & UnsetCameraEverything();
19163 
19166  TransformMaskControl & UnsetModellingMatrixRotation();
19167 
19170  TransformMaskControl & UnsetModellingMatrixScale();
19171 
19174  TransformMaskControl & UnsetModellingMatrixTranslation();
19175 
19178  TransformMaskControl & UnsetModellingMatrixOffset();
19179 
19182  TransformMaskControl & UnsetModellingMatrixEverything();
19183 
19186  TransformMaskControl & UnsetEverything();
19187 
19188 
19192  bool ShowCameraRotation(bool & out_state) const;
19193 
19197  bool ShowCameraScale(bool & out_state) const;
19198 
19202  bool ShowCameraTranslation(bool & out_state) const;
19203 
19207  bool ShowCameraPerspectiveScale(bool & out_state) const;
19208 
19212  bool ShowCameraProjection(bool & out_state) const;
19213 
19217  bool ShowCameraOffset(bool & out_state) const;
19218 
19222  bool ShowCameraNearLimit(bool & out_state) const;
19223 
19227  bool ShowModellingMatrixRotation(bool & out_state) const;
19228 
19232  bool ShowModellingMatrixScale(bool & out_state) const;
19233 
19237  bool ShowModellingMatrixTranslation(bool & out_state) const;
19238 
19242  bool ShowModellingMatrixOffset(bool & out_state) const;
19243 
19244 private:
19247 };
19248 
19249 
19250 
19252 class HPS_API VisualEffectsKit : public Object
19253 {
19254 public:
19255 
19257  VisualEffectsKit();
19258 
19261  VisualEffectsKit(VisualEffectsKit const & in_kit);
19262 
19266  VisualEffectsKit(VisualEffectsKit && in_that);
19267 
19271  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
19272 
19274  virtual ~VisualEffectsKit();
19275 
19276  Type ObjectType() const {return Type::VisualEffectsKit;};
19277 
19281  static VisualEffectsKit GetDefault();
19282 
19285  void Set(VisualEffectsKit const & in_kit);
19286 
19289  void Show(VisualEffectsKit & out_kit) const;
19290 
19294  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
19295 
19298  bool Empty() const;
19299 
19303  bool Equals(VisualEffectsKit const & in_kit) const;
19304 
19308  bool operator==(VisualEffectsKit const & in_kit) const;
19309 
19313  bool operator!=(VisualEffectsKit const & in_kit) const;
19314 
19318  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
19319 
19323  VisualEffectsKit & SetAntiAliasing(bool in_state);
19324 
19334  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19335 
19344  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19345 
19352  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19353 
19359  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19360 
19364  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19365 
19369  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19370 
19374  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19375 
19386  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);
19387 
19397  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19398 
19402  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19403 
19407  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19408 
19409 
19412  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
19413 
19416  VisualEffectsKit & UnsetAntiAliasing();
19417 
19420  VisualEffectsKit & UnsetShadowMaps();
19421 
19424  VisualEffectsKit & UnsetSimpleShadow();
19425 
19428  VisualEffectsKit & UnsetSimpleShadowPlane();
19429 
19432  VisualEffectsKit & UnsetSimpleShadowLightDirection();
19433 
19436  VisualEffectsKit & UnsetSimpleShadowColor();
19437 
19440  VisualEffectsKit & UnsetSimpleReflection();
19441 
19444  VisualEffectsKit & UnsetSimpleReflectionPlane();
19445 
19448  VisualEffectsKit & UnsetSimpleReflectionVisibility();
19449 
19452  VisualEffectsKit & UnsetEverything();
19453 
19457  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19458 
19462  bool ShowAntiAliasing(bool & out_state) const;
19463 
19471  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19472 
19479  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19480 
19484  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
19485 
19489  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
19490 
19494  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
19495 
19504  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;
19505 
19506 
19510  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
19511 
19515  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
19516 };
19517 
19518 
19524 class HPS_API VisualEffectsControl : public Control
19525 {
19526 public:
19527 
19529  explicit VisualEffectsControl(SegmentKey & in_seg);
19530 
19532  VisualEffectsControl(VisualEffectsControl const & in_that);
19533 
19538 
19542  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
19543 
19546 
19547  Type ObjectType() const {return Type::VisualEffectsControl;};
19548 
19550  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
19551 
19555  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
19556 
19560  VisualEffectsControl & SetAntiAliasing(bool in_state);
19561 
19571  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19572 
19581  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19582 
19589  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19590 
19596  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19597 
19601  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19602 
19606  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19607 
19611  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19612 
19623  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);
19624 
19634  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19635 
19639  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19640 
19644  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19645 
19646 
19649  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
19650 
19653  VisualEffectsControl & UnsetAntiAliasing();
19654 
19657  VisualEffectsControl & UnsetShadowMaps();
19658 
19661  VisualEffectsControl & UnsetSimpleShadow();
19662 
19665  VisualEffectsControl & UnsetSimpleShadowPlane();
19666 
19669  VisualEffectsControl & UnsetSimpleShadowLightDirection();
19670 
19673  VisualEffectsControl & UnsetSimpleShadowColor();
19674 
19677  VisualEffectsControl & UnsetSimpleReflection();
19678 
19681  VisualEffectsControl & UnsetSimpleReflectionPlane();
19682 
19685  VisualEffectsControl & UnsetSimpleReflectionVisibility();
19686 
19689  VisualEffectsControl & UnsetEverything();
19690 
19691 
19695  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19696 
19700  bool ShowAntiAliasing(bool & out_state) const;
19701 
19709  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19710 
19717  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19718 
19722  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
19723 
19727  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
19728 
19732  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
19733 
19742  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;
19743 
19747  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
19748 
19752  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
19753 
19754 private:
19757 };
19758 
19759 
19760 
19762 class HPS_API ContourLineKit : public Object
19763 {
19764 public:
19765 
19767  ContourLineKit();
19768 
19771  ContourLineKit(ContourLineKit const & in_kit);
19772 
19776  ContourLineKit(ContourLineKit && in_that);
19777 
19781  ContourLineKit & operator=(ContourLineKit && in_that);
19782 
19784  virtual ~ContourLineKit();
19785 
19786  Type ObjectType() const { return Type::ContourLineKit; };
19787 
19791  static ContourLineKit GetDefault();
19792 
19795  void Set(ContourLineKit const & in_kit);
19796 
19799  void Show(ContourLineKit & out_kit) const;
19800 
19804  ContourLineKit & operator=(ContourLineKit const & in_kit);
19805 
19808  bool Empty() const;
19809 
19813  bool Equals(ContourLineKit const & in_kit) const;
19814 
19818  bool operator==(ContourLineKit const & in_kit) const;
19819 
19823  bool operator!=(ContourLineKit const & in_kit) const;
19824 
19825 
19829  ContourLineKit & SetVisibility(bool in_state);
19830 
19835  ContourLineKit & SetPositions(float in_interval, float in_offset);
19836 
19840  ContourLineKit & SetPositions(FloatArray const & in_positions);
19841 
19846  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
19847 
19851  ContourLineKit & SetColors(RGBColorArray const & in_colors);
19852 
19857  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
19858 
19862  ContourLineKit & SetColors(RGBColor const & in_color);
19863 
19867  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
19868 
19873  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
19874 
19878  ContourLineKit & SetPatterns(char const * in_pattern);
19879 
19884  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
19885 
19891  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
19892 
19897  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
19898 
19902  ContourLineKit & SetLighting(bool in_state);
19903 
19904 
19907  ContourLineKit & UnsetVisibility();
19908 
19911  ContourLineKit & UnsetPositions();
19912 
19915  ContourLineKit & UnsetColors();
19916 
19919  ContourLineKit & UnsetPatterns();
19920 
19923  ContourLineKit & UnsetWeights();
19924 
19927  ContourLineKit & UnsetLighting();
19928 
19931  ContourLineKit & UnsetEverything();
19932 
19933 
19937  bool ShowVisibility(bool & out_state) const;
19938 
19944  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
19945 
19949  bool ShowColors(RGBColorArray & out_colors) const;
19950 
19954  bool ShowPatterns(UTF8Array & out_patterns) const;
19955 
19960  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
19961 
19965  bool ShowLighting(bool & out_state) const;
19966 };
19967 
19971 class HPS_API ContourLineControl : public Control
19972 {
19973 public:
19974 
19976  explicit ContourLineControl(SegmentKey & in_seg);
19977 
19979  ContourLineControl(ContourLineControl const & in_that);
19980 
19985 
19989  ContourLineControl & operator=(ContourLineControl && in_that);
19990 
19992  ~ContourLineControl();
19993 
19994  Type ObjectType() const { return Type::ContourLineControl; };
19995 
19997  ContourLineControl & operator=(ContourLineControl const & in_that);
19998 
19999 
20003  ContourLineControl & SetVisibility(bool in_state);
20004 
20009  ContourLineControl & SetPositions(float in_interval, float in_offset);
20010 
20014  ContourLineControl & SetPositions(FloatArray const & in_positions);
20015 
20020  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20021 
20025  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20026 
20031  ContourLineControl & SetColors(size_t in_count, RGBColor const in_rgb_colors[]);
20032 
20036  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20037 
20041  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20042 
20047  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20048 
20052  ContourLineControl & SetPatterns(char const * in_pattern);
20053 
20058  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20059 
20065  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20066 
20071  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20072 
20076  ContourLineControl & SetLighting(bool in_state);
20077 
20078 
20081  ContourLineControl & UnsetVisibility();
20082 
20085  ContourLineControl & UnsetPositions();
20086 
20089  ContourLineControl & UnsetColors();
20090 
20093  ContourLineControl & UnsetPatterns();
20094 
20097  ContourLineControl & UnsetWeights();
20098 
20101  ContourLineControl & UnsetLighting();
20102 
20105  ContourLineControl & UnsetEverything();
20106 
20107 
20111  bool ShowVisibility(bool & out_state) const;
20112 
20118  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20119 
20123  bool ShowColors(RGBColorArray & out_colors) const;
20124 
20128  bool ShowPatterns(UTF8Array & out_patterns) const;
20129 
20134  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20135 
20139  bool ShowLighting(bool & out_state) const;
20140 
20141 private:
20144 };
20145 
20146 
20147 
20149 class HPS_API SubwindowKit : public Object
20150 {
20151 public:
20152 
20154  SubwindowKit();
20155 
20157  SubwindowKit(SubwindowKit const & in_kit);
20158 
20162  SubwindowKit(SubwindowKit && in_that);
20163 
20167  SubwindowKit & operator=(SubwindowKit && in_that);
20168 
20170  virtual ~SubwindowKit();
20171 
20172  Type ObjectType() const {return Type::SubwindowKit;}
20173 
20177  static SubwindowKit GetDefault();
20178 
20181  void Set(SubwindowKit const & in_kit);
20182 
20185  void Show(SubwindowKit & out_kit) const;
20186 
20190  SubwindowKit & operator=(SubwindowKit const & in_kit);
20191 
20194  bool Empty() const;
20195 
20199  bool Equals(SubwindowKit const & in_kit) const;
20200 
20204  bool operator==(SubwindowKit const & in_kit) const;
20205 
20209  bool operator!=(SubwindowKit const & in_kit) const;
20210 
20211 
20221  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20222 
20229  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20230 
20235  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
20236 
20241  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20242 
20243 
20246  SubwindowKit & UnsetSubwindow();
20247 
20250  SubwindowKit & UnsetBackground();
20251 
20254  SubwindowKit & UnsetBorder();
20255 
20258  SubwindowKit & UnsetRenderingAlgorithm();
20259 
20262  SubwindowKit & UnsetEverything();
20263 
20264 
20269  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
20270 
20275  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20276 
20280  bool ShowBorder(Subwindow::Border & out_border_type) const;
20281 
20285  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20286 };
20287 
20288 
20289 
20295 class HPS_API SubwindowControl : public Control
20296 {
20297 public:
20298 
20300  explicit SubwindowControl(SegmentKey & in_seg);
20301 
20303  SubwindowControl(SubwindowControl const & in_that);
20304 
20308  SubwindowControl(SubwindowControl && in_that);
20309 
20313  SubwindowControl & operator=(SubwindowControl && in_that);
20314 
20316  ~SubwindowControl();
20317 
20318  Type ObjectType() const {return Type::SubwindowControl;}
20319 
20321  SubwindowControl & operator=(SubwindowControl const & in_that);
20322 
20333  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
20334 
20341  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20342 
20347  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
20348 
20354  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20355 
20356 
20359  SubwindowControl & UnsetSubwindow();
20360 
20363  SubwindowControl & UnsetBackground();
20364 
20367  SubwindowControl & UnsetBorder();
20368 
20371  SubwindowControl & UnsetRenderingAlgorithm();
20372 
20375  SubwindowControl & UnsetEverything();
20376 
20377 
20382  bool ShowSubwindow(Rectangle & out_window_position, Subwindow::Type & out_subwindow_type) const;
20383 
20388  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20389 
20393  bool ShowBorder(Subwindow::Border & out_border_type) const;
20394 
20398  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20399 
20400 private:
20402  SubwindowControl();
20403 };
20404 
20405 
20406 
20408 class HPS_API DebuggingKit : public Object
20409 {
20410 public:
20411 
20413  DebuggingKit();
20414 
20416  DebuggingKit(DebuggingKit const & in_kit);
20417 
20421  DebuggingKit(DebuggingKit && in_that);
20422 
20426  DebuggingKit & operator=(DebuggingKit && in_that);
20427 
20429  virtual ~DebuggingKit();
20430 
20431  Type ObjectType() const {return Type::DebuggingKit;}
20432 
20436  static DebuggingKit GetDefault();
20437 
20440  void Set(DebuggingKit const & in_kit);
20441 
20444  void Show(DebuggingKit & out_kit) const;
20445 
20449  DebuggingKit & operator=(DebuggingKit const & in_kit);
20450 
20453  bool Empty() const;
20454 
20458  bool Equals(DebuggingKit const & in_kit) const;
20459 
20463  bool operator==(DebuggingKit const & in_kit) const;
20464 
20468  bool operator!=(DebuggingKit const & in_kit) const;
20469 
20470 
20474  DebuggingKit & SetResourceMonitor(bool in_display);
20475 
20476 
20479  DebuggingKit & UnsetResourceMonitor();
20480 
20483  DebuggingKit & UnsetEverything();
20484 
20485 
20489  bool ShowResourceMonitor(bool & out_display) const;
20490 };
20491 
20492 
20495 class HPS_API DebuggingControl : public Control
20496 {
20497 public:
20498 
20500  explicit DebuggingControl(WindowKey & in_window);
20501 
20503  DebuggingControl(DebuggingControl const & in_that);
20504 
20508  DebuggingControl(DebuggingControl && in_that);
20509 
20513  DebuggingControl & operator=(DebuggingControl && in_that);
20514 
20516  ~DebuggingControl();
20517 
20518  Type ObjectType() const {return Type::DebuggingControl;}
20519 
20521  DebuggingControl & operator=(DebuggingControl const & in_that);
20522 
20527  DebuggingControl & SetResourceMonitor(bool in_display);
20528 
20529 
20533  bool ShowResourceMonitor(bool & out_display) const;
20534 
20535 private:
20537  DebuggingControl();
20538 };
20539 
20540 
20542 class HPS_API WindowInfoKit : public Object
20543 {
20544 public:
20545 
20547  WindowInfoKit();
20548 
20550  WindowInfoKit(WindowInfoKit const & in_kit);
20551 
20555  WindowInfoKit(WindowInfoKit && in_that);
20556 
20560  WindowInfoKit & operator=(WindowInfoKit && in_that);
20561 
20563  virtual ~WindowInfoKit();
20564 
20565  Type ObjectType() const {return Type::WindowInfoKit;}
20566 
20569  void Set(WindowInfoKit const & in_kit);
20570 
20573  void Show(WindowInfoKit & out_kit) const;
20574 
20578  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
20579 
20582  bool Empty() const;
20583 
20587  bool Equals(WindowInfoKit const & in_kit) const;
20588 
20592  bool operator==(WindowInfoKit const & in_kit) const;
20593 
20597  bool operator!=(WindowInfoKit const & in_kit) const;
20598 
20599 
20604  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
20605 
20610  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
20611 
20616  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
20617 
20622  WindowInfoKit & SetWindowSize(float in_width, float in_height);
20623 
20624 
20627  WindowInfoKit & UnsetPhysicalPixels();
20628 
20631  WindowInfoKit & UnsetPhysicalSize();
20632 
20635  WindowInfoKit & UnsetWindowPixels();
20636 
20639  WindowInfoKit & UnsetWindowSize();
20640 
20643  WindowInfoKit & UnsetEverything();
20644 
20645 
20650  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
20651 
20656  bool ShowPhysicalSize(float & out_width, float & out_height) const;
20657 
20662  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
20663 
20668  bool ShowWindowSize(float & out_width, float & out_height) const;
20669 
20675  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
20676 
20680  bool ShowWindowAspectRatio(float & out_window_aspect) const;
20681 
20685  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
20686 };
20687 
20688 
20691 class HPS_API WindowInfoControl : public Control
20692 {
20693 public:
20694 
20696  explicit WindowInfoControl(WindowKey & in_window);
20697 
20699  WindowInfoControl(WindowInfoControl const & in_that);
20700 
20705 
20709  WindowInfoControl & operator=(WindowInfoControl && in_that);
20710 
20712  ~WindowInfoControl();
20713 
20714  Type ObjectType() const {return Type::WindowInfoControl;}
20715 
20717  WindowInfoControl & operator=(WindowInfoControl const & in_that);
20718 
20719 
20724  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
20725 
20730  bool ShowPhysicalSize(float & out_width, float & out_height) const;
20731 
20736  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
20737 
20742  bool ShowWindowSize(float & out_width, float & out_height) const;
20743 
20749  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
20750 
20754  bool ShowWindowAspectRatio(float & out_window_aspect) const;
20755 
20759  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
20760 
20761 private:
20764 };
20765 
20767 class HPS_API FontInfoState : public Object
20768 {
20769 public:
20770 
20772  FontInfoState();
20773 
20775  FontInfoState(FontInfoState const & in_kit);
20776 
20780  FontInfoState(FontInfoState && in_that);
20781 
20785  FontInfoState & operator=(FontInfoState && in_that);
20786 
20788  virtual ~FontInfoState();
20789 
20790  Type ObjectType() const {return Type::FontInfoState;}
20791 
20794  void Assign(FontInfoState const & in_that);
20795 
20798  void Set(FontInfoState const & in_kit);
20799 
20802  void Show(FontInfoState & out_kit) const;
20803 
20807  FontInfoState & operator=(FontInfoState const & in_kit);
20808 
20811  bool Empty() const;
20812 
20816  bool Equals(FontInfoState const & in_kit) const;
20817 
20821  bool operator==(FontInfoState const & in_kit) const;
20822 
20826  bool operator!=(FontInfoState const & in_kit) const;
20827 
20830  UTF8 GetName() const;
20831 
20834  bool GetShellConvertibility() const;
20835 };
20836 
20837 
20842 class HPS_API AttributeLockKit : public Object
20843 {
20844 public:
20845 
20847  AttributeLockKit();
20848 
20850  AttributeLockKit(AttributeLockKit const & in_kit);
20851 
20855  AttributeLockKit(AttributeLockKit && in_that);
20856 
20860  AttributeLockKit & operator=(AttributeLockKit && in_that);
20861 
20863  virtual ~AttributeLockKit();
20864 
20865  Type ObjectType() const {return Type::AttributeLockKit;}
20866 
20870  static AttributeLockKit GetDefault();
20871 
20874  void Set(AttributeLockKit const & in_kit);
20875 
20878  void Show(AttributeLockKit & out_kit) const;
20879 
20883  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
20884 
20887  bool Empty() const;
20888 
20892  bool Equals(AttributeLockKit const & in_kit) const;
20893 
20897  bool operator==(AttributeLockKit const & in_kit) const;
20898 
20902  bool operator!=(AttributeLockKit const & in_kit) const;
20903 
20909  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
20910 
20915  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
20916 
20922  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
20923 
20929  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
20930 
20931 
20934  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
20935 
20938  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
20939 
20942  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
20943 
20946  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
20947 
20950  AttributeLockKit & UnsetEverything();
20951 
20952 
20957  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
20958 
20963  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
20964 
20969  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
20970 
20975  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
20976 };
20977 
20978 
20983 class HPS_API AttributeLockControl : public Control
20984 {
20985 public:
20986 
20988  explicit AttributeLockControl(SegmentKey & in_seg);
20989 
20994 
20998  AttributeLockControl & operator=(AttributeLockControl && in_that);
20999 
21001  AttributeLockControl(AttributeLockControl const & in_that);
21002 
21005 
21006  Type ObjectType() const {return Type::AttributeLockControl;}
21007 
21009  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21010 
21011 
21017  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21018 
21023  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21024 
21030  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21031 
21037  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21038 
21039 
21042  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21043 
21046  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21047 
21050  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21051 
21054  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21055 
21058  AttributeLockControl & UnsetEverything();
21059 
21060 
21065  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21066 
21071  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21072 
21077  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21078 
21083  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21084 
21085 private:
21088 };
21089 
21093 
21094 class HPS_API GeometryKey : public Key
21095 {
21096 public:
21098  GeometryKey();
21099 
21103  explicit GeometryKey(Key const & in_that);
21104 
21107  GeometryKey(GeometryKey const & in_that);
21108 
21112  GeometryKey & operator=(GeometryKey const & in_that);
21113 
21117  GeometryKey(GeometryKey && in_that);
21118 
21122  GeometryKey & operator=(GeometryKey && in_that);
21123 
21124  ~GeometryKey();
21125 
21126  Type ObjectType() const { return Type::GeometryKey; };
21127 
21128 
21132  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21133 
21137  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
21138 
21139 
21140 
21147  GeometryKey & SetPriority(int in_priority);
21148 
21151  GeometryKey & UnsetPriority();
21152 
21156  bool ShowPriority(int & out_priority) const;
21157 
21158 
21164  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21165 
21170  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
21171 
21176  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21177 
21181  GeometryKey & UnsetUserData(intptr_t in_index);
21182 
21187  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21188 
21192  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
21193 
21196  GeometryKey & UnsetAllUserData();
21197 
21199  size_t ShowUserDataCount() const;
21200 
21204  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21205 
21210  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21211 
21216  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21217 
21221  bool ShowBoundings(BoundingKit & out_kit) const;
21222 };
21223 
21224 
21226 class HPS_API LineKit : public Object
21227 {
21228 public:
21230  LineKit();
21231 
21234  LineKit(LineKit const & in_kit);
21235 
21239  LineKit(LineKit && in_that);
21240 
21244  LineKit & operator=(LineKit && in_that);
21245 
21246  virtual ~LineKit();
21247 
21248  Type ObjectType() const { return Type::LineKit; };
21249 
21252  void Consume(LineKit & in_kit);
21253 
21256  void Set(LineKit const & in_kit);
21257 
21260  void Show(LineKit & out_kit) const;
21261 
21265  LineKit & operator=(LineKit const & in_kit);
21266 
21269  bool Empty() const;
21270 
21274  bool Equals(LineKit const & in_kit) const;
21275 
21279  bool operator==(LineKit const & in_kit) const;
21280 
21284  bool operator!=(LineKit const & in_kit) const;
21285 
21288  size_t GetPointCount() const;
21289 
21296  LineKit & SetPriority(int in_priority);
21297 
21300  LineKit & UnsetPriority();
21301 
21305  bool ShowPriority(int & out_priority) const;
21306 
21307 
21311  LineKit & SetPoints(PointArray const & in_points);
21312 
21317  LineKit & SetPoints(size_t in_count, Point const in_points []);
21318 
21319 
21322  LineKit & UnsetPoints();
21323 
21326  LineKit & UnsetEverything();
21327 
21328 
21332  bool ShowPoints(PointArray & out_points) const;
21333 
21334 
21340  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21341 
21346  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21347 
21352  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
21353 
21359  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21360 
21366  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21367 
21373  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21374 
21379  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21380 
21385  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21386 
21390  LineKit & UnsetUserData(intptr_t in_index);
21391 
21396  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21397 
21401  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
21402 
21405  LineKit & UnsetAllUserData();
21406 
21408  size_t ShowUserDataCount() const;
21409 
21413  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21414 
21419  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21420 
21425  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21426 };
21427 
21429 class HPS_API LineKey : public GeometryKey
21430 {
21431 public:
21433  LineKey();
21434 
21438  explicit LineKey(Key const & in_that);
21439 
21442  LineKey(LineKey const & in_that);
21443 
21447  LineKey & operator=(LineKey const & in_that);
21448 
21452  LineKey(LineKey && in_that);
21453 
21457  LineKey & operator=(LineKey && in_that);
21458 
21459  ~LineKey();
21460 
21461  Type ObjectType() const { return Type::LineKey; };
21462 
21463 
21466  void Consume(LineKit & in_kit);
21467 
21470  void Set(LineKit const & in_kit);
21471 
21474  void Show(LineKit & out_kit) const;
21475 
21478  size_t GetPointCount() const;
21479 
21483  LineKey & SetPoints(PointArray const & in_points);
21484 
21489  LineKey & SetPoints(size_t in_count, Point const in_points []);
21490 
21491 
21495  bool ShowPoints(PointArray & out_points) const;
21496 
21497 
21503  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21504 
21509  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21510 
21515  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
21516 
21522  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21523 
21529  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21530 };
21531 
21532 
21533 
21535 class HPS_API MarkerKit : public Object
21536 {
21537 public:
21539  MarkerKit();
21540 
21543  MarkerKit(MarkerKit const & in_kit);
21544 
21548  MarkerKit(MarkerKit && in_that);
21549 
21553  MarkerKit & operator=(MarkerKit && in_that);
21554 
21555  virtual ~MarkerKit();
21556 
21557  Type ObjectType() const { return Type::MarkerKit; };
21558 
21561  void Consume(MarkerKit & in_kit);
21562 
21565  void Set(MarkerKit const & in_kit);
21566 
21569  void Show(MarkerKit & out_kit) const;
21570 
21574  MarkerKit & operator=(MarkerKit const & in_kit);
21575 
21578  bool Empty() const;
21579 
21583  bool Equals(MarkerKit const & in_kit) const;
21584 
21588  bool operator==(MarkerKit const & in_kit) const;
21589 
21593  bool operator!=(MarkerKit const & in_kit) const;
21594 
21595 
21602  MarkerKit & SetPriority(int in_priority);
21603 
21606  MarkerKit & UnsetPriority();
21607 
21611  bool ShowPriority(int & out_priority) const;
21612 
21616  MarkerKit & SetPoint(Point const & in_point);
21617 
21618 
21621  MarkerKit & UnsetPoint();
21622 
21625  MarkerKit & UnsetEverything();
21626 
21627 
21631  bool ShowPoint(Point & out_point) const;
21632 
21638  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21639 
21644  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21645 
21650  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21651 
21655  MarkerKit & UnsetUserData(intptr_t in_index);
21656 
21661  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21662 
21666  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
21667 
21670  MarkerKit & UnsetAllUserData();
21671 
21673  size_t ShowUserDataCount() const;
21674 
21678  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21679 
21684  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21685 
21690  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21691 };
21692 
21694 class HPS_API MarkerKey : public GeometryKey
21695 {
21696 public:
21698  MarkerKey();
21699 
21703  explicit MarkerKey(Key const & in_that);
21704 
21707  MarkerKey(MarkerKey const & in_that);
21708 
21712  MarkerKey & operator=(MarkerKey const & in_that);
21713 
21717  MarkerKey(MarkerKey && in_that);
21718 
21722  MarkerKey & operator=(MarkerKey && in_that);
21723 
21724  ~MarkerKey();
21725 
21726  Type ObjectType() const { return Type::MarkerKey; };
21727 
21728 
21731  void Consume(MarkerKit & in_kit);
21732 
21735  void Set(MarkerKit const & in_kit);
21736 
21739  void Show(MarkerKit & out_kit) const;
21740 
21741 
21745  MarkerKey & SetPoint(Point const & in_point);
21746 
21750  bool ShowPoint(Point & out_point) const;
21751 };
21752 
21753 
21754 
21756 class HPS_API DistantLightKit : public Object
21757 {
21758 public:
21760  DistantLightKit();
21761 
21764  DistantLightKit(DistantLightKit const & in_kit);
21765 
21769  DistantLightKit(DistantLightKit && in_that);
21770 
21774  DistantLightKit & operator=(DistantLightKit && in_that);
21775 
21776  virtual ~DistantLightKit();
21777 
21778  Type ObjectType() const { return Type::DistantLightKit; };
21779 
21782  void Consume(DistantLightKit & in_kit);
21783 
21786  void Set(DistantLightKit const & in_kit);
21787 
21790  void Show(DistantLightKit & out_kit) const;
21791 
21795  DistantLightKit & operator=(DistantLightKit const & in_kit);
21796 
21799  bool Empty() const;
21800 
21804  bool Equals(DistantLightKit const & in_kit) const;
21805 
21809  bool operator==(DistantLightKit const & in_kit) const;
21810 
21814  bool operator!=(DistantLightKit const & in_kit) const;
21815 
21816 
21823  DistantLightKit & SetPriority(int in_priority);
21824 
21830  DistantLightKit & SetDirection(Vector const & in_vector);
21831 
21835  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
21836 
21840  DistantLightKit & SetColorByIndex(float in_index);
21841 
21847  DistantLightKit & SetCameraRelative(bool in_state);
21848 
21849 
21852  DistantLightKit & UnsetPriority();
21853 
21856  DistantLightKit & UnsetDirection();
21857 
21860  DistantLightKit & UnsetColor();
21861 
21864  DistantLightKit & UnsetCameraRelative();
21865 
21868  DistantLightKit & UnsetEverything();
21869 
21870 
21874  bool ShowPriority(int & out_priority) const;
21875 
21879  bool ShowDirection(Vector & out_vector) const;
21880 
21886  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
21887 
21891  bool ShowCameraRelative(bool & out_state) const;
21892 
21898  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21899 
21904  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21905 
21910  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21911 
21915  DistantLightKit & UnsetUserData(intptr_t in_index);
21916 
21921  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21922 
21926  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
21927 
21930  DistantLightKit & UnsetAllUserData();
21931 
21933  size_t ShowUserDataCount() const;
21934 
21938  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21939 
21944  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21945 
21950  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21951 };
21952 
21953 
21954 
21956 class HPS_API DistantLightKey : public GeometryKey
21957 {
21958 public:
21960  DistantLightKey();
21961 
21965  explicit DistantLightKey(Key const & in_that);
21966 
21969  DistantLightKey(DistantLightKey const & in_that);
21970 
21974  DistantLightKey & operator=(DistantLightKey const & in_that);
21975 
21979  DistantLightKey(DistantLightKey && in_that);
21980 
21984  DistantLightKey & operator=(DistantLightKey && in_that);
21985 
21986  ~DistantLightKey();
21987 
21988  Type ObjectType() const { return Type::DistantLightKey; };
21989 
21992  void Consume(DistantLightKit & in_kit);
21993 
21996  void Set(DistantLightKit const & in_kit);
21997 
22000  void Show(DistantLightKit & out_kit) const;
22001 
22002 
22007  DistantLightKey & SetDirection(Vector const & in_vector);
22008 
22012  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22013 
22017  DistantLightKey & SetColorByIndex(float in_index);
22018 
22023  DistantLightKey & SetCameraRelative(bool in_state);
22024 
22025 
22028  DistantLightKey & UnsetColor();
22029 
22030 
22034  bool ShowDirection(Vector & out_vector) const;
22035 
22041  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22042 
22046  bool ShowCameraRelative(bool & out_state) const;
22047 };
22048 
22049 
22050 
22051 
22053 class HPS_API CylinderKit : public Object
22054 {
22055 public:
22057  CylinderKit();
22058 
22061  CylinderKit(CylinderKit const & in_kit);
22062 
22066  CylinderKit(CylinderKit && in_that);
22067 
22071  CylinderKit & operator=(CylinderKit && in_that);
22072 
22073  virtual ~CylinderKit();
22074 
22075  Type ObjectType() const { return Type::CylinderKit; };
22076 
22079  void Consume(CylinderKit & in_kit);
22080 
22083  void Set(CylinderKit const & in_kit);
22084 
22087  void Show(CylinderKit & out_kit) const;
22088 
22092  CylinderKit & operator=(CylinderKit const & in_kit);
22093 
22096  bool Empty() const;
22097 
22101  bool Equals(CylinderKit const & in_kit) const;
22102 
22106  bool operator==(CylinderKit const & in_kit) const;
22107 
22111  bool operator!=(CylinderKit const & in_kit) const;
22112 
22115  size_t GetPointCount() const;
22116 
22123  CylinderKit & SetPriority(int in_priority);
22124 
22127  CylinderKit & UnsetPriority();
22128 
22132  bool ShowPriority(int & out_priority) const;
22133 
22134 
22138  CylinderKit & SetPoints(PointArray const & in_points);
22139 
22144  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
22145 
22149  CylinderKit & SetRadii(FloatArray const & in_radii);
22150 
22155  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
22156 
22160  CylinderKit & SetCaps(Cylinder::Capping in_capping);
22161 
22162 
22165  CylinderKit & UnsetPoints();
22166 
22169  CylinderKit & UnsetRadii();
22170 
22173  CylinderKit & UnsetCaps();
22174 
22177  CylinderKit & UnsetEverything();
22178 
22179 
22183  bool ShowPoints(PointArray & out_points) const;
22184 
22188  bool ShowRadii(FloatArray & out_radii) const;
22189 
22193  bool ShowCaps(Cylinder::Capping & out_caps) const;
22194 
22195 
22202  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22203 
22209  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22210 
22217  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22218 
22225  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22226 
22233  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22234 
22241  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22242 
22248  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22249 
22250 
22257  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22258 
22264  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22265 
22272  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22273 
22280  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22281 
22288  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22289 
22296  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22297 
22303  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22304 
22305 
22308  CylinderKit & UnsetVertexColors();
22309 
22314  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22315 
22319  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
22320 
22321 
22325  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
22326 
22332  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22333 
22338  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
22339 
22340 
22352  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;
22353 
22366  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22367 
22373  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22374 
22379  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22380 
22385  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22386 
22390  CylinderKit & UnsetUserData(intptr_t in_index);
22391 
22396  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22397 
22401  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
22402 
22405  CylinderKit & UnsetAllUserData();
22406 
22408  size_t ShowUserDataCount() const;
22409 
22413  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22414 
22419  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22420 
22425  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22426 };
22427 
22428 
22429 
22431 class HPS_API CylinderKey : public GeometryKey
22432 {
22433 public:
22435  CylinderKey();
22436 
22440  explicit CylinderKey(Key const & in_that);
22441 
22444  CylinderKey(CylinderKey const & in_that);
22445 
22449  CylinderKey & operator=(CylinderKey const & in_that);
22450 
22454  CylinderKey(CylinderKey && in_that);
22455 
22459  CylinderKey & operator=(CylinderKey && in_that);
22460 
22461  ~CylinderKey();
22462 
22463  Type ObjectType() const { return Type::CylinderKey; };
22464 
22467  void Consume(CylinderKit & in_kit);
22468 
22471  void Set(CylinderKit const & in_kit);
22472 
22473 
22479  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22480 
22485  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22486 
22491  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22492 
22498  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22499 
22505  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22506 
22507 
22513  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
22514 
22519  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
22520 
22525  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
22526 
22532  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
22533 
22539  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
22540 
22541 
22544  void Show(CylinderKit & out_kit) const;
22545 
22548  size_t GetPointCount() const;
22549 
22553  bool ShowPoints(PointArray & out_points) const;
22554 
22558  bool ShowRadii(FloatArray & out_radii) const;
22559 
22563  bool ShowCaps(Cylinder::Capping & out_caps) const;
22564 
22565 
22572  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22573 
22580  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22581 
22588  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22589 
22590 
22597  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22598 
22605  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22606 
22613  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22614 
22615 
22618  CylinderKey & UnsetVertexColors();
22619 
22624  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22625 
22629  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
22630 
22636  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22637 
22638 
22650  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;
22651 
22664  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22665 };
22666 
22667 
22668 
22669 
22671 class HPS_API SphereKit : public Object
22672 {
22673 public:
22675  SphereKit();
22676 
22679  SphereKit(SphereKit const & in_kit);
22680 
22684  SphereKit(SphereKit && in_that);
22685 
22689  SphereKit & operator=(SphereKit && in_that);
22690 
22691  virtual ~SphereKit();
22692 
22693  Type ObjectType() const { return Type::SphereKit; };
22694 
22697  void Consume(SphereKit & in_kit);
22698 
22701  void Set(SphereKit const & in_kit);
22702 
22705  void Show(SphereKit & out_kit) const;
22706 
22710  SphereKit & operator=(SphereKit const & in_kit);
22711 
22714  bool Empty() const;
22715 
22719  bool Equals(SphereKit const & in_kit) const;
22720 
22724  bool operator==(SphereKit const & in_kit) const;
22725 
22729  bool operator!=(SphereKit const & in_kit) const;
22730 
22737  SphereKit & SetPriority(int in_priority);
22738 
22741  SphereKit & UnsetPriority();
22742 
22746  bool ShowPriority(int & out_priority) const;
22747 
22751  SphereKit & SetCenter(Point const & in_center);
22752 
22756  SphereKit & SetRadius(float in_radius);
22757 
22762  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
22763 
22764 
22767  SphereKit & UnsetCenter();
22768 
22771  SphereKit & UnsetRadius();
22772 
22775  SphereKit & UnsetBasis();
22776 
22779  SphereKit & UnsetEverything();
22780 
22781 
22785  bool ShowCenter(Point & out_center) const;
22786 
22790  bool ShowRadius(float & out_radius) const;
22791 
22796  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
22797 
22803  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22804 
22809  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22810 
22815  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22816 
22820  SphereKit & UnsetUserData(intptr_t in_index);
22821 
22826  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22827 
22831  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
22832 
22835  SphereKit & UnsetAllUserData();
22836 
22838  size_t ShowUserDataCount() const;
22839 
22843  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22844 
22849  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22850 
22855  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22856 };
22857 
22859 class HPS_API SphereKey : public GeometryKey
22860 {
22861 public:
22863  SphereKey();
22864 
22868  explicit SphereKey(Key const & in_that);
22869 
22872  SphereKey(SphereKey const & in_that);
22873 
22877  SphereKey & operator=(SphereKey const & in_that);
22878 
22882  SphereKey(SphereKey && in_that);
22883 
22887  SphereKey & operator=(SphereKey && in_that);
22888 
22889  ~SphereKey();
22890 
22891  Type ObjectType() const {return Type::SphereKey;};
22892 
22895  void Consume(SphereKit & in_kit);
22896 
22899  void Set(SphereKit const & in_kit);
22900 
22903  void Show(SphereKit & out_kit) const;
22904 
22905 
22909  SphereKey & SetCenter(Point const & in_center);
22910 
22914  SphereKey & SetRadius(float in_radius);
22915 
22920  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
22921 
22922 
22926  bool ShowCenter(Point & out_center) const;
22927 
22931  bool ShowRadius(float & out_radius) const;
22932 
22937  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
22938 };
22939 
22940 
22941 
22942 
22944 class HPS_API CircleKit : public Object
22945 {
22946 public:
22948  CircleKit();
22949 
22952  CircleKit(CircleKit const & in_kit);
22953 
22957  CircleKit(CircleKit && in_that);
22958 
22962  CircleKit & operator=(CircleKit && in_that);
22963 
22964  virtual ~CircleKit();
22965 
22966  Type ObjectType() const { return Type::CircleKit; };
22967 
22970  void Consume(CircleKit & in_kit);
22971 
22974  void Set(CircleKit const & in_kit);
22975 
22978  void Show(CircleKit & out_kit) const;
22979 
22983  CircleKit & operator=(CircleKit const & in_kit);
22984 
22987  bool Empty() const;
22988 
22992  bool Equals(CircleKit const & in_kit) const;
22993 
22997  bool operator==(CircleKit const & in_kit) const;
22998 
23002  bool operator!=(CircleKit const & in_kit) const;
23003 
23010  CircleKit & SetPriority(int const in_priority);
23011 
23014  CircleKit & UnsetPriority();
23015 
23019  bool ShowPriority(int & out_priority) const;
23020 
23021 
23022 
23026  CircleKit & SetCenter(Point const & in_center);
23027 
23031  CircleKit & SetRadius(float in_radius);
23032 
23036  CircleKit & SetNormal(Vector const & in_normal);
23037 
23038 
23041  CircleKit & UnsetCenter();
23042 
23045  CircleKit & UnsetRadius();
23046 
23049  CircleKit & UnsetNormal();
23050 
23053  CircleKit & UnsetEverything();
23054 
23055 
23059  bool ShowCenter(Point & out_center) const;
23060 
23064  bool ShowRadius(float & out_radius) const;
23065 
23069  bool ShowNormal(Vector & out_normal) const;
23070 
23076  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23077 
23082  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23083 
23088  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23089 
23093  CircleKit & UnsetUserData(intptr_t in_index);
23094 
23099  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23100 
23104  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
23105 
23108  CircleKit & UnsetAllUserData();
23109 
23111  size_t ShowUserDataCount() const;
23112 
23116  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23117 
23122  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23123 
23128  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23129 };
23130 
23131 
23134 class HPS_API CircleKey : public GeometryKey
23135 {
23136 public:
23138  CircleKey();
23139 
23143  explicit CircleKey(Key const & in_that);
23144 
23147  CircleKey(CircleKey const & in_that);
23148 
23152  CircleKey & operator=(CircleKey const & in_that);
23153 
23157  CircleKey(CircleKey && in_that);
23158 
23162  CircleKey & operator=(CircleKey && in_that);
23163 
23164  ~CircleKey();
23165 
23166  Type ObjectType() const { return Type::CircleKey; };
23167 
23168 
23171  void Consume(CircleKit & in_kit);
23172 
23175  void Set(CircleKit const & in_kit);
23176 
23179  void Show(CircleKit & out_kit) const;
23180 
23181 
23185  CircleKey & SetCenter(Point const & in_center);
23186 
23190  CircleKey & SetRadius(float in_radius);
23191 
23195  CircleKey & SetNormal(Vector const & in_normal);
23196 
23197 
23201  bool ShowCenter(Point & out_center) const;
23202 
23206  bool ShowRadius(float & out_radius) const;
23207 
23211  bool ShowNormal(Vector & out_normal) const;
23212 };
23213 
23214 
23215 
23216 
23218 class HPS_API CircularArcKit : public Object
23219 {
23220 public:
23222  CircularArcKit();
23223 
23226  CircularArcKit(CircularArcKit const & in_kit);
23227 
23231  CircularArcKit(CircularArcKit && in_that);
23232 
23236  CircularArcKit & operator=(CircularArcKit && in_that);
23237 
23238  virtual ~CircularArcKit();
23239 
23240  Type ObjectType() const { return Type::CircularArcKit; };
23241 
23244  void Consume(CircularArcKit & in_kit);
23245 
23248  void Set(CircularArcKit const & in_kit);
23249 
23252  void Show(CircularArcKit & out_kit) const;
23253 
23257  CircularArcKit & operator=(CircularArcKit const & in_kit);
23258 
23261  bool Empty() const;
23262 
23266  bool Equals(CircularArcKit const & in_kit) const;
23267 
23271  bool operator==(CircularArcKit const & in_kit) const;
23272 
23276  bool operator!=(CircularArcKit const & in_kit) const;
23277 
23284  CircularArcKit & SetPriority(int in_priority);
23285 
23288  CircularArcKit & UnsetPriority();
23289 
23293  bool ShowPriority(int & out_priority) const;
23294 
23295 
23299  CircularArcKit & SetStart(Point const & in_start);
23300 
23304  CircularArcKit & SetMiddle(Point const & in_middle);
23305 
23309  CircularArcKit & SetEnd(Point const & in_end);
23310 
23311 
23314  CircularArcKit & UnsetStart();
23315 
23318  CircularArcKit & UnsetMiddle();
23319 
23322  CircularArcKit & UnsetEnd();
23323 
23326  CircularArcKit & UnsetEverything();
23327 
23328 
23332  bool ShowStart(Point & out_start) const;
23333 
23337  bool ShowMiddle(Point & out_middle) const;
23338 
23342  bool ShowEnd(Point & out_end) const;
23343 
23349  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23350 
23355  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23356 
23361  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23362 
23366  CircularArcKit & UnsetUserData(intptr_t in_index);
23367 
23372  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23373 
23377  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
23378 
23381  CircularArcKit & UnsetAllUserData();
23382 
23384  size_t ShowUserDataCount() const;
23385 
23389  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23390 
23395  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23396 
23401  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23402 };
23403 
23406 class HPS_API CircularArcKey : public GeometryKey
23407 {
23408 public:
23410  CircularArcKey();
23411 
23415  explicit CircularArcKey(Key const & in_that);
23416 
23419  CircularArcKey(CircularArcKey const & in_that);
23420 
23424  CircularArcKey & operator=(CircularArcKey const & in_that);
23425 
23429  CircularArcKey(CircularArcKey && in_that);
23430 
23434  CircularArcKey & operator=(CircularArcKey && in_that);
23435 
23436  ~CircularArcKey();
23437 
23438  Type ObjectType() const { return Type::CircularArcKey; };
23439 
23440 
23443  void Consume(CircularArcKit & in_kit);
23444 
23447  void Set(CircularArcKit const & in_kit);
23448 
23451  void Show(CircularArcKit & out_kit) const;
23452 
23453 
23457  CircularArcKey & SetStart(Point const & in_start);
23458 
23462  CircularArcKey & SetMiddle(Point const & in_middle);
23463 
23467  CircularArcKey & SetEnd(Point const & in_end);
23468 
23469 
23473  bool ShowStart(Point & out_start) const;
23474 
23478  bool ShowMiddle(Point & out_middle) const;
23479 
23483  bool ShowEnd(Point & out_end) const;
23484 };
23485 
23486 
23487 
23489 class HPS_API CircularWedgeKit : public Object
23490 {
23491 public:
23493  CircularWedgeKit();
23494 
23497  CircularWedgeKit(CircularWedgeKit const & in_kit);
23498 
23502  CircularWedgeKit(CircularWedgeKit && in_that);
23503 
23507  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
23508 
23509  virtual ~CircularWedgeKit();
23510 
23511  Type ObjectType() const { return Type::CircularWedgeKit; };
23512 
23515  void Consume(CircularWedgeKit & in_kit);
23516 
23519  void Set(CircularWedgeKit const & in_kit);
23520 
23523  void Show(CircularWedgeKit & out_kit) const;
23524 
23528  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
23529 
23532  bool Empty() const;
23533 
23537  bool Equals(CircularWedgeKit const & in_kit) const;
23538 
23542  bool operator==(CircularWedgeKit const & in_kit) const;
23543 
23547  bool operator!=(CircularWedgeKit const & in_kit) const;
23548 
23549 
23556  CircularWedgeKit & SetPriority(int in_priority);
23557 
23560  CircularWedgeKit & UnsetPriority();
23561 
23565  bool ShowPriority(int & out_priority) const;
23566 
23567 
23571  CircularWedgeKit & SetStart(Point const & in_start);
23572 
23576  CircularWedgeKit & SetMiddle(Point const & in_middle);
23577 
23581  CircularWedgeKit & SetEnd(Point const & in_end);
23582 
23583 
23586  CircularWedgeKit & UnsetStart();
23587 
23590  CircularWedgeKit & UnsetMiddle();
23591 
23594  CircularWedgeKit & UnsetEnd();
23595 
23598  CircularWedgeKit & UnsetEverything();
23599 
23600 
23604  bool ShowStart(Point & out_start) const;
23605 
23609  bool ShowMiddle(Point & out_middle) const;
23610 
23614  bool ShowEnd(Point & out_end) const;
23615 
23621  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23622 
23627  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23628 
23633  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23634 
23638  CircularWedgeKit & UnsetUserData(intptr_t in_index);
23639 
23644  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23645 
23649  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
23650 
23653  CircularWedgeKit & UnsetAllUserData();
23654 
23656  size_t ShowUserDataCount() const;
23657 
23661  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23662 
23667  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23668 
23673  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23674 };
23675 
23676 
23680 class HPS_API CircularWedgeKey : public GeometryKey
23681 {
23682 public:
23684  CircularWedgeKey();
23685 
23689  explicit CircularWedgeKey(Key const & in_that);
23690 
23693  CircularWedgeKey(CircularWedgeKey const & in_that);
23694 
23698  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
23699 
23703  CircularWedgeKey(CircularWedgeKey && in_that);
23704 
23708  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
23709 
23710  ~CircularWedgeKey();
23711 
23712  Type ObjectType() const { return Type::CircularWedgeKey; };
23713 
23714 
23717  void Consume(CircularWedgeKit & in_kit);
23718 
23721  void Set(CircularWedgeKit const & in_kit);
23722 
23725  void Show(CircularWedgeKit & out_kit) const;
23726 
23727 
23731  CircularWedgeKey & SetStart(Point const & in_start);
23732 
23736  CircularWedgeKey & SetMiddle(Point const & in_middle);
23737 
23741  CircularWedgeKey & SetEnd(Point const & in_end);
23742 
23743 
23747  bool ShowStart(Point & out_start) const;
23748 
23752  bool ShowMiddle(Point & out_middle) const;
23753 
23757  bool ShowEnd(Point & out_end) const;
23758 };
23759 
23760 
23761 
23763 class HPS_API CuttingSectionKit : public Object
23764 {
23765 public:
23768 
23771  CuttingSectionKit(CuttingSectionKit const & in_kit);
23772 
23777 
23781  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
23782 
23783  virtual ~CuttingSectionKit();
23784 
23785  Type ObjectType() const { return Type::CuttingSectionKit; };
23786 
23789  void Consume(CuttingSectionKit & in_kit);
23790 
23793  void Set(CuttingSectionKit const & in_kit);
23794 
23797  void Show(CuttingSectionKit & out_kit) const;
23798 
23802  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
23803 
23806  bool Empty() const;
23807 
23811  bool Equals(CuttingSectionKit const & in_kit) const;
23812 
23816  bool operator==(CuttingSectionKit const & in_kit) const;
23817 
23821  bool operator!=(CuttingSectionKit const & in_kit) const;
23822 
23829  CuttingSectionKit & SetPriority(int in_priority);
23830 
23833  CuttingSectionKit & UnsetPriority();
23834 
23838  bool ShowPriority(int & out_priority) const;
23839 
23840 
23844  CuttingSectionKit & SetPlanes(Plane const & in_plane);
23845 
23849  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
23850 
23855  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
23856 
23862  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
23863 
23864 
23867  CuttingSectionKit & UnsetPlanes();
23868 
23871  CuttingSectionKit & UnsetVisualization();
23872 
23875  CuttingSectionKit & UnsetEverything();
23876 
23877 
23880  size_t GetPlaneCount() const;
23881 
23885  bool ShowPlanes(PlaneArray & out_planes) const;
23886 
23892  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
23893 
23894 
23901  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
23902 
23908  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
23909 
23916  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
23917 
23924  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
23925 
23933  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
23934 
23940  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23941 
23946  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23947 
23952  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23953 
23957  CuttingSectionKit & UnsetUserData(intptr_t in_index);
23958 
23963  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23964 
23968  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
23969 
23972  CuttingSectionKit & UnsetAllUserData();
23973 
23975  size_t ShowUserDataCount() const;
23976 
23980  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23981 
23986  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23987 
23992  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23993 };
23994 
23995 
23997 class HPS_API CuttingSectionKey : public GeometryKey
23998 {
23999 public:
24002 
24006  explicit CuttingSectionKey(Key const & in_that);
24007 
24010  CuttingSectionKey(CuttingSectionKey const & in_that);
24011 
24015  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24016 
24021 
24025  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24026 
24027  ~CuttingSectionKey();
24028 
24029  Type ObjectType() const { return Type::CuttingSectionKey; };
24030 
24031 
24034  void Consume(CuttingSectionKit & in_kit);
24035 
24038  void Set(CuttingSectionKit const & in_kit);
24039 
24042  void Show(CuttingSectionKit & out_kit) const;
24043 
24044 
24048  CuttingSectionKey & SetPlanes(Plane const & in_plane);
24049 
24053  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
24054 
24059  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
24060 
24066  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24067 
24068 
24071  size_t GetPlaneCount() const;
24072 
24076  bool ShowPlanes(PlaneArray & out_planes) const;
24077 
24083  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24084 
24085 
24092  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24093 
24099  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24100 
24107  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24108 
24115  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24116 
24124  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24125 };
24126 
24127 
24128 
24130 class HPS_API InfiniteLineKit : public Object
24131 {
24132 public:
24134  InfiniteLineKit();
24135 
24138  InfiniteLineKit(InfiniteLineKit const & in_kit);
24139 
24143  InfiniteLineKit(InfiniteLineKit && in_that);
24144 
24148  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
24149 
24150  virtual ~InfiniteLineKit();
24151 
24152  Type ObjectType() const { return Type::InfiniteLineKit; };
24153 
24156  void Consume(InfiniteLineKit & in_kit);
24157 
24160  void Set(InfiniteLineKit const & in_kit);
24161 
24164  void Show(InfiniteLineKit & out_kit) const;
24165 
24169  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
24170 
24173  bool Empty() const;
24174 
24178  bool Equals(InfiniteLineKit const & in_kit) const;
24179 
24183  bool operator==(InfiniteLineKit const & in_kit) const;
24184 
24188  bool operator!=(InfiniteLineKit const & in_kit) const;
24189 
24196  InfiniteLineKit & SetPriority(int in_priority);
24197 
24200  InfiniteLineKit & UnsetPriority();
24201 
24205  bool ShowPriority(int & out_priority) const;
24206 
24207 
24211  InfiniteLineKit & SetFirst(Point const & in_first);
24212 
24216  InfiniteLineKit & SetSecond(Point const & in_second);
24217 
24221  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
24222 
24223 
24226  InfiniteLineKit & UnsetFirst();
24227 
24230  InfiniteLineKit & UnsetSecond();
24231 
24234  InfiniteLineKit & UnsetType();
24235 
24238  InfiniteLineKit & UnsetEverything();
24239 
24240 
24244  bool ShowFirst(Point & out_first) const;
24245 
24249  bool ShowSecond(Point & out_second) const;
24250 
24254  bool ShowType(InfiniteLine::Type & out_type) const;
24255 
24261  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24262 
24267  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24268 
24273  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24274 
24278  InfiniteLineKit & UnsetUserData(intptr_t in_index);
24279 
24284  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24285 
24289  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
24290 
24293  InfiniteLineKit & UnsetAllUserData();
24294 
24296  size_t ShowUserDataCount() const;
24297 
24301  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24302 
24307  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24308 
24313  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24314 };
24315 
24316 
24318 class HPS_API InfiniteLineKey : public GeometryKey
24319 {
24320 public:
24322  InfiniteLineKey();
24323 
24327  explicit InfiniteLineKey(Key const & in_that);
24328 
24331  InfiniteLineKey(InfiniteLineKey const & in_that);
24332 
24336  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
24337 
24341  InfiniteLineKey(InfiniteLineKey && in_that);
24342 
24346  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
24347 
24348  ~InfiniteLineKey();
24349 
24350  Type ObjectType() const { return Type::InfiniteLineKey; };
24351 
24354  void Consume(InfiniteLineKit & in_kit);
24355 
24358  void Set(InfiniteLineKit const & in_kit);
24359 
24362  void Show(InfiniteLineKit & out_kit) const;
24363 
24364 
24368  InfiniteLineKey & SetFirst(Point const & in_first);
24369 
24373  InfiniteLineKey & SetSecond(Point const & in_second);
24374 
24378  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
24379 
24380 
24384  bool ShowFirst(Point & out_first) const;
24385 
24389  bool ShowSecond(Point & out_second) const;
24390 
24394  bool ShowType(InfiniteLine::Type & out_type) const;
24395 };
24396 
24397 
24398 
24402 class HPS_API SpotlightKit : public Object
24403 {
24404 public:
24406  SpotlightKit();
24407 
24410  SpotlightKit(SpotlightKit const & in_kit);
24411 
24415  SpotlightKit(SpotlightKit && in_that);
24416 
24420  SpotlightKit & operator=(SpotlightKit && in_that);
24421 
24422  virtual ~SpotlightKit();
24423 
24424  Type ObjectType() const { return Type::SpotlightKit; };
24425 
24429  static SpotlightKit GetDefault();
24430 
24433  void Consume(SpotlightKit & in_kit);
24434 
24437  void Set(SpotlightKit const & in_kit);
24438 
24441  void Show(SpotlightKit & out_kit) const;
24442 
24446  SpotlightKit & operator=(SpotlightKit const & in_kit);
24447 
24450  bool Empty() const;
24451 
24455  bool Equals(SpotlightKit const & in_kit) const;
24456 
24460  bool operator==(SpotlightKit const & in_kit) const;
24461 
24465  bool operator!=(SpotlightKit const & in_kit) const;
24466 
24467 
24474  SpotlightKit & SetPriority(int in_priority);
24475 
24481  SpotlightKit & SetPosition(Point const & in_position);
24482 
24488  SpotlightKit & SetTarget(Point const & in_target);
24489 
24493  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
24494 
24498  SpotlightKit & SetColorByIndex(float in_index);
24499 
24505  SpotlightKit & SetOuterCone(float in_size, Spotlight::OuterConeUnits in_units = Spotlight::OuterConeUnits::Degrees);
24506 
24512  SpotlightKit & SetInnerCone(float in_size, Spotlight::InnerConeUnits in_units = Spotlight::InnerConeUnits::Percent);
24513 
24519  SpotlightKit & SetConcentration(float in_concentration);
24520 
24526  SpotlightKit & SetCameraRelative(bool in_state);
24527 
24528 
24531  SpotlightKit & UnsetPriority();
24532 
24535  SpotlightKit & UnsetPosition();
24536 
24539  SpotlightKit & UnsetTarget();
24540 
24543  SpotlightKit & UnsetColor();
24544 
24547  SpotlightKit & UnsetOuterCone();
24548 
24551  SpotlightKit & UnsetInnerCone();
24552 
24555  SpotlightKit & UnsetConcentration();
24556 
24559  SpotlightKit & UnsetCameraRelative();
24560 
24563  SpotlightKit & UnsetEverything();
24564 
24565 
24569  bool ShowPriority(int & out_priority) const;
24570 
24574  bool ShowPosition(Point & out_position) const;
24575 
24579  bool ShowTarget(Point & out_target) const;
24580 
24586  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
24587 
24592  bool ShowOuterCone(float & out_size, Spotlight::OuterConeUnits & out_units) const;
24593 
24598  bool ShowInnerCone(float & out_size, Spotlight::InnerConeUnits & out_units) const;
24599 
24603  bool ShowConcentration(float & out_concentration) const;
24604 
24608  bool ShowCameraRelative(bool & out_state) const;
24609 
24615  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24616 
24621  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24622 
24627  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24628 
24632  SpotlightKit & UnsetUserData(intptr_t in_index);
24633 
24638  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24639 
24643  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
24644 
24647  SpotlightKit & UnsetAllUserData();
24648 
24650  size_t ShowUserDataCount() const;
24651 
24655  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24656 
24661  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24662 
24667  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24668 };
24669 
24670 
24672 class HPS_API SpotlightKey : public GeometryKey
24673 {
24674 public:
24676  SpotlightKey();
24677 
24681  explicit SpotlightKey(Key const & in_that);
24682 
24685  SpotlightKey(SpotlightKey const & in_that);
24686 
24690  SpotlightKey & operator=(SpotlightKey const & in_that);
24691 
24695  SpotlightKey(SpotlightKey && in_that);
24696 
24700  SpotlightKey & operator=(SpotlightKey && in_that);
24701 
24702  ~SpotlightKey();
24703 
24704  Type ObjectType() const { return Type::SpotlightKey; };
24705 
24708  void Consume(SpotlightKit & in_kit);
24709 
24712  void Set(SpotlightKit const & in_kit);
24713 
24716  void Show(SpotlightKit & out_kit) const;
24717 
24718 
24724  SpotlightKey & SetPosition(Point const & in_position);
24725 
24731  SpotlightKey & SetTarget(Point const & in_target);
24732 
24736  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
24737 
24741  SpotlightKey & SetColorByIndex(float in_index);
24742 
24748  SpotlightKey & SetOuterCone(float in_size, Spotlight::OuterConeUnits in_units = Spotlight::OuterConeUnits::Degrees);
24749 
24755  SpotlightKey & SetInnerCone(float in_size, Spotlight::InnerConeUnits in_units = Spotlight::InnerConeUnits::Percent);
24756 
24762  SpotlightKey & SetConcentration(float in_concentration);
24763 
24769  SpotlightKey & SetCameraRelative(bool in_state);
24770 
24771 
24774  SpotlightKey & UnsetColor();
24775 
24776 
24780  bool ShowPosition(Point & out_position) const;
24781 
24785  bool ShowTarget(Point & out_target) const;
24786 
24792  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
24793 
24798  bool ShowOuterCone(float & out_size, Spotlight::OuterConeUnits & out_units) const;
24799 
24804  bool ShowInnerCone(float & out_size, Spotlight::InnerConeUnits & out_units) const;
24805 
24809  bool ShowConcentration(float & out_concentration) const;
24810 
24814  bool ShowCameraRelative(bool & out_state) const;
24815 };
24816 
24817 
24818 
24820 class HPS_API NURBSCurveKit : public Object
24821 {
24822 public:
24824  NURBSCurveKit();
24825 
24828  NURBSCurveKit(NURBSCurveKit const & in_kit);
24829 
24833  NURBSCurveKit(NURBSCurveKit && in_that);
24834 
24838  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
24839 
24840  virtual ~NURBSCurveKit();
24841 
24842  Type ObjectType() const { return Type::NURBSCurveKit; };
24843 
24846  void Consume(NURBSCurveKit & in_kit);
24847 
24850  void Set(NURBSCurveKit const & in_kit);
24851 
24854  void Show(NURBSCurveKit & out_kit) const;
24855 
24859  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
24860 
24863  bool Empty() const;
24864 
24868  bool Equals(NURBSCurveKit const & in_kit) const;
24869 
24873  bool operator==(NURBSCurveKit const & in_kit) const;
24874 
24878  bool operator!=(NURBSCurveKit const & in_kit) const;
24879 
24882  size_t GetPointCount() const;
24883 
24890  NURBSCurveKit & SetPriority(int in_priority);
24891 
24894  NURBSCurveKit & UnsetPriority();
24895 
24899  bool ShowPriority(int & out_priority) const;
24900 
24904  NURBSCurveKit & SetDegree(size_t in_degree);
24905 
24909  NURBSCurveKit & SetPoints(PointArray const & in_points);
24910 
24915  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
24916 
24920  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
24921 
24926  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
24927 
24931  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
24932 
24937  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
24938 
24943  NURBSCurveKit & SetParameters(float in_start, float in_end);
24944 
24945 
24948  NURBSCurveKit & UnsetDegree();
24949 
24952  NURBSCurveKit & UnsetPoints();
24953 
24956  NURBSCurveKit & UnsetWeights();
24957 
24960  NURBSCurveKit & UnsetKnots();
24961 
24964  NURBSCurveKit & UnsetParameters();
24965 
24968  NURBSCurveKit & UnsetEverything();
24969 
24970 
24974  bool ShowDegree(size_t & out_degree) const;
24975 
24979  bool ShowPoints(PointArray & out_points) const;
24980 
24984  bool ShowWeights(FloatArray & out_weights) const;
24985 
24989  bool ShowKnots(FloatArray & out_knots) const;
24990 
24995  bool ShowParameters(float & out_start, float & out_end) const;
24996 
24997 
25004  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25005 
25011  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25012 
25019  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25020 
25027  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25028 
25035  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25036 
25037 
25045  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25046 
25053  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25054 
25062  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25063 
25070  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25071 
25078  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25079 
25080 
25086  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25087 
25092  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25093 
25099  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
25100 
25107  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25108 
25115  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25116 
25122  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25123 
25128  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25129 
25134  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25135 
25139  NURBSCurveKit & UnsetUserData(intptr_t in_index);
25140 
25145  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25146 
25150  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
25151 
25154  NURBSCurveKit & UnsetAllUserData();
25155 
25157  size_t ShowUserDataCount() const;
25158 
25162  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25163 
25168  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25169 
25174  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25175 };
25176 
25177 
25179 class HPS_API NURBSCurveKey : public GeometryKey
25180 {
25181 public:
25183  NURBSCurveKey();
25184 
25188  explicit NURBSCurveKey(Key const & in_that);
25189 
25192  NURBSCurveKey(NURBSCurveKey const & in_that);
25193 
25197  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
25198 
25202  NURBSCurveKey(NURBSCurveKey && in_that);
25203 
25207  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
25208 
25209  ~NURBSCurveKey();
25210 
25211  Type ObjectType() const {return Type::NURBSCurveKey;};
25212 
25215  void Consume(NURBSCurveKit & in_kit);
25216 
25219  void Set(NURBSCurveKit const & in_kit);
25220 
25223  void Show(NURBSCurveKit & out_kit) const;
25224 
25227  size_t GetPointCount() const;
25228 
25233  NURBSCurveKey & SetParameters(float in_start, float in_end);
25234 
25238  bool ShowDegree(size_t & out_degree) const;
25239 
25243  bool ShowPoints(PointArray & out_points) const;
25244 
25248  bool ShowWeights(FloatArray & out_weights) const;
25249 
25253  bool ShowKnots(FloatArray & out_knots) const;
25254 
25259  bool ShowParameters(float & out_start, float & out_end) const;
25260 
25261 
25269  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25270 
25277  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25278 
25279 
25288  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25289 
25297  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25298 
25299 
25307  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25308 
25315  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25316 };
25317 
25318 
25319 
25321 class HPS_API NURBSSurfaceKit : public Object
25322 {
25323 public:
25325  NURBSSurfaceKit();
25326 
25329  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
25330 
25334  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
25335 
25339  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
25340 
25341  virtual ~NURBSSurfaceKit();
25342 
25343  Type ObjectType() const { return Type::NURBSSurfaceKit; };
25344 
25347  void Consume(NURBSSurfaceKit & in_kit);
25348 
25351  void Set(NURBSSurfaceKit const & in_kit);
25352 
25355  void Show(NURBSSurfaceKit & out_kit) const;
25356 
25360  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
25361 
25364  bool Empty() const;
25365 
25369  bool Equals(NURBSSurfaceKit const & in_kit) const;
25370 
25374  bool operator==(NURBSSurfaceKit const & in_kit) const;
25375 
25379  bool operator!=(NURBSSurfaceKit const & in_kit) const;
25380 
25383  size_t GetPointCount() const;
25384 
25391  NURBSSurfaceKit & SetPriority(int in_priority);
25392 
25395  NURBSSurfaceKit & UnsetPriority();
25396 
25400  bool ShowPriority(int & out_priority) const;
25401 
25405  NURBSSurfaceKit & SetUDegree(size_t in_degree);
25406 
25410  NURBSSurfaceKit & SetVDegree(size_t in_degree);
25411 
25415  NURBSSurfaceKit & SetUCount(size_t in_count);
25416 
25420  NURBSSurfaceKit & SetVCount(size_t in_count);
25421 
25425  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
25426 
25431  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
25432 
25437  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
25438 
25444  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
25445 
25450  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
25451 
25457  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
25458 
25463  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
25464 
25470  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
25471 
25475  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
25476 
25481  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
25482 
25483 
25486  NURBSSurfaceKit & UnsetUDegree();
25487 
25490  NURBSSurfaceKit & UnsetVDegree();
25491 
25494  NURBSSurfaceKit & UnsetUCount();
25495 
25498  NURBSSurfaceKit & UnsetVCount();
25499 
25502  NURBSSurfaceKit & UnsetPoints();
25503 
25506  NURBSSurfaceKit & UnsetWeights();
25507 
25510  NURBSSurfaceKit & UnsetUKnots();
25511 
25514  NURBSSurfaceKit & UnsetVKnots();
25515 
25518  NURBSSurfaceKit & UnsetTrims();
25519 
25522  NURBSSurfaceKit & UnsetEverything();
25523 
25524 
25528  bool ShowUDegree(size_t & out_degree) const;
25529 
25533  bool ShowVDegree(size_t & out_degree) const;
25534 
25538  bool ShowUCount(size_t & out_count) const;
25539 
25543  bool ShowVCount(size_t & out_count) const;
25544 
25548  bool ShowPoints(PointArray & out_points) const;
25549 
25553  bool ShowWeights(FloatArray & out_weights) const;
25554 
25558  bool ShowUKnots(FloatArray & out_knots) const;
25559 
25563  bool ShowVKnots(FloatArray & out_knots) const;
25564 
25568  bool ShowTrims(TrimKitArray & out_trims) const;
25569 
25570 
25577  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25578 
25584  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25585 
25592  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25593 
25600  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25601 
25608  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25609 
25610 
25618  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25619 
25626  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25627 
25635  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25636 
25643  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25644 
25651  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25652 
25653 
25660  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25661 
25667  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25668 
25675  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
25676 
25683  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25684 
25691  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25692 
25693 
25700  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25701 
25707  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25708 
25715  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
25716 
25723  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25724 
25731  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25732 
25738  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25739 
25744  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25745 
25750  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25751 
25755  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
25756 
25761  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25762 
25766  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
25767 
25770  NURBSSurfaceKit & UnsetAllUserData();
25771 
25773  size_t ShowUserDataCount() const;
25774 
25778  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25779 
25784  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25785 
25790  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25791 };
25792 
25793 
25795 class HPS_API NURBSSurfaceKey : public GeometryKey
25796 {
25797 public:
25799  NURBSSurfaceKey();
25800 
25804  explicit NURBSSurfaceKey(Key const & in_that);
25805 
25808  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
25809 
25813  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
25814 
25818  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
25819 
25823  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
25824 
25825  ~NURBSSurfaceKey();
25826 
25827  Type ObjectType() const { return Type::NURBSSurfaceKey; };
25828 
25831  void Consume(NURBSSurfaceKit & in_kit);
25832 
25835  void Set(NURBSSurfaceKit const & in_kit);
25836 
25839  void Show(NURBSSurfaceKit & out_kit) const;
25840 
25843  size_t GetPointCount() const;
25844 
25849  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
25850 
25854  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
25855 
25856 
25859  NURBSSurfaceKey & UnsetTrims();
25860 
25861 
25865  bool ShowUDegree(size_t & out_degree) const;
25866 
25870  bool ShowVDegree(size_t & out_degree) const;
25871 
25875  bool ShowUCount(size_t & out_count) const;
25876 
25880  bool ShowVCount(size_t & out_count) const;
25881 
25885  bool ShowPoints(PointArray & out_points) const;
25886 
25890  bool ShowWeights(FloatArray & out_weights) const;
25891 
25895  bool ShowUKnots(FloatArray & out_knots) const;
25896 
25900  bool ShowVKnots(FloatArray & out_knots) const;
25901 
25905  bool ShowTrims(TrimKitArray & out_trims) const;
25906 
25907 
25915  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25916 
25923  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25924 
25925 
25934  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25935 
25943  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25944 
25945 
25953  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25954 
25961  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25962 
25963 
25971  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25972 
25979  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25980 };
25981 
25982 
25983 
25985 class HPS_API TrimElement : public Object
25986 {
25987 public:
25989  TrimElement();
25990 
25993  TrimElement(TrimElement const & in_that);
25994 
25998  TrimElement(LineKit const & in_line);
25999 
26003  TrimElement(NURBSCurveKit const & in_curve);
26004 
26008  TrimElement(TrimElement && in_that);
26009 
26013  TrimElement & operator=(TrimElement && in_that);
26014 
26015  ~TrimElement();
26016 
26017  Type ObjectType() const { return Type::TrimElement; };
26018 
26021  void Set(TrimElement const & in_that);
26022 
26026  TrimElement & operator=(TrimElement const & in_that);
26027 
26031  bool Equals(TrimElement const & in_that) const;
26032 
26036  bool operator==(TrimElement const & in_that) const;
26037 
26041  bool operator!=(TrimElement const & in_that) const;
26042 
26043 
26047  void SetCurve(LineKit const & in_line);
26048 
26052  void SetCurve(NURBSCurveKit const & in_curve);
26053 
26059  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
26060 };
26061 
26062 
26063 
26065 class HPS_API TrimKit : public Object
26066 {
26067 public:
26069  TrimKit();
26070 
26073  TrimKit(TrimKit const & in_kit);
26074 
26078  TrimKit(TrimKit && in_that);
26079 
26083  TrimKit & operator=(TrimKit && in_that);
26084 
26085  virtual ~TrimKit();
26086 
26087  Type ObjectType() const { return Type::TrimKit; };
26088 
26091  void Set(TrimKit const & in_kit);
26092 
26095  void Show(TrimKit & out_kit) const;
26096 
26100  TrimKit & operator=(TrimKit const & in_kit);
26101 
26104  bool Empty() const;
26105 
26109  bool Equals(TrimKit const & in_kit) const;
26110 
26114  bool operator==(TrimKit const & in_kit) const;
26115 
26119  bool operator!=(TrimKit const & in_kit) const;
26120 
26121 
26126  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
26127 
26131  TrimKit & SetShape(TrimElementArray const & in_shape);
26132 
26136  TrimKit & SetOperation(Trim::Operation in_operation);
26137 
26138 
26141  TrimKit & UnsetShape();
26142 
26145  TrimKit & UnsetOperation();
26146 
26149  TrimKit & UnsetEverything();
26150 
26151 
26155  bool ShowShape(TrimElementArray & out_shape) const;
26156 
26160  bool ShowOperation(Trim::Operation & out_operation) const;
26161 };
26162 
26163 
26164 
26166 class HPS_API EllipseKit : public Object
26167 {
26168 public:
26170  EllipseKit();
26171 
26174  EllipseKit(EllipseKit const & in_kit);
26175 
26179  EllipseKit(EllipseKit && in_that);
26180 
26184  EllipseKit & operator=(EllipseKit && in_that);
26185 
26186  virtual ~EllipseKit();
26187 
26188  Type ObjectType() const { return Type::EllipseKit; };
26189 
26192  void Consume(EllipseKit & in_kit);
26193 
26196  void Set(EllipseKit const & in_kit);
26197 
26200  void Show(EllipseKit & out_kit) const;
26201 
26205  EllipseKit & operator=(EllipseKit const & in_kit);
26206 
26209  bool Empty() const;
26210 
26214  bool Equals(EllipseKit const & in_kit) const;
26215 
26219  bool operator==(EllipseKit const & in_kit) const;
26220 
26224  bool operator!=(EllipseKit const & in_kit) const;
26225 
26232  EllipseKit & SetPriority(int in_priority);
26233 
26236  EllipseKit & UnsetPriority();
26237 
26241  bool ShowPriority(int & out_priority) const;
26242 
26243 
26247  EllipseKit & SetCenter(Point const & in_center);
26248 
26252  EllipseKit & SetMajor(Point const & in_major);
26253 
26257  EllipseKit & SetMinor(Point const & in_minor);
26258 
26259 
26262  EllipseKit & UnsetCenter();
26263 
26266  EllipseKit & UnsetMajor();
26267 
26270  EllipseKit & UnsetMinor();
26271 
26274  EllipseKit & UnsetEverything();
26275 
26276 
26280  bool ShowCenter(Point & out_center) const;
26281 
26285  bool ShowMajor(Point & out_major) const;
26286 
26290  bool ShowMinor(Point & out_minor) const;
26291 
26297  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26298 
26303  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26304 
26309  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26310 
26314  EllipseKit & UnsetUserData(intptr_t in_index);
26315 
26320  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26321 
26325  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
26326 
26329  EllipseKit & UnsetAllUserData();
26330 
26332  size_t ShowUserDataCount() const;
26333 
26337  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26338 
26343  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26344 
26349  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26350 };
26351 
26352 
26353 
26355 class HPS_API EllipseKey : public GeometryKey
26356 {
26357 public:
26359  EllipseKey();
26360 
26364  explicit EllipseKey(Key const & in_that);
26365 
26368  EllipseKey(EllipseKey const & in_that);
26369 
26373  EllipseKey & operator=(EllipseKey const & other);
26374 
26378  EllipseKey(EllipseKey && in_that);
26379 
26383  EllipseKey & operator=(EllipseKey && in_that);
26384 
26385  ~EllipseKey();
26386 
26387  Type ObjectType() const { return Type::EllipseKey; };
26388 
26391  void Consume(EllipseKit & in_kit);
26392 
26395  void Set(EllipseKit const & in_kit);
26396 
26399  void Show(EllipseKit & out_kit) const;
26400 
26401 
26405  EllipseKey & SetCenter(Point const & in_center);
26406 
26410  EllipseKey & SetMajor(Point const & in_major);
26411 
26415  EllipseKey & SetMinor(Point const & in_minor);
26416 
26417 
26421  bool ShowCenter(Point & out_center) const;
26422 
26426  bool ShowMajor(Point & out_major) const;
26427 
26431  bool ShowMinor(Point & out_minor) const;
26432 };
26433 
26434 
26435 
26437 class HPS_API EllipticalArcKit : public Object
26438 {
26439 public:
26441  EllipticalArcKit();
26442 
26445  EllipticalArcKit(EllipticalArcKit const & in_kit);
26446 
26450  EllipticalArcKit(EllipticalArcKit && in_that);
26451 
26455  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
26456 
26457  virtual ~EllipticalArcKit();
26458 
26459  Type ObjectType() const { return Type::EllipticalArcKit; };
26460 
26463  void Consume(EllipticalArcKit & in_kit);
26464 
26467  void Set(EllipticalArcKit const & in_kit);
26468 
26471  void Show(EllipticalArcKit & out_kit) const;
26472 
26476  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
26477 
26480  bool Empty() const;
26481 
26485  bool Equals(EllipticalArcKit const & in_kit) const;
26486 
26490  bool operator==(EllipticalArcKit const & in_kit) const;
26491 
26495  bool operator!=(EllipticalArcKit const & in_kit) const;
26496 
26503  EllipticalArcKit & SetPriority(int in_priority);
26504 
26507  EllipticalArcKit & UnsetPriority();
26508 
26512  bool ShowPriority(int & out_priority) const;
26513 
26514 
26518  EllipticalArcKit & SetCenter(Point const & in_center);
26519 
26523  EllipticalArcKit & SetMajor(Point const & in_major);
26524 
26528  EllipticalArcKit & SetMinor(Point const & in_minor);
26529 
26537  EllipticalArcKit & SetStart(float in_start);
26538 
26546  EllipticalArcKit & SetEnd(float in_end);
26547 
26548 
26551  EllipticalArcKit & UnsetCenter();
26552 
26555  EllipticalArcKit & UnsetMajor();
26556 
26559  EllipticalArcKit & UnsetMinor();
26560 
26563  EllipticalArcKit & UnsetStart();
26564 
26567  EllipticalArcKit & UnsetEnd();
26568 
26571  EllipticalArcKit & UnsetEverything();
26572 
26573 
26577  bool ShowCenter(Point & out_center) const;
26578 
26582  bool ShowMajor(Point & out_major) const;
26583 
26587  bool ShowMinor(Point & out_minor) const;
26588 
26592  bool ShowStart(float & out_start) const;
26593 
26597  bool ShowEnd(float & out_end) const;
26598 
26604  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26605 
26610  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26611 
26616  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26617 
26621  EllipticalArcKit & UnsetUserData(intptr_t in_index);
26622 
26627  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26628 
26632  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
26633 
26636  EllipticalArcKit & UnsetAllUserData();
26637 
26639  size_t ShowUserDataCount() const;
26640 
26644  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26645 
26650  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26651 
26656  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26657 };
26658 
26659 
26661 class HPS_API EllipticalArcKey : public GeometryKey
26662 {
26663 public:
26665  EllipticalArcKey();
26666 
26670  explicit EllipticalArcKey(Key const & in_that);
26671 
26674  EllipticalArcKey(EllipticalArcKey const & in_that);
26675 
26679  EllipticalArcKey & operator=(EllipticalArcKey const & other);
26680 
26684  EllipticalArcKey(EllipticalArcKey && in_that);
26685 
26689  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
26690 
26691  ~EllipticalArcKey();
26692 
26693  Type ObjectType() const { return Type::EllipticalArcKey; };
26694 
26695 
26698  void Consume(EllipticalArcKit & in_kit);
26699 
26702  void Set(EllipticalArcKit const & in_kit);
26703 
26706  void Show(EllipticalArcKit & out_kit) const;
26707 
26708 
26712  EllipticalArcKey & SetCenter(Point const & in_center);
26713 
26717  EllipticalArcKey & SetMajor(Point const & in_major);
26718 
26722  EllipticalArcKey & SetMinor(Point const & in_minor);
26723 
26731  EllipticalArcKey & SetStart(float in_start);
26732 
26740  EllipticalArcKey & SetEnd(float in_end);
26741 
26742 
26746  bool ShowCenter(Point & out_center) const;
26747 
26751  bool ShowMajor(Point & out_major) const;
26752 
26756  bool ShowMinor(Point & out_minor) const;
26757 
26761  bool ShowStart(float & out_start) const;
26762 
26766  bool ShowEnd(float & out_end) const;
26767 };
26768 
26769 
26770 
26772 class HPS_API TextKit : public Object
26773 {
26774 public:
26776  TextKit();
26777 
26780  TextKit(TextKit const & in_kit);
26781 
26785  TextKit(TextKit && in_that);
26786 
26790  TextKit & operator=(TextKit && in_that);
26791 
26792  virtual ~TextKit();
26793 
26794  Type ObjectType() const { return Type::TextKit; };
26795 
26798  void Consume(TextKit & in_kit);
26799 
26802  void Set(TextKit const & in_kit);
26803 
26806  void Show(TextKit & out_kit) const;
26807 
26811  TextKit & operator=(TextKit const & in_kit);
26812 
26815  bool Empty() const;
26816 
26820  bool Equals(TextKit const & in_kit) const;
26821 
26825  bool operator==(TextKit const & in_kit) const;
26826 
26830  bool operator!=(TextKit const & in_kit) const;
26831 
26838  TextKit & SetPriority(int in_priority);
26839 
26842  TextKit & UnsetPriority();
26843 
26847  bool ShowPriority(int & out_priority) const;
26848 
26852  TextKit & SetPosition(Point const & in_position);
26853 
26857  TextKit & SetText(char const * in_string);
26858 
26862  TextKit & SetColor(RGBAColor const & in_rgba_color);
26863 
26867  TextKit & SetColorByIndex(float in_index);
26868 
26872  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
26873 
26880 
26884  TextKit & SetBold(bool in_state);
26885 
26889  TextKit & SetItalic(bool in_state);
26890 
26894  TextKit & SetOverline(bool in_state);
26895 
26899  TextKit & SetStrikethrough(bool in_state);
26900 
26904  TextKit & SetUnderline(bool in_state);
26905 
26910  TextKit & SetSlant(float in_angle);
26911 
26915  TextKit & SetLineSpacing(float in_multiplier);
26916 
26922  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
26923 
26927  TextKit & SetRotation(float in_angle);
26928 
26934  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
26935 
26940  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
26941 
26948  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
26949 
26955  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
26956 
26965  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
26966 
26974  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
26975 
26980  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
26981 
26987  TextKit & SetFont(char const * in_name);
26988 
26992  TextKit & SetTransform(Text::Transform in_trans);
26993 
26997  TextKit & SetRenderer(Text::Renderer in_rend);
26998 
27002  TextKit & SetPreference(Text::Preference in_pref);
27003 
27010  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27011 
27015  TextKit & SetPath(Vector const & in_path);
27016 
27022  TextKit & SetSpacing(float in_multiplier);
27023 
27024 
27027  TextKit & UnsetPosition();
27028 
27031  TextKit & UnsetText();
27032 
27035  TextKit & UnsetColor();
27036 
27039  TextKit & UnsetModellingMatrix();
27040 
27043  TextKit & UnsetAlignment();
27044 
27047  TextKit & UnsetBold();
27048 
27051  TextKit & UnsetItalic();
27052 
27055  TextKit & UnsetOverline();
27056 
27059  TextKit & UnsetStrikethrough();
27060 
27063  TextKit & UnsetUnderline();
27064 
27067  TextKit & UnsetSlant();
27068 
27071  TextKit & UnsetLineSpacing();
27072 
27075  TextKit & UnsetRotation();
27076 
27079  TextKit & UnsetExtraSpace();
27080 
27083  TextKit & UnsetGreeking();
27084 
27087  TextKit & UnsetSizeTolerance();
27088 
27091  TextKit & UnsetSize();
27092 
27095  TextKit & UnsetFont();
27096 
27099  TextKit & UnsetTransform();
27100 
27103  TextKit & UnsetRenderer();
27104 
27107  TextKit & UnsetPreference();
27108 
27111  TextKit & UnsetPath();
27112 
27115  TextKit & UnsetSpacing();
27116 
27119  TextKit & UnsetEverything();
27120 
27121 
27125  bool ShowPosition(Point & out_position) const;
27126 
27130  bool ShowText(UTF8 & out_string) const;
27131 
27137  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27138 
27142  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27143 
27149  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27150 
27154  bool ShowBold(bool & out_state) const;
27155 
27159  bool ShowItalic(bool & out_state) const;
27160 
27164  bool ShowOverline(bool & out_state) const;
27165 
27169  bool ShowStrikethrough(bool & out_state) const;
27170 
27174  bool ShowUnderline(bool & out_state) const;
27175 
27179  bool ShowSlant(float & out_angle) const;
27180 
27184  bool ShowLineSpacing(float & out_multiplier) const;
27185 
27190  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27191 
27197  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27198 
27205  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27206 
27212  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27213 
27218  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27219 
27223  bool ShowFont(UTF8 & out_name) const;
27224 
27228  bool ShowTransform(Text::Transform & out_trans) const;
27229 
27233  bool ShowRenderer(Text::Renderer & out_renderer) const;
27234 
27241  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
27242 
27246  bool ShowPath(Vector & out_path) const;
27247 
27251  bool ShowSpacing(float & out_multiplier) const;
27252 
27253 
27261  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27262 
27269  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
27270 
27277  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27278 
27287  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;
27288 
27301  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);
27302 
27316  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);
27317 
27323  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27324 
27327  TextKit & UnsetRegion();
27328 
27333  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27334 
27339  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27340 
27344  TextKit & UnsetUserData(intptr_t in_index);
27345 
27350  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27351 
27355  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
27356 
27359  TextKit & UnsetAllUserData();
27360 
27362  size_t ShowUserDataCount() const;
27363 
27367  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27368 
27373  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27374 
27379  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27380 };
27381 
27382 
27384 class HPS_API TextKey : public GeometryKey
27385 {
27386 public:
27388  TextKey();
27389 
27393  explicit TextKey(Key const & in_that);
27394 
27397  TextKey(TextKey const & in_that);
27398 
27402  TextKey & operator=(TextKey const & other);
27403 
27407  TextKey(TextKey && in_that);
27408 
27412  TextKey & operator=(TextKey && in_that);
27413 
27414  ~TextKey();
27415 
27416  Type ObjectType() const {return Type::TextKey;};
27417 
27420  void Consume(TextKit & in_kit);
27421 
27424  void Set(TextKit const & in_kit);
27425 
27428  void Show(TextKit & out_kit) const;
27429 
27432  TextKey & SetTextAttributes(TextAttributeKit const & in_kit);
27433 
27437  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
27438 
27442  TextKey & SetPosition(Point const & in_position);
27443 
27447  TextKey & SetText(char const * in_string);
27448 
27452  TextKey & SetColor(RGBAColor const & in_rgba_color);
27453 
27457  TextKey & SetColorByIndex(float in_index);
27458 
27462  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
27463 
27470 
27474  TextKey & SetBold(bool in_state);
27475 
27479  TextKey & SetItalic(bool in_state);
27480 
27484  TextKey & SetOverline(bool in_state);
27485 
27489  TextKey & SetStrikethrough(bool in_state);
27490 
27494  TextKey & SetUnderline(bool in_state);
27495 
27500  TextKey & SetSlant(float in_angle);
27501 
27506  TextKey & SetLineSpacing(float in_multiplier);
27507 
27513  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27514 
27518  TextKey & SetRotation(float in_angle);
27519 
27525  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27526 
27531  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
27532 
27539  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27540 
27546  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27547 
27556  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
27557 
27565  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
27566 
27571  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
27572 
27578  TextKey & SetFont(char const * in_name);
27579 
27583  TextKey & SetTransform(Text::Transform in_transform);
27584 
27588  TextKey & SetRenderer(Text::Renderer in_renderer);
27589 
27593  TextKey & SetPreference(Text::Preference in_preference);
27594 
27602  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27603 
27608  TextKey & SetPath(Vector const & in_path);
27609 
27615  TextKey & SetSpacing(float in_multiplier);
27616 
27629  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);
27630 
27644  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);
27645 
27646 
27649  TextKey & UnsetColor();
27650 
27653  TextKey & UnsetModellingMatrix();
27654 
27657  TextKey & UnsetAlignment();
27658 
27661  TextKey & UnsetBold();
27662 
27665  TextKey & UnsetItalic();
27666 
27669  TextKey & UnsetOverline();
27670 
27673  TextKey & UnsetStrikethrough();
27674 
27677  TextKey & UnsetUnderline();
27678 
27681  TextKey & UnsetSlant();
27682 
27685  TextKey & UnsetLineSpacing();
27686 
27689  TextKey & UnsetRotation();
27690 
27693  TextKey & UnsetExtraSpace();
27694 
27697  TextKey & UnsetGreeking();
27698 
27701  TextKey & UnsetSizeTolerance();
27702 
27705  TextKey & UnsetSize();
27706 
27709  TextKey & UnsetFont();
27710 
27713  TextKey & UnsetTransform();
27714 
27717  TextKey & UnsetRenderer();
27718 
27721  TextKey & UnsetPreference();
27722 
27725  TextKey & UnsetPath();
27726 
27729  TextKey & UnsetSpacing();
27730 
27733  TextKey & UnsetRegion();
27734 
27737  TextKey & UnsetEverything();
27738 
27739 
27743  bool ShowPosition(Point & out_position) const;
27744 
27748  bool ShowText(UTF8 & out_string) const;
27749 
27755  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27756 
27760  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27761 
27767  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27768 
27772  bool ShowBold(bool & out_state) const;
27773 
27777  bool ShowItalic(bool & out_state) const;
27778 
27782  bool ShowOverline(bool & out_state) const;
27783 
27787  bool ShowStrikethrough(bool & out_state) const;
27788 
27792  bool ShowUnderline(bool & out_state) const;
27793 
27797  bool ShowSlant(float & out_angle) const;
27798 
27802  bool ShowLineSpacing(float & out_multiplier) const;
27803 
27808  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27809 
27815  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27816 
27823  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27824 
27830  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27831 
27836  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27837 
27841  bool ShowFont(UTF8 & out_name) const;
27842 
27846  bool ShowTransform(Text::Transform & out_trans) const;
27847 
27851  bool ShowRenderer(Text::Renderer & out_renderer) const;
27852 
27859  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
27860 
27864  bool ShowPath(Vector & out_path) const;
27865 
27869  bool ShowSpacing(float & out_multiplier) const;
27870 
27879  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;
27880 
27881 
27889  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27890 
27897  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
27898 
27905  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27906 };
27907 
27908 
27910 class HPS_API ShellOptimizationOptionsKit : public Object
27911 {
27912 public:
27915 
27919 
27924 
27925  virtual ~ShellOptimizationOptionsKit();
27926 
27927  Type ObjectType() const { return Type::ShellOptimizationOptionsKit; };
27928 
27931  void Consume(ShellOptimizationOptionsKit & in_kit);
27932 
27935  void Set(ShellOptimizationOptionsKit const & in_kit);
27936 
27939  void Show(ShellOptimizationOptionsKit & out_kit) const;
27940 
27944  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
27945 
27950 
27953  bool Empty() const;
27954 
27958  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
27959 
27963  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
27964 
27968  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
27969 
27973  static ShellOptimizationOptionsKit GetDefault();
27974 
27975 
27979  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
27980 
27985  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
27986 
27991  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
27992 
27997  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
27998 
27999 
28002  ShellOptimizationOptionsKit & UnsetNormalTolerance();
28003 
28006  ShellOptimizationOptionsKit & UnsetTolerance();
28007 
28010  ShellOptimizationOptionsKit & UnsetOrphanElimination();
28011 
28014  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
28015 
28018  ShellOptimizationOptionsKit & UnsetEverything();
28019 
28020 
28024  bool ShowNormalTolerance(float & out_normal_tolerance) const;
28025 
28030  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
28031 
28035  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
28036 
28041  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
28042 };
28043 
28044 
28048 class HPS_API ShellRelationOptionsKit : public Object
28049 {
28050 public:
28053 
28057 
28062 
28066  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
28067 
28068  virtual ~ShellRelationOptionsKit();
28069 
28070  Type ObjectType() const { return Type::ShellRelationOptionsKit; };
28071 
28075  static ShellRelationOptionsKit GetDefault();
28076 
28079  void Consume(ShellRelationOptionsKit & in_kit);
28080 
28083  void Set(ShellRelationOptionsKit const & in_kit);
28084 
28087  void Show(ShellRelationOptionsKit & out_kit) const;
28088 
28092  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
28093 
28096  bool Empty() const;
28097 
28101  bool Equals(ShellRelationOptionsKit const & in_kit) const;
28102 
28106  bool operator==(ShellRelationOptionsKit const & in_kit) const;
28107 
28111  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
28112 
28113 
28117  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
28118 
28122  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
28123 
28128  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
28129 
28133  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
28134 
28135 
28138  ShellRelationOptionsKit & UnsetTolerance();
28139 
28142  ShellRelationOptionsKit & UnsetTest();
28143 
28146  ShellRelationOptionsKit & UnsetTreeContext();
28147 
28150  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
28151 
28154  ShellRelationOptionsKit & UnsetEverything();
28155 
28156 
28160  bool ShowTolerance(float & out_tolerance) const;
28161 
28165  bool ShowTest(Shell::RelationTest & out_test) const;
28166 
28170  bool ShowTreeContext(TreeContext & out_tree_context) const;
28171 
28175  bool ShowNearestFaceCalculation(bool & out_state) const;
28176 };
28177 
28179 class HPS_API ShellRelationResultsKit : public Object
28180 {
28181 public:
28184 
28188 
28193 
28197  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
28198 
28199  virtual ~ShellRelationResultsKit();
28200 
28201  Type ObjectType() const { return Type::ShellRelationResultsKit; };
28202 
28205  void Consume(ShellRelationResultsKit & in_kit);
28206 
28209  void Set(ShellRelationResultsKit const & in_kit);
28210 
28213  void Show(ShellRelationResultsKit & out_kit) const;
28214 
28218  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
28219 
28222  bool Empty() const;
28223 
28227  bool Equals(ShellRelationResultsKit const & in_kit) const;
28228 
28232  bool operator==(ShellRelationResultsKit const & in_kit) const;
28233 
28237  bool operator!=(ShellRelationResultsKit const & in_kit) const;
28238 
28239 
28243  bool ShowRelations(ShellRelationArray & out_results) const;
28244 
28248  bool ShowNearestFaces(SizeTArray & out_faces) const;
28249 
28253  bool ShowDistances(FloatArray & out_distances) const;
28254 };
28255 
28256 
28258 class HPS_API ShellKit : public Object
28259 {
28260 public:
28262  ShellKit();
28263 
28266  ShellKit(ShellKit const & in_kit);
28267 
28271  ShellKit(ShellKit && in_that);
28272 
28276  ShellKit & operator=(ShellKit && in_that);
28277 
28278  virtual ~ShellKit();
28279 
28280  Type ObjectType() const { return Type::ShellKit; };
28281 
28284  void Consume(ShellKit & in_kit);
28285 
28288  void Set(ShellKit const & in_kit);
28289 
28292  void Show(ShellKit & out_kit) const;
28293 
28296  size_t GetPointCount() const;
28297 
28300  size_t GetFaceCount() const;
28301 
28305  ShellKit & operator=(ShellKit const & in_kit);
28306 
28309  bool Empty() const;
28310 
28314  bool Equals(ShellKit const & in_kit) const;
28315 
28319  bool operator==(ShellKit const & in_kit) const;
28320 
28324  bool operator!=(ShellKit const & in_kit) const;
28325 
28332  ShellKit & SetPriority(int in_priority);
28333 
28336  ShellKit & UnsetPriority();
28337 
28341  bool ShowPriority(int & out_priority) const;
28342 
28343 
28344 
28348  ShellKit & SetPoints(PointArray const & in_points);
28349 
28354  ShellKit & SetPoints(size_t in_count, Point const in_points []);
28355 
28359  ShellKit & SetFacelist(IntArray const & in_facelist);
28360 
28365  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
28366 
28369  ShellKit & UnsetPoints();
28370 
28373  ShellKit & UnsetFacelist();
28374 
28377  ShellKit & UnsetEverything();
28378 
28382  bool ShowPoints(PointArray & out_points) const;
28383 
28387  bool ShowFacelist(IntArray & out_facelist) const;
28388 
28389 
28395  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
28396 
28397 
28404  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28405 
28411  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28412 
28419  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
28420 
28427  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28428 
28435  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28436 
28443  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
28444 
28450  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
28451 
28452 
28459  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28460 
28466  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28467 
28474  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
28475 
28482  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28483 
28490  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28491 
28498  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
28499 
28505  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
28506 
28507 
28514  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
28515 
28521  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
28522 
28529  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
28530 
28537  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
28538 
28545  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
28546 
28553  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
28554 
28560  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
28561 
28562 
28568  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
28569 
28574  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
28575 
28581  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
28582 
28588  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
28589 
28594  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
28595 
28601  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
28602 
28607  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
28608 
28609 
28616  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
28617 
28624  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
28625 
28634  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);
28635 
28643  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
28644 
28645 
28651  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
28652 
28657  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
28658 
28664  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
28665 
28671  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
28672 
28677  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
28678 
28684  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
28685 
28690  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
28691 
28692 
28695  ShellKit & UnsetMaterialMapping();
28696 
28697 
28700  ShellKit & UnsetVertexColors();
28701 
28706  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
28707 
28711  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
28712 
28713 
28717  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
28718 
28724  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
28725 
28730  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
28731 
28732 
28735  ShellKit & UnsetVertexNormals();
28736 
28741  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
28742 
28746  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
28747 
28748 
28751  ShellKit & UnsetVertexParameters();
28752 
28757  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
28758 
28762  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
28763 
28764 
28767  ShellKit & UnsetVertexVisibilities();
28768 
28773  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
28774 
28778  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
28779 
28780 
28783  ShellKit & UnsetVertexEverything();
28784 
28785 
28789  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
28790 
28791 
28805  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
28806  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
28807 
28822  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
28823  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
28824 
28825 
28834  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
28835 
28844  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
28845 
28846 
28856  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
28857 
28867  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
28868 
28878  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
28879 
28889  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
28890 
28891 
28900  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
28901 
28910  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
28911 
28912 
28913 
28919  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
28920 
28925  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
28926 
28932  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
28933 
28939  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
28940 
28945  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
28946 
28952  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
28953 
28958  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
28959 
28960 
28966  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
28967 
28972  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
28973 
28979  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
28980 
28986  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
28987 
28992  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
28993 
28999  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
29000 
29005  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
29006 
29007 
29013  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29014 
29019  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
29020 
29026  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29027 
29033  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
29034 
29039  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
29040 
29046  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
29047 
29052  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
29053 
29054 
29060  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29061 
29066  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29067 
29073  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29074 
29080  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
29081 
29086  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
29087 
29093  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
29094 
29099  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
29100 
29101 
29104  ShellKit & UnsetFaceColors();
29105 
29110  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
29111 
29115  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
29116 
29117 
29120  ShellKit & UnsetFaceNormals();
29121 
29126  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
29127 
29131  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
29132 
29133 
29136  ShellKit & UnsetFaceVisibilities();
29137 
29142  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
29143 
29147  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
29148 
29149 
29152  ShellKit & UnsetFaceEverything();
29153 
29154 
29164  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29165 
29176  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29177 
29178 
29187  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29188 
29197  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
29198 
29199 
29208  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29209 
29218  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
29219 
29220 
29227  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
29228 
29234  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
29235 
29241  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
29242 
29248  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29249 
29255  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29256 
29257 
29264  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
29265 
29271  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
29272 
29278  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
29279 
29288  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
29289 
29297  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
29298 
29301  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
29302 
29307  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
29308 
29313  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
29314 
29319  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
29320 
29326  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
29327 
29332  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
29333 
29338  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
29339 
29343  ShellKit & UnsetUserData(intptr_t in_index);
29344 
29349  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
29350 
29354  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
29355 
29358  ShellKit & UnsetAllUserData();
29359 
29361  size_t ShowUserDataCount() const;
29362 
29366  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
29367 
29372  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
29373 
29378  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
29379 };
29380 
29381 
29382 
29384 class HPS_API ShellKey : public GeometryKey
29385 {
29386 public:
29388  ShellKey();
29389 
29394  explicit ShellKey(Key const & in_that);
29395 
29398  ShellKey(ShellKey const & in_that);
29399 
29403  ShellKey & operator=(ShellKey const & other);
29404 
29408  ShellKey(ShellKey && in_that);
29409 
29413  ShellKey & operator=(ShellKey && in_that);
29414 
29415  ~ShellKey();
29416 
29417  Type ObjectType() const { return Type::ShellKey; };
29418 
29421  void Consume(ShellKit & in_kit);
29422 
29425  void Set(ShellKit const & in_kit);
29426 
29429  void Show(ShellKit & out_kit) const;
29430 
29433  size_t GetPointCount() const;
29434 
29437  size_t GetFaceCount() const;
29438 
29439 
29443  ShellKey & SetPoints(PointArray const & in_points);
29444 
29449  ShellKey & SetPoints(size_t in_count, Point const in_points []);
29450 
29454  ShellKey & SetFacelist(IntArray const & in_facelist);
29455 
29460  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
29461 
29466  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
29467 
29470  ShellKey & UnsetPoints();
29471 
29474  ShellKey & UnsetFacelist();
29475 
29478  ShellKey & UnsetMaterialMapping();
29479 
29482  ShellKey & UnsetEverything();
29483 
29487  bool ShowPoints(PointArray & out_points) const;
29488 
29492  bool ShowFacelist(IntArray & out_facelist) const;
29493 
29497  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29498 
29499 
29506  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29507 
29514  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29515 
29522  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29523 
29530  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29531 
29538  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29539 
29546  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29547 
29553  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29554 
29555 
29562  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29563 
29570  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29571 
29578  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29579 
29586  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29587 
29594  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29595 
29602  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29603 
29609  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29610 
29611 
29618  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29619 
29626  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29627 
29634  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29635 
29642  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29643 
29650  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29651 
29658  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29659 
29665  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29666 
29667 
29673  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29674 
29680  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29681 
29687  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29688 
29694  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29695 
29700  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29701 
29707  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29708 
29713  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29714 
29715 
29723  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29724 
29731  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29732 
29741  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);
29742 
29750  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29751 
29752 
29758  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29759 
29765  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29766 
29772  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29773 
29779  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29780 
29785  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29786 
29792  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29793 
29798  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29799 
29800 
29803  ShellKey & UnsetVertexColors();
29804 
29809  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29810 
29814  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29815 
29816 
29820  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
29821 
29827  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29828 
29833  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29834 
29835 
29838  ShellKey & UnsetVertexNormals();
29839 
29844  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29845 
29849  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29850 
29851 
29854  ShellKey & UnsetVertexParameters();
29855 
29860  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29861 
29865  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29866 
29867 
29870  ShellKey & UnsetVertexVisibilities();
29871 
29876  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29877 
29881  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29882 
29883 
29886  ShellKey & UnsetVertexEverything();
29887 
29888 
29902  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29903  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29904 
29919  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29920  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29921 
29922 
29931  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29932 
29941  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29942 
29943 
29953  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29954 
29964  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29965 
29975  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
29976 
29986  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29987 
29988 
29997  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29998 
30007  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30008 
30009 
30015  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30016 
30022  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
30023 
30029  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
30030 
30036  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
30037 
30042  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
30043 
30049  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
30050 
30055  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
30056 
30057 
30063  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
30064 
30070  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
30071 
30077  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
30078 
30084  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
30085 
30090  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
30091 
30097  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
30098 
30103  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
30104 
30105 
30111  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30112 
30118  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
30119 
30125  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30126 
30132  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
30133 
30138  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
30139 
30145  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
30146 
30151  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
30152 
30153 
30159  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30160 
30166  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30167 
30173  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30174 
30180  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
30181 
30186  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
30187 
30193  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
30194 
30199  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
30200 
30201 
30204  ShellKey & UnsetFaceColors();
30205 
30210  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
30211 
30215  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
30216 
30217 
30220  ShellKey & UnsetFaceNormals();
30221 
30226  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
30227 
30231  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
30232 
30233 
30236  ShellKey & UnsetFaceVisibilities();
30237 
30242  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
30243 
30247  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
30248 
30249 
30252  ShellKey & UnsetFaceEverything();
30253 
30254 
30264  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30265 
30276  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30277 
30278 
30287  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30288 
30297  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
30298 
30299 
30305  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
30306 
30313  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
30314 
30315 
30324  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30325 
30334  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
30335 
30336 
30343  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
30344 
30350  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
30351 
30357  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
30358 
30364  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
30365 
30371  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
30372 
30373 
30380  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
30381 
30387  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
30388 
30394  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
30395 
30404  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
30405 
30413  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
30414 
30417  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
30418 
30423  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30424 
30429  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30430 
30435  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30436 };
30437 
30438 
30439 
30441 class HPS_API MeshKit : public Object
30442 {
30443 public:
30445  MeshKit();
30446 
30449  MeshKit(MeshKit const & in_kit);
30450 
30454  MeshKit(MeshKit && in_that);
30455 
30459  MeshKit & operator=(MeshKit && in_that);
30460 
30461  virtual ~MeshKit();
30462 
30463  Type ObjectType() const { return Type::MeshKit; };
30464 
30467  void Consume(MeshKit & in_kit);
30468 
30471  void Set(MeshKit const & in_kit);
30472 
30475  void Show(MeshKit & out_kit) const;
30476 
30480  MeshKit & operator=(MeshKit const & in_kit);
30481 
30484  bool Empty() const;
30485 
30489  bool Equals(MeshKit const & in_kit) const;
30490 
30494  bool operator==(MeshKit const & in_kit) const;
30495 
30499  bool operator!=(MeshKit const & in_kit) const;
30500 
30503  size_t GetPointCount() const;
30504 
30511  MeshKit & SetPriority(int in_priority);
30512 
30515  MeshKit & UnsetPriority();
30516 
30520  bool ShowPriority(int & out_priority) const;
30521 
30525  MeshKit & SetPoints(PointArray const & in_points);
30526 
30531  MeshKit & SetPoints(size_t in_count, Point const in_points []);
30532 
30538  MeshKit & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
30539 
30546  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
30547 
30551  MeshKit & SetRows(size_t in_rows);
30552 
30556  MeshKit & SetColumns(size_t in_columns);
30557 
30560  MeshKit & UnsetPoints();
30561 
30564  MeshKit & UnsetRows();
30565 
30568  MeshKit & UnsetColumns();
30569 
30572  MeshKit & UnsetEverything();
30573 
30577  bool ShowPoints(PointArray & out_points) const;
30578 
30584  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
30585 
30589  bool ShowRows(size_t & out_rows) const;
30590 
30594  bool ShowColumns(size_t & out_columns) const;
30595 
30596 
30602  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
30603 
30610  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30611 
30617  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30618 
30625  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30626 
30633  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30634 
30641  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30642 
30649  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30650 
30656  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30657 
30658 
30665  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30666 
30672  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30673 
30680  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30681 
30688  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30689 
30696  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30697 
30704  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30705 
30711  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30712 
30713 
30720  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30721 
30727  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
30728 
30735  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
30736 
30743  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30744 
30751  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
30752 
30759  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
30760 
30766  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
30767 
30768 
30774  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30775 
30780  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30781 
30787  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30788 
30794  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30795 
30800  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30801 
30807  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30808 
30813  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30814 
30815 
30822  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30823 
30830  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30831 
30840  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);
30841 
30849  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30850 
30851 
30857  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30858 
30863  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30864 
30870  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30871 
30877  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30878 
30883  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
30884 
30890  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
30891 
30896  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
30897 
30898 
30901  MeshKit & UnsetMaterialMapping();
30902 
30905  MeshKit & UnsetVertexColors();
30906 
30911  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
30912 
30916  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
30917 
30918 
30922  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
30923 
30929  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
30930 
30935  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
30936 
30937 
30940  MeshKit & UnsetVertexNormals();
30941 
30946  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
30947 
30951  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
30952 
30953 
30956  MeshKit & UnsetVertexParameters();
30957 
30962  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
30963 
30967  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
30968 
30969 
30972  MeshKit & UnsetVertexVisibilities();
30973 
30978  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
30979 
30983  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
30984 
30985 
30988  MeshKit & UnsetVertexEverything();
30989 
30990 
30994  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30995 
31009  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31010  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31011 
31026  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31027  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31028 
31029 
31038  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31039 
31048  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31049 
31050 
31060  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31061 
31071  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31072 
31082  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31083 
31093  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31094 
31095 
31104  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31105 
31114  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31115 
31116 
31122  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31123 
31128  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31129 
31135  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31136 
31142  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
31143 
31148  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
31149 
31155  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
31156 
31161  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
31162 
31163 
31169  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
31170 
31175  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
31176 
31182  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
31183 
31189  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
31190 
31195  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
31196 
31202  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
31203 
31208  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
31209 
31210 
31216  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31217 
31222  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
31223 
31229  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31230 
31236  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
31237 
31242  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
31243 
31249  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
31250 
31255  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
31256 
31257 
31263  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31264 
31269  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31270 
31276  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31277 
31283  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
31284 
31289  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
31290 
31296  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
31297 
31302  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
31303 
31304 
31307  MeshKit & UnsetFaceColors();
31308 
31313  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
31314 
31318  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
31319 
31320 
31323  MeshKit & UnsetFaceNormals();
31324 
31329  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
31330 
31334  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
31335 
31336 
31339  MeshKit & UnsetFaceVisibilities();
31340 
31345  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
31346 
31350  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
31351 
31352 
31355  MeshKit & UnsetFaceEverything();
31356 
31357 
31367  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31368 
31379  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31380 
31381 
31390  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31391 
31400  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31401 
31402 
31411  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31412 
31421  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31422 
31428  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
31429 
31434  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
31435 
31440  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
31441 
31445  MeshKit & UnsetUserData(intptr_t in_index);
31446 
31451  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
31452 
31456  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
31457 
31460  MeshKit & UnsetAllUserData();
31461 
31463  size_t ShowUserDataCount() const;
31464 
31468  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
31469 
31474  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
31475 
31480  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
31481 
31482 };
31483 
31484 
31485 
31487 class HPS_API MeshKey : public GeometryKey
31488 {
31489 public:
31491  MeshKey();
31492 
31497  explicit MeshKey(Key const & in_that);
31498 
31501  MeshKey(MeshKey const & in_that);
31502 
31506  MeshKey & operator=(MeshKey const & in_that);
31507 
31511  MeshKey(MeshKey && in_that);
31512 
31516  MeshKey & operator=(MeshKey && in_that);
31517 
31518  ~MeshKey();
31519 
31520  Type ObjectType() const { return Type::MeshKey; };
31521 
31524  void Consume(MeshKit & in_kit);
31525 
31528  void Set(MeshKit const & in_kit);
31529 
31532  void Show(MeshKit & out_kit) const;
31533 
31536  size_t GetPointCount() const;
31537 
31543  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
31544 
31551  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31552 
31556  bool ShowPoints(PointArray & out_points) const;
31557 
31563  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31564 
31568  bool ShowRows(size_t & out_rows) const;
31569 
31573  bool ShowColumns(size_t & out_columns) const;
31574 
31575 
31580  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
31581 
31584  MeshKey & UnsetMaterialMapping();
31585 
31589  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31590 
31591 
31598  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31599 
31606  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31607 
31614  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31615 
31622  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31623 
31630  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31631 
31638  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31639 
31645  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31646 
31647 
31654  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31655 
31662  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31663 
31670  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31671 
31678  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31679 
31686  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31687 
31694  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31695 
31701  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31702 
31703 
31710  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31711 
31718  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31719 
31726  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31727 
31734  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31735 
31742  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31743 
31750  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31751 
31757  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31758 
31759 
31765  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31766 
31772  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31773 
31779  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31780 
31786  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31787 
31792  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31793 
31799  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31800 
31805  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31806 
31807 
31815  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31816 
31823  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31824 
31833  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);
31834 
31842  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31843 
31844 
31850  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31851 
31857  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31858 
31864  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31865 
31871  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31872 
31877  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31878 
31884  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31885 
31890  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31891 
31892 
31895  MeshKey & UnsetVertexColors();
31896 
31901  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31902 
31906  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31907 
31908 
31912  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
31913 
31919  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
31920 
31925  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
31926 
31927 
31930  MeshKey & UnsetVertexNormals();
31931 
31936  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31937 
31941  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31942 
31943 
31946  MeshKey & UnsetVertexParameters();
31947 
31952  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31953 
31957  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31958 
31959 
31962  MeshKey & UnsetVertexVisibilities();
31963 
31968  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31969 
31973  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31974 
31975 
31978  MeshKey & UnsetVertexEverything();
31979 
31982  MeshKey & UnsetEverything();
31983 
31984 
31998  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31999  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32000 
32015  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32016  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32017 
32018 
32027  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32028 
32037  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32038 
32039 
32049  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32050 
32060  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32061 
32071  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32072 
32082  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32083 
32084 
32093  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32094 
32103  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32104 
32105 
32111  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32112 
32118  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32119 
32125  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
32126 
32132  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32133 
32138  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32139 
32145  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32146 
32151  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32152 
32153 
32159  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32160 
32166  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32167 
32173  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32174 
32180  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32181 
32186  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32187 
32193  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32194 
32199  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32200 
32201 
32207  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32208 
32214  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
32215 
32221  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32222 
32228  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
32229 
32234  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
32235 
32241  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32242 
32247  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32248 
32249 
32255  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32256 
32262  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32263 
32269  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32270 
32276  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32277 
32282  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32283 
32289  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32290 
32295  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32296 
32297 
32300  MeshKey & UnsetFaceColors();
32301 
32306  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32307 
32311  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
32312 
32313 
32316  MeshKey & UnsetFaceNormals();
32317 
32322  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32323 
32327  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
32328 
32329 
32332  MeshKey & UnsetFaceVisibilities();
32333 
32338  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32339 
32343  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
32344 
32345 
32348  MeshKey & UnsetFaceEverything();
32349 
32350 
32360  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32361 
32372  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32373 
32374 
32383  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32384 
32393  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32394 
32395 
32404  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32405 
32414  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32415 
32424  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[]);
32425 
32433  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);
32434 };
32435 
32436 
32437 
32438 
32440 class HPS_API PolygonKit : public Object
32441 {
32442 public:
32444  PolygonKit();
32445 
32448  PolygonKit(PolygonKit const & in_kit);
32449 
32453  PolygonKit(PolygonKit && in_that);
32454 
32458  PolygonKit & operator=(PolygonKit && in_that);
32459 
32460  virtual ~PolygonKit();
32461 
32462  Type ObjectType() const { return Type::PolygonKit; };
32463 
32466  void Consume(PolygonKit & in_kit);
32467 
32470  void Set(PolygonKit const & in_kit);
32471 
32474  void Show(PolygonKit & out_kit) const;
32475 
32479  PolygonKit & operator=(PolygonKit const & in_kit);
32480 
32483  bool Empty() const;
32484 
32488  bool Equals(PolygonKit const & in_kit) const;
32489 
32493  bool operator==(PolygonKit const & in_kit) const;
32494 
32498  bool operator!=(PolygonKit const & in_kit) const;
32499 
32502  size_t GetPointCount() const;
32503 
32510  PolygonKit & SetPriority(int in_priority);
32511 
32514  PolygonKit & UnsetPriority();
32515 
32519  bool ShowPriority(int & out_priority) const;
32520 
32521 
32525  PolygonKit & SetPoints(PointArray const & in_points);
32526 
32531  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
32532 
32535  PolygonKit & UnsetPoints();
32536 
32539  PolygonKit & UnsetEverything();
32540 
32544  bool ShowPoints(PointArray & out_points) const;
32545 
32551  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
32552 
32557  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
32558 
32563  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
32564 
32570  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
32571 
32576  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
32577 
32583  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32584 
32589  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32590 
32595  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32596 
32600  PolygonKit & UnsetUserData(intptr_t in_index);
32601 
32606  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32607 
32611  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
32612 
32615  PolygonKit & UnsetAllUserData();
32616 
32618  size_t ShowUserDataCount() const;
32619 
32623  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32624 
32629  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32630 
32635  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32636 };
32637 
32638 
32640 class HPS_API PolygonKey : public GeometryKey
32641 {
32642 public:
32644  PolygonKey();
32645 
32650  explicit PolygonKey(Key const & in_that);
32651 
32654  PolygonKey(PolygonKey const & in_that);
32655 
32659  PolygonKey & operator=(PolygonKey const & in_that);
32660 
32664  PolygonKey(PolygonKey && in_that);
32665 
32669  PolygonKey & operator=(PolygonKey && in_that);
32670 
32671  ~PolygonKey();
32672 
32673  Type ObjectType() const { return Type::PolygonKey; };
32674 
32675 
32678  void Consume(PolygonKit & in_kit);
32679 
32682  void Set(PolygonKit const & in_kit);
32683 
32686  void Show(PolygonKit & out_kit) const;
32687 
32690  size_t GetPointCount() const;
32691 
32695  PolygonKey & SetPoints(PointArray const & in_points);
32696 
32701  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
32702 
32706  bool ShowPoints(PointArray & out_points) const;
32707 
32713  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
32714 
32719  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
32720 
32725  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
32726 
32732  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
32733 
32738  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
32739 };
32740 
32741 
32742 
32743 
32745 class HPS_API GridKit : public Object
32746 {
32747 public:
32749  GridKit();
32750 
32753  GridKit(GridKit const & in_kit);
32754 
32757  GridKit(GridKit && in_that);
32758 
32759  virtual ~GridKit();
32760 
32761  Type ObjectType() const { return Type::GridKit; };
32762 
32765  void Consume(GridKit & in_kit);
32766 
32769  void Set(GridKit const & in_kit);
32770 
32773  void Show(GridKit & out_kit) const;
32774 
32778  GridKit & operator=(GridKit const & in_kit);
32779 
32783  GridKit & operator=(GridKit && in_that);
32784 
32787  bool Empty() const;
32788 
32792  bool Equals(GridKit const & in_kit) const;
32793 
32797  bool operator==(GridKit const & in_kit) const;
32798 
32802  bool operator!=(GridKit const & in_kit) const;
32803 
32804 
32811  GridKit & SetPriority(int in_priority);
32812 
32816  GridKit & SetType(Grid::Type in_type);
32817 
32821  GridKit & SetOrigin(Point const & in_origin);
32822 
32829  GridKit & SetFirstPoint(Point const & in_first_point);
32830 
32838  GridKit & SetSecondPoint(Point const & in_second_point);
32839 
32853  GridKit & SetFirstCount(int in_first_count);
32854 
32865  GridKit & SetSecondCount(int in_second_count);
32866 
32867 
32870  GridKit & UnsetPriority();
32871 
32874  GridKit & UnsetType();
32875 
32878  GridKit & UnsetOrigin();
32879 
32882  GridKit & UnsetFirstPoint();
32883 
32886  GridKit & UnsetSecondPoint();
32887 
32890  GridKit & UnsetFirstCount();
32891 
32894  GridKit & UnsetSecondCount();
32895 
32898  GridKit & UnsetEverything();
32899 
32900 
32904  bool ShowPriority(int & out_priority) const;
32905 
32909  bool ShowType(Grid::Type & out_type) const;
32910 
32914  bool ShowOrigin(Point & out_origin) const;
32915 
32919  bool ShowFirstPoint(Point & out_first_point) const;
32920 
32924  bool ShowSecondPoint(Point & out_second_point) const;
32925 
32929  bool ShowFirstCount(int & out_first_count) const;
32930 
32934  bool ShowSecondCount(int & out_second_count) const;
32935 
32941  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32942 
32947  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32948 
32953  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32954 
32958  GridKit & UnsetUserData(intptr_t in_index);
32959 
32964  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32965 
32969  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
32970 
32973  GridKit & UnsetAllUserData();
32974 
32976  size_t ShowUserDataCount() const;
32977 
32981  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32982 
32987  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32988 
32993  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32994 };
32995 
32996 
32998 class HPS_API GridKey : public GeometryKey
32999 {
33000 public:
33002  GridKey();
33003 
33008  explicit GridKey(Key const & in_that);
33009 
33012  GridKey(GridKey const & in_that);
33013 
33016  GridKey(GridKey && in_that);
33017 
33021  GridKey & operator=(GridKey const & in_that);
33022 
33026  GridKey & operator=(GridKey && in_that);
33027 
33028  ~GridKey();
33029 
33030  Type ObjectType() const { return Type::GridKey; };
33031 
33034  void Consume(GridKit & in_kit);
33035 
33038  void Set(GridKit const & in_kit);
33039 
33042  void Show(GridKit & out_kit) const;
33043 
33044 
33048  GridKey & SetType(Grid::Type in_type);
33049 
33053  GridKey & SetOrigin(Point const & in_origin);
33054 
33061  GridKey & SetFirstPoint(Point const & in_first_point);
33062 
33070  GridKey & SetSecondPoint(Point const & in_second_point);
33071 
33085  GridKey & SetFirstCount(int in_first_count);
33086 
33097  GridKey & SetSecondCount(int in_second_count);
33098 
33099 
33100 
33104  bool ShowType(Grid::Type & out_type) const;
33105 
33109  bool ShowOrigin(Point & out_origin) const;
33110 
33114  bool ShowFirstPoint(Point & out_first_point) const;
33115 
33119  bool ShowSecondPoint(Point & out_second_point) const;
33120 
33124  bool ShowFirstCount(int & out_first_count) const;
33125 
33129  bool ShowSecondCount(int & out_second_count) const;
33130 };
33131 
33132 
33133 
33134 
33136 class HPS_API IncludeKey : public Key
33137 {
33138 public:
33140  IncludeKey();
33141 
33146  explicit IncludeKey(Key const & in_that);
33147 
33150  IncludeKey(IncludeKey const & in_that);
33151 
33155  IncludeKey & operator=(IncludeKey const & in_that);
33156 
33160  IncludeKey(IncludeKey && in_that);
33161 
33165  IncludeKey & operator=(IncludeKey && in_that);
33166 
33167  ~IncludeKey();
33168 
33169 
33170  Type ObjectType() const { return Type::IncludeKey; };
33171 
33174  SegmentKey GetTarget() const;
33175 
33176 
33181  IncludeKey & SetPriority(int in_priority);
33182 
33190  IncludeKey & SetCondition(Condition const & in_condition);
33191 
33192 
33195  IncludeKey & UnsetPriority();
33196 
33199  IncludeKey & UnsetCondition();
33200 
33201 
33205  bool ShowPriority(int & out_priority) const;
33206 
33210  bool ShowCondition(Condition & out_condition) const;
33211 
33217  IncludeKey & SetFilter(AttributeLock::Type in_type);
33218 
33225  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33226 
33232  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
33233 
33239  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
33240 
33247  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33248 
33254  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
33255 
33261  bool ShowFilter(AttributeLockTypeArray & out_types) const;
33262 
33268  bool ShowFilter(AttributeLock::Type in_type) const;
33269 };
33270 
33271 
33272 
33274 class HPS_API StyleKey : public Key
33275 {
33276 public:
33278  StyleKey();
33279 
33284  explicit StyleKey(Key const & in_that);
33285 
33288  StyleKey(StyleKey const & in_that);
33289 
33293  StyleKey & operator=(StyleKey const & other);
33294 
33298  StyleKey(StyleKey && in_that);
33299 
33303  StyleKey & operator=(StyleKey && in_that);
33304 
33305  ~StyleKey();
33306 
33307  Type ObjectType() const { return Type::StyleKey; };
33308 
33309 
33315  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
33316 
33317 
33325  StyleKey & SetCondition(Condition const & in_condition);
33326 
33327 
33330  StyleKey & UnsetCondition();
33331 
33332 
33336  bool ShowCondition(Condition & out_condition) const;
33337 
33338 
33344  StyleKey & SetFilter(AttributeLock::Type in_type);
33345 
33352  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33353 
33359  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
33360 
33366  StyleKey & UnsetFilter(AttributeLock::Type in_type);
33367 
33374  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33375 
33381  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
33382 
33388  bool ShowFilter(AttributeLockTypeArray & out_types) const;
33389 
33395  bool ShowFilter(AttributeLock::Type in_type) const;
33396 };
33397 
33398 
33399 
33401 class HPS_API ReferenceKey : public GeometryKey
33402 {
33403 public:
33405  ReferenceKey();
33406 
33411  explicit ReferenceKey(Key const & in_that);
33412 
33415  ReferenceKey(ReferenceKey const & in_that);
33416 
33420  ReferenceKey & operator=(ReferenceKey const & in_that);
33421 
33425  ReferenceKey(ReferenceKey && in_that);
33426 
33430  ReferenceKey & operator=(ReferenceKey && in_that);
33431 
33432  ~ReferenceKey();
33433 
33434  Type ObjectType() const { return Type::ReferenceKey; };
33435 
33439  Key GetTarget() const;
33440 
33444  size_t ShowTargets(bool masked=true) const;
33445 
33450  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
33451 
33455  size_t ShowGeometryMask() const;
33456 
33461  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
33462 
33466  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
33467 
33470  ReferenceKey & UnsetGeometryMask();
33471 
33474  void SetModellingMatrix(MatrixKit const & in_kit);
33475 
33484  ReferenceKey & SetCondition(Condition const & in_condition);
33485 
33486 
33488  void UnsetModellingMatrix();
33489 
33492  ReferenceKey & UnsetCondition();
33493 
33494 
33498  bool ShowModellingMatrix(MatrixKit & out_kit) const;
33499 
33503  bool ShowCondition(Condition & out_condition) const;
33504 
33505 
33508  ModellingMatrixControl GetModellingMatrixControl();
33509 
33512  ModellingMatrixControl const GetModellingMatrixControl() const;
33513 };
33514 
33515 
33516 
33520 class HPS_API StandAloneWindowOptionsKit : public Object
33521 {
33522 public:
33525 
33529 
33534 
33539 
33540  virtual ~StandAloneWindowOptionsKit();
33541 
33542  Type ObjectType() const { return Type::StandAloneWindowOptionsKit; };
33543 
33547  static StandAloneWindowOptionsKit GetDefault();
33548 
33551  void Set(StandAloneWindowOptionsKit const & in_kit);
33552 
33555  void Show(StandAloneWindowOptionsKit & out_kit) const;
33556 
33560  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
33561 
33564  bool Empty() const;
33565 
33569  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
33570 
33574  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
33575 
33579  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
33580 
33584  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
33585 
33590  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
33591 
33595  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
33596 
33601  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
33602 
33606  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
33607 
33611  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
33612 
33615  StandAloneWindowOptionsKit & UnsetDriver();
33616 
33619  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
33620 
33623  StandAloneWindowOptionsKit & UnsetTitle();
33624 
33627  StandAloneWindowOptionsKit & UnsetSubscreen();
33628 
33631  StandAloneWindowOptionsKit & UnsetMobility();
33632 
33635  StandAloneWindowOptionsKit & UnsetFullScreen();
33636 
33639  StandAloneWindowOptionsKit & UnsetEverything();
33640 
33644  bool ShowDriver(Window::Driver & out_driver) const;
33645 
33650  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
33651 
33655  bool ShowTitle(UTF8 & out_window_name) const;
33656 
33660  bool ShowSubscreen(Rectangle & out_subscreen) const;
33661 
33665  bool ShowMobility(Window::Mobility & out_mobility) const;
33666 
33670  bool ShowFullScreen(bool & out_state) const;
33671 };
33672 
33673 
33674 
33681 {
33682 public:
33686 
33690 
33695 
33700 
33703 
33704  Type ObjectType() const { return Type::StandAloneWindowOptionsControl; };
33705 
33710 
33715  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
33716 
33720  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
33721 
33725  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
33726 
33730  bool ShowDriver(Window::Driver & out_driver) const;
33731 
33736  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
33737 
33741  bool ShowTitle(UTF8 & out_window_name) const;
33742 
33746  bool ShowSubscreen(Rectangle & out_subscreen) const;
33747 
33751  bool ShowMobility(Window::Mobility & out_mobility) const;
33752 
33756  bool ShowFullScreen(bool & out_state) const;
33757 
33758 private:
33761 };
33762 
33763 
33764 
33768 class HPS_API OffScreenWindowOptionsKit : public Object
33769 {
33770 public:
33773 
33777 
33782 
33786  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
33787 
33788  virtual ~OffScreenWindowOptionsKit();
33789 
33790  Type ObjectType() const { return Type::OffScreenWindowOptionsKit; };
33791 
33795  static OffScreenWindowOptionsKit GetDefault();
33796 
33799  void Set(OffScreenWindowOptionsKit const & in_kit);
33800 
33803  void Show(OffScreenWindowOptionsKit & out_kit) const;
33804 
33808  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
33809 
33812  bool Empty() const;
33813 
33817  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
33818 
33822  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
33823 
33827  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
33828 
33832  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
33833 
33838  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
33839 
33844  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
33845 
33850  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
33851 
33855  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
33856 
33859  OffScreenWindowOptionsKit & UnsetDriver();
33860 
33863  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
33864 
33867  OffScreenWindowOptionsKit & UnsetHardwareResident();
33868 
33871  OffScreenWindowOptionsKit & UnsetOpacity();
33872 
33875  OffScreenWindowOptionsKit & UnsetEverything();
33876 
33880  bool ShowDriver(Window::Driver & out_driver) const;
33881 
33886  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
33887 
33891  bool ShowHardwareResident(bool & out_state) const;
33892 
33897  bool ShowOpacity(bool & out_state, float & out_opacity) const;
33898 };
33899 
33903 class HPS_API ApplicationWindowOptionsKit : public Object
33904 {
33905 public:
33908 
33912 
33917 
33922 
33923  virtual ~ApplicationWindowOptionsKit();
33924 
33925  Type ObjectType() const { return Type::ApplicationWindowOptionsKit; };
33926 
33930  static ApplicationWindowOptionsKit GetDefault();
33931 
33934  void Set(ApplicationWindowOptionsKit const & in_kit);
33935 
33938  void Show(ApplicationWindowOptionsKit & out_kit) const;
33939 
33943  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
33944 
33947  bool Empty() const;
33948 
33952  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
33953 
33957  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
33958 
33962  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
33963 
33967  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
33968 
33973  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
33974 
33978  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
33979 
33983  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
33984 
33987  ApplicationWindowOptionsKit & UnsetDriver();
33988 
33991  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
33992 
33995  ApplicationWindowOptionsKit & UnsetPlatformData();
33996 
33999  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
34000 
34003  ApplicationWindowOptionsKit & UnsetEverything();
34004 
34008  bool ShowDriver(Window::Driver & out_driver) const;
34009 
34014  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34015 
34019  bool ShowPlatformData(PlatformData & out_platform_data) const;
34020 
34024  bool ShowFramebufferRetention(bool & out_retain) const;
34025 
34026 };
34027 
34028 
34029 
34032 {
34033 public:
34037 
34041 
34046 
34051 
34054 
34055  Type ObjectType() const { return Type::ApplicationWindowOptionsControl; };
34056 
34061 
34066  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34067 
34071  bool ShowDriver(Window::Driver & out_driver) const;
34072 
34076  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
34077 
34081  bool ShowPlatformData(PlatformData & out_platform_data) const;
34082 
34086  bool ShowFramebufferRetention(bool & out_retain) const;
34087 
34091  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
34092 
34096  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
34097 
34098 private:
34101 };
34102 
34103 
34104 
34109 class HPS_API StandAloneWindowKey : public WindowKey
34110 {
34111 public:
34114 
34119  StandAloneWindowKey(Key const & in_key);
34120 
34123  StandAloneWindowKey(StandAloneWindowKey const & in_that);
34124 
34129 
34133  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
34134 
34136 
34137  Type ObjectType() const { return Type::StandAloneWindowKey; };
34138 
34141  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
34142 
34145  StandAloneWindowOptionsControl GetWindowOptionsControl();
34146 
34150  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
34151 
34154  Window::UpdateStatus Pause();
34155 };
34156 
34157 
34158 
34160 class HPS_API ApplicationWindowKey : public WindowKey
34161 {
34162 public:
34165 
34170  ApplicationWindowKey(Key const & in_key);
34171 
34174  ApplicationWindowKey(ApplicationWindowKey const & in_that);
34175 
34180 
34184  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
34185 
34187 
34188  Type ObjectType() const { return Type::ApplicationWindowKey; };
34189 
34192  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
34193 
34196  ApplicationWindowOptionsControl GetWindowOptionsControl();
34197 
34201  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
34202 };
34203 
34207 
34208 
34209 
34211 class HPS_API GlyphElement : public Object
34212 {
34213 public:
34215  GlyphElement();
34216 
34219  GlyphElement(GlyphElement const & in_that);
34220 
34224  GlyphElement(GlyphElement && in_that);
34225 
34229  GlyphElement & operator=(GlyphElement && in_that);
34230 
34231  virtual ~GlyphElement();
34232 
34233  Type ObjectType() const { return Type::GlyphElement; };
34234 
34237  void Set(GlyphElement const & in_that);
34238 
34242  GlyphElement & operator=(GlyphElement const & in_that);
34243 
34247  bool Equals(GlyphElement const & in_that) const;
34248 
34252  bool operator==(GlyphElement const & in_that) const;
34253 
34257  bool operator!=(GlyphElement const & in_that) const;
34258 
34261  void SetFill(Glyph::Fill in_fill);
34262 
34265  void SetIndexedColor(byte in_index);
34266 
34268  void SetNormalColor();
34269 
34272  void SetExplicitColor(RGBAColor const & in_color);
34273 
34277  bool ShowFill(Glyph::Fill & out_fill) const;
34278 
34284  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
34285 };
34286 
34287 
34289 class HPS_API LineGlyphElement : public GlyphElement
34290 {
34291 public:
34293  LineGlyphElement();
34294 
34299  LineGlyphElement(GlyphElement const & in_that);
34300 
34303  LineGlyphElement(LineGlyphElement const & in_that);
34304 
34307  explicit LineGlyphElement(GlyphPointArray const & in_points);
34308 
34312  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
34313 
34317  LineGlyphElement(LineGlyphElement && in_that);
34318 
34322  LineGlyphElement & operator=(LineGlyphElement && in_that);
34323 
34324  ~LineGlyphElement();
34325 
34326  Type ObjectType() const { return Type::LineGlyphElement; };
34327 
34330  void SetPoints(GlyphPointArray const & in_points);
34331 
34335  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
34336 
34340  bool ShowPoints(GlyphPointArray & out_points) const;
34341 };
34342 
34344 class HPS_API DotGlyphElement : public GlyphElement
34345 {
34346 public:
34348  DotGlyphElement();
34349 
34354  DotGlyphElement(GlyphElement const & in_that);
34355 
34358  DotGlyphElement(DotGlyphElement const & in_that);
34359 
34362  explicit DotGlyphElement(GlyphPoint const & in_point);
34363 
34367  DotGlyphElement(DotGlyphElement && in_that);
34368 
34372  DotGlyphElement & operator=(DotGlyphElement && in_that);
34373 
34374  ~DotGlyphElement();
34375 
34376  Type ObjectType() const { return Type::DotGlyphElement; };
34377 
34380  void SetPoint(GlyphPoint const & in_point);
34381 
34385  bool ShowPoint(GlyphPoint & out_point) const;
34386 };
34387 
34388 
34390 class HPS_API EllipseGlyphElement : public GlyphElement
34391 {
34392 public:
34395 
34400  EllipseGlyphElement(GlyphElement const & in_that);
34401 
34404  EllipseGlyphElement(EllipseGlyphElement const & in_that);
34405 
34409  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
34410 
34415 
34419  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
34420 
34422 
34423  Type ObjectType() const { return Type::EllipseGlyphElement; };
34424 
34427  void SetLowerLeft(GlyphPoint const & in_point);
34428 
34431  void SetUpperRight(GlyphPoint const & in_point);
34432 
34436  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
34437 
34441  bool ShowLowerLeft(GlyphPoint & out_point) const;
34442 
34446  bool ShowUpperRight(GlyphPoint & out_point) const;
34447 };
34448 
34449 
34452 {
34453 public:
34456 
34461  CircularArcGlyphElement(GlyphElement const & in_that);
34462 
34466 
34471  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
34472 
34477 
34481  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
34482 
34484 
34485  Type ObjectType() const { return Type::CircularArcGlyphElement; };
34486 
34489  void SetStartPoint(GlyphPoint const & in_point);
34490 
34493  void SetIntermediatePoint(GlyphPoint const & in_point);
34494 
34497  void SetEndPoint(GlyphPoint const & in_point);
34498 
34503  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
34504 
34508  bool ShowStartPoint(GlyphPoint & out_point) const;
34509 
34513  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
34514 
34518  bool ShowEndPoint(GlyphPoint & out_point) const;
34519 };
34520 
34521 
34522 
34525 {
34526 public:
34529 
34534  InfiniteLineGlyphElement(GlyphElement const & in_that);
34535 
34539 
34543  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
34544 
34549 
34553  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
34554 
34556 
34557  Type ObjectType() const { return Type::InfiniteLineGlyphElement; };
34558 
34561  void SetFirstPoint(GlyphPoint const & in_point);
34562 
34565  void SetSecondPoint(GlyphPoint const & in_point);
34566 
34570  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
34571 
34574  void SetInfiniteType(InfiniteLine::Type in_type);
34575 
34579  bool ShowFirstPoint(GlyphPoint & out_point) const;
34580 
34584  bool ShowSecondPoint(GlyphPoint & out_point) const;
34585 
34589  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
34590 };
34591 
34592 
34593 
34595 class HPS_API GlyphKit : public Object
34596 {
34597 public:
34599  GlyphKit();
34600 
34603  GlyphKit(GlyphKit const & in_kit);
34604 
34608  GlyphKit(GlyphKit && in_that);
34609 
34613  GlyphKit & operator=(GlyphKit && in_that);
34614 
34615  virtual ~GlyphKit();
34616 
34617  Type ObjectType() const { return Type::GlyphKit; };
34618 
34622  static GlyphKit GetDefault(Glyph::Default in_default_glyph);
34623 
34626  void Set(GlyphKit const & in_kit);
34627 
34630  void Show(GlyphKit & out_kit) const;
34631 
34635  GlyphKit & operator=(GlyphKit const & in_kit);
34636 
34639  bool Empty() const;
34640 
34644  bool Equals(GlyphKit const & in_kit) const;
34645 
34649  bool operator==(GlyphKit const & in_kit) const;
34650 
34654  bool operator!=(GlyphKit const & in_kit) const;
34655 
34659  GlyphKit & SetRadius(sbyte in_radius);
34660 
34665  GlyphKit & SetOffset(GlyphPoint const & in_point);
34666 
34670  GlyphKit & SetElements(GlyphElementArray const & in_def);
34671 
34676  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
34677 
34680  GlyphKit & UnsetRadius();
34681 
34684  GlyphKit & UnsetOffset();
34685 
34688  GlyphKit & UnsetElements();
34689 
34692  GlyphKit & UnsetEverything();
34693 
34697  bool ShowRadius(sbyte & out_radius) const;
34698 
34702  bool ShowOffset(GlyphPoint & out_point) const;
34703 
34707  bool ShowElements(GlyphElementArray & out_def) const;
34708 };
34709 
34713 
34714 
34717 class HPS_API LinePatternOptionsKit : public Object
34718 {
34719 public:
34722 
34726 
34731 
34735  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
34736 
34737  virtual ~LinePatternOptionsKit();
34738 
34739  Type ObjectType() const { return Type::LinePatternOptionsKit; };
34740 
34743  void Set(LinePatternOptionsKit const & in_kit);
34744 
34747  void Show(LinePatternOptionsKit & out_kit) const;
34748 
34752  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
34753 
34756  bool Empty() const;
34757 
34761  bool Equals(LinePatternOptionsKit const & in_kit) const;
34762 
34766  bool operator==(LinePatternOptionsKit const & in_kit) const;
34767 
34771  bool operator!=(LinePatternOptionsKit const & in_kit) const;
34772 
34776  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
34777 
34781  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
34782 
34786  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
34787 
34791  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
34792 
34796  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
34797 
34801  LinePatternOptionsKit & SetJoin(char const * in_glyph);
34802 
34806  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
34807 
34811  LinePatternOptionsKit & UnsetStartCap();
34812 
34816  LinePatternOptionsKit & UnsetEndCap();
34817 
34820  LinePatternOptionsKit & UnsetInnerCap();
34821 
34825  LinePatternOptionsKit & UnsetJoin();
34826 
34829  LinePatternOptionsKit & UnsetEverything();
34830 
34836  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
34837 
34843  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
34844 
34848  bool ShowInnerCap(LinePattern::Cap & out_type) const;
34849 
34855  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
34856 };
34857 
34860 class HPS_API LinePatternElement : public Object
34861 {
34862 public:
34865 
34868  LinePatternElement(LinePatternElement const & in_that);
34869 
34874 
34878  LinePatternElement & operator=(LinePatternElement && in_that);
34879 
34880  ~LinePatternElement();
34881 
34882  Type ObjectType() const { return Type::LinePatternElement; };
34883 
34886  void Set(LinePatternElement const & in_that);
34887 
34891  LinePatternElement & operator=(LinePatternElement const & in_that);
34892 
34896  bool Equals(LinePatternElement const & in_that) const;
34897 
34901  bool operator==(LinePatternElement const & in_that) const;
34902 
34906  bool operator!=(LinePatternElement const & in_that) const;
34907 
34911  void SetSize(float in_size, LinePattern::SizeUnits in_units);
34912 
34917  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
34918 };
34919 
34922 {
34923 public:
34926 
34932 
34936 
34940  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
34941 
34946 
34950  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
34951 
34953 
34954  Type ObjectType() const { return Type::SolidLinePatternElement; };
34955 
34959  void SetColor(RGBAColor const & in_color);
34960 
34964  void SetMaterialByIndex(float in_material_index);
34965 
34971  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
34972 };
34973 
34974 
34977 {
34978 public:
34981 
34987 
34991 
34995  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
34996 
35001 
35005  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
35006 
35008 
35009  Type ObjectType() const { return Type::BlankLinePatternElement; };
35010 };
35011 
35012 
35015 {
35016 public:
35019 
35025 
35029 
35033  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
35034 
35039 
35043  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
35044 
35046 
35047  Type ObjectType() const { return Type::GlyphLinePatternElement; };
35048 
35051  void SetSource(char const * in_source);
35052 
35056  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
35057 
35060  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
35061 
35064  void SetMirror(bool in_state);
35065 
35068  void SetFixed(bool in_state);
35069 
35072  void SetRotation(float in_degrees);
35073 
35077  bool ShowSource(UTF8 & out_source) const;
35078 
35083  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
35084 
35088  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
35089 
35093  bool ShowMirror(bool & out_state) const;
35094 
35098  bool ShowFixed(bool & out_state) const;
35099 
35103  bool ShowRotation(float & out_degrees) const;
35104 };
35105 
35107 class HPS_API LinePatternParallelKit : public Object
35108 {
35109 public:
35112 
35116 
35121 
35125  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
35126 
35127  virtual ~LinePatternParallelKit();
35128 
35129  Type ObjectType() const { return Type::LinePatternParallelKit; };
35130 
35133  void Set(LinePatternParallelKit const & in_kit);
35134 
35137  void Show(LinePatternParallelKit & out_kit) const;
35138 
35142  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
35143 
35146  bool Empty() const;
35147 
35151  bool Equals(LinePatternParallelKit const & in_kit) const;
35152 
35156  bool operator==(LinePatternParallelKit const & in_kit) const;
35157 
35161  bool operator!=(LinePatternParallelKit const & in_kit) const;
35162 
35166  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
35167 
35171  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
35172 
35176  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
35177 
35181  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
35182 
35187  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
35188 
35192  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
35193 
35197  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
35198 
35202  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
35203 
35210  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
35211 
35217  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
35218 
35222  LinePatternParallelKit & SetContinuous(bool in_state);
35223 
35226  LinePatternParallelKit & UnsetStartCap();
35227 
35230  LinePatternParallelKit & UnsetEndCap();
35231 
35234  LinePatternParallelKit & UnsetJoin();
35235 
35238  LinePatternParallelKit & UnsetBody();
35239 
35242  LinePatternParallelKit & UnsetAbsoluteLength();
35243 
35246  LinePatternParallelKit & UnsetAbsoluteWeight();
35247 
35250  LinePatternParallelKit & UnsetJustification();
35251 
35254  LinePatternParallelKit & UnsetOffset();
35255 
35258  LinePatternParallelKit & UnsetWeight();
35259 
35262  LinePatternParallelKit & UnsetContinuous();
35263 
35266  LinePatternParallelKit & UnsetEverything();
35267 
35271  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
35272 
35276  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
35277 
35281  bool ShowJoin(GlyphLinePatternElement & out_join) const;
35282 
35286  bool ShowBody(LinePatternElementArray & out_elements) const;
35287 
35291  bool ShowAbsoluteLength(bool & out_state) const;
35292 
35296  bool ShowAbsoluteWeight(bool & out_state) const;
35297 
35301  bool ShowJustification(LinePattern::Justification & out_type) const;
35302 
35308  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
35309 
35315  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
35316 
35320  bool ShowContinuous(bool & out_state) const;
35321 };
35322 
35323 
35325 class HPS_API LinePatternKit : public Object
35326 {
35327 public:
35329  LinePatternKit();
35330 
35333  LinePatternKit(LinePatternKit const & in_kit);
35334 
35338  LinePatternKit(LinePatternKit && in_that);
35339 
35343  LinePatternKit & operator=(LinePatternKit && in_that);
35344 
35345  virtual ~LinePatternKit();
35346 
35347  Type ObjectType() const { return Type::LinePatternKit; };
35348 
35352  static LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
35353 
35356  void Set(LinePatternKit const & in_kit);
35357 
35360  void Show(LinePatternKit & out_kit) const;
35361 
35365  LinePatternKit & operator=(LinePatternKit const & in_kit);
35366 
35369  bool Empty() const;
35370 
35374  bool Equals(LinePatternKit const & in_kit) const;
35375 
35379  bool operator==(LinePatternKit const & in_kit) const;
35380 
35384  bool operator!=(LinePatternKit const & in_kit) const;
35385 
35389  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
35390 
35395  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
35396 
35400  LinePatternKit & SetJoin(LinePattern::Join in_type);
35401 
35404  LinePatternKit & UnsetParallels();
35405 
35408  LinePatternKit & UnsetJoin();
35409 
35412  LinePatternKit & UnsetEverything();
35413 
35417  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
35418 
35422  bool ShowJoin(LinePattern::Join & out_type) const;
35423 };
35424 
35425 
35426 
35430 
35431 
35433 class HPS_API Definition : public Object
35434 {
35435 public:
35437  Definition();
35438 
35441  Definition(Definition const & in_that);
35442 
35446  Definition & operator=(Definition const & in_that);
35447 
35451  Definition(Definition && in_that);
35452 
35456  Definition & operator=(Definition && in_that);
35457 
35458  virtual ~Definition();
35459 
35460  Type ObjectType() const { return Type::Definition; };
35461 
35463  void Undefine();
35464 
35467  PortfolioKey Owner() const;
35468 
35471  UTF8 Name() const;
35472 
35475  virtual void Assign(Definition const & in_that);
35476 
35480  bool Equals(Definition const & in_that) const;
35481 
35485  bool operator==(Definition const & in_that) const;
35486 
35490  bool operator!=(Definition const & in_that) const;
35491 };
35492 
35493 
35496 class HPS_API PortfolioKey : public Key
35497 {
35498 public:
35500  PortfolioKey();
35501 
35506  explicit PortfolioKey(Key const & in_that);
35507 
35510  PortfolioKey(PortfolioKey const & in_that);
35511 
35515  PortfolioKey & operator=(PortfolioKey const & in_that);
35516 
35520  PortfolioKey(PortfolioKey && in_that);
35521 
35525  PortfolioKey & operator=(PortfolioKey && in_that);
35526 
35527  ~PortfolioKey();
35528 
35529  Type ObjectType() const { return Type::PortfolioKey; };
35530 
35531  // Define
35532 
35539  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
35540 
35548  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
35549 
35550 
35562  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
35563  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
35564  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
35565 
35578  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
35579  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
35580  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
35581 
35582 
35588  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
35589 
35590 
35596  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
35597 
35598 
35604  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
35605 
35612  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
35613 
35614 
35620  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
35621 
35622 
35628  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
35629 
35630 
35636  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
35637 
35638 
35639  // UnDefine
35640 
35644  PortfolioKey & UndefineTexture(char const * in_name);
35645 
35649  PortfolioKey & UndefineCubeMap(char const * in_name);
35650 
35654  PortfolioKey & UndefineImage(char const * in_name);
35655 
35659  PortfolioKey & UndefineNamedStyle(char const * in_name);
35660 
35664  PortfolioKey & UndefineMaterialPalette(char const * in_name);
35665 
35669  PortfolioKey & UndefineGlyph(char const * in_name);
35670 
35674  PortfolioKey & UndefineLinePattern(char const * in_name);
35675 
35679  PortfolioKey & UndefineShader(char const * in_name);
35680 
35681 
35682  // Import collections
35688  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35689 
35690 
35696  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35697 
35703  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35704 
35710  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35711 
35717  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35718 
35724  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35725 
35731  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35732 
35738  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35739 
35745  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35746 
35747 
35748  // Import individual definitions
35752  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
35753 
35757  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
35758 
35762  ImageDefinition ImportImage(ImageDefinition const & in_definition);
35763 
35767  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
35768 
35772  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
35773 
35777  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
35778 
35782  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
35783 
35787  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
35788 
35789 
35790  // Show
35792  size_t GetDefinitionCount() const;
35793 
35795  size_t GetTextureDefinitionCount() const;
35796 
35798  size_t GetCubeMapDefinitionCount() const;
35799 
35801  size_t GetImageDefinitionCount() const;
35802 
35804  size_t GetNamedStyleDefinitionCount() const;
35805 
35807  size_t GetMaterialPaletteDefinitionCount() const;
35808 
35810  size_t GetGlyphDefinitionCount() const;
35811 
35813  size_t GetLinePatternDefinitionCount() const;
35814 
35816  size_t GetShaderDefinitionCount() const;
35817 
35822  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
35823 
35827  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
35828 
35833  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
35834 
35838  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
35839 
35844  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
35845 
35849  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
35850 
35855  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
35856 
35860  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
35861 
35866  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
35867 
35871  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
35872 
35877  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
35878 
35882  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
35883 
35888  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
35889 
35893  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
35894 
35899  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
35900 
35904  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
35905 
35906 private:
35908  void MoveTo(SegmentKey const & in_new_owner);
35909 
35911  Key CopyTo(SegmentKey const & in_destination) const;
35912 };
35913 
35914 
35915 
35917 class HPS_API GlyphDefinition : public Definition
35918 {
35919 public:
35921  GlyphDefinition();
35922 
35927  GlyphDefinition(Definition const & in_that);
35928 
35931  GlyphDefinition(GlyphDefinition const & in_that);
35932 
35936  GlyphDefinition & operator=(GlyphDefinition const & in_that);
35937 
35941  GlyphDefinition(GlyphDefinition && in_that);
35942 
35946  GlyphDefinition & operator=(GlyphDefinition && in_that);
35947 
35948  ~GlyphDefinition();
35949 
35950  Type ObjectType() const { return Type::GlyphDefinition; };
35951 
35954  void Set(GlyphKit const & in_kit);
35955 
35958  void Show(GlyphKit & out_kit) const;
35959 };
35960 
35961 
35963 class HPS_API TextureDefinition : public Definition
35964 {
35965 public:
35968 
35973  TextureDefinition(Definition const & in_that);
35974 
35977  TextureDefinition(TextureDefinition const & in_that);
35978 
35982  TextureDefinition & operator=(TextureDefinition const & in_that);
35983 
35988 
35992  TextureDefinition & operator=(TextureDefinition && in_that);
35993 
35994  ~TextureDefinition();
35995 
35996  Type ObjectType() const { return Type::TextureDefinition; };
35997 
36000  void SetSource(ImageDefinition const & in_source);
36001 
36004  void ShowSource(ImageDefinition & out_source) const;
36005 
36008  void SetOptions(TextureOptionsKit const & in_options);
36009 
36012  void ShowOptions(TextureOptionsKit & out_options) const;
36013 
36014 };
36015 
36019 class HPS_API TextureOptionsKit : public Object
36020 {
36021 public:
36024 
36027  TextureOptionsKit(TextureOptionsKit const & in_kit);
36028 
36033 
36037  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
36038 
36039  virtual ~TextureOptionsKit();
36040 
36041  Type ObjectType() const { return Type::TextureOptionsKit; };
36042 
36046  static TextureOptionsKit GetDefault();
36047 
36050  void Set(TextureOptionsKit const & in_kit);
36051 
36054  void Show(TextureOptionsKit & out_kit) const;
36055 
36059  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
36060 
36063  bool Empty() const;
36064 
36068  bool Equals(TextureOptionsKit const & in_kit) const;
36069 
36073  bool operator==(TextureOptionsKit const & in_kit) const;
36074 
36078  bool operator!=(TextureOptionsKit const & in_kit) const;
36079 
36084  TextureOptionsKit & SetDecal(bool in_state);
36085 
36089  TextureOptionsKit & SetDownSampling(bool in_state);
36090 
36094  TextureOptionsKit & SetModulation(bool in_state);
36095 
36099  TextureOptionsKit & SetParameterOffset(size_t in_offset);
36100 
36104  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
36105 
36109  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
36110 
36114  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
36115 
36119  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
36120 
36124  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
36125 
36128  TextureOptionsKit & UnsetDecal();
36129 
36132  TextureOptionsKit & UnsetDownSampling();
36133 
36136  TextureOptionsKit & UnsetModulation();
36137 
36140  TextureOptionsKit & UnsetParameterOffset();
36141 
36144  TextureOptionsKit & UnsetParameterizationSource();
36145 
36148  TextureOptionsKit & UnsetTiling();
36149 
36152  TextureOptionsKit & UnsetInterpolationFilter();
36153 
36156  TextureOptionsKit & UnsetDecimationFilter();
36157 
36160  TextureOptionsKit & UnsetTransformMatrix();
36161 
36164  TextureOptionsKit & UnsetEverything();
36165 
36169  bool ShowDecal(bool & out_state) const;
36170 
36174  bool ShowDownSampling(bool & out_state) const;
36175 
36179  bool ShowModulation(bool & out_state) const;
36180 
36184  bool ShowParameterOffset(size_t & out_offset) const;
36185 
36189  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
36190 
36194  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
36195 
36199  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
36200 
36204  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
36205 
36209  bool ShowTransformMatrix(MatrixKit & out_transform) const;
36210 };
36211 
36212 
36214 class HPS_API Image
36215 {
36216 public:
36219  enum class Format
36220  {
36221  RGB,
36222  RGBA,
36223  ARGB,
36224  Mapped8,
36225  Grayscale,
36226  Jpeg,
36227  Png,
36228  Targa,
36229  DXT1,
36230  DXT3,
36231  DXT5
36232  };
36233 
36235  class HPS_API ExportOptionsKit : public Object
36236  {
36237  public:
36239  ExportOptionsKit();
36240 
36243  ExportOptionsKit(ExportOptionsKit const & in_kit);
36244 
36248  ExportOptionsKit(ExportOptionsKit && in_that);
36249 
36253  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
36254 
36255  virtual ~ExportOptionsKit();
36256 
36257  Type ObjectType() const { return Type::ImageExportOptionsKit; };
36258 
36262  static ExportOptionsKit GetDefault();
36263 
36266  void Set(ExportOptionsKit const & in_kit);
36267 
36270  void Show(ExportOptionsKit & out_kit) const;
36271 
36275  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
36276 
36279  bool Empty() const;
36280 
36284  bool Equals(ExportOptionsKit const & in_kit) const;
36285 
36289  bool operator==(ExportOptionsKit const & in_kit) const;
36290 
36294  bool operator!=(ExportOptionsKit const & in_kit) const;
36295 
36300  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
36301 
36306  ExportOptionsKit & SetFormat(Image::Format in_format);
36307 
36310  ExportOptionsKit & UnsetSize();
36311 
36314  ExportOptionsKit & UnsetFormat();
36315 
36318  ExportOptionsKit & UnsetEverything();
36319 
36324  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36325 
36329  bool ShowFormat(Image::Format & out_format) const;
36330  };
36331 
36333  class HPS_API ImportOptionsKit : public Object
36334  {
36335  public:
36337  ImportOptionsKit();
36338 
36341  ImportOptionsKit(ImportOptionsKit const & in_kit);
36342 
36346  ImportOptionsKit(ImportOptionsKit && in_that);
36347 
36351  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
36352 
36353  virtual ~ImportOptionsKit();
36354 
36355  Type ObjectType() const { return Type::ImageImportOptionsKit; };
36356 
36359  void Set(ImportOptionsKit const & in_kit);
36360 
36363  void Show(ImportOptionsKit & out_kit) const;
36364 
36368  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
36369 
36372  bool Empty() const;
36373 
36377  bool Equals(ImportOptionsKit const & in_kit) const;
36378 
36382  bool operator==(ImportOptionsKit const & in_kit) const;
36383 
36387  bool operator!=(ImportOptionsKit const & in_kit) const;
36388 
36395  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
36396 
36400  ImportOptionsKit & SetFormat(Image::Format in_format);
36401 
36406  ImportOptionsKit & SetDownSampling(bool in_state);
36407 
36412  ImportOptionsKit & SetCompressionQuality(float in_quality);
36413 
36416  ImportOptionsKit & UnsetSize();
36417 
36420  ImportOptionsKit & UnsetFormat();
36421 
36424  ImportOptionsKit & UnsetDownSampling();
36425 
36428  ImportOptionsKit & UnsetCompressionQuality();
36429 
36432  ImportOptionsKit & UnsetEverything();
36433 
36438  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36439 
36443  bool ShowFormat(Image::Format & out_format) const;
36444 
36448  bool ShowDownSampling(bool & out_state) const;
36449 
36453  bool ShowCompressionQuality(float & out_quality) const;
36454  };
36455 
36457  class HPS_API File
36458  {
36459  public:
36465  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
36466 
36473  static void Export(char const * in_file_name, WindowKey const & in_window, ExportOptionsKit const & in_options);
36474 
36482  static void Export(char const * in_file_name, WindowKey const & in_window, unsigned int in_width, unsigned int in_height, Format in_format = Format::Png);
36483 
36488  static void Export(char const * in_file_name, ImageKit const & in_image_kit);
36489 
36490  private:
36492  File();
36493  };
36494 
36495 private:
36497  Image();
36498 };
36499 
36500 
36502 class HPS_API ImageKit : public Object
36503 {
36504 public:
36506  ImageKit();
36507 
36510  ImageKit(ImageKit const & in_kit);
36511 
36516  ImageKit(ImageKit const & in_kit, Image::Format in_format);
36517 
36521  ImageKit(ImageKit && in_that);
36522 
36526  ImageKit & operator=(ImageKit && in_that);
36527 
36528  virtual ~ImageKit();
36529 
36530  Type ObjectType() const { return Type::ImageKit; };
36531 
36534  void Set(ImageKit const & in_kit);
36535 
36538  void Show(ImageKit & out_kit) const;
36539 
36543  ImageKit & operator=(ImageKit const & in_kit);
36544 
36547  bool Empty() const;
36548 
36552  bool Equals(ImageKit const & in_kit) const;
36553 
36557  bool operator==(ImageKit const & in_kit) const;
36558 
36562  bool operator!=(ImageKit const & in_kit) const;
36563 
36567  void Convert(ImageKit const & in_kit, Image::Format in_format);
36568 
36571  void Convert(Image::Format in_format);
36572 
36577  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
36578 
36582  ImageKit & SetData(ByteArray const & in_image_data);
36583 
36588  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
36589 
36593  ImageKit & SetFormat(Image::Format in_format);
36594 
36598  ImageKit & SetDownSampling(bool in_state);
36599 
36603  ImageKit & SetCompressionQuality(float in_quality);
36604 
36607  ImageKit & UnsetSize();
36608 
36611  ImageKit & UnsetData();
36612 
36615  ImageKit & UnsetFormat();
36616 
36619  ImageKit & UnsetDownSampling();
36620 
36623  ImageKit & UnsetCompressionQuality();
36624 
36627  ImageKit & UnsetEverything();
36628 
36633  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36634 
36638  bool ShowData(ByteArray & out_image_data) const;
36639 
36643  bool ShowFormat(Image::Format & out_format) const;
36644 
36648  bool ShowDownSampling(bool & out_state) const;
36649 
36653  bool ShowCompressionQuality(float & out_quality) const;
36654 };
36655 
36656 
36662 {
36663 public:
36667 
36672 
36677 
36682 
36684 
36685  Type ObjectType() const { return Type::OffScreenWindowOptionsControl; };
36686 
36690  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
36691 
36696  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
36697 
36701  bool ShowDriver(Window::Driver & out_driver) const;
36702 
36707  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
36708 
36713  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36714 
36719  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
36720 
36724  bool ShowHardwareResident(bool & out_state) const;
36725 
36730  bool ShowOpacity(bool & out_state, float & out_opacity) const;
36731 
36732 private:
36735 };
36736 
36737 
36740 class HPS_API OffScreenWindowKey : public WindowKey
36741 {
36742 public:
36745 
36750  OffScreenWindowKey(Key const & in_key);
36751 
36754  OffScreenWindowKey(OffScreenWindowKey const & in_that);
36755 
36760 
36764  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
36765 
36766  ~OffScreenWindowKey();
36767 
36768  Type ObjectType() const { return Type::OffScreenWindowKey; };
36769 
36772  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
36773 
36776  OffScreenWindowOptionsControl GetWindowOptionsControl();
36777 
36781  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
36782 };
36783 
36784 
36785 
36786 
36788 class HPS_API ImageDefinition : public Definition
36789 {
36790 public:
36792  ImageDefinition();
36793 
36798  ImageDefinition(Definition const & in_that);
36799 
36802  ImageDefinition(ImageDefinition const & in_that);
36803 
36807  ImageDefinition & operator=(ImageDefinition const & in_that);
36808 
36812  ImageDefinition(ImageDefinition && in_that);
36813 
36817  ImageDefinition & operator=(ImageDefinition && in_that);
36818 
36819  ~ImageDefinition();
36820 
36821  Type ObjectType() const { return Type::ImageDefinition; };
36822 
36825  void Set(ImageKit const & in_kit);
36826 
36829  void Show(ImageKit & out_kit) const;
36830 };
36831 
36833 class HPS_API CubeMapDefinition : public Definition
36834 {
36835 public:
36838 
36843  CubeMapDefinition(Definition const & in_that);
36844 
36847  CubeMapDefinition(CubeMapDefinition const & in_that);
36848 
36852  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
36853 
36858 
36862  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
36863 
36864  ~CubeMapDefinition();
36865 
36866  Type ObjectType() const { return Type::CubeMapDefinition; };
36867 
36875  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36876  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36877  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
36878 
36886  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
36887  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
36888  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
36889 
36893  void ShowSource(ImageDefinitionArray & out_image_sources) const;
36894 
36897  void SetOptions(TextureOptionsKit const & in_options);
36898 
36901  void ShowOptions(TextureOptionsKit & out_options) const;
36902 };
36903 
36904 
36906 class HPS_API NamedStyleDefinition : public Definition
36907 {
36908 public:
36911 
36916  NamedStyleDefinition(Definition const & in_that);
36917 
36920  NamedStyleDefinition(NamedStyleDefinition const & in_that);
36921 
36925  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
36926 
36931 
36935  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
36936 
36938 
36939  Type ObjectType() const { return Type::NamedStyleDefinition; };
36940 
36944  SegmentKey GetSource() const;
36945 };
36946 
36947 
36950 {
36951 public:
36954 
36959  MaterialPaletteDefinition(Definition const & in_that);
36960 
36964 
36968  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
36969 
36974 
36978  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
36979 
36981 
36982  Type ObjectType() const { return Type::MaterialPaletteDefinition; };
36983 
36986  void Set(MaterialKitArray const & in_source);
36987 
36991  void Set(size_t in_count, MaterialKit const in_source []);
36992 
36995  void Show(MaterialKitArray & out_source) const;
36996 };
36997 
36998 
36999 
37001 class HPS_API LinePatternDefinition : public Definition
37002 {
37003 public:
37006 
37011  LinePatternDefinition(Definition const & in_that);
37012 
37016 
37020  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
37021 
37026 
37030  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
37031 
37033 
37034  Type ObjectType() const { return Type::LinePatternDefinition; };
37035 
37038  void Set(LinePatternKit const & in_kit);
37039 
37042  void Show(LinePatternKit & out_kit) const;
37043 };
37044 
37045 
37046 
37048 class HPS_API Shader
37049 {
37050 public:
37053  enum class Parameterization
37054  {
37056  Cylinder,
37058  PhysicalReflection,
37060  Object,
37066  NaturalUV,
37068  ReflectionVector,
37070  SurfaceNormal,
37072  Sphere,
37074  UV,
37076  World
37077  };
37078 
37080  class HPS_API ImportOptionsKit : public Object
37081  {
37082  public:
37084  ImportOptionsKit();
37085 
37088  ImportOptionsKit(ImportOptionsKit const & in_kit);
37089 
37093  ImportOptionsKit(ImportOptionsKit && in_that);
37094 
37098  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37099 
37100  virtual ~ImportOptionsKit();
37101 
37102  Type ObjectType() const { return Type::ShaderImportOptionsKit; };
37103 
37106  void Set(ImportOptionsKit const & in_kit);
37107 
37110  void Show(ImportOptionsKit & out_kit) const;
37111 
37115  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37116 
37119  bool Empty() const;
37120 
37124  bool Equals(ImportOptionsKit const & in_kit) const;
37125 
37129  bool operator==(ImportOptionsKit const & in_kit) const;
37130 
37134  bool operator!=(ImportOptionsKit const & in_kit) const;
37135 
37142  ImportOptionsKit & SetMultitexture(bool in_state);
37143 
37147  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
37148 
37152  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
37153 
37157  ImportOptionsKit & UnsetMultitexture();
37158 
37161  ImportOptionsKit & UnsetParameterizationSource();
37162 
37165  ImportOptionsKit & UnsetTransformMatrix();
37166 
37169  ImportOptionsKit & UnsetEverything();
37170 
37176  bool ShowMultitexture(bool & out_state) const;
37177 
37181  bool ShowParameterizationSource(Parameterization & out_source) const;
37182 
37186  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37187  };
37188 
37190  class HPS_API File
37191  {
37192  public:
37198  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
37199 
37200  private:
37202  File();
37203  };
37204 
37205 private:
37207  Shader();
37208 };
37209 
37210 
37212 class HPS_API ShaderKit : public Object
37213 {
37214 public:
37216  ShaderKit();
37217 
37220  ShaderKit(ShaderKit const & in_kit);
37221 
37225  ShaderKit(ShaderKit && in_that);
37226 
37230  ShaderKit & operator=(ShaderKit && in_that);
37231 
37232  virtual ~ShaderKit();
37233 
37234  Type ObjectType() const { return Type::ShaderKit; };
37235 
37238  void Set(ShaderKit const & in_kit);
37239 
37242  void Show(ShaderKit & out_kit) const;
37243 
37247  ShaderKit & operator=(ShaderKit const & in_kit);
37248 
37251  bool Empty() const;
37252 
37256  bool Equals(ShaderKit const & in_kit) const;
37257 
37261  bool operator==(ShaderKit const & in_kit) const;
37262 
37266  bool operator!=(ShaderKit const & in_kit) const;
37267 
37271  ShaderKit & SetSource(char const * in_source);
37272 
37279  ShaderKit & SetMultitexture(bool in_state);
37280 
37284  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
37285 
37289  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
37290 
37293  ShaderKit & UnsetSource();
37294 
37298  ShaderKit & UnsetMultitexture();
37299 
37302  ShaderKit & UnsetParameterizationSource();
37303 
37306  ShaderKit & UnsetTransformMatrix();
37307 
37310  ShaderKit & UnsetEverything();
37311 
37315  bool ShowSource(UTF8 & out_source) const;
37316 
37322  bool ShowMultitexture(bool & out_state) const;
37323 
37327  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
37328 
37332  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37333 };
37334 
37335 
37337 class HPS_API ShaderDefinition : public Definition
37338 {
37339 public:
37341  ShaderDefinition();
37342 
37347  ShaderDefinition(Definition const & in_that);
37348 
37351  ShaderDefinition(ShaderDefinition const & in_that);
37352 
37356  ShaderDefinition & operator=(ShaderDefinition const & in_that);
37357 
37361  ShaderDefinition(ShaderDefinition && in_that);
37362 
37366  ShaderDefinition & operator=(ShaderDefinition && in_that);
37367 
37368  ~ShaderDefinition();
37369 
37370  Type ObjectType() const { return Type::ShaderDefinition; };
37371 
37374  void Set(ShaderKit const & in_kit);
37375 
37378  void Show(ShaderKit & out_kit) const;
37379 };
37380 
37381 
37382 
37383 
37387 
37389 {
37390 public:
37393 
37397 
37402 
37407 
37408  virtual ~CutGeometryGatheringOptionsKit();
37409 
37410  Type ObjectType() const {return Type::CutGeometryGatheringOptionsKit;};
37411 
37415  static CutGeometryGatheringOptionsKit GetDefault();
37416 
37419  void Set(CutGeometryGatheringOptionsKit const & in_kit);
37420 
37423  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
37424 
37429 
37432  bool Empty() const;
37433 
37437  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
37438 
37442  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
37443 
37447  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
37448 
37449 
37453  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
37454 
37458  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
37459 
37464 
37465 
37468  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
37469 
37472  CutGeometryGatheringOptionsKit & UnsetOffset();
37473 
37476  CutGeometryGatheringOptionsKit & UnsetLevel();
37477 
37480  CutGeometryGatheringOptionsKit & UnsetEverything();
37481 
37482 
37486  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
37487 
37491  bool ShowOffset(size_t & out_offset) const;
37492 
37496  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
37497 };
37498 
37500 class HPS_API SearchOptionsKit : public Object
37501 {
37502 public:
37504  SearchOptionsKit();
37505 
37508  SearchOptionsKit(SearchOptionsKit const & in_kit);
37509 
37513  SearchOptionsKit(SearchOptionsKit && in_that);
37514 
37518  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
37519 
37520  virtual ~SearchOptionsKit();
37521 
37522  Type ObjectType() const {return Type::SearchOptionsKit;};
37523 
37527  static SearchOptionsKit GetDefault();
37528 
37531  void Set(SearchOptionsKit const & in_kit);
37532 
37535  void Show(SearchOptionsKit & out_kit) const;
37536 
37540  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
37541 
37544  bool Empty() const;
37545 
37549  bool Equals(SearchOptionsKit const & in_kit) const;
37550 
37554  bool operator==(SearchOptionsKit const & in_kit) const;
37555 
37559  bool operator!=(SearchOptionsKit const & in_kit) const;
37560 
37564  SearchOptionsKit & SetCriteria(Search::Type in_request);
37565 
37569  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
37570 
37574  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
37575 
37580  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
37581 
37585  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
37586 
37589  SearchOptionsKit & UnsetBehavior();
37590 
37593  SearchOptionsKit & UnsetCriteria();
37594 
37597  SearchOptionsKit & UnsetSearchSpace();
37598 
37601  SearchOptionsKit & UnsetEverything();
37602 
37606  bool ShowBehavior(Search::Behavior & out_behavior) const;
37607 
37611  bool ShowCriteria(SearchTypeArray & out_types) const;
37612 
37616  bool ShowSearchSpace(Search::Space & out_search_space) const;
37617 };
37618 
37622 class HPS_API TreeContext : public Object
37623 {
37624 public:
37627  TreeContext(bool in_create = true);
37628 
37631  TreeContext(TreeContext const & in_that);
37632 
37636  TreeContext(TreeContext && in_that);
37637 
37641  TreeContext & operator=(TreeContext && in_that);
37642 
37644  virtual ~TreeContext();
37645 
37646  Type ObjectType() const {return Type::TreeContext;};
37647 
37651  TreeContext & operator=(TreeContext const & in_that);
37652 
37656  bool Equals(TreeContext const & in_that) const;
37657 
37661  bool operator==(TreeContext const & in_that) const;
37662 
37666  bool operator!=(TreeContext const & in_that) const;
37667 
37668 };
37669 
37671 class HPS_API SelectionOptionsKit : public Object
37672 {
37673 public:
37676 
37679  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
37680 
37685 
37689  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
37690 
37691  virtual ~SelectionOptionsKit();
37692 
37693  Type ObjectType() const {return Type::SelectionOptionsKit;};
37694 
37698  static SelectionOptionsKit GetDefault();
37699 
37702  void Set(SelectionOptionsKit const & in_kit);
37703 
37706  void Show(SelectionOptionsKit & out_kit) const;
37707 
37711  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
37712 
37715  bool Empty() const;
37716 
37720  bool Equals(SelectionOptionsKit const & in_kit) const;
37721 
37725  bool operator==(SelectionOptionsKit const & in_kit) const;
37726 
37730  bool operator!=(SelectionOptionsKit const & in_kit) const;
37731 
37739  SelectionOptionsKit & SetProximity(float in_proximity);
37740 
37746  SelectionOptionsKit & SetLevel(Selection::Level in_level);
37747 
37752  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
37753 
37762  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
37763 
37771  SelectionOptionsKit & SetSorting(bool in_sorted);
37772 
37778  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
37779 
37785  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
37786 
37791  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
37792 
37797  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
37798 
37803  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
37804 
37811  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
37812 
37819  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
37820 
37827  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
37828 
37835  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
37836 
37839  SelectionOptionsKit & UnsetProximity();
37840 
37843  SelectionOptionsKit & UnsetLevel();
37844 
37847  SelectionOptionsKit & UnsetInternalLimit();
37848 
37851  SelectionOptionsKit & UnsetRelatedLimit();
37852 
37855  SelectionOptionsKit & UnsetSorting();
37856 
37859  SelectionOptionsKit & UnsetAlgorithm();
37860 
37863  SelectionOptionsKit & UnsetGranularity();
37864 
37867  SelectionOptionsKit & UnsetScope();
37868 
37871  SelectionOptionsKit & UnsetTreeContext();
37872 
37875  SelectionOptionsKit & UnsetExtentCullingRespected();
37876 
37879  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
37880 
37883  SelectionOptionsKit & UnsetFrustumCullingRespected();
37884 
37887  SelectionOptionsKit & UnsetVectorCullingRespected();
37888 
37889 
37892  SelectionOptionsKit & UnsetEverything();
37893 
37897  bool ShowProximity(float & out_proximity) const;
37898 
37902  bool ShowLevel(Selection::Level & out_level) const;
37903 
37907  bool ShowInternalLimit(size_t & out_limit) const;
37908 
37912  bool ShowRelatedLimit(size_t & out_limit) const;
37913 
37917  bool ShowSorting(bool & out_sorted) const;
37918 
37922  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
37923 
37927  bool ShowGranularity(Selection::Granularity & out_granularity) const;
37928 
37932  bool ShowScope(KeyPath & out_start_path) const;
37933 
37937  bool ShowTreeContext(TreeContext & out_tree_context) const;
37938 
37942  bool ShowExtentCullingRespected(bool & out_state) const;
37943 
37947  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
37948 
37952  bool ShowFrustumCullingRespected(bool & out_state) const;
37953 
37957  bool ShowVectorCullingRespected(bool & out_state) const;
37958 };
37959 
37960 
37961 
37965 class HPS_API SelectionOptionsControl : public Control
37966 {
37967 public:
37970  explicit SelectionOptionsControl(WindowKey const & in_window);
37971 
37975 
37980 
37984  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
37985 
37987 
37988  Type ObjectType() const {return Type::SelectionOptionsControl;};
37989 
37993  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
37994 
38000  SelectionOptionsControl & SetProximity(float in_proximity);
38001 
38007  SelectionOptionsControl & SetLevel(Selection::Level in_level);
38008 
38015  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
38016 
38025  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
38026 
38034  SelectionOptionsControl & SetSorting(bool in_sorted);
38035 
38041  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
38042 
38048  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
38049 
38056  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
38057 
38064  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
38065 
38072  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
38073 
38080  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
38081 
38082  // there is no way to unset default values, intentionally
38083 
38087  bool ShowProximity(float & out_proximity) const;
38088 
38092  bool ShowLevel(Selection::Level & out_level) const;
38093 
38097  bool ShowInternalLimit(size_t & out_limit) const;
38098 
38102  bool ShowRelatedLimit(size_t & out_limit) const;
38103 
38107  bool ShowSorting(bool & out_sorted) const;
38108 
38112  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38113 
38117  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38118 
38122  bool ShowExtentCullingRespected(bool & out_state) const;
38123 
38127  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38128 
38132  bool ShowFrustumCullingRespected(bool & out_state) const;
38133 
38137  bool ShowVectorCullingRespected(bool & out_state) const;
38138 
38139 private:
38142 };
38143 
38144 
38145 
38147 class HPS_API SelectionItem : public Object
38148 {
38149 public:
38151  SelectionItem();
38152 
38155  SelectionItem(SelectionItem const & in_that);
38156 
38160  SelectionItem(SelectionItem && in_that);
38161 
38165  SelectionItem & operator=(SelectionItem && in_that);
38166 
38167  virtual ~SelectionItem();
38168 
38169  Type ObjectType() const {return Type::SelectionItem;};
38170 
38173  void Set(SelectionItem const & in_that);
38174 
38178  SelectionItem & operator=(SelectionItem const & in_that);
38179 
38183  bool Equals(SelectionItem const & in_that) const;
38184 
38188  bool operator==(SelectionItem const & in_that) const;
38189 
38193  bool operator!=(SelectionItem const & in_that) const;
38194 
38198  bool ShowSelectionLevel(Selection::Level & out_level) const;
38199 
38203  bool ShowSelectedItem(Key & out_selection) const;
38204 
38208  bool ShowPath(KeyPath & out_path) const;
38209 
38213  bool ShowFaces(SizeTArray & out_faces) const;
38214 
38218  bool ShowVertices(SizeTArray & out_vertices) const;
38219 
38224  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
38225 
38229  bool ShowCharacters(SizeTArray & out_characters) const;
38230 
38234  bool ShowSelectionPosition(WindowPoint & out_location) const;
38235 
38239  bool ShowSelectionPosition(WorldPoint & out_location) const;
38240 
38241 };
38242 
38244 class HPS_API SelectionResultsIterator : public Object
38245 {
38246 public:
38249 
38254 
38259 
38263  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
38264 
38266 
38267  Type ObjectType() const {return Type::SelectionResultsIterator;}
38268 
38272  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
38273 
38276  void Set(SelectionResultsIterator const & in_that);
38277 
38279  void Next();
38280 
38283  SelectionResultsIterator & operator++();
38284 
38287  SelectionResultsIterator operator++(int in_val);
38288 
38291  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
38292 
38295  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
38296 
38297 
38300  bool IsValid() const;
38301 
38303  void Reset();
38304 
38307  SelectionItem GetItem() const;
38308 
38311  SelectionItem operator*() const;
38312 
38313 
38314 };
38315 
38319 class HPS_API SelectionResults : public Object
38320 {
38321 public:
38323  SelectionResults();
38324 
38327  SelectionResults(SelectionResults const & in_that);
38328 
38332  SelectionResults(SelectionResults && in_that);
38333 
38337  SelectionResults & operator=(SelectionResults && in_that);
38338 
38339  ~SelectionResults();
38340 
38341  Type ObjectType() const {return Type::SelectionResults;}
38342 
38345  void Assign(SelectionResults const & in_that);
38346 
38350  SelectionResults & operator=(SelectionResults const & in_that);
38351 
38355  bool Equals(SelectionResults const & in_that) const;
38356 
38360  bool operator==(SelectionResults const & in_that) const;
38361 
38365  bool operator!=(SelectionResults const & in_that) const;
38366 
38368  virtual void Reset();
38369 
38372  Selection::Level GetSelectionLevel() const;
38373 
38376  size_t GetCount() const;
38377 
38380  SelectionResultsIterator GetIterator() const;
38381 
38387  bool Union(SelectionResults const & in_that);
38388 
38393  bool Intersect(SelectionResults const & in_that);
38394 
38400  bool SymmetricDifference(SelectionResults const & in_that);
38401 
38406  bool Difference(SelectionResults const & in_that);
38407 
38410  void Copy(SelectionResults const & in_that);
38411 };
38412 
38415 class HPS_API SelectionControl : public Object
38416 {
38417 public:
38420  explicit SelectionControl(WindowKey const & in_window);
38421 
38424  SelectionControl(SelectionControl const & in_that);
38425 
38429  SelectionControl(SelectionControl && in_that);
38430 
38434  SelectionControl & operator=(SelectionControl && in_that);
38435 
38436  ~SelectionControl();
38437 
38438  Type ObjectType() const {return Type::SelectionControl;};
38439 
38443  SelectionControl & operator=(SelectionControl const & in_that);
38444 
38450  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38451 
38456  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
38457 
38463  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38464 
38469  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
38470 
38476  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38477 
38482  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
38483 
38490  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38491 
38497  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
38498 
38504  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38505 
38510  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
38511 
38518  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38519 
38525  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
38526 
38527 
38528  //Object space selections
38529 
38535  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38536 
38541  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
38542 
38548  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38549 
38554  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
38555 
38556 
38563  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38564 
38570  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
38571 
38572 
38579  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38580 
38586  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
38587 
38588 private:
38590  SelectionControl();
38591 };
38592 
38593 
38594 
38596 class HPS_API HighlightOptionsKit : public Object
38597 {
38598 public:
38601 
38604  HighlightOptionsKit(char const * in_style_name);
38605 
38609  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
38610 
38613  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
38614 
38619 
38623  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
38624 
38625  virtual ~HighlightOptionsKit();
38626 
38627  Type ObjectType() const {return Type::HighlightOptionsKit;};
38628 
38632  static HighlightOptionsKit GetDefault();
38633 
38636  void Set(HighlightOptionsKit const & in_kit);
38637 
38640  void Show(HighlightOptionsKit & out_kit) const;
38641 
38645  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
38646 
38649  bool Empty() const;
38650 
38654  bool Equals(HighlightOptionsKit const & in_kit) const;
38655 
38659  bool operator==(HighlightOptionsKit const & in_kit) const;
38660 
38664  bool operator!=(HighlightOptionsKit const & in_kit) const;
38665 
38666 
38670  HighlightOptionsKit & SetStyleName(char const * in_style_name);
38671 
38675  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
38676 
38683  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
38684 
38690  HighlightOptionsKit & SetNotification(bool in_state);
38691 
38692 
38695  HighlightOptionsKit & UnsetStyleName();
38696 
38699  HighlightOptionsKit & UnsetSecondaryStyleName();
38700 
38703  HighlightOptionsKit & UnsetOverlay();
38704 
38707  HighlightOptionsKit & UnsetNotification();
38708 
38711  HighlightOptionsKit & UnsetEverything();
38712 
38713 
38717  bool ShowStyleName(UTF8 & out_style_name) const;
38718 
38722  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
38723 
38727  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
38728 
38732  bool ShowNotification(bool & out_state) const;
38733 };
38734 
38737 class HPS_API HighlightControl : public Control
38738 {
38739 public:
38742  explicit HighlightControl(WindowKey const & in_window);
38743 
38746  HighlightControl(HighlightControl const & in_that);
38747 
38751  HighlightControl(HighlightControl && in_that);
38752 
38756  HighlightControl & operator=(HighlightControl && in_that);
38757 
38758  ~HighlightControl();
38759 
38760  Type ObjectType() const {return Type::HighlightControl;};
38761 
38765  HighlightControl & operator=(HighlightControl const & in_that);
38766 
38771  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
38772 
38777  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
38778 
38783  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
38784 
38789  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
38790 
38795  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
38796 
38801  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38802 
38807  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38808 
38813  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38814 
38819  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38820 
38825  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38826 
38830  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
38831 
38834  HighlightControl & UnhighlightEverything();
38835 
38836 private:
38838  HighlightControl();
38839 };
38840 
38842 class HPS_API UpdateOptionsKit : public Object
38843 {
38844 public:
38846  UpdateOptionsKit();
38847 
38850  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
38851 
38855  UpdateOptionsKit(UpdateOptionsKit && in_that);
38856 
38860  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
38861 
38862  virtual ~UpdateOptionsKit();
38863 
38864  Type ObjectType() const {return Type::UpdateOptionsKit;};
38865 
38869  static UpdateOptionsKit GetDefault();
38870 
38873  void Set(UpdateOptionsKit const & in_kit);
38874 
38877  void Show(UpdateOptionsKit & out_kit) const;
38878 
38882  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
38883 
38886  bool Empty() const;
38887 
38891  bool Equals(UpdateOptionsKit const & in_kit) const;
38892 
38896  bool operator==(UpdateOptionsKit const & in_kit) const;
38897 
38901  bool operator!=(UpdateOptionsKit const & in_kit) const;
38902 
38906  UpdateOptionsKit & SetUpdateControl(Window::UpdateControl in_control);
38907 
38911  UpdateOptionsKit & SetTimeLimit(Time in_time_limit);
38912 
38915  UpdateOptionsKit & UnsetUpdateControl();
38916 
38919  UpdateOptionsKit & UnsetTimeLimit();
38920 
38923  UpdateOptionsKit & UnsetEverything();
38924 
38925 
38929  bool ShowUpdateControl(Window::UpdateControl & out_control) const;
38930 
38934  bool ShowTimeLimit(Time & out_time_limit) const;
38935 
38936 };
38937 
38938 
38939 
38945 class HPS_API UpdateOptionsControl : public Control
38946 {
38947 public:
38950  explicit UpdateOptionsControl(WindowKey const & in_window);
38951 
38954  UpdateOptionsControl(UpdateOptionsControl const & in_that);
38955 
38960 
38964  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
38965 
38967 
38968  Type ObjectType() const {return Type::UpdateOptionsControl;};
38969 
38973  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
38974 
38978  UpdateOptionsControl & SetUpdateControl(Window::UpdateControl in_control);
38979 
38983  UpdateOptionsControl & SetTimeLimit(Time in_time_limit);
38984 
38987  UpdateOptionsControl & UnsetUpdateControl();
38988 
38991  UpdateOptionsControl & UnsetTimeLimit();
38992 
38995  UpdateOptionsControl & UnsetEverything();
38996 
39000  bool ShowUpdateControl(Window::UpdateControl & out_control) const;
39001 
39005  bool ShowTimeLimit(Time & out_time_limit) const;
39006 
39007 private:
39010 };
39011 
39014 class HPS_API World : public Object
39015 {
39016 public:
39020  World(char const * in_license);
39021 
39023  ~World();
39024 
39025  Type ObjectType() const {return Type::World;};
39026 
39031  World & SetMaterialLibraryDirectory(char const * in_directory);
39032 
39037  World & SetFontDirectory(char const * in_directory);
39038 
39044  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
39045 
39050  World & SetFontDirectories(UTF8Array const & in_directories);
39051 
39057  World & SetDriverConfigFile(char const * in_filename);
39058 
39064  World & SetExchangeLibraryDirectory(char const * in_directory);
39065 
39071  World & SetPublishResourceDirectory(char const * in_directory);
39072 
39077  World & SetParasolidSchemaDirectory(char const * in_directory);
39078 
39081  World & UnsetMaterialLibraryDirectory();
39082 
39085  World & UnsetFontDirectories();
39086 
39089  World & UnsetDriverConfigFile();
39090 
39093  World & UnsetExchangeLibraryDirectory();
39094 
39097  World & UnsetPublishResourceDirectory();
39098 
39101  World & UnsetParasolidSchemaDirectory();
39102 
39106  bool ShowLicense(UTF8 & out_license) const;
39107 
39111  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
39112 
39116  bool ShowFontDirectories(UTF8Array & out_directories) const;
39117 
39121  bool ShowDriverConfigFile(UTF8 & out_filename) const;
39122 
39126  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
39127 
39131  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
39132 
39136  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
39137 
39138 
39139 private:
39141  World();
39142 
39144  virtual void Reset() {}
39145 };
39146 
39147 
39163 class HPS_API EmergencyHandler
39164 {
39165 public:
39166 
39169 
39170  virtual ~EmergencyHandler();
39171 
39173  intptr_t GetClassID() const;
39174 
39177  virtual EmergencyHandler * Clone() const = 0;
39178 
39182  virtual void Handle(const char * message, Emergency::Code code) const = 0;
39183 
39184  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
39185  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
39186 };
39187 
39188 
39191 class HPS_API Database
39192 {
39193 public:
39198  static void Execute(bool in_once=true);
39199 
39202  static Time GetTime();
39203 
39205  static void Sleep(Time milliseconds);
39206 
39231  static void RelinquishMemory();
39232 
39233 
39259  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
39260 
39268  static void Reset();
39269 
39271  static void Synchronize();
39272 
39275  static WindowKeyArray GetWindowKeys();
39276 
39279  static SegmentKeyArray GetRootSegments();
39280 
39283  static PortfolioKeyArray GetPortfolios();
39284 
39289  static PortfolioKey const GetMaterialLibraryPortfolio();
39290 
39296  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
39297 
39302  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
39303 
39307  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
39308 
39312  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
39313 
39320  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
39321 
39327  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
39328 
39334  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
39335 
39340  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
39341 
39344  static SegmentKey CreateRootSegment();
39345 
39348  static PortfolioKey CreatePortfolio();
39349 
39352  static EventDispatcher CreateEventDispatcher();
39353 
39357  static EventDispatcher CreateEventDispatcher(char const * in_name);
39358 
39364  static size_t SelectByShell(ShellKit const & in_shell,
39365  SelectionOptionsKit const & in_options,
39366  SelectionResults & out_results);
39367 
39373  static size_t SelectByShell(ShellKey const & in_shell,
39374  SelectionOptionsKit const & in_options,
39375  SelectionResults & out_results);
39376 
39383  static size_t SelectByVolume(SimpleCuboid const & in_volume,
39384  SelectionOptionsKit const & in_options,
39385  SelectionResults & out_results);
39386 
39393  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
39394  SelectionOptionsKit const & in_options,
39395  SelectionResults & out_results);
39396 
39399  static EventDispatcher const & GetEventDispatcher();
39400 
39401 
39405  static bool GetInformationEventFilter(Info::Code in_code);
39406 
39410  static bool GetWarningEventFilter(Info::Code in_code);
39411 
39415  static bool GetErrorEventFilter(Info::Code in_code);
39416 
39421  static bool SetInformationEventFilter(Info::Code in_code, bool in_filtered);
39422 
39427  static bool SetWarningEventFilter(Info::Code in_code, bool in_filtered);
39428 
39433  static bool SetErrorEventFilter(Info::Code in_code, bool in_filtered);
39434 
39435 
39438  static void SetEmergencyHandler(EmergencyHandler const & in_emergency_handler);
39439 
39441  static void UnsetEmergencyHandler();
39442 
39445  static size_t GetSoftMemoryLimit();
39446 
39450  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
39451 
39455  static bool IsDriverAvailable(Window::Driver in_driver);
39456 
39457 private:
39459  Database();
39460 };
39461 
39462 
39466 
39467 
39468 
39470 class HPS_API EventDispatcher : public Object
39471 {
39472 public:
39475  EventDispatcher();
39476 
39479  EventDispatcher(EventDispatcher const & in_that);
39480 
39484  EventDispatcher(EventDispatcher && in_that);
39485 
39489  EventDispatcher & operator=(EventDispatcher && in_that);
39490 
39491  virtual ~EventDispatcher();
39492 
39493  Type ObjectType() const {return Type::EventDispatcher;};
39494 
39498  EventDispatcher & operator=(EventDispatcher const & in_that);
39499 
39503  bool Equals(EventDispatcher const & in_that) const;
39504 
39508  bool operator==(EventDispatcher const & in_that) const;
39509 
39513  bool operator!=(EventDispatcher const & in_that) const;
39514 
39519  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
39520 
39525  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
39526 
39531  bool UnSubscribe(EventHandler const & in_handler) const;
39532 
39537  bool UnSubscribe(intptr_t in_type) const;
39538 
39542  bool InjectEvent(Event const & in_event) const;
39543 
39548  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
39549 
39552  void Shutdown() const;
39553 
39556  bool IsShutdown() const;
39557 
39558 
39561  void SetName(char const * in_name) const;
39562 
39565  void ShowName(UTF8 & out_name) const;
39566 
39567 private:
39569  virtual void Reset() {}
39570 };
39571 
39572 
39575 class HPS_API EventHandler : public Object
39576 {
39577 public:
39579  EventHandler();
39580 
39583  EventHandler(EventHandler const & in_that);
39584 
39588  EventHandler(EventHandler && in_that);
39589 
39593  EventHandler & operator=(EventHandler && in_that);
39594 
39598  EventHandler & operator=(EventHandler const & in_that);
39599 
39600  virtual ~EventHandler();
39601 
39602  Type ObjectType() const {return Type::EventHandler;};
39603 
39608  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
39609 
39614  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
39615 
39619  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
39620 
39622  void UnSubscribeEverything() const;
39623 
39625  virtual void Reset() { UnSubscribeEverything(); }
39626 
39629  void Shutdown();
39630 
39633  enum class HandleResult
39634  {
39635  Handled,
39636  NotHandled
39637  };
39638 
39643  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
39644 };
39645 
39646 
39647 
39649 class HPS_API TimerTickEvent : public Event
39650 {
39651 public:
39654  {
39655  channel = GetClassID();
39656  consumable = false;
39657  }
39658 
39659 
39662  TimerTickEvent(Event const & in_event) : Event(in_event)
39663  {
39664  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
39665  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39666  }
39667 
39668  ~TimerTickEvent();
39669 
39672  Event * Clone() const
39673  {
39674  TimerTickEvent * new_event = new TimerTickEvent(*this);
39675  return new_event;
39676  }
39677 
39681  virtual bool Drop(Event const * in_that_event) const
39682  {
39683  HPS_UNREFERENCED(in_that_event);
39684  return true;
39685  }
39686 
39687  virtual intptr_t Freshen() const {
39688  return GetClassID();
39689  }
39690 };
39691 
39693 class HPS_API HighlightEvent : public Event
39694 {
39695 public:
39696  enum class Action
39697  {
39698  None = 0,
39699  Highlight,
39700  Unhighlight,
39701  };
39702 
39705  {
39706  channel = GetClassID();
39707  consumable = false;
39708  action = Action::None;
39709  }
39710 
39711  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
39712  : Event(), action(in_action), results(in_results), options(in_options)
39713  {
39714  channel = GetClassID();
39715  consumable = false;
39716  }
39717 
39720  HighlightEvent(Event const & in_event) : Event(in_event)
39721  {
39722  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
39723  {
39724  auto that = static_cast<HighlightEvent const &>(in_event);
39725  action = that.action;
39726  results = that.results;
39727  options = that.options;
39728  }
39729  else
39730  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39731  }
39732 
39733  ~HighlightEvent();
39734 
39737  Event * Clone() const
39738  {
39739  HighlightEvent * new_event = new HighlightEvent(*this);
39740  return new_event;
39741  }
39742 
39743  Action action;
39744  SelectionResults results;
39745  HighlightOptionsKit options;
39746 };
39747 
39749 class HPS_API InformationEvent : public Event
39750 {
39751 public:
39753  InformationEvent() : Event(), code(Info::Code::Unknown) { channel = GetClassID(); }
39754 
39757  InformationEvent(char const * in_message) : Event(), message(in_message), code(Info::Code::Unknown) { channel = GetClassID(); }
39758 
39762  InformationEvent(char const * in_message, Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
39763 
39766  InformationEvent(Event const & in_event) : Event(in_event)
39767  {
39768  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
39769  {
39770  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
39771  message = event->message;
39772  code = event->code;
39773  }
39774  else
39775  {
39776  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39777  }
39778  }
39779 
39780  ~InformationEvent();
39781 
39784  Event * Clone() const
39785  {
39786  InformationEvent * new_event = new InformationEvent(*this);
39787  return new_event;
39788  }
39789 
39793  virtual bool Equals(InformationEvent const & in_that) const
39794  {
39795  return message == in_that.message && code == in_that.code;
39796  }
39797 
39801  virtual bool operator== (InformationEvent const & in_that) const
39802  {
39803  return Equals(in_that);
39804  }
39805 
39809  virtual bool operator!= (InformationEvent const & in_that) const
39810  {
39811  return !Equals(in_that);
39812  }
39813 
39816 };
39817 
39818 
39820 class HPS_API WarningEvent : public Event
39821 {
39822 public:
39824  WarningEvent() : Event(), code(Info::Code::Unknown) { channel = GetClassID(); }
39825 
39828  WarningEvent(char const * in_message) : Event(), message(in_message), code(Info::Code::Unknown) { channel = GetClassID(); }
39829 
39833  WarningEvent(char const * in_message, Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
39834 
39837  WarningEvent(Event const & in_event) : Event(in_event)
39838  {
39839  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
39840  {
39841  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
39842  message = event->message;
39843  code = event->code;
39844  }
39845  else
39846  {
39847  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39848  }
39849  }
39850 
39851  ~WarningEvent();
39852 
39855  Event * Clone() const
39856  {
39857  WarningEvent * new_event = new WarningEvent(*this);
39858  return new_event;
39859  }
39860 
39864  virtual bool Equals(WarningEvent const & in_that) const
39865  {
39866  return message == in_that.message && code == in_that.code;
39867  }
39868 
39872  virtual bool operator== (WarningEvent const & in_that) const
39873  {
39874  return Equals(in_that);
39875  }
39876 
39880  virtual bool operator!= (WarningEvent const & in_that) const
39881  {
39882  return !Equals(in_that);
39883  }
39884 
39887 };
39888 
39889 
39891 class HPS_API ErrorEvent : public Event
39892 {
39893 public:
39895  ErrorEvent() : Event(), code(Info::Code::Unknown) { channel = GetClassID(); }
39896 
39899  ErrorEvent(char const * in_message) : Event(), message(in_message), code(Info::Code::Unknown) { channel = GetClassID(); }
39900 
39904  ErrorEvent(char const * in_message, Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
39905 
39908  ErrorEvent(Event const & in_event) : Event(in_event)
39909  {
39910  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
39911  {
39912  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
39913  message = event->message;
39914  code = event->code;
39915  }
39916  else
39917  {
39918  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39919  }
39920  }
39921 
39922  ~ErrorEvent();
39923 
39926  Event * Clone() const
39927  {
39928  ErrorEvent * new_event = new ErrorEvent(*this);
39929  return new_event;
39930  }
39931 
39935  virtual bool Equals(ErrorEvent const & in_that) const
39936  {
39937  return message == in_that.message && code == in_that.code;
39938  }
39939 
39943  virtual bool operator== (ErrorEvent const & in_that) const
39944  {
39945  return Equals(in_that);
39946  }
39947 
39951  virtual bool operator!= (ErrorEvent const & in_that) const
39952  {
39953  return !Equals(in_that);
39954  }
39955 
39958 };
39959 
39960 
39962 class HPS_API StandAloneWindowEvent : public Event
39963 {
39964 public:
39965 
39968  enum class Action
39969  {
39970  Unknown,
39971  Close,
39972  FocusIn,
39973  FocusOut,
39974  };
39975 
39977  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
39978 
39979 
39982  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
39983 
39986  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
39987  {
39988  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
39989  {
39990  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
39991  action = event->action;
39992  }
39993  else
39994  {
39995  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39996  }
39997  }
39998 
40000 
40003  Event * Clone() const
40004  {
40005  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
40006  return new_event;
40007  }
40008 
40012  virtual bool Equals(StandAloneWindowEvent const & in_that) const
40013  {
40014  return action == in_that.action;
40015  }
40016 
40020  virtual bool operator== (StandAloneWindowEvent const & in_that) const
40021  {
40022  return Equals(in_that);
40023  }
40024 
40028  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
40029  {
40030  return !Equals(in_that);
40031  }
40032 
40034 };
40035 
40037 class HPS_API FocusLostEvent : public Event
40038 {
40039 public:
40042  Event()
40043  { channel = GetClassID(); }
40044 
40045  ~FocusLostEvent() {};
40046 
40049  Event * Clone() const
40050  {
40051  FocusLostEvent * new_event = new FocusLostEvent(*this);
40052  return new_event;
40053  }
40054 };
40055 
40056 
40058 class HPS_API UpdateCompletedEvent : public Event
40059 {
40060 public:
40062  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
40063 
40065  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
40066 
40067  virtual ~UpdateCompletedEvent();
40068 
40071  Event * Clone() const
40072  {
40073  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
40074  return new_event;
40075  }
40076 
40077  Time update_time;
40078 };
40079 
40081 class HPS_API ImportStatusEvent : public Event
40082 {
40083 public:
40086  : Event()
40087  , import_status_message(UTF8())
40088  { channel = GetClassID(); }
40089 
40090  ImportStatusEvent(char const * in_message)
40091  : Event()
40092  , import_status_message(in_message)
40093  { channel = GetClassID(); }
40094 
40095  ~ImportStatusEvent() {};
40096 
40099  Event * Clone() const
40100  {
40101  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
40102  return new_event;
40103  }
40104 
40105  UTF8 import_status_message;
40106 };
40107 
40109 class HPS_API ModifierKeys
40110 {
40111 public:
40113  ModifierKeys() : modifiers(_key_none) {}
40114 
40118  bool Equals(ModifierKeys const & in_that) const
40119  {
40120  return modifiers == in_that.modifiers;
40121  }
40122 
40126  bool operator== (ModifierKeys const & in_that) const
40127  {
40128  return Equals(in_that);
40129  }
40130 
40134  bool operator!= (ModifierKeys const & in_that) const
40135  {
40136  return !Equals(in_that);
40137  }
40138 
40141  bool None() const { return modifiers == _key_none; }
40142 
40145  bool Shift() const { return (modifiers & _key_shift) != 0; }
40146 
40149  bool Control() const { return (modifiers & _key_control) != 0; }
40150 
40153  bool Alt() const { return (modifiers & _key_alt) != 0; }
40154 
40157  bool Meta() const { return (modifiers & _key_meta) != 0; }
40158 
40159 
40163  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
40164 
40168  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
40169 
40170 
40173  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
40174 
40177  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
40178 
40181  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
40182 
40185  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
40186 
40190  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
40191  {
40192  ModifierKeys ret;
40193  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
40194  return ret;
40195  }
40196 
40200  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
40201  {
40202  ModifierKeys ret;
40203  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
40204  return ret;
40205  }
40206 
40210  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
40211 
40215  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
40216 
40217 
40220  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
40221 
40224  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
40225 
40228  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
40229 
40232  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
40233 
40234 protected:
40235 
40239  {
40240  _key_none = 0x0000,
40241  _key_shift = 0x0001,
40242  _key_control = 0x0002,
40243  _key_alt = 0x0004,
40244  _key_meta = 0x0008,
40245  };
40246 
40247  int modifiers;
40248 };
40249 
40250 
40253 class HPS_API InputEvent : public Event
40254 {
40255 public:
40256 
40258  InputEvent() : Event() { channel = GetClassID(); }
40259 
40262  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
40263 
40264  ~InputEvent();
40265 
40268  Event * Clone() const
40269  {
40270  InputEvent * new_event = new InputEvent(*this);
40271  return new_event;
40272  }
40273 
40277  virtual bool Equals(InputEvent const & in_that) const
40278  {
40279  return ModifierKeyState == in_that.ModifierKeyState;
40280  }
40281 
40285  virtual bool operator== (InputEvent const & in_that) const
40286  {
40287  return Equals(in_that);
40288  }
40289 
40293  virtual bool operator!= (InputEvent const & in_that) const
40294  {
40295  return !Equals(in_that);
40296  }
40297 
40302  {
40303  return ModifierKeyState;
40304  }
40305 
40307 };
40308 
40310 class HPS_API TouchEvent : public InputEvent
40311 {
40312 public:
40315  enum class Action
40316  {
40317  TouchDown,
40318  TouchUp,
40319  Move,
40320  };
40321 
40323  TouchEvent() : InputEvent() { channel = GetClassID(); }
40324 
40329  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
40330  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
40331 
40337  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
40338  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
40339 
40346  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
40347  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
40348 
40349 
40352  TouchEvent(Event const & in_event) : InputEvent()
40353  {
40354  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
40355  {
40356  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
40357  channel = GetClassID();
40358  CurrentAction = event->CurrentAction;
40359  Touches = event->Touches;
40360  ModifierKeyState = event->ModifierKeyState;
40361  }
40362  else
40363  throw InvalidSpecificationException("Invalid Event type to cast from.");
40364  }
40365 
40366  ~TouchEvent();
40367 
40368 
40371  Event * Clone() const
40372  {
40373  TouchEvent * new_event = new TouchEvent(*this);
40374  return new_event;
40375  }
40376 
40380  virtual bool Equals(TouchEvent const & in_that) const
40381  {
40382  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
40383  }
40384 
40388  virtual bool operator== (TouchEvent const & in_that) const
40389  {
40390  return Equals(in_that);
40391  }
40392 
40396  virtual bool operator!= (TouchEvent const & in_that) const
40397  {
40398  return !Equals(in_that);
40399  }
40400 
40404  virtual bool Drop(Event const * in_that_event) const
40405  {
40406  TouchEvent const * that_touch_event = static_cast<TouchEvent const *>(in_that_event);
40407 
40408  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
40409  && Touches.size() == that_touch_event->Touches.size() )
40410  {
40411  TouchArray these_touches = Touches;
40412  TouchArray those_touches = that_touch_event->Touches;
40413 
40414  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
40415  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
40416 
40417  for (size_t i = 0 ; i < these_touches.size() ; i++)
40418  {
40419  if (these_touches[i].ID != those_touches[i].ID)
40420  return false;
40421  }
40422  return true;
40423  }
40424 
40425  return false;
40426  }
40427 
40431  void SetTouches(size_t in_touch_count, Touch const in_touches[])
40432  {
40433  Touches.assign(in_touches, in_touches + in_touch_count);
40434  }
40435 
40438  void SetTouches(TouchArray const & in_touches)
40439  {
40440  Touches = in_touches;
40441  }
40442 
40444  TouchArray Touches;
40445 
40446 private:
40452  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
40453  {
40454  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
40455  }
40456 };
40457 
40458 
40460 class HPS_API MouseButtons
40461 {
40462 public:
40464  MouseButtons() : buttons(_button_none) {}
40465 
40469  bool Equals(MouseButtons const & in_that) const
40470  {
40471  return buttons == in_that.buttons;
40472  }
40473 
40477  bool operator== (MouseButtons const & in_that) const
40478  {
40479  return Equals(in_that);
40480  }
40481 
40485  bool operator!= (MouseButtons const & in_that) const
40486  {
40487  return !Equals(in_that);
40488  }
40489 
40492  bool None() const { return buttons == _button_none; }
40493 
40496  bool Left() const { return (buttons & _button_left) != 0; }
40497 
40500  bool Right() const { return (buttons & _button_right) != 0; }
40501 
40504  bool Middle() const { return (buttons & _button_middle) != 0; }
40505 
40508  bool X1() const { return (buttons & _button_x1) != 0; }
40509 
40512  bool X2() const { return (buttons & _button_x2) != 0; }
40513 
40514 
40518  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
40519 
40523  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
40524 
40527  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
40528 
40531  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
40532 
40535  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
40536 
40539  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
40540 
40543  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
40544 
40548  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
40549  {
40550  MouseButtons ret;
40551  ret.buttons = buttons | in_buttons_to_merge.buttons;
40552  return ret;
40553  }
40554 
40558  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
40559  {
40560  MouseButtons ret;
40561  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
40562  return ret;
40563  }
40564 
40568  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
40569 
40573  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
40574 
40575 
40578  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
40579 
40582  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
40583 
40586  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
40587 
40590  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
40591 
40594  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
40595 
40596 protected:
40597 
40600  enum Buttons
40601  {
40602  _button_none = 0x0000,
40603  _button_left = 0x0001,
40604  _button_right = 0x0002,
40605  _button_middle = 0x0004,
40606  _button_x1 = 0x0008,
40607  _button_x2 = 0x0010
40608  };
40609 
40610  int buttons;
40611 };
40612 
40614 class HPS_API MouseEvent : public InputEvent
40615 {
40616 public:
40617 
40620  enum class Action
40621  {
40622  ButtonUp,
40623  ButtonDown,
40624  Move,
40625  Scroll,
40626  Enter,
40627  Leave
40628  };
40629 
40631  MouseEvent() : InputEvent() { channel = GetClassID(); }
40632 
40639  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
40640  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
40641 
40649  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)
40650  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
40651 
40654  MouseEvent(Event const & in_event) : InputEvent()
40655  {
40656  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
40657  {
40658  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
40659  channel = GetClassID();
40660  CurrentAction = event->CurrentAction;
40661  Location = event->Location;
40662  CurrentButton = event->CurrentButton;
40663  WheelDelta = event->WheelDelta;
40664  ClickCount = event->ClickCount;
40665  }
40666  else
40667  {
40668  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
40669  }
40670  }
40671 
40672  ~MouseEvent();
40673 
40676  Event * Clone() const
40677  {
40678  MouseEvent * new_event = new MouseEvent(*this);
40679  return new_event;
40680  }
40681 
40685  virtual bool Equals(MouseEvent const & in_that) const
40686  {
40687  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
40688  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
40689  && Location == in_that.Location && ClickCount == in_that.ClickCount;
40690  }
40691 
40695  virtual bool operator== (MouseEvent const & in_that) const
40696  {
40697  return Equals(in_that);
40698  }
40699 
40703  virtual bool operator!= (MouseEvent const & in_that) const
40704  {
40705  return !Equals(in_that);
40706  }
40707 
40711  virtual bool Drop(Event const * in_that_event) const
40712  {
40713  MouseEvent const * that_mouse_event = static_cast<MouseEvent const *>(in_that_event);
40714 
40715  if (CurrentAction == that_mouse_event->CurrentAction &&
40716  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
40717  CurrentButton == that_mouse_event->CurrentButton)
40718  return true;
40719 
40720  return false;
40721  }
40722 
40723  virtual intptr_t Freshen() const {
40724 
40725  if (CurrentAction == Action::Move)
40726  return GetClassID();
40727 
40728  return 0;
40729  }
40730 
40734  float WheelDelta;
40735  size_t ClickCount;
40736 };
40737 
40738 
40740 class HPS_API KeyboardEvent : public InputEvent
40741 {
40742 public:
40745  enum class Action
40746  {
40747  None,
40748  KeyDown,
40749  KeyUp
40750  };
40751 
40753  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
40754 
40759  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
40760 
40766  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
40767  : InputEvent(in_modifiers), CurrentAction(in_action)
40768  {
40769  channel = GetClassID();
40770  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40771  }
40772 
40777  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
40778  : InputEvent(in_modifiers), CurrentAction(in_action)
40779  {
40780  channel = GetClassID();
40781  KeyboardCodes = in_keyboardcodes;
40782  }
40783 
40786  KeyboardEvent(Event const & in_event) : InputEvent()
40787  {
40788  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
40789  {
40790  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
40791  channel = GetClassID();
40792  KeyboardCodes = event->KeyboardCodes;
40793  CurrentAction = event->CurrentAction;
40794  }
40795  else
40796  {
40797  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
40798  }
40799  }
40800 
40801  ~KeyboardEvent();
40802 
40805  Event * Clone() const
40806  {
40807  KeyboardEvent * new_event = new KeyboardEvent(*this);
40808  return new_event;
40809  }
40810 
40814  virtual bool Equals(KeyboardEvent const & in_that) const
40815  {
40816  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
40817  }
40818 
40822  virtual bool operator== (KeyboardEvent const & in_that) const
40823  {
40824  return Equals(in_that);
40825  }
40826 
40830  virtual bool operator!= (KeyboardEvent const & in_that) const
40831  {
40832  return !Equals(in_that);
40833  }
40834 
40838  void SetKeyboardCodes(size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[])
40839  {
40840  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40841  }
40842 
40845  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboardcodes)
40846  {
40847  KeyboardCodes = in_keyboardcodes;
40848  }
40849 
40850  KeyboardCodeArray KeyboardCodes;
40852 };
40853 
40854 
40856 class HPS_API MouseState : public Object
40857 {
40858 public:
40860  MouseState();
40861 
40864  MouseState(MouseState const & in_that);
40865 
40869  MouseState(MouseState && in_that);
40870 
40874  MouseState & operator=(MouseState && in_that);
40875 
40876  ~MouseState();
40877 
40878  Type ObjectType() const {return Type::MouseState;};
40879 
40882  void Assign(MouseState const & in_that);
40883 
40887  MouseState & operator=(MouseState const & in_that);
40888 
40892  bool Equals(MouseState const & in_that) const;
40893 
40897  bool operator== (MouseState const & in_that) const;
40898 
40902  bool operator!= (MouseState const & in_that) const;
40903 
40906  MouseEvent GetActiveEvent() const;
40907 
40911  WindowKey GetEventSource() const;
40912 
40916  KeyArray GetEventPath() const;
40917 
40920  MouseButtons GetButtons() const;
40921 
40924  WindowPoint GetLocation() const;
40925 
40928  ModifierKeys GetModifierKeys() const;
40929 };
40930 
40931 
40932 
40934 class HPS_API TouchState : public Object
40935 {
40936 public:
40938  TouchState();
40939 
40942  TouchState(TouchState const & in_that);
40943 
40947  TouchState(TouchState && in_that);
40948 
40952  TouchState & operator=(TouchState && in_that);
40953 
40954  ~TouchState();
40955 
40956  Type ObjectType() const {return Type::TouchState;};
40957 
40960  void Assign(TouchState const & in_that);
40961 
40965  TouchState & operator=(TouchState const & in_that);
40966 
40970  bool Equals(TouchState const & in_that) const;
40971 
40975  bool operator== (TouchState const & in_that) const;
40976 
40980  bool operator!= (TouchState const & in_that) const;
40981 
40984  TouchEvent GetActiveEvent() const;
40985 
40989  WindowKey GetEventSource() const;
40990 
40994  KeyArray GetEventPath() const;
40995 
40998  size_t GetTouchCount() const;
40999 
41002  TouchArray GetTouches() const;
41003 
41006  ModifierKeys GetModifierKeys() const;
41007 };
41008 
41009 
41010 
41012 class HPS_API KeyboardState : public Object
41013 {
41014 public:
41016  KeyboardState();
41017 
41020  KeyboardState(KeyboardState const & in_that);
41021 
41025  KeyboardState(KeyboardState && in_that);
41026 
41030  KeyboardState & operator=(KeyboardState && in_that);
41031 
41032  ~KeyboardState();
41033 
41034  Type ObjectType() const {return Type::KeyboardState;};
41035 
41038  void Assign(KeyboardState const & in_that);
41039 
41043  KeyboardState & operator=(KeyboardState const & in_that);
41044 
41048  bool Equals(KeyboardState const & in_that) const;
41049 
41053  bool operator== (KeyboardState const & in_that) const;
41054 
41058  bool operator!= (KeyboardState const & in_that) const;
41059 
41062  KeyboardEvent GetActiveEvent() const;
41063 
41067  WindowKey GetEventSource() const;
41068 
41072  KeyArray GetEventPath() const;
41073 
41076  size_t GetKeyboardCodeCount() const;
41077 
41080  KeyboardCodeArray GetKeyboardCodes() const;
41081 
41085  bool GetKeyState(KeyboardCode in_key_code) const;
41086 
41089  ModifierKeys GetModifierKeys() const;
41090 };
41091 
41092 
41096 
41099 class HPS_API IONotifier : public Object
41100 {
41101 public:
41103  IONotifier();
41104 
41107  IONotifier(IONotifier const & in_that);
41108 
41112  IONotifier(IONotifier && in_that);
41113 
41117  IONotifier & operator=(IONotifier && in_that);
41118 
41119  virtual ~IONotifier();
41120 
41121  Type ObjectType() const {return Type::IONotifier;};
41122 
41126  IONotifier & operator=(IONotifier const & in_that);
41127 
41130  void Assign(IONotifier const & in_that);
41131 
41133  void Wait();
41134 
41137  IOResult Status() const;
41138 
41142  IOResult Status(float & out_percent_complete) const;
41143 
41147  void Cancel();
41148 };
41149 
41151 class HPS_API Stream
41152 {
41153 public:
41154 
41156  class HPS_API ImportOptionsKit : public Object
41157  {
41158  public:
41160  ImportOptionsKit();
41161 
41164  ImportOptionsKit(ImportOptionsKit const & in_kit);
41165 
41169  ImportOptionsKit(ImportOptionsKit && in_that);
41170 
41174  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
41175 
41176  virtual ~ImportOptionsKit();
41177 
41178  Type ObjectType() const { return Type::StreamImportOptionsKit; };
41179 
41182  void Set(ImportOptionsKit const & in_kit);
41183 
41186  void Show(ImportOptionsKit & out_kit) const;
41187 
41191  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
41192 
41195  bool Empty() const;
41196 
41200  bool Equals(ImportOptionsKit const & in_kit) const;
41201 
41205  bool operator==(ImportOptionsKit const & in_kit) const;
41206 
41210  bool operator!=(ImportOptionsKit const & in_kit) const;
41211 
41216  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
41217 
41220  ImportOptionsKit & UnsetSegment();
41221 
41225  bool ShowSegment(SegmentKey & out_segment) const;
41226 
41231  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
41232 
41235  ImportOptionsKit & UnsetAlternateRoot();
41236 
41240  bool ShowAlternateRoot(SegmentKey & out_segment) const;
41241 
41246  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
41247 
41250  ImportOptionsKit & UnsetPortfolio();
41251 
41255  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
41256 
41259  ImportOptionsKit & UnsetEverything();
41260  };
41261 
41263  class HPS_API ImportResultsKit : public Object
41264  {
41265  public:
41267  ImportResultsKit();
41268 
41271  ImportResultsKit(ImportResultsKit const & in_kit);
41272 
41276  ImportResultsKit(ImportResultsKit && in_that);
41277 
41281  ImportResultsKit & operator=(ImportResultsKit && in_that);
41282 
41283  virtual ~ImportResultsKit();
41284 
41285  Type ObjectType() const { return Type::StreamImportResultsKit; };
41286 
41289  void Set(ImportResultsKit const & in_kit);
41290 
41293  void Show(ImportResultsKit & out_kit) const;
41294 
41298  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
41299 
41302  bool Empty() const;
41303 
41307  bool Equals(ImportResultsKit const & in_kit) const;
41308 
41312  bool operator==(ImportResultsKit const & in_kit) const;
41313 
41317  bool operator!=(ImportResultsKit const & in_kit) const;
41318 
41323  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
41324 
41328  ImportResultsKit & UnsetSegment();
41329 
41334  bool ShowSegment(SegmentKey & out_segment) const;
41335 
41340  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
41341 
41345  ImportResultsKit & UnsetAlternateRoot();
41346 
41352  bool ShowAlternateRoot(SegmentKey & out_segment) const;
41353 
41358  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
41359 
41363  ImportResultsKit & UnsetPortfolio();
41364 
41370  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
41371 
41376  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
41377 
41381  ImportResultsKit & UnsetDefaultCamera();
41382 
41386  bool ShowDefaultCamera(CameraKit & out_camera) const;
41387 
41388 
41394  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
41395 
41399  ImportResultsKit & UnsetAlternateCameras();
41400 
41405  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
41406 
41407 
41410  ImportResultsKit & UnsetEverything();
41411  };
41412 
41414  class HPS_API ExportOptionsKit : public Object
41415  {
41416  public:
41418  ExportOptionsKit();
41419 
41422  ExportOptionsKit(ExportOptionsKit const & in_kit);
41423 
41427  ExportOptionsKit(ExportOptionsKit && in_that);
41428 
41432  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
41433 
41437  static ExportOptionsKit GetDefault();
41438 
41439  virtual ~ExportOptionsKit();
41440 
41441  Type ObjectType() const { return Type::StreamExportOptionsKit; };
41442 
41445  void Set(ExportOptionsKit const & in_kit);
41446 
41449  void Show(ExportOptionsKit & out_kit) const;
41450 
41454  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
41455 
41458  bool Empty() const;
41459 
41463  bool Equals(ExportOptionsKit const & in_kit) const;
41464 
41468  bool operator==(ExportOptionsKit const & in_kit) const;
41469 
41473  bool operator!=(ExportOptionsKit const & in_kit) const;
41474 
41482  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
41483 
41491  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
41492 
41498  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
41499 
41507  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
41508 
41516  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
41517 
41523  ExportOptionsKit & SetConnectivityCompression(bool in_state);
41524 
41533  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
41534 
41537  ExportOptionsKit & UnsetVertexCompression();
41538 
41541  ExportOptionsKit & UnsetNormalCompression();
41542 
41545  ExportOptionsKit & UnsetParameterCompression();
41546 
41549  ExportOptionsKit & UnsetColorCompression();
41550 
41553  ExportOptionsKit & UnsetIndexCompression();
41554 
41557  ExportOptionsKit & UnsetConnectivityCompression();
41558 
41561  ExportOptionsKit & UnsetImageCompression();
41562 
41565  ExportOptionsKit & UnsetEverything();
41566 
41571  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
41572 
41577  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
41578 
41583  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
41584 
41589  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
41590 
41595  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
41596 
41600  bool ShowConnectivityCompression(bool & out_state) const;
41601 
41606  bool ShowImageCompression(bool & out_state, float & out_quality) const;
41607  };
41608 
41611  class HPS_API ImportNotifier : public IONotifier
41612  {
41613  public:
41615  ImportNotifier();
41616 
41619  ImportNotifier(ImportNotifier const & in_that);
41620 
41625  ImportNotifier(IONotifier const & in_that);
41626 
41630  ImportNotifier(ImportNotifier && in_that);
41631 
41635  ImportNotifier & operator=(ImportNotifier && in_that);
41636 
41637  virtual ~ImportNotifier();
41638 
41639  Type ObjectType() const {return Type::StreamImportNotifier;};
41640 
41644  ImportNotifier & operator=(ImportNotifier const & in_that);
41645 
41648  void Assign(ImportNotifier const & in_that);
41649 
41653  ImportResultsKit GetResults() const;
41654  };
41655 
41656 
41658  class HPS_API File
41659  {
41660  public:
41666  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
41667 
41673  static void Export(const char * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
41674 
41680  static void Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
41681 
41682  private:
41684  File();
41685  };
41686 private:
41688  Stream();
41689 };
41690 
41694 
41699 class HPS_API Hardcopy
41700 {
41701 public:
41702 
41704  enum class SizeUnits
41705  {
41706  Centimeters,
41707  Inches,
41708  };
41709 
41711  enum class ResolutionUnits
41712  {
41713  DPCM,
41714  DPI,
41715  DotsPerCentimeter = DPCM,
41716  DotsPerInch = DPI,
41717  };
41718 
41720  class HPS_API File
41721  {
41722  public:
41723 
41725  class HPS_API ExportOptionsKit : public Object
41726  {
41727  public:
41729  ExportOptionsKit();
41730 
41733  ExportOptionsKit(ExportOptionsKit const & in_kit);
41734 
41738  ExportOptionsKit(ExportOptionsKit && in_that);
41739 
41743  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
41744 
41745  virtual ~ExportOptionsKit();
41746 
41747  Type ObjectType() const { return Type::HardcopyExportOptionsKit; };
41748 
41751  void Set(ExportOptionsKit const & in_kit);
41752 
41755  void Show(ExportOptionsKit & out_kit) const;
41756 
41760  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
41761 
41764  bool Empty() const;
41765 
41769  bool Equals(ExportOptionsKit const & in_kit) const;
41770 
41774  bool operator==(ExportOptionsKit const & in_kit) const;
41775 
41779  bool operator!=(ExportOptionsKit const & in_kit) const;
41780 
41781 
41782 
41783 
41789  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
41790 
41798  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
41799 
41802  ExportOptionsKit & UnsetSize();
41803 
41804 
41805 
41811  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
41812 
41819  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
41820 
41823  ExportOptionsKit & UnsetResolution();
41824 
41825 
41826 
41829  bool ShowWYSIWYG(bool & out_onoff) const;
41830 
41836  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
41837 
41840  ExportOptionsKit & UnsetWYSIWYG();
41841 
41842 
41845  ExportOptionsKit & UnsetEverything();
41846 
41847 
41851  static ExportOptionsKit GetDefault();
41852  };
41853 
41855  enum class Driver
41856  {
41857  PDF,
41858  Postscript
41859  };
41860 
41866  static IOResult Export(char const * in_filename, Driver in_driver_type, WindowKey const & in_window, ExportOptionsKit const & in_options);
41867  private:
41868  File();
41869  };
41870 
41871 #ifdef _MSC_VER
41872  class HPS_API GDI
41873  {
41874  public:
41875 
41877  class HPS_API ExportOptionsKit : public Object
41878  {
41879  public:
41881  ExportOptionsKit();
41882 
41885  ExportOptionsKit(ExportOptionsKit const & in_kit);
41886 
41890  ExportOptionsKit(ExportOptionsKit && in_that);
41891 
41895  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
41896 
41897  virtual ~ExportOptionsKit();
41898 
41899  Type ObjectType() const { return Type::HardcopyExportOptionsKit; };
41900 
41903  void Set(ExportOptionsKit const & in_kit);
41904 
41907  void Show(ExportOptionsKit & out_kit) const;
41908 
41912  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
41913 
41916  bool Empty() const;
41917 
41921  bool Equals(ExportOptionsKit const & in_kit) const;
41922 
41926  bool operator==(ExportOptionsKit const & in_kit) const;
41927 
41931  bool operator!=(ExportOptionsKit const & in_kit) const;
41932 
41933 
41934 
41935 
41939  bool ShowResolution(float & out_resolution) const;
41940 
41944  ExportOptionsKit & SetResolution(float in_resolution);
41945 
41948  ExportOptionsKit & UnsetResolution();
41949 
41950 
41951 
41952 
41955  bool ShowWYSIWYG(bool & out_onoff) const;
41956 
41960  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
41961 
41964  ExportOptionsKit & UnsetWYSIWYG();
41965 
41966 
41969  ExportOptionsKit & UnsetEverything();
41970  };
41971 
41978  static IOResult Export(intptr_t hdc, intptr_t attribdc, WindowKey const & window, ExportOptionsKit const & options);
41979 
41980  private:
41981  GDI();
41982  };
41983 #endif
41984 
41985 private:
41986  Hardcopy();
41987 };
41988 
41992 
41994 class HPS_API OBJ
41995 {
41996 public:
41997 
41999  class HPS_API ImportOptionsKit : public Object
42000  {
42001  public:
42003  ImportOptionsKit();
42004 
42007  ImportOptionsKit(ImportOptionsKit const & in_kit);
42008 
42012  ImportOptionsKit(ImportOptionsKit && in_that);
42013 
42017  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42018 
42019  virtual ~ImportOptionsKit();
42020 
42021  Type ObjectType() const { return Type::OBJImportOptionsKit; };
42022 
42025  void Set(ImportOptionsKit const & in_kit);
42026 
42029  void Show(ImportOptionsKit & out_kit) const;
42030 
42034  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42035 
42038  bool Empty() const;
42039 
42043  bool Equals(ImportOptionsKit const & in_kit) const;
42044 
42048  bool operator==(ImportOptionsKit const & in_kit) const;
42049 
42053  bool operator!=(ImportOptionsKit const & in_kit) const;
42054 
42059  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42060 
42063  ImportOptionsKit & UnsetSegment();
42064 
42068  bool ShowSegment(SegmentKey & out_segment) const;
42069 
42074  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42075 
42078  ImportOptionsKit & UnsetPortfolio();
42079 
42083  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42084 
42090  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
42091 
42094  ImportOptionsKit & UnsetHandedness();
42095 
42099  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
42100 
42103  ImportOptionsKit & UnsetEverything();
42104  };
42105 
42107  class HPS_API ImportResultsKit : public Object
42108  {
42109  public:
42111  ImportResultsKit();
42112 
42115  ImportResultsKit(ImportResultsKit const & in_kit);
42116 
42120  ImportResultsKit(ImportResultsKit && in_that);
42121 
42125  ImportResultsKit & operator=(ImportResultsKit && in_that);
42126 
42127  virtual ~ImportResultsKit();
42128 
42129  Type ObjectType() const { return Type::OBJImportResultsKit; };
42130 
42133  void Set(ImportResultsKit const & in_kit);
42134 
42137  void Show(ImportResultsKit & out_kit) const;
42138 
42142  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42143 
42146  bool Empty() const;
42147 
42151  bool Equals(ImportResultsKit const & in_kit) const;
42152 
42156  bool operator==(ImportResultsKit const & in_kit) const;
42157 
42161  bool operator!=(ImportResultsKit const & in_kit) const;
42162 
42167  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42168 
42172  ImportResultsKit & UnsetSegment();
42173 
42178  bool ShowSegment(SegmentKey & out_segment) const;
42179 
42184  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42185 
42189  ImportResultsKit & UnsetPortfolio();
42190 
42196  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42197 
42202  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
42203 
42207  ImportResultsKit & UnsetHandedness();
42208 
42213  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
42214 
42217  ImportResultsKit & UnsetEverything();
42218  };
42219 
42222  class HPS_API ImportNotifier : public IONotifier
42223  {
42224  public:
42226  ImportNotifier();
42227 
42230  ImportNotifier(ImportNotifier const & in_that);
42231 
42236  ImportNotifier(IONotifier const & in_that);
42237 
42241  ImportNotifier(ImportNotifier && in_that);
42242 
42246  ImportNotifier & operator=(ImportNotifier && in_that);
42247 
42248  virtual ~ImportNotifier();
42249 
42250  Type ObjectType() const {return Type::OBJImportNotifier;};
42251 
42255  ImportNotifier & operator=(ImportNotifier const & in_that);
42256 
42259  void Assign(ImportNotifier const & in_that);
42260 
42264  ImportResultsKit GetResults() const;
42265  };
42266 
42267 
42269  class HPS_API File
42270  {
42271  public:
42277  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42278 
42279  private:
42281  File();
42282  };
42283 private:
42285  OBJ();
42286 };
42287 
42291 
42293 class HPS_API STL
42294 {
42295 public:
42296 
42298  class HPS_API ImportOptionsKit : public Object
42299  {
42300  public:
42302  ImportOptionsKit();
42303 
42306  ImportOptionsKit(ImportOptionsKit const & in_kit);
42307 
42311  ImportOptionsKit(ImportOptionsKit && in_that);
42312 
42316  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42317 
42318  virtual ~ImportOptionsKit();
42319 
42320  Type ObjectType() const { return Type::STLImportOptionsKit; };
42321 
42324  void Set(ImportOptionsKit const & in_kit);
42325 
42328  void Show(ImportOptionsKit & out_kit) const;
42329 
42333  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42334 
42337  bool Empty() const;
42338 
42342  bool Equals(ImportOptionsKit const & in_kit) const;
42343 
42347  bool operator==(ImportOptionsKit const & in_kit) const;
42348 
42352  bool operator!=(ImportOptionsKit const & in_kit) const;
42353 
42357  static ImportOptionsKit GetDefault();
42358 
42363  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42364 
42372  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
42373 
42380  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
42381 
42382 
42385  ImportOptionsKit & UnsetSegment();
42386 
42389  ImportOptionsKit & UnsetOptimization();
42390 
42393  ImportOptionsKit & UnsetEverything();
42394 
42395 
42399  bool ShowSegment(SegmentKey & out_segment) const;
42400 
42405  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
42406  };
42407 
42409  class HPS_API ImportResultsKit : public Object
42410  {
42411  public:
42413  ImportResultsKit();
42414 
42417  ImportResultsKit(ImportResultsKit const & in_kit);
42418 
42422  ImportResultsKit(ImportResultsKit && in_that);
42423 
42427  ImportResultsKit & operator=(ImportResultsKit && in_that);
42428 
42429  virtual ~ImportResultsKit();
42430 
42431  Type ObjectType() const { return Type::STLImportResultsKit; };
42432 
42435  void Set(ImportResultsKit const & in_kit);
42436 
42439  void Show(ImportResultsKit & out_kit) const;
42440 
42444  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42445 
42448  bool Empty() const;
42449 
42453  bool Equals(ImportResultsKit const & in_kit) const;
42454 
42458  bool operator==(ImportResultsKit const & in_kit) const;
42459 
42463  bool operator!=(ImportResultsKit const & in_kit) const;
42464 
42469  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42470 
42474  ImportResultsKit & UnsetSegment();
42475 
42480  bool ShowSegment(SegmentKey & out_segment) const;
42481 
42484  ImportResultsKit & UnsetEverything();
42485  };
42486 
42489  class HPS_API ImportNotifier : public IONotifier
42490  {
42491  public:
42493  ImportNotifier();
42494 
42497  ImportNotifier(ImportNotifier const & in_that);
42498 
42503  ImportNotifier(IONotifier const & in_that);
42504 
42508  ImportNotifier(ImportNotifier && in_that);
42509 
42513  ImportNotifier & operator=(ImportNotifier && in_that);
42514 
42515  virtual ~ImportNotifier();
42516 
42517  Type ObjectType() const {return Type::STLImportNotifier;};
42518 
42522  ImportNotifier & operator=(ImportNotifier const & in_that);
42523 
42526  void Assign(ImportNotifier const & in_that);
42527 
42531  ImportResultsKit GetResults() const;
42532  };
42533 
42534 
42536  class HPS_API File
42537  {
42538  public:
42544  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42545 
42546  private:
42548  File();
42549  };
42550 private:
42552  STL();
42553 };
42554 
42555 }
42556 
42557 #ifdef _MSC_VER
42558 # pragma warning(pop)
42559 #endif
42560 
42561 #endif
42562 
42563 
Type ObjectType() const
Definition: hps.h:39025
Rotation
Definition: hps.h:1580
Type ObjectType() const
Definition: hps.h:26188
bool Empty() const
Definition: hps.h:6709
CameraPoint(Point const &in_point)
Definition: hps.h:5660
Alignment
Definition: hps.h:1513
Type ObjectType() const
Definition: hps.h:18818
Space
Definition: hps.h:546
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:40732
Definition: hps.h:3201
Definition: hps.h:5899
Channel
Definition: hps.h:930
Type ObjectType() const
Definition: hps.h:23438
Handedness
Definition: hps.h:1261
Definition: hps.h:13694
Definition: hps.h:1036
Definition: hps.h:11477
ColorSource
Definition: hps.h:1906
Type ObjectType() const
Definition: hps.h:16555
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:40518
Type ObjectType() const
Definition: hps.h:35347
Event(intptr_t in_channel=0)
Definition: hps.h:6013
Definition: hps.h:17670
Type ObjectType() const
Definition: hps.h:42250
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3693
float alpha
Definition: hps.h:4217
Definition: hps.h:33768
Type ObjectType() const
Definition: hps.h:34954
bool operator==(Touch const &in_that) const
Definition: hps.h:6303
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:40539
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:40173
Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:39957
InformationEvent(char const *in_message)
Definition: hps.h:39757
Type ObjectType() const
Definition: hps.h:37370
Type ObjectType() const
Definition: hps.h:33434
Type ObjectType() const
Definition: hps.h:21248
Type ObjectType() const
Definition: hps.h:22966
Type ObjectType() const
Definition: hps.h:23712
Action
Definition: hps.h:40315
Orientation
Definition: hps.h:522
Definition: hps.h:20149
Code
Definition: hps.h:127
Definition: sprk_exchange.h:42
Algorithm
Definition: hps.h:1316
Multiline strings will be left justfied.
Definition: hps.h:38842
Type ObjectType() const
Definition: hps.h:14438
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40012
Type ObjectType() const
Definition: hps.h:8193
Type ObjectType() const
Definition: hps.h:27416
Event * Clone() const
Definition: hps.h:39855
Definition: hps.h:12753
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:40649
Definition: hps.h:41994
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:39643
ImportStatusEvent()
Definition: hps.h:40085
Type ObjectType() const
Definition: hps.h:20865
Type ObjectType() const
Definition: hps.h:35129
Definition: hps.h:13260
Type ObjectType() const
Definition: hps.h:25211
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:40380
Type ObjectType() const
Definition: hps.h:29417
Type ObjectType() const
Definition: hps.h:24842
Type ObjectType() const
Definition: hps.h:11128
static MouseButtons ButtonX2()
Definition: hps.h:40594
Definition: hps.h:19252
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, Info::Code in_code)
Definition: hps.h:39904
void SetKeyboardCodes(size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[])
Definition: hps.h:40838
Definition: hps.h:42409
Definition: hps.h:37001
Definition: hps.h:18612
Type ObjectType() const
Definition: hps.h:36821
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5557
Definition: hps.h:1479
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5805
bool Middle() const
Definition: hps.h:40504
Definition: hps.h:452
Driver
Definition: hps.h:147
Type ObjectType() const
Definition: hps.h:40878
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2134
Definition: hps.h:34451
Type ObjectType() const
Definition: hps.h:38169
CappingLevel
Definition: hps.h:1712
Definition: hps.h:40740
Type ObjectType() const
Definition: hps.h:22693
Type ObjectType() const
Definition: hps.h:34882
Definition: hps.h:8883
Object space units ignoring any scaling components in modelling matrices.
Type ObjectType() const
Definition: hps.h:12266
Type ObjectType() const
Definition: hps.h:40956
Type ObjectType() const
Definition: hps.h:19994
Definition: hps.h:25795
Type ObjectType() const
Definition: hps.h:13283
InputEvent()
Definition: hps.h:40258
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5417
static MouseButtons ButtonRight()
Definition: hps.h:40582
Type ObjectType() const
Definition: hps.h:28201
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3800
Definition: hps.h:5457
Definition: hps.h:34717
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40777
static ModifierKeys KeyMeta()
Definition: hps.h:40232
Type ObjectType() const
Definition: hps.h:34617
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1490
Definition: hps.h:22859
Type ObjectType() const
Definition: hps.h:35996
Definition: hps.h:16151
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:40469
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3679
Definition: hps.h:34109
Type ObjectType() const
Definition: hps.h:19057
Type ObjectType() const
Definition: hps.h:38341
Type ObjectType() const
Definition: hps.h:22891
Type ObjectType() const
Definition: hps.h:34188
Definition: hps.h:21756
Type ObjectType() const
Definition: hps.h:16264
MouseButtons()
Definition: hps.h:40464
Type ObjectType() const
Definition: hps.h:37410
Definition: hps.h:19762
Time GetTimeStamp() const
Definition: hps.h:6035
Definition: hps.h:42536
void Left(bool in_state)
Definition: hps.h:40527
Type ObjectType() const
Definition: hps.h:21726
NormalizedPoint(Point const &in_point)
Definition: hps.h:5710
Type ObjectType() const
Definition: hps.h:23240
Event * Clone() const
Definition: hps.h:39672
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3728
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:40523
Renderer
Definition: hps.h:1561
Type ObjectType() const
Definition: hps.h:33170
Definition: hps.h:39163
KeyboardEvent()
Definition: hps.h:40753
Type ObjectType() const
Definition: hps.h:7084
Definition: hps.h:36788
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3908
ObjectPoint(Point const &in_point)
Definition: hps.h:5560
Type ObjectType() const
Definition: hps.h:17142
Definition: hps.h:32640
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:38945
Definition: hps.h:4294
Definition: hps.h:6518
Definition: hps.h:1310
Definition: hps.h:39693
Definition: hps.h:23680
Point_3D< F > min
Definition: hps.h:3663
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:39986
static ModifierKeys KeyAlt()
Definition: hps.h:40228
bool IsConsumable() const
Definition: hps.h:6038
Definition: hps.h:1033
size_t GetHash() const
Definition: hps.h:1651
MaterialPreference
Definition: hps.h:1729
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40766
Mobility
Definition: hps.h:188
Type ObjectType() const
Definition: hps.h:12776
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5758
Definition: hps.h:14121
InterpolationAlgorithm
Definition: hps.h:1496
Fill
Definition: hps.h:1897
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3716
Definition: hps.h:23134
Definition: hps.h:18795
Type ObjectType() const
Definition: hps.h:26693
Type ObjectType() const
Definition: hps.h:18635
char At(size_t in_index) const
Definition: hps.h:6752
Definition: hps.h:39014
Definition: hps.h:4320
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:40168
Type ObjectType() const
Definition: hps.h:35009
Definition: hps.h:122
ReferenceFrame
Definition: hps.h:1528
Definition: hps.h:25179
Bloom Shape.
Definition: hps.h:41012
Definition: hps.h:37388
Definition: hps.h:3661
Definition: hps.h:3658
Type ObjectType() const
Definition: hps.h:16471
GreekingUnits
Definition: hps.h:1615
Definition: hps.h:18162
Definition: hps.h:7136
Type ObjectType() const
Definition: hps.h:11678
InnerConeUnits
Definition: hps.h:471
Definition: hps.h:25985
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5854
static MouseButtons ButtonX1()
Definition: hps.h:40590
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40062
Definition: hps.h:17881
Definition: hps.h:3348
OuterConeUnits
Definition: hps.h:457
Definition: hps.h:6285
void X2(bool in_state)
Definition: hps.h:40543
Type ObjectType() const
Definition: hps.h:18419
Type ObjectType() const
Definition: hps.h:39493
Type ObjectType() const
Definition: hps.h:38438
Type ObjectType() const
Definition: hps.h:13879
Definition: hps.h:14414
Definition: hps.h:1978
Type ObjectType() const
Definition: hps.h:32673
void SetKeyboardCodes(KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:40845
Type ObjectType() const
Definition: hps.h:26087
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40404
Type ObjectType() const
Definition: hps.h:12149
Type ObjectType() const
Definition: hps.h:24424
Definition: hps.h:426
Type ObjectType() const
Definition: hps.h:35460
Definition: hps.h:21226
Channel
Definition: hps.h:889
Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:39886
AreaUnits
Definition: hps.h:1442
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3770
Definition: hps.h:37190
Type ObjectType() const
Definition: hps.h:11501
Definition: hps.h:8144
Definition: hps.h:26065
Definition: hps.h:19034
Type ObjectType() const
Definition: hps.h:33790
Action
Definition: hps.h:39968
Event * Clone() const
Definition: hps.h:39784
Type ObjectType() const
Definition: hps.h:13717
Definition: hps.h:4569
Type ObjectType() const
Definition: hps.h:41441
Type ObjectType() const
Definition: hps.h:26794
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6318
Definition: hps.h:20691
Definition: hps.h:4451
Type ObjectType() const
Definition: hps.h:36939
Type ObjectType() const
Definition: hps.h:33307
Definition: hps.h:1369
Definition: hps.h:17352
Definition: hps.h:864
Definition: hps.h:5443
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40337
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3866
Border
Definition: hps.h:249
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:40163
Definition: hps.h:36906
Definition: hps.h:35107
Definition: hps.h:7126
Type ObjectType() const
Definition: hps.h:22463
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:40814
Type ObjectType() const
Definition: hps.h:20790
WarningEvent(Event const &in_event)
Definition: hps.h:39837
Definition: hps.h:36019
Type ObjectType() const
Definition: hps.h:11004
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1916
Definition: hps.h:1697
static ModifierKeys KeyShift()
Definition: hps.h:40220
Definition: hps.h:142
Type ObjectType() const
Definition: hps.h:27927
Shape
Definition: hps.h:1058
bool IsValid() const
Definition: hps.h:6702
Definition: hps.h:19971
Definition: hps.h:1508
Cuboid_3D()
Definition: hps.h:3671
ErrorEvent(Event const &in_event)
Definition: hps.h:39908
size_t GetWStrLength() const
Definition: hps.h:6731
Event * Clone() const
Definition: hps.h:39737
Type ObjectType() const
Definition: hps.h:10595
AppendMode
Definition: hps.h:317
Definition: hps.h:8173
Definition: hps.h:24672
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:40508
Definition: hps.h:221
Definition: hps.h:40081
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3851
void Meta(bool in_state)
Definition: hps.h:40185
Definition: hps.h:6470
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5953
Definition: hps.h:26166
Type ObjectType() const
Definition: hps.h:14147
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3721
Type ObjectType() const
Definition: hps.h:37522
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40033
Definition: hps.h:20495
Quality
Definition: hps.h:1042
ResolutionUnits
Definition: hps.h:41711
Event * Clone() const
Definition: hps.h:40268
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:40306
Definition: hps.h:4393
TimerTickEvent(Event const &in_event)
Definition: hps.h:39662
Component
Definition: hps.h:337
Definition: hps.h:42107
Definition: hps.h:5552
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5904
Type ObjectType() const
Definition: hps.h:11765
Definition: hps.h:11891
Default
Definition: hps.h:1870
Type ObjectType() const
Definition: hps.h:10225
Definition: hps.h:16448
Definition: hps.h:2074
Definition: hps.h:24130
InformationEvent()
Definition: hps.h:39753
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:4965
Definition: hps.h:36740
Definition: hps.h:11104
Definition: hps.h:13340
Definition: hps.h:10571
Definition: hps.h:42489
bool Shift() const
Definition: hps.h:40145
SizeToleranceUnits
Definition: hps.h:1602
Type ObjectType() const
Definition: hps.h:37646
Definition: hps.h:1749
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:3937
Cap
Definition: hps.h:1821
Point_3D< F > max
Definition: hps.h:3665
Type ObjectType() const
Definition: hps.h:7164
Definition: hps.h:10837
Definition: hps.h:20295
Definition: hps.h:13446
Type ObjectType() const
Definition: hps.h:42021
Type ObjectType() const
Definition: hps.h:42129
MouseEvent()
Definition: hps.h:40631
Definition: hps.h:13517
Type ObjectType() const
Definition: hps.h:11606
Definition: hps.h:19524
Definition: hps.h:26437
Definition: hps.h:1052
Type ObjectType() const
Definition: hps.h:16173
Definition: hps.h:11799
Definition: hps.h:31487
Type ObjectType() const
Definition: hps.h:34233
Definition: hps.h:12125
static const float Infinity
Definition: hps.h:2129
InsetBehavior
Definition: hps.h:1802
Type ObjectType() const
Definition: hps.h:24350
Definition: hps.h:5526
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2142
Type ObjectType() const
Definition: hps.h:13171
Type ObjectType() const
Definition: hps.h:26387
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6317
Type ObjectType() const
Definition: hps.h:34423
Type ObjectType() const
Definition: hps.h:36685
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3830
Algorithm
Definition: hps.h:1430
Definition: hps.h:40934
Decimation
Definition: hps.h:999
StaticModel
Definition: hps.h:1100
Definition: hps.h:37622
Granularity
Definition: hps.h:1351
Parameterization
Definition: hps.h:37053
Definition: hps.h:35917
DisplayLists
Definition: hps.h:1078
Definition: hps.h:10403
Search the current segment only.
Definition: hps.h:2588
Definition: hps.h:41414
Definition: hps.h:541
KeyboardEvent(Event const &in_event)
Definition: hps.h:40786
Definition: hps.h:20542
Definition: hps.h:34160
Definition: hps.h:33680
ClipOperation
Definition: hps.h:1290
Type ObjectType() const
Definition: hps.h:8445
Definition: hps.h:2501
Definition: hps.h:29384
Method
Definition: hps.h:1420
Definition: hps.h:35963
Type ObjectType() const
Definition: hps.h:25827
Definition: hps.h:41658
Parameterization
Definition: hps.h:944
Definition: hps.h:4211
Definition: hps.h:36214
Definition: hps.h:35433
FocusLostEvent()
Definition: hps.h:40041
CuttingLevel
Definition: hps.h:1721
Channel
Definition: hps.h:910
Definition: hps.h:8964
Definition: hps.h:42298
HandleResult
Definition: hps.h:39633
Definition: hps.h:38147
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:4977
Definition: hps.h:5800
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:39956
Value
Definition: hps.h:1401
Definition: hps.h:1072
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2150
Code
Definition: hps.h:99
Type ObjectType() const
Definition: hps.h:25343
Event * Clone() const
Definition: hps.h:40049
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:40685
Definition: hps.h:40614
ErrorEvent()
Definition: hps.h:39895
Definition: hps.h:39962
Justification
Definition: hps.h:1536
The vertex colors applied to faces.
Definition: hps.h:6390
Type ObjectType() const
Definition: hps.h:13541
Definition: hps.h:34289
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5435
ErrorEvent(char const *in_message)
Definition: hps.h:39899
Definition: hps.h:40310
FrameSize
Definition: hps.h:199
Definition: hps.h:2089
Definition: hps.h:8774
Definition: hps.h:22944
Definition: hps.h:11583
Justification
Definition: hps.h:1838
Definition: hps.h:20983
Type ObjectType() const
Definition: hps.h:11326
Definition: hps.h:39470
Definition: hps.h:36949
Type ObjectType() const
Definition: hps.h:19276
Definition: hps.h:1675
Definition: hps.h:1456
Type ObjectType() const
Definition: hps.h:21557
bool None() const
Definition: hps.h:40492
Definition: hps.h:301
Definition: hps.h:1395
Type ObjectType() const
Definition: hps.h:8240
Type ObjectType() const
Definition: hps.h:35950
Type ObjectType() const
Definition: hps.h:34137
Definition: hps.h:17119
GreekingMode
Definition: hps.h:1627
Type ObjectType() const
Definition: hps.h:19786
Definition: hps.h:35325
KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:40850
Operation
Definition: hps.h:440
Definition: hps.h:1414
Type ObjectType() const
Definition: hps.h:36530
Type
Definition: hps.h:1984
WorldPoint(Point const &in_point)
Definition: hps.h:5610
TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:40444
Definition: hps.h:42269
Type ObjectType() const
Definition: hps.h:9424
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2421
Definition: hps.h:21956
Definition: hps.h:33903
Type ObjectType() const
Definition: hps.h:6549
Definition: hps.h:17424
TouchEvent(Event const &in_event)
Definition: hps.h:40352
void SetTouches(TouchArray const &in_touches)
Definition: hps.h:40438
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6834
Definition: hps.h:4948
Definition: hps.h:38415
Definition: hps.h:42293
Definition: hps.h:34390
Definition: hps.h:4150
Relation
Definition: hps.h:363
Action
Definition: hps.h:40745
ChannelMapping
Definition: hps.h:1013
Type ObjectType() const
Definition: hps.h:22075
Definition: hps.h:6647
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5452
Type ObjectType() const
Definition: hps.h:37988
Type ObjectType() const
Definition: hps.h:38627
Definition: hps.h:23218
Definition: hps.h:5653
bool Alt() const
Definition: hps.h:40153
Definition: hps.h:40460
ToleranceUnits
Definition: hps.h:346
Definition: hps.h:23997
Definition: hps.h:26661
Definition: hps.h:37048
Type ObjectType() const
Definition: hps.h:12076
SizeUnits
Definition: hps.h:1789
Type
Definition: hps.h:2001
Type ObjectType() const
Definition: hps.h:17271
The vertex colors applied to faces.
RelationTest
Definition: hps.h:373
Definition: hps.h:38319
Type
Definition: hps.h:308
Type ObjectType() const
Definition: hps.h:14291
Behavior
Definition: hps.h:555
Definition: hps.h:5603
Ambient Occulsion Quality.
Type ObjectType() const
Definition: hps.h:6624
KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:40851
Definition: hps.h:39649
Type ObjectType() const
Definition: hps.h:18185
Style Append Mode.
Definition: hps.h:37671
Definition: hps.h:24820
Definition: hps.h:40856
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5426
float blue
Definition: hps.h:4216
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:40037
Type
Definition: hps.h:413
Type ObjectType() const
Definition: hps.h:20565
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6852
PixelPoint(Point const &in_point)
Definition: hps.h:5956
Type ObjectType() const
Definition: hps.h:6078
Type ObjectType() const
Definition: hps.h:6927
Definition: hps.h:17247
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40711
Definition: hps.h:20408
Definition: hps.h:41611
Type ObjectType() const
Definition: hps.h:21126
Type ObjectType() const
Definition: hps.h:21006
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
Type ObjectType() const
Definition: hps.h:34376
Type ObjectType() const
Definition: hps.h:28070
Type ObjectType() const
Definition: hps.h:23511
Type ObjectType() const
Definition: hps.h:38267
Type ObjectType() const
Definition: hps.h:20431
MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:40731
Event * Clone() const
Definition: hps.h:40099
Definition: hps.h:13841
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:4971
Definition: hps.h:34976
Definition: hps.h:40058
Type ObjectType() const
Definition: hps.h:33704
Type ObjectType() const
Definition: hps.h:39602
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:41263
Type ObjectType() const
Definition: hps.h:15322
Definition: hps.h:1892
Definition: hps.h:30441
Infinite line which extends infinitely in both directions along a vector.
InformationEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39762
intptr_t GetChannel() const
Definition: hps.h:6032
Type ObjectType() const
Definition: hps.h:8798
Definition: hps.h:1329
Definition: hps.h:13147
Algorithm
Definition: hps.h:1343
Type ObjectType() const
Definition: hps.h:30463
Type ObjectType() const
Definition: hps.h:36982
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3788
Definition: hps.h:12053
Definition: hps.h:10201
Driver
Definition: hps.h:41855
Definition: hps.h:6893
Definition: hps.h:41099
SizeUnits
Definition: hps.h:1657
StandAloneWindowEvent()
Definition: hps.h:39977
Type ObjectType() const
Definition: hps.h:35529
Type ObjectType() const
Definition: hps.h:33542
ModifierKeys GetModifierKeys() const
Definition: hps.h:40301
Definition: hps.h:40109
Definition: hps.h:38596
Definition: hps.h:39820
Type ObjectType() const
Definition: hps.h:11914
Type ObjectType() const
Definition: hps.h:10745
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:39864
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:40639
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5398
Type ObjectType() const
Definition: hps.h:16982
Definition: hps.h:37337
Level
Definition: hps.h:1334
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:39793
bool X2() const
Definition: hps.h:40512
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:40118
Definition: hps.h:33520
Definition: hps.h:42222
bool Left() const
Definition: hps.h:40496
void Control(bool in_state)
Definition: hps.h:40177
Definition: hps.h:21094
Definition: hps.h:41872
Definition: hps.h:2838
Definition: hps.h:16531
Definition: hps.h:40253
Type ObjectType() const
Definition: hps.h:41639
Type ObjectType() const
Definition: hps.h:17693
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3922
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:39885
The base class of all HPS exceptions.
Definition: hps.h:5390
RegionAlignment
Definition: hps.h:1636
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40346
Event * Clone() const
Definition: hps.h:40676
Definition: hps.h:5999
Type ObjectType() const
Definition: hps.h:20714
Definition: hps.h:36457
InformationEvent(Event const &in_event)
Definition: hps.h:39766
Definition: hps.h:12328
void Invalidate()
Definition: hps.h:3733
Definition: hps.h:22431
Definition: hps.h:37965
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4712
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5449
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40065
Type ObjectType() const
Definition: hps.h:33030
Definition: hps.h:5949
Type ObjectType() const
Definition: hps.h:38864
Definition: hps.h:41725
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6025
Definition: hps.h:388
char const * GetBytes() const
Definition: hps.h:6738
Definition: hps.h:37212
virtual intptr_t Freshen() const
Definition: hps.h:40723
Definition: hps.h:33401
Type ObjectType() const
Definition: hps.h:34485
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:40262
float green
Definition: hps.h:4215
Action
Definition: hps.h:40620
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1681
Type ObjectType() const
Definition: hps.h:9829
Type ObjectType() const
Definition: hps.h:26459
Type ObjectType() const
Definition: hps.h:24029
Type ObjectType() const
Definition: hps.h:23785
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10028
Type ObjectType() const
Definition: hps.h:37034
Type ObjectType() const
Definition: hps.h:24152
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5857
Type ObjectType() const
Definition: hps.h:41899
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5707
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6297
static const float NegativeInfinity
Definition: hps.h:2131
HighlightEvent(Event const &in_event)
Definition: hps.h:39720
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6843
SizeUnits
Definition: hps.h:1462
Type ObjectType() const
Definition: hps.h:12352
Type ObjectType() const
Definition: hps.h:20172
Definition: hps.h:20767
MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:40733
Type ObjectType() const
Definition: hps.h:10050
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5808
GatheringLevel
Definition: hps.h:1737
Type ObjectType() const
Definition: hps.h:28280
Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:39815
Definition: hps.h:39575
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3700
Definition: hps.h:11948
FrameOptions
Definition: hps.h:208
Type ObjectType() const
Definition: hps.h:34326
Space
Definition: hps.h:8151
void Alt(bool in_state)
Definition: hps.h:40181
Definition: hps.h:6902
Buttons
Definition: hps.h:40600
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40758
Type ObjectType() const
Definition: hps.h:36257
Type
Definition: hps.h:243
bool operator!=(Touch const &in_that) const
Definition: hps.h:6311
Definition: hps.h:39191
Definition: hps.h:23406
Definition: hps.h:94
Type
Definition: hps.h:431
Type ObjectType() const
Definition: hps.h:41178
Definition: hps.h:12243
Type ObjectType() const
Definition: hps.h:42431
Type ObjectType() const
Definition: hps.h:37234
Type ObjectType() const
Definition: hps.h:42320
Type ObjectType() const
Definition: hps.h:32761
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5607
Type ObjectType() const
Definition: hps.h:8988
Type ObjectType() const
Definition: hps.h:42517
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6825
Definition: hps.h:22671
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:40431
Definition: hps.h:34211
Definition: hps.h:1256
Event * Clone() const
Definition: hps.h:40371
void Middle(bool in_state)
Definition: hps.h:40535
Definition: hps.h:28258
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:39935
Event * Clone() const
Definition: hps.h:40003
size_t GetLength() const
Definition: hps.h:6723
Type ObjectType() const
Definition: hps.h:20518
Type ObjectType() const
Definition: hps.h:26017
Type
Definition: hps.h:1119
Definition: hps.h:408
Type ObjectType() const
Definition: hps.h:8906
bool None() const
Definition: hps.h:40141
size_t ClickCount
The number of clicks received.
Definition: hps.h:40735
virtual intptr_t Freshen() const
Definition: hps.h:6029
void Reset()
Definition: hps.h:6718
Type ObjectType() const
Definition: hps.h:36768
Type ObjectType() const
Definition: hps.h:23166
Definition: hps.h:33274
Type ObjectType() const
Definition: hps.h:38968
Definition: hps.h:38244
SizeUnits
Definition: hps.h:1590
Event * Clone() const
Definition: hps.h:39926
MouseEvent(Event const &in_event)
Definition: hps.h:40654
bool Right() const
Definition: hps.h:40500
Definition: hps.h:1996
virtual bool Empty() const
Definition: hps.h:5490
Join
Definition: hps.h:1812
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3844
Modifier
Definition: hps.h:1849
static MouseButtons ButtonLeft()
Definition: hps.h:40578
static MouseButtons ButtonMiddle()
Definition: hps.h:40586
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40329
HighlightEvent()
Definition: hps.h:39704
virtual Type ObjectType() const
Definition: hps.h:5486
Definition: hps.h:18395
Type ObjectType() const
Definition: hps.h:13364
Definition: hps.h:27910
Definition: hps.h:16242
Definition: hps.h:5702
TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:40443
Definition: hps.h:8211
Type
Definition: hps.h:566
virtual intptr_t Freshen() const
Definition: hps.h:39687
Background
Definition: hps.h:224
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3777
Definition: hps.h:41720
static ModifierKeys KeyControl()
Definition: hps.h:40224
Type ObjectType() const
Definition: hps.h:17905
Definition: hps.h:5408
Type ObjectType() const
Definition: hps.h:34739
Definition: hps.h:7058
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5755
Type ObjectType() const
Definition: hps.h:38760
StandAloneWindowEvent(Action in_action)
Definition: hps.h:39982
Mode
Definition: hps.h:1702
Definition: hps.h:32440
Definition: hps.h:10722
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:39814
Event * Clone() const
Definition: hps.h:40071
Definition: hps.h:33136
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:3981
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3812
Definition: hps.h:32998
Type
Definition: hps.h:869
Definition: hps.h:331
Definition: hps.h:14268
Definition: hps.h:20842
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3765
Definition: hps.h:904
Type ObjectType() const
Definition: hps.h:11823
Definition: hps.h:34921
Type ObjectType() const
Definition: hps.h:31520
Type ObjectType() const
Definition: hps.h:17375
Definition: hps.h:41151
Type ObjectType() const
Definition: hps.h:36866
Definition: hps.h:41877
Definition: hps.h:34595
Type ObjectType() const
Definition: hps.h:41285
Definition: hps.h:5751
Definition: hps.h:37080
Type ObjectType() const
Definition: hps.h:41034
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3751
Type ObjectType() const
Definition: hps.h:36041
Definition: hps.h:34860
Type ObjectType() const
Definition: hps.h:11972
Type ObjectType() const
Definition: hps.h:17448
Definition: hps.h:23489
Mode
Definition: hps.h:1755
Definition: hps.h:8413
Event * Clone() const
Definition: hps.h:40805
Definition: hps.h:9805
Tiling
Definition: hps.h:972
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:3966
WindowPoint(Point const &in_point)
Definition: hps.h:5907
Transform
Definition: hps.h:1545
Type ObjectType() const
Definition: hps.h:36355
Definition: hps.h:10981
Definition: hps.h:39749
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:21429
Definition: hps.h:34344
Definition: hps.h:26772
Definition: hps.h:21694
Grid composed of quadrilaterals.
Type ObjectType() const
Definition: hps.h:37693
Definition: hps.h:25321
Definition: hps.h:924
ModifierKeys()
Definition: hps.h:40113
Definition: hps.h:24402
Definition: hps.h:1784
Definition: hps.h:22053
Definition: hps.h:27384
Preference
Definition: hps.h:1570
Type ObjectType() const
Definition: hps.h:24704
Capping
Definition: hps.h:511
Definition: hps.h:39891
Type ObjectType() const
Definition: hps.h:34557
TouchEvent()
Definition: hps.h:40323
Interpolation
Definition: hps.h:988
Type ObjectType() const
Definition: hps.h:19547
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:40277
WarningEvent(char const *in_message)
Definition: hps.h:39828
Type ObjectType() const
Definition: hps.h:20318
Modifiers
Definition: hps.h:40238
Component
Definition: hps.h:503
Definition: hps.h:498
Definition: hps.h:9401
Definition: hps.h:36661
Type ObjectType() const
Definition: hps.h:35047
Type ObjectType() const
Definition: hps.h:6414
Type ObjectType() const
Definition: hps.h:21988
Definition: hps.h:16958
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:3951
Type ObjectType() const
Definition: hps.h:41747
Type ObjectType() const
Definition: hps.h:21778
Definition: hps.h:3124
Format
Definition: hps.h:36219
WarningEvent()
Definition: hps.h:39824
Definition: hps.h:24318
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:39681
Touch()
Definition: hps.h:6291
Definition: hps.h:11742
Definition: hps.h:35014
Component
Definition: hps.h:393
Definition: hps.h:32745
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:38737
Definition: hps.h:1114
float red
Definition: hps.h:4214
ClipSpace
Definition: hps.h:1298
Definition: hps.h:11654
Definition: hps.h:36833
Definition: hps.h:15299
Control & operator=(Control &&in_that)
Definition: hps.h:5543
WarningEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39833
Type ObjectType() const
Definition: hps.h:13469
Definition: hps.h:28179
SizeUnits
Definition: hps.h:41704
void Right(bool in_state)
Definition: hps.h:40531
virtual void Reset()
Definition: hps.h:39625
Definition: hps.h:11303
Type ObjectType() const
Definition: hps.h:10860
bool Meta() const
Definition: hps.h:40157
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:3993
Definition: hps.h:34524
TimerTickEvent()
Definition: hps.h:39653
Definition: hps.h:37500
Definition: hps.h:36235
Type ObjectType() const
Definition: hps.h:21461
RenderingAlgorithm
Definition: hps.h:260
EmergencyHandler()
Definition: hps.h:39168
Definition: hps.h:34031
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5657
TouchID ID
TouchID for this Touch.
Definition: hps.h:6316
Definition: hps.h:35496
Type ObjectType() const
Definition: hps.h:10426
Type ObjectType() const
Definition: hps.h:32462
Definition: hps.h:41699
Definition: hps.h:6055
Definition: hps.h:23763
HandednessOptimization
Definition: hps.h:354
Definition: hps.h:6597
Projection
Definition: hps.h:1380
Control(Control &&in_that)
Definition: hps.h:5538
bool Control() const
Definition: hps.h:40149
Definition: hps.h:5316
Type ObjectType() const
Definition: hps.h:33925
Overlay
Definition: hps.h:1270
Definition: hps.h:28048
Definition: hps.h:5849
Definition: hps.h:36333
Definition: hps.h:41999
Type ObjectType() const
Definition: hps.h:37102
size_t GetHash() const
Status
Definition: hps.h:6005
Definition: hps.h:21535
Type ObjectType() const
Definition: hps.h:34055
Type ObjectType() const
Definition: hps.h:6496
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:40734
Definition: hps.h:36502
Definition: hps.h:41156
Definition: hps.h:26355
Type ObjectType() const
Definition: hps.h:41121