15 # ifdef HPS_CORE_BUILD
16 # define HPS_API __declspec (dllexport)
17 # define EXPIMP_TEMPLATE
19 # define HPS_API __declspec (dllimport)
20 # define EXPIMP_TEMPLATE extern
22 # define HPS_TEMPLATE_API __declspec (dllexport)
32 # pragma warning(push)
33 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
39 # ifdef HPS_CORE_BUILD
40 # define HPS_API __attribute__ ((visibility ("default")))
41 # define EXPIMP_TEMPLATE
43 # define EXPIMP_TEMPLATE extern
45 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
52 #ifndef HPS_TEMPLATE_API
53 # define HPS_TEMPLATE_API
55 #ifndef EXPIMP_TEMPLATE
56 # define EXPIMP_TEMPLATE
59 # define ENUM_CLASS enum class
75 # if !defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
79 # define OVERRIDE override
87 class EventDispatcherImpl;
263 GradientTopLeftToBottomRight,
264 GradientTopRightToBottomLeft,
265 GradientBottomLeftToTopRight,
266 GradientBottomRightToTopLeft,
372 FeatureSizePercentage
566 SubsegmentsAndIncludes
582 Everything = 0x00ffffff,
584 Include = 0x00000042,
585 Segment = 0x00000043,
587 Includer = 0x00000100,
590 Geometry = 0x10000000,
596 NURBSSurface = 0x1000002b,
599 Polygon = 0x1000002f,
602 CircularWedge = 0x10000032,
603 Ellipse = 0x10000033,
605 NURBSCurve = 0x10000037,
606 CircularArc = 0x10000038,
607 EllipticalArc = 0x10000039,
612 Reference = 0x10000040,
614 DistantLight = 0x10000100,
616 InfiniteRay = 0x10000102,
619 Attribute = 0x20000000,
621 Priority = 0x20000001,
626 ModellingMatrix = 0x20000010,
627 UserData = 0x20000021,
628 TextureMatrix = 0x20000023,
631 Culling = 0x20001000,
632 CullingBackFace = 0x20001001,
633 CullingExtent = 0x20001002,
634 CullingVector = 0x20001003,
635 CullingVectorTolerance = 0x20001004,
636 CullingFrustum = 0x20001005,
637 CullingDeferralExtent = 0x20001006,
639 CurveAttribute = 0x20002000,
640 CurveAttributeBudget = 0x20002001,
641 CurveAttributeContinuedBudget = 0x20002002,
642 CurveAttributeViewDependent = 0x20002003,
643 CurveAttributeMaximumDeviation = 0x20002004,
644 CurveAttributeMaximumAngle = 0x20002005,
645 CurveAttributeMaximumLength = 0x20002006,
647 CylinderAttribute = 0x20003000,
648 CylinderAttributeTessellation = 0x20003001,
649 CylinderAttributeOrientation = 0x20003002,
651 EdgeAttribute = 0x20004000,
652 EdgeAttributePattern = 0x20004015,
653 EdgeAttributeWeight = 0x20004016,
654 EdgeAttributeHardAngle = 0x20004017,
656 LightingAttribute = 0x20005000,
657 LightingAttributeInterpolation = 0x20005001,
659 LineAttribute = 0x20006000,
660 LineAttributePattern = 0x20006019,
661 LineAttributeWeight = 0x2000601a,
663 MarkerAttribute = 0x20007000,
664 MarkerAttributeSize = 0x2000701b,
665 MarkerAttributeSymbol = 0x2000701c,
667 SurfaceAttribute = 0x20008000,
668 SurfaceAttributeBudget = 0x20008001,
669 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
670 SurfaceAttributeMaximumFacetAngle = 0x20008003,
671 SurfaceAttributeMaximumFacetWidth = 0x20008004,
672 SurfaceAttributeTrimCurveBudget = 0x20008005,
673 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
676 SelectabilityWindows = 0x20009001,
677 SelectabilityEdges = 0x20009002,
678 SelectabilityFaces = 0x20009003,
679 SelectabilityLights = 0x20009004,
680 SelectabilityLines = 0x20009005,
681 SelectabilityMarkers = 0x20009006,
682 SelectabilityVertices = 0x20009007,
683 SelectabilityText = 0x20009008,
685 SphereAttribute = 0x2000a000,
686 SphereAttributeTessellation = 0x2000a001,
689 SubwindowEitherType = 0x2000b001,
690 SubwindowStandard = 0x2000b00d,
691 SubwindowLightweight = 0x2000b002,
692 SubwindowBackground = 0x2000b003,
693 SubwindowBorder = 0x2000b004,
694 SubwindowRenderingAlgorithm = 0x2000b005,
696 TextAttribute = 0x2000c000,
697 TextAttributeAlignment = 0x2000c01d,
698 TextAttributeBold = 0x2000c002,
699 TextAttributeItalic = 0x2000c003,
700 TextAttributeOverline = 0x2000c004,
701 TextAttributeStrikethrough = 0x2000c005,
702 TextAttributeUnderline = 0x2000c006,
703 TextAttributeSlant = 0x2000c007,
704 TextAttributeLineSpacing = 0x2000c008,
705 TextAttributeRotation = 0x2000c00a,
706 TextAttributeExtraSpace = 0x2000c00b,
707 TextAttributeGreeking = 0x2000c00c,
708 TextAttributeSizeTolerance = 0x2000c00d,
709 TextAttributeSize = 0x2000c00e,
710 TextAttributeFont = 0x2000c00f,
711 TextAttributeTransform = 0x2000c010,
712 TextAttributeRenderer = 0x2000c011,
713 TextAttributePreference = 0x2000c012,
714 TextAttributePath = 0x2000c01f,
715 TextAttributeSpacing = 0x2000c020,
718 TransparencyMethod = 0x2000d001,
719 TransparencyAlgorithm = 0x2000d002,
720 TransparencyDepthPeelingLayers = 0x2000d004,
721 TransparencyDepthPeelingMinimumArea = 0x2000d005,
722 TransparencyDepthWriting = 0x2000d006,
724 Visibility = 0x2000e000,
725 VisibilityCuttingSections = 0x2000e001,
726 VisibilityCutEdges = 0x2000e002,
727 VisibilityCutFaces = 0x2000e003,
728 VisibilityWindows = 0x2000e004,
729 VisibilityText = 0x2000e005,
730 VisibilityLines = 0x2000e006,
731 VisibilityEdgeLights = 0x2000e007,
732 VisibilityMarkerLights = 0x2000e008,
733 VisibilityFaceLights = 0x2000e009,
734 VisibilityGenericEdges = 0x2000e00a,
735 VisibilityHardEdges = 0x2000e00b,
736 VisibilityAdjacentEdges = 0x2000e00c,
737 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
738 VisibilityShadowEmitting = 0x2000e00e,
739 VisibilityShadowReceiving = 0x2000e00f,
740 VisibilityShadowCasting = 0x2000e010,
741 VisibilityMarkers = 0x2000e011,
742 VisibilityVertices = 0x2000e012,
743 VisibilityFaces = 0x2000e013,
744 VisibilityPerimeterEdges = 0x2000e014,
745 VisibilityNonCulledEdges = 0x2000e015,
746 VisibilityMeshQuadEdges = 0x2000e016,
748 VisualEffects = 0x2000f000,
749 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
750 VisualEffectsAntiAliasing = 0x2000f002,
751 VisualEffectsShadowMaps = 0x2000f003,
752 VisualEffectsSimpleShadow = 0x2000f004,
753 VisualEffectsSimpleShadowPlane = 0x2000f005,
754 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
755 VisualEffectsSimpleShadowColor = 0x2000f007,
756 VisualEffectsSimpleReflection = 0x2000f008,
757 VisualEffectsSimpleReflectionPlane = 0x2000f009,
758 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
761 PerformanceDisplayLists = 0x20010001,
762 PerformanceStaticModel = 0x20010002,
763 StaticModelSegment = 0x40000043,
765 DrawingAttribute = 0x20011000,
766 DrawingAttributePolygonHandedness = 0x20011001,
767 DrawingAttributeDepthRange = 0x20011002,
768 DrawingAttributeFaceDisplacement = 0x20011003,
769 DrawingAttributeGeneralDisplacement = 0x20011004,
770 DrawingAttributeVertexDisplacement = 0x20011005,
771 DrawingAttributeOverlay = 0x20011006,
772 DrawingAttributeDeferral = 0x20011007,
773 DrawingAttributeClipRegion = 0x20011012,
774 DrawingAttributeWorldHandedness = 0x20011018,
776 HiddenLineAttribute = 0x20012000,
777 HiddenLineAttributeColor = 0x20012001,
778 HiddenLineAttributeDimFactor = 0x20012002,
779 HiddenLineAttributeFaceDisplacement = 0x20012003,
780 HiddenLineAttributeLinePattern = 0x20012005,
781 HiddenLineAttributeRenderFaces = 0x20012006,
782 HiddenLineAttributeRenderText = 0x20012007,
783 HiddenLineAttributeAlgorithm = 0x20012008,
784 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
785 HiddenLineAttributeVisibility = 0x2001200a,
786 HiddenLineAttributeWeight = 0x2001200b,
787 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
789 SegmentStyle = 0x20013001,
790 NamedStyle = 0x20013002,
791 MaterialPalette = 0x20013003,
792 Portfolio = 0x20013004,
795 ContourLineVisibility = 0x20014001,
796 ContourLinePosition = 0x20014002,
797 ContourLineColor = 0x20014003,
798 ContourLinePattern = 0x20014004,
799 ContourLineWeight = 0x20014005,
800 ContourLineLighting = 0x20014006,
805 BoundingVolume = 0x20016001,
806 BoundingExclusion = 0x20016002,
809 AttributeLockSetting = 0x20017001,
810 AttributeLockSubsegmentOverride = 0x20017002,
812 TransformMask = 0x20018000,
813 TransformMaskCamera = 0x20018001,
814 TransformMaskCameraTranslation = 0x20018002,
815 TransformMaskCameraScale = 0x20018003,
816 TransformMaskCameraOffset = 0x20018004,
817 TransformMaskCameraRotation = 0x20018005,
818 TransformMaskCameraPerspectiveScale = 0x20018006,
819 TransformMaskCameraProjection = 0x20018007,
820 TransformMaskModellingMatrix = 0x20018008,
821 TransformMaskModellingMatrixTranslation = 0x20018009,
822 TransformMaskModellingMatrixScale = 0x20018010,
823 TransformMaskModellingMatrixOffset = 0x20018011,
824 TransformMaskModellingMatrixRotation = 0x20018012,
826 ColorInterpolation = 0x20019000,
827 ColorInterpolationFaceColor = 0x20019001,
828 ColorInterpolationEdgeColor = 0x20019002,
829 ColorInterpolationMarkerColor = 0x20019003,
830 ColorInterpolationFaceIndex = 0x20019004,
831 ColorInterpolationEdgeIndex = 0x20019005,
832 ColorInterpolationMarkerIndex = 0x20019006,
834 CuttingSectionAttribute = 0x2001a000,
835 CuttingSectionAttributeCuttingLevel = 0x2001a001,
836 CuttingSectionAttributeCappingLevel = 0x2001a002,
837 CuttingSectionAttributeMaterialPreference = 0x2001a003,
879 EnvironmentTexture = 8,
880 EnvironmentCubeMap = 9,
918 EnvironmentTexture = 8,
919 EnvironmentCubeMap = 9
1063 PostProcessEffects() {}
1116 Everything = 0x01000000,
1118 Visibility = 0x02000000,
1120 VisibilityCuttingSections,
1126 VisibilityEdgeLights,
1127 VisibilityMarkerLights,
1128 VisibilityFaceLights,
1129 VisibilityGenericEdges,
1130 VisibilityHardEdges,
1131 VisibilityAdjacentEdges,
1132 VisibilityInteriorSilhouetteEdges,
1133 VisibilityShadowEmitting,
1134 VisibilityShadowReceiving,
1135 VisibilityShadowCasting,
1139 VisibilityPerimeterEdges,
1140 VisibilityNonCulledEdges,
1141 VisibilityMeshQuadEdges,
1142 VisibilityCutGeometry,
1151 MaterialCutGeometry,
1153 MaterialAmbientLightUpColor,
1154 MaterialAmbientLightDownColor,
1155 MaterialAmbientLightColor,
1157 MaterialWindowColor,
1158 MaterialWindowContrastColor,
1162 MaterialMarkerColor,
1164 MaterialCutEdgeColor,
1167 MaterialVertexDiffuse,
1168 MaterialVertexDiffuseColor,
1169 MaterialVertexDiffuseAlpha,
1170 MaterialVertexDiffuseTexture,
1171 MaterialVertexSpecular,
1172 MaterialVertexMirror,
1173 MaterialVertexTransmission,
1174 MaterialVertexEmission,
1175 MaterialVertexEnvironment,
1177 MaterialVertexGloss,
1180 MaterialEdgeDiffuse,
1181 MaterialEdgeDiffuseColor,
1182 MaterialEdgeDiffuseAlpha,
1183 MaterialEdgeDiffuseTexture,
1184 MaterialEdgeSpecular,
1186 MaterialEdgeTransmission,
1187 MaterialEdgeEmission,
1188 MaterialEdgeEnvironment,
1193 MaterialFaceDiffuse,
1194 MaterialFaceDiffuseColor,
1195 MaterialFaceDiffuseAlpha,
1196 MaterialFaceDiffuseTexture,
1197 MaterialFaceSpecular,
1199 MaterialFaceTransmission,
1200 MaterialFaceEmission,
1201 MaterialFaceEnvironment,
1206 MaterialBackFaceDiffuse,
1207 MaterialBackFaceDiffuseColor,
1208 MaterialBackFaceDiffuseAlpha,
1209 MaterialBackFaceDiffuseTexture,
1210 MaterialBackFaceSpecular,
1211 MaterialBackFaceMirror,
1212 MaterialBackFaceTransmission,
1213 MaterialBackFaceEmission,
1214 MaterialBackFaceEnvironment,
1215 MaterialBackFaceBump,
1216 MaterialBackFaceGloss,
1219 MaterialFrontFaceDiffuse,
1220 MaterialFrontFaceDiffuseColor,
1221 MaterialFrontFaceDiffuseAlpha,
1222 MaterialFrontFaceDiffuseTexture,
1223 MaterialFrontFaceSpecular,
1224 MaterialFrontFaceMirror,
1225 MaterialFrontFaceTransmission,
1226 MaterialFrontFaceEmission,
1227 MaterialFrontFaceEnvironment,
1228 MaterialFrontFaceBump,
1229 MaterialFrontFaceGloss,
1232 MaterialCutFaceDiffuse,
1233 MaterialCutFaceDiffuseColor,
1234 MaterialCutFaceDiffuseAlpha,
1235 MaterialCutFaceDiffuseTexture,
1236 MaterialCutFaceSpecular,
1237 MaterialCutFaceMirror,
1238 MaterialCutFaceTransmission,
1239 MaterialCutFaceEmission,
1240 MaterialCutFaceEnvironment,
1241 MaterialCutFaceBump,
1242 MaterialCutFaceGloss,
1542 CharacterPositionOnly,
1545 CharacterPositionAdjusted
1766 UnableToLoadLibraries,
1767 VersionIncompatibility,
1768 InitializationFailed,
1929 TriangleDownWithDot,
1932 TriangleRightWithDot,
1935 TriangleLeftWithDot,
1942 SolidTriangleRightV,
1990 enum class Intrinsic
2035 SubsegmentsAndIncludes,
2038 enum class Expansion
2043 IncludesAndReferences,
2053 enum class Reorganization
2085 NormalizedInnerWindow,
2086 NormalizedInnerPixel,
2096 typedef double Time;
2100 # define HPS_INLINE __forceinline
2103 # define HPS_INLINE inline
2106 #ifndef HPS_UNREFERENCED
2107 #define HPS_UNREFERENCED(param) ((void)(param))
2111 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2113 template<
typename T>
2114 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2116 return degrees * (T)(PI / 180.0);
2119 template<
typename T>
2120 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2122 return radians * (T)(180.0 / PI);
2125 template<
typename T>
2126 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2127 T a = Degrees_To_Radians(angle);
2132 template<
typename T>
2133 HPS_INLINE T Cos(T
const & angle) {
2134 return cos (Degrees_To_Radians(angle));
2137 template<
typename T>
2138 HPS_INLINE T Sin(T
const & angle) {
2139 return sin (Degrees_To_Radians(angle));
2142 template<
typename T>
2143 HPS_INLINE T ACos(T
const & x) {
2148 return Radians_To_Degrees(acos(x));
2151 template<
typename T>
2152 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2153 if (x == 0 && y == 0)
2155 return Radians_To_Degrees(atan2(y, x));
2161 typedef double Alternative;
2162 static const int Type = 1;
2163 static float Epsilon () {
return 1.0e-30f; }
2166 typedef float Alternative;
2167 static const int Type = 2;
2168 static double Epsilon () {
return 1.0e-300; }
2177 # if HOOPS_BIGENDIAN
2185 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2186 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2187 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2188 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2190 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2191 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2192 return exp == 0x7F800000 && mantissa != 0;
2194 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2195 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2196 return exp == 0x7F800000 && mantissa != 0;
2198 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2199 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2200 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2202 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2203 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2204 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2207 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2208 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2209 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2210 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2219 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2220 static HPS_INLINE
bool IsInfinite(
double const & a) {
2222 memcpy (v, &a,
sizeof(
double));
2223 return is_infinite (v);
2227 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2228 static HPS_INLINE
bool IsNAN(
double const & a) {
2230 memcpy (v, &a,
sizeof(
double));
2235 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2236 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2238 memcpy (v, &a,
sizeof(
double));
2239 return is_special (v);
2244 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2245 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2247 #ifndef HOOPS_DEFINED
2248 template <
typename Alloc>
2249 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2251 if (a.size() != b.size())
2254 auto it1 = a.begin();
2255 auto it2 = b.begin();
2256 auto const end = a.end();
2257 for ( ; it1 != end; ++it1, ++it2)
2259 if (!Equals(*it1, *it2, tolerance))
2266 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2267 return extract_uint32_t(a) & 0x80000000;
2269 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2271 memcpy (v, &a,
sizeof(
double));
2272 return v[High] & 0x80000000;
2275 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2276 uint32_t v = extract_uint32_t(a);
2279 inject_uint32_t(a, v);
2281 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2283 memcpy (v, &a,
sizeof(
double));
2284 v[High] &= 0x7FFFFFFF;
2285 v[High] |= sign_bit;
2286 memcpy (&a, v,
sizeof(
double));
2290 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2291 uint32_t v = extract_uint32_t(a);
2299 uint32_t exp = v >> 23;
2300 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2302 return (
unsigned char) (man >> (16 + 126 - exp));
2305 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2306 uint32_t v = extract_uint32_t(a);
2314 uint32_t exp = v >> 23;
2315 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2317 uint32_t x = (man >> (16 + 126 - exp));
2319 return (
unsigned char) ((x * (mix+1)) >> 8);
2323 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2324 uint32_t va = extract_uint32_t(a);
2325 uint32_t vb = extract_uint32_t(b);
2327 if (((va | vb) & 0x7FFFFFFF) == 0)
2332 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2337 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2338 uint32_t va = extract_uint32_t(a);
2339 uint32_t vb = extract_uint32_t(b);
2341 uint32_t a_sign = va & 0x80000000;
2342 uint32_t b_sign = vb & 0x80000000;
2344 (int32_t&)a_sign >>= 31;
2345 (int32_t&)b_sign >>= 31;
2347 uint32_t mash = (a_sign&b_sign);
2352 if ((int32_t&)vb < (int32_t&)va)
2353 memcpy(&a, &b,
sizeof(
float));
2355 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2360 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2361 uint32_t va = extract_uint32_t(a);
2362 uint32_t vb = extract_uint32_t(b);
2364 uint32_t a_sign = va & 0x80000000;
2365 uint32_t b_sign = vb & 0x80000000;
2367 (int32_t&)a_sign >>= 31;
2368 (int32_t&)b_sign >>= 31;
2370 uint32_t mash = (a_sign&b_sign);
2375 if ((int32_t&)vb > (int32_t&)va)
2376 memcpy(&a, &b,
sizeof(
float));
2378 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2384 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2386 memcpy(&i, &a,
sizeof(
float));
2390 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2391 memcpy(&a, &i,
sizeof(
float));
2394 static HPS_INLINE
float C2F(
unsigned char x) {
2396 return char_to_float[x];
2401 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2402 memcpy(&m[0], &f,
sizeof(
float));
2403 memcpy(&m[1], &f,
sizeof(
float));
2404 memcpy(&m[2], &f,
sizeof(
float));
2405 memcpy(&m[3], &f,
sizeof(
float));
2408 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2409 memcpy(&m[0], &f0,
sizeof(
float));
2410 memcpy(&m[1], &f1,
sizeof(
float));
2411 memcpy(&m[2], &f2,
sizeof(
float));
2412 memcpy(&m[3], &f3,
sizeof(
float));
2415 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2416 memcpy(f0, m,
sizeof(
float)*4);
2419 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2420 memcpy(&f0, &m[0],
sizeof(
float));
2421 memcpy(&f1, &m[1],
sizeof(
float));
2422 memcpy(&f2, &m[2],
sizeof(
float));
2423 memcpy(&f3, &m[3],
sizeof(
float));
2427 static const float char_to_float[256];
2436 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2437 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2439 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2440 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2441 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2442 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2443 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2444 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2446 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2447 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2448 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d) {
return Min(Min(a, b, c),d); }
2449 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Min(Min(a,b,c,d),e); }
2450 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Min(Min(a,b,c,d,e),f); }
2452 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2453 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2454 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d) {
return Max(Max(a, b, c),d); }
2455 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Max(Max(a,b,c,d),e); }
2456 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Max(Max(a,b,c,d,e),f); }
2458 template <
typename T> HPS_INLINE T
const & Clamp(T
const & x, T
const & min, T
const & max) {
return x < min ? min : x > max ? max : x; }
2461 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2462 uint32_t v = Float::extract_uint32_t(a);
2465 Float::inject_uint32_t(f,v);
2469 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2470 uint32_t v = Float::extract_uint32_t(a);
2472 if ((v & 0x7FFFFFFF) == 0)
2475 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2478 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2479 int a_sign = Sign(a);
2480 int b_sign = Sign(b);
2482 if (a_sign != b_sign)
2483 return Compare(a_sign, b_sign);
2485 uint32_t v = Float::extract_uint32_t(a);
2486 uint32_t u = Float::extract_uint32_t(b);
2488 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2491 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2497 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2506 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2507 int32_t va = Float::extract_uint32_t(a);
2508 int32_t vb = Float::extract_uint32_t(b);
2510 if (is_special(va) || is_special(vb)) {
2511 if (is_infinite(va) || is_infinite(vb))
2513 if (is_nan(va) || is_nan(vb))
2517 int const close_to_zero = 0x36A00000;
2518 if ((va & 0x7FFFFFFF) == 0)
2519 return (vb & 0x7FFFFFFF) < close_to_zero;
2520 else if ((vb & 0x7FFFFFFF) == 0)
2521 return (va & 0x7FFFFFFF) < close_to_zero;
2523 uint32_t sign_mask = va ^ vb;
2524 (int32_t &)sign_mask >>= 31;
2526 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2527 int32_t v1 = tolerance + diff;
2528 int32_t v2 = tolerance - diff;
2529 return (v1|v2) >= 0;
2532 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2533 int32_t va[2], vb[2];
2534 memcpy (va, &a,
sizeof(
double));
2535 memcpy (vb, &b,
sizeof(
double));
2537 if (is_special(va) || is_special(vb)) {
2538 if (is_infinite(va) || is_infinite(vb))
2539 return va[High] == vb[High] && va[Low] == vb[Low];
2540 if (is_nan(va) || is_nan(vb))
2544 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2545 return Abs(a - b) < 0.000000000000005;
2547 if (extract_sign_bit(a) != extract_sign_bit(b))
2550 if (va[High] != vb[High])
2553 return Abs(va[Low] - vb[Low]) <= tolerance;
2560 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2562 template <
typename T>
2563 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2565 if (Is_Abnormal (*t++))
2570 template <
typename T>
2571 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2572 return count >= 0 && Is_Abnormal((
size_t)count, t);
2579 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2580 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2581 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2582 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2585 template <
typename F>
2593 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2595 template <
typename D>
2596 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2604 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2605 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2607 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2614 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2615 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2616 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2617 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2619 F & operator[] (
size_t i) {
return (&x)[i]; }
2620 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2653 template <
typename F,
typename S>
2656 template <
typename F>
2657 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2658 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2661 template <
typename F>
2662 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2663 return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2666 template <
typename F>
2667 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2668 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2672 template <
typename F>
2679 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2681 template <
typename D>
2689 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2690 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2692 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2697 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2698 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2700 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2702 F & operator[] (
size_t i) {
return (&x)[i]; }
2703 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2724 template <
typename F>
2727 template <
typename F,
typename S>
2728 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F>
const & a) {
return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2730 template <
typename F>
2731 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2732 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2735 template <
typename F>
2736 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2737 return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2740 template <
typename F>
2741 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2742 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2746 template <
typename F>
2754 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2755 template <
typename D>
2764 bool operator== (
Vector_3D const & v)
const {
2765 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2767 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2769 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2775 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2776 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2780 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2781 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2783 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2785 F & operator[] (
size_t i) {
return (&x)[i]; }
2786 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2788 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2790 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2792 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2794 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2798 F range = Max (Abs (x), Abs (y), Abs (z));
2799 if (range > F(1.0e10))
2803 F len = (F)Length();
2810 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2812 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2813 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2815 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2818 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2823 return Vector_3D (x * v.x, y * v.y, z * v.z);
2837 template <
typename F,
typename S>
2840 template <
typename F>
2841 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2842 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2846 template <
typename F>
2847 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2849 template <
typename F>
2850 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F>
const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2851 template <
typename F>
2852 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F>
const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2854 template <
typename F>
2855 HPS_INLINE Vector_3D<F>
const Point_3D<F>::operator- (Point_3D<F>
const & p)
const {
return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2857 template <
typename F>
2858 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2859 template <
typename F>
2860 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2862 template <
typename F>
2863 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F>
const & v) { x *= v.x; y *= v.y; z *= v.z;
return *
this; }
2864 template <
typename F>
2865 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F>
const & v) { x /= v.x; y /= v.y; z /= v.z;
return *
this; }
2866 template <
typename F>
2867 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2868 template <
typename F>
2869 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2873 template <
typename F>
2874 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2875 return a + (b - a) * t;
2878 template <
typename F>
2879 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2880 return Vector_3D<F>(a + (b - a) * t).Normalize();
2885 template <
typename F>
2886 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2887 return (p2 - p1).Length();
2890 template <
typename F>
2891 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2892 return (p2 - p1).LengthSquared();
2895 template <
typename F>
2896 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2897 F p =
static_cast<F
>((c - b).LengthSquared());
2898 F q =
static_cast<F
>((c - a).LengthSquared());
2899 F r =
static_cast<F
>((b - a).LengthSquared());
2902 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2903 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2908 template <
typename F>
2909 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2910 bool success =
true;
2911 for (
size_t i = 0; i < count; ++i) {
2912 if (vectors->Normalize() == Vector_3D<F>::Zero())
2920 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2922 template <
typename F>
2929 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2930 template <
typename D>
2939 bool operator== (
Vector_2D const & v)
const {
2940 return Float::match(x, v.x) && Float::match(y, v.y);
2942 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2944 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2953 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2954 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2956 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2958 F & operator[] (
size_t i) {
return (&x)[i]; }
2959 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2961 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2963 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2967 F range = Max (Abs (x), Abs (y));
2968 if (range > F(1.0e10))
2972 F len = (F)Length();
2979 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2981 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2982 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2984 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2987 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2988 return x * v.y - y * v.x;
3005 template <
typename F,
typename S>
3008 template <
typename F>
3009 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
3010 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
3014 template <
typename F>
3015 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
3017 template <
typename F>
3018 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
3020 template <
typename F>
3021 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3022 template <
typename F>
3023 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3025 template <
typename F>
3026 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z); }
3027 template <
typename F>
3028 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z); }
3030 template <
typename F>
3031 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3032 template <
typename F>
3033 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3035 template <
typename F>
3036 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z); }
3037 template <
typename F>
3038 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z); }
3041 template <
typename F>
3042 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3043 template <
typename F>
3044 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3046 template <
typename F>
3047 HPS_INLINE Vector_2D<F>
const Point_2D<F>::operator- (Point_2D<F>
const & p)
const {
return Vector_2D<F> (x - p.x, y - p.y); }
3049 template <
typename F>
3050 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x + v.x, y + v.y); }
3051 template <
typename F>
3052 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x - v.x, y - v.y); }
3054 template <
typename F>
3055 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3056 template <
typename F>
3057 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3058 template <
typename F>
3059 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x * v.x, y * v.y); }
3060 template <
typename F>
3061 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x / v.x, y / v.y); }
3067 template <
typename F>
3076 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3080 template <
typename D>
3081 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3097 for (
size_t i=0; i<count; ++i) {
3100 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3101 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3102 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3112 double inv_count = 1.0 / (double)count;
3120 *
this = Plane_3D::Zero();
3126 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3127 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3129 F & operator[] (
size_t i) {
return (&a)[i]; }
3130 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3132 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3147 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3148 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3151 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3152 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3153 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3160 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3161 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3163 return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3166 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3170 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3171 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3172 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3173 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3180 template <
typename F>
3181 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3182 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3186 template <
typename F>
3187 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3188 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3190 template <
typename F>
3191 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3192 return plane * point;
3195 template <
typename F>
3196 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3197 return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3200 template <
typename F>
3201 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3208 template <
typename F>
3216 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3220 template <
typename D>
3221 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3225 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3226 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3228 F & operator[] (
size_t i) {
return (&a)[i]; }
3229 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3231 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3248 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3249 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3250 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3251 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3258 template <
typename F>
3259 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3260 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3264 template <
typename F>
3265 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3266 return plane.a * point.x + plane.b * point.y + plane.c;
3268 template <
typename F>
3269 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3270 return plane * point;
3273 template <
typename F>
3274 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3275 return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3278 template <
typename F>
3279 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3293 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3294 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3296 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3297 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3300 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3305 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3309 return !(*
this == rect);
3312 HPS_INLINE
int PixelWidth()
const {
3313 return right - left + 1;
3316 HPS_INLINE
int PixelHeight()
const {
3317 return top - bottom + 1;
3320 HPS_INLINE
int Width()
const {
3321 return right - left;
3324 HPS_INLINE
int Height()
const {
3325 return top - bottom;
3328 HPS_INLINE
int Area()
const {
3329 return Width() * Height();
3332 HPS_INLINE
Point2D Center()
const {
3333 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3336 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3337 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3340 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3341 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3354 right += rect.right;
3355 bottom -= rect.bottom;
3370 right -= rect.right;
3371 bottom += rect.bottom;
3377 left = Max(left, rect.left);
3378 right = Min(right, rect.right);
3379 bottom = Max(bottom, rect.bottom);
3380 top = Min(top, rect.top);
3385 left = Min(left, rect.left);
3386 right = Max(right, rect.right);
3387 bottom = Min(bottom, rect.bottom);
3388 top = Max(top, rect.top);
3405 return temp.Expand(border);
3408 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3409 IntRectangle temp = a;
3410 return temp.Expand(border);
3413 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3414 IntRectangle temp = a;
3415 return temp.Contract(border);
3418 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3419 IntRectangle temp = a;
3420 return temp.Contract(border);
3423 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3424 IntRectangle temp = a;
3425 return temp.Intersect(b);
3428 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3429 IntRectangle temp = a;
3430 return temp.Union(b);
3440 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3441 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3443 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3444 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3447 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3450 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3460 Merge(count, points);
3472 Merge(count, points);
3476 HPS_INLINE
float Width()
const {
3477 return right - left;
3480 HPS_INLINE
float Height()
const {
3481 return top - bottom;
3484 HPS_INLINE
float Area()
const {
3485 return Width() * Height();
3488 HPS_INLINE
Point2D Center()
const {
3489 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3492 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3495 if (Compare(points[0].x, points[1].x)>0) {
3496 Float::replace_if_smaller(left, points[1].x);
3497 Float::replace_if_larger(right, points[0].x);
3500 Float::replace_if_smaller(left, points[0].x);
3501 Float::replace_if_larger(right, points[1].x);
3504 if (Compare(points[0].y, points[1].y)>0) {
3505 Float::replace_if_smaller(bottom, points[1].y);
3506 Float::replace_if_larger(top, points[0].y);
3509 Float::replace_if_smaller(bottom, points[0].y);
3510 Float::replace_if_larger(top, points[1].y);
3521 HPS_INLINE
void Merge(
Point const & point) {
3522 Float::replace_if_smaller(left, point.x);
3523 Float::replace_if_smaller(bottom, point.y);
3524 Float::replace_if_larger(right, point.x);
3525 Float::replace_if_larger(top, point.y);
3528 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3531 if (Compare(points[0].x, points[1].x)>0) {
3532 Float::replace_if_smaller(left, points[1].x);
3533 Float::replace_if_larger(right, points[0].x);
3536 Float::replace_if_smaller(left, points[0].x);
3537 Float::replace_if_larger(right, points[1].x);
3540 if (Compare(points[0].y, points[1].y)>0) {
3541 Float::replace_if_smaller(bottom, points[1].y);
3542 Float::replace_if_larger(top, points[0].y);
3545 Float::replace_if_smaller(bottom, points[0].y);
3546 Float::replace_if_larger(top, points[1].y);
3557 HPS_INLINE
void Merge(
Point2D const & point) {
3558 Float::replace_if_smaller(left, point.x);
3559 Float::replace_if_smaller(bottom, point.y);
3560 Float::replace_if_larger(right, point.x);
3561 Float::replace_if_larger(top, point.y);
3564 bool operator==(
Rectangle const & rect)
const {
3565 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3568 bool operator!=(
Rectangle const & rect)
const {
3569 return !(*
this == rect);
3572 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3573 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3576 HPS_INLINE
bool Contains(
Point const & contained)
const {
3577 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3580 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3581 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3584 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3585 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3588 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3589 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3590 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3593 HPS_INLINE
Rectangle & Expand(
float border) {
3601 HPS_INLINE
Rectangle & Expand(
int border) {
3602 Expand((
float)border);
3608 right += rect.right;
3609 bottom -= rect.bottom;
3614 HPS_INLINE
Rectangle & Contract(
int border) {
3624 right -= rect.right;
3625 bottom += rect.bottom;
3631 left = Max(left, rect.left);
3632 right = Min(right, rect.right);
3633 bottom = Max(bottom, rect.bottom);
3634 top = Min(top, rect.top);
3639 left = Min(left, rect.left);
3640 right = Max(right, rect.right);
3641 bottom = Min(bottom, rect.bottom);
3642 top = Max(top, rect.top);
3647 float scale = (scope.right - scope.left) * 0.5f;
3648 float trans = (scope.right + scope.left) * 0.5f;
3650 left = left * scale + trans;
3651 right = right * scale + trans;
3653 scale = (scope.top - scope.bottom) * 0.5f;
3654 trans = (scope.top + scope.bottom) * 0.5f;
3656 bottom = bottom * scale + trans;
3657 top = top * scale + trans;
3662 float tmp = 2.0f/(scope.right - scope.left);
3663 right = (right - scope.left) * tmp - 1.0f;
3664 left = (left - scope.left) * tmp - 1.0f;
3666 tmp = 2.0f/(scope.top - scope.bottom);
3667 top = (top - scope.bottom) * tmp - 1.0f;
3668 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3672 static HPS_INLINE
Rectangle FullScope() {
3673 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3676 static HPS_INLINE
Rectangle InvalidScope() {
3677 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3689 temp.left = Floor (a.left);
3690 temp.right = Floor (a.right);
3691 temp.bottom = Floor (a.bottom);
3692 temp.top = Floor (a.top);
3696 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3698 return temp.Expand(border);
3701 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3703 return temp.Expand(border);
3706 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3708 return temp.Contract(border);
3711 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3713 return temp.Contract(border);
3716 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3718 return temp.Intersect(b);
3721 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3723 return temp.Union(b);
3726 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3728 return temp.Inscribe_Scope(scope);
3731 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3733 return temp.Circumscribe_Scope(scope);
3736 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3737 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3742 template <
typename F>
3745 template <
typename F>
3758 template <
typename D>
3787 min = Limit_Point();
3788 max = -Limit_Point();
3791 min = max = *points++;
3794 Merge(count, points);
3807 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3824 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3830 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3855 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3863 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3864 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3865 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3874 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3875 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3876 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3887 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3899 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3909 return LineIntersecting(start, direction,
true);
3920 return LineIntersecting(point1, direction,
false);
3929 Float::replace_if_smaller(min.x, cuboid.
min.x);
3930 Float::replace_if_smaller(min.y, cuboid.
min.y);
3931 Float::replace_if_smaller(min.z, cuboid.
min.z);
3932 Float::replace_if_larger(max.x, cuboid.
max.x);
3933 Float::replace_if_larger(max.y, cuboid.
max.y);
3934 Float::replace_if_larger(max.z, cuboid.
max.z);
3950 Float::replace_if_smaller(min.x, point.x);
3951 Float::replace_if_smaller(min.y, point.y);
3952 Float::replace_if_smaller(min.z, point.z);
3953 Float::replace_if_larger(max.x, point.x);
3954 Float::replace_if_larger(max.y, point.y);
3955 Float::replace_if_larger(max.z, point.z);
3966 if (Compare(points[0].x, points[1].x)>0) {
3967 Float::replace_if_smaller(min.x, points[1].x);
3968 Float::replace_if_larger(max.x, points[0].x);
3971 Float::replace_if_smaller(min.x, points[0].x);
3972 Float::replace_if_larger(max.x, points[1].x);
3975 if (Compare(points[0].y, points[1].y)>0) {
3976 Float::replace_if_smaller(min.y, points[1].y);
3977 Float::replace_if_larger(max.y, points[0].y);
3980 Float::replace_if_smaller(min.y, points[0].y);
3981 Float::replace_if_larger(max.y, points[1].y);
3984 if (Compare(points[0].z, points[1].z)>0) {
3985 Float::replace_if_smaller(min.z, points[1].z);
3986 Float::replace_if_larger(max.z, points[0].z);
3989 Float::replace_if_smaller(min.z, points[0].z);
3990 Float::replace_if_larger(max.z, points[1].z);
4007 return (contained.
min.x >= min.x &&
4008 contained.
min.y >= min.y &&
4009 contained.
min.z >= min.z &&
4010 contained.
max.x <= max.x &&
4011 contained.
max.y <= max.y &&
4012 contained.
max.z <= max.z);
4021 return (contained.x >= min.x &&
4022 contained.y >= min.y &&
4023 contained.z >= min.z &&
4024 contained.x <= max.x &&
4025 contained.y <= max.y &&
4026 contained.z <= max.z);
4036 return (contained.x >= min.x - epsilon &&
4037 contained.y >= min.y - epsilon &&
4038 contained.z >= min.z - epsilon &&
4039 contained.x <= max.x + epsilon &&
4040 contained.y <= max.y + epsilon &&
4041 contained.z <= max.z + epsilon);
4050 Float::replace_if_larger(min.x, cuboid.
min.x);
4051 Float::replace_if_larger(min.y, cuboid.
min.y);
4052 Float::replace_if_larger(min.z, cuboid.
min.z);
4053 Float::replace_if_smaller(max.x, cuboid.
max.x);
4054 Float::replace_if_smaller(max.y, cuboid.
max.y);
4055 Float::replace_if_smaller(max.z, cuboid.
max.z);
4065 Float::replace_if_smaller(min.x, cuboid.
min.x);
4066 Float::replace_if_smaller(min.y, cuboid.
min.y);
4067 Float::replace_if_smaller(min.z, cuboid.
min.z);
4068 Float::replace_if_larger(max.x, cuboid.
max.x);
4069 Float::replace_if_larger(max.y, cuboid.
max.y);
4070 Float::replace_if_larger(max.z, cuboid.
max.z);
4100 F
const limit = std::numeric_limits<F>::max();
4104 bool LineIntersecting (Point_3D<F>
const & start, Vector_3D<F>
const & direction,
bool is_ray)
const;
4107 typedef Cuboid_3D<float> SimpleCuboid;
4108 typedef Cuboid_3D<double> DSimpleCuboid;
4111 template <
typename F>
4112 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4113 Cuboid_3D<F> temp = a;
4114 return temp.Intersect(b);
4117 template <
typename F>
4118 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4119 Cuboid_3D<F> temp = a;
4120 return temp.Union(b);
4123 template <
typename F>
4124 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4125 Cuboid_3D<F> temp = a;
4126 return temp.Expand(border);
4129 template <
typename F>
4130 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4131 Cuboid_3D<F> temp = a;
4132 return temp.Contract(border);
4137 template <
typename F>
4138 struct HPS_TEMPLATE_API Sphere_3D {
4142 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4144 template <
typename D>
4145 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4147 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4148 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4150 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4152 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4153 Cuboid_3D<F> cuboid(count, points);
4154 center = Midpoint(cuboid.min, cuboid.max);
4155 Engulf (count, points);
4158 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4159 Engulf (count, points);
4162 HPS_INLINE
bool IsValid()
const {
4166 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4168 void Invalidate() {radius = -1;}
4170 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4171 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4173 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4175 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4176 Vector_3D<F> dir = point - center;
4177 F distance = (F)dir.Length();
4179 if (distance > radius) {
4180 F t = F(0.5) * (distance - radius);
4181 center += t * dir.Normalize();
4186 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4188 for (
size_t i = 0; i < count; ++i) {
4189 Vector_3D<F> dir = *points - center;
4190 F distance = (F)dir.Length();
4192 if (distance > radius) {
4193 F t = F(0.5) * (distance - radius);
4194 center += t * dir.Normalize();
4202 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4203 Vector_3D<F> dir = sphere.center - center;
4204 F distance = (F)dir.Length();
4206 if (distance + sphere.radius > radius) {
4207 if (distance + radius > sphere.radius) {
4208 F t = F(0.5 * (sphere.radius + distance - radius));
4209 center += t * dir.Normalize();
4213 center = sphere.center;
4214 radius = sphere.radius;
4219 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4223 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4224 for (
size_t i = 0; i < count; ++i) {
4225 double dsq = (*points++ - center).LengthSquared();
4226 if ((F)dsq > radius * radius)
4227 radius = (F)sqrt(dsq);
4232 typedef Sphere_3D<float> SimpleSphere;
4233 typedef Sphere_3D<double> DSimpleSphere;
4236 template <
typename F>
4238 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4239 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4257 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4258 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4259 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4260 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4261 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4262 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4264 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4265 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4266 float Distance(RGBColor
const & other_color)
const;
4267 HPS_INLINE
bool IsValid()
const {
4268 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4271 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4272 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4274 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4277 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4278 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4279 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4280 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4281 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4282 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4284 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4285 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4286 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4287 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4288 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4289 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4290 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4291 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4293 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4294 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4295 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4297 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4298 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4299 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4301 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4302 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4303 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4306 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4307 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4308 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4320 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4321 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4323 HPS_INLINE RGBAColor (RGBColor
const & c) {
4324 memcpy(
this, &c,
sizeof(RGBColor));
4326 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4328 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4329 memcpy(
this, &c,
sizeof(RGBColor));
4330 memcpy(&alpha, &a,
sizeof(
float));
4331 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4333 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4334 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4336 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4337 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4338 HPS_INLINE
bool IsValid()
const {
4339 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4356 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4358 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4363 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4364 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4365 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4366 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4367 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4368 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4370 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4371 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4372 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4373 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4374 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4375 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4376 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4377 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4379 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4380 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4381 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4382 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4383 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4384 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4386 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4387 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4388 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4389 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4403 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4404 unsigned char b, g, r, a;
4408 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4409 unsigned char r, g, b, a;
4413 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4414 unsigned char r, g, b, a;
4424 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4430 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4438 explicit HPS_INLINE RGBAS32Color (
RGBColor const & c)
4440 r = Float::unit_to_byte(c.red);
4441 g = Float::unit_to_byte(c.green);
4442 b = Float::unit_to_byte(c.blue);
4446 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4450 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4452 r = Float::unit_to_byte(c.red);
4453 g = Float::unit_to_byte(c.green);
4454 b = Float::unit_to_byte(c.blue);
4455 a = Float::unit_to_byte(alpha);
4457 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4459 r = Float::unit_to_byte(c.red);
4460 g = Float::unit_to_byte(c.green);
4461 b = Float::unit_to_byte(c.blue);
4464 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
4466 r = Float::unit_to_byte(c.
red);
4467 g = Float::unit_to_byte(c.
green);
4468 b = Float::unit_to_byte(c.
blue);
4469 a = Float::unit_to_byte(c.
alpha);
4471 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4473 r = Float::unit_to_byte(c.
red);
4474 g = Float::unit_to_byte(c.
green);
4475 b = Float::unit_to_byte(c.
blue);
4476 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4479 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4480 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4481 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4483 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4484 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4486 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4487 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4488 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4490 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4501 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4502 : r (gray), g (gray), b (gray), a (aa) {}
4503 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4504 : r (rr), g (gg), b (bb), a (aa) {}
4506 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4507 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4508 r = Float::unit_to_byte(c.red);
4509 g = Float::unit_to_byte(c.green);
4510 b = Float::unit_to_byte(c.blue);
4513 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4514 r = Float::unit_to_byte(c.red);
4515 g = Float::unit_to_byte(c.green);
4516 b = Float::unit_to_byte(c.blue);
4517 a = Float::unit_to_byte(alpha);
4519 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4520 r = Float::unit_to_byte(c.red);
4521 g = Float::unit_to_byte(c.green);
4522 b = Float::unit_to_byte(c.blue);
4525 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4526 r = Float::unit_to_byte(c.
red);
4527 g = Float::unit_to_byte(c.
green);
4528 b = Float::unit_to_byte(c.
blue);
4529 a = Float::unit_to_byte(c.
alpha);
4531 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4532 r = Float::unit_to_byte(c.
red);
4533 g = Float::unit_to_byte(c.
green);
4534 b = Float::unit_to_byte(c.
blue);
4535 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4538 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4539 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4541 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4542 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4544 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4545 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4547 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4559 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4560 : r (gray), g (gray), b (gray) {}
4561 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4562 : r (rr), g (gg), b (bb) {}
4563 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4564 r = Float::unit_to_byte(c.red);
4565 g = Float::unit_to_byte(c.green);
4566 b = Float::unit_to_byte(c.blue);
4569 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4570 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4572 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4573 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4576 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4577 red = Float::C2F(c32.r);
4578 green = Float::C2F(c32.g);
4579 blue = Float::C2F(c32.b);
4582 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4583 red = Float::C2F(c32.r);
4584 green = Float::C2F(c32.g);
4585 blue = Float::C2F(c32.b);
4588 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4594 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4595 red = Float::C2F(c24.r);
4596 green = Float::C2F(c24.g);
4597 blue = Float::C2F(c24.b);
4600 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4608 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4616 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
const & c32) {
4617 red = Float::C2F(c32.r);
4618 green = Float::C2F(c32.g);
4619 blue = Float::C2F(c32.b);
4620 alpha = Float::C2F(c32.a);
4623 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4624 red = Float::C2F(c32.r);
4625 green = Float::C2F(c32.g);
4626 blue = Float::C2F(c32.b);
4627 alpha = Float::C2F(c32.a);
4630 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4631 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4636 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4637 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4640 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4641 return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4644 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4645 return RGBAS32Color(
4646 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4647 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4648 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4649 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4652 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4654 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4655 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4656 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4657 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4660 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4662 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4663 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4664 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4676 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4678 Quaternion(
float in_w,
float in_x,
float in_y,
float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4696 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4697 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4698 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4699 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4702 Quaternion operator* (
float in_right)
const {
4703 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4707 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4710 Quaternion operator/ (
float in_right)
const {
4711 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4715 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4719 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4722 inline float Norm()
const {
4723 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4729 float mag_q = Norm();
4730 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4732 ret.w =
static_cast<float>(log(mag_q));
4735 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4742 ret.x = ret.y = ret.z = 0;
4749 float ea =
static_cast<float>(exp(w));
4750 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4751 float scale = ea * sin(mag_V) / mag_V;
4753 ret.w = ea * cos(mag_V);
4762 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4763 return ret.Normalize();
4767 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4769 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4771 if (in_shortest_path_only && dot < 0) {
4778 if (dot > -0.95f && dot < 0.95f) {
4779 float angle =
static_cast<float>(acos(dot));
4780 float sina =
static_cast<float>(sin(angle));
4781 float sinat =
static_cast<float>(sin(angle*in_fraction));
4782 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4784 return (*
this * sinaomt + q3 * sinat) / sina;
4787 return Lerp(q3, in_fraction);
4800 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4801 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4803 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4815 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4848 typedef unsigned char byte;
4849 typedef signed char sbyte;
4850 typedef intptr_t WindowHandle;
4851 typedef int64_t TouchID;
4852 typedef intptr_t PlatformData;
4853 typedef intptr_t OpaqueHandle;
4886 class AttributesControl;
4902 class GeometryInsertControl;
4999 class ShaderDefinition;
5047 class FontInfoControl;
5114 enum class Type : uint32_t
5117 GenericMask = 0xffffff00,
5121 EventDispatcher = 0x00000003,
5122 EventHandler = 0x00000004,
5123 EventNotifier = 0x00000005,
5124 UpdateNotifier = 0x00000006,
5125 SearchResults = 0x00000008,
5126 FontSearchResults = 0x00000009,
5127 SearchResultsIterator = 0x0100000a,
5128 FontSearchResultsIterator = 0x0100000b,
5129 SelectionResults = 0x0000000c,
5130 SelectionResultsIterator = 0x0100000d,
5131 SelectionItem = 0x0000000e,
5132 TreeContext = 0x0000000f,
5133 StreamToolkit = 0x00000010,
5134 DriverEventHandler = 0x00000011,
5136 IONotifier = 0x04000100,
5137 StreamImportNotifier = 0x04000101,
5138 STLImportNotifier = 0x04000102,
5139 OBJImportNotifier = 0x04000103,
5140 ExchangeImportNotifier = 0x04000104,
5141 SketchupImportNotifier = 0x04000105,
5142 ParasolidImportNotifier = 0x04000106,
5143 ExchangeTranslationNotifier = 0x04000107,
5144 ExchangeExportNotifier = 0x04000108,
5145 StreamExportNotifier = 0x04000109,
5146 ExchangeReloadNotifier = 0x0400010a,
5147 DWGImportNotifier = 0x0400010b,
5148 ExchangeParasolidImportNotifier = 0x0400010c,
5151 MarkerKit = 0x01000010,
5152 SphereAttributeKit = 0x01000011,
5153 TextAttributeKit = 0x01000012,
5154 TransparencyKit = 0x01000013,
5155 VisibilityKit = 0x01000014,
5156 VisualEffectsKit = 0x01000015,
5157 CuttingSectionAttributeKit = 0x01000016,
5158 CircleKit = 0x01000017,
5159 CircularArcKit = 0x01000018,
5160 CircularWedgeKit = 0x01000019,
5161 CuttingSectionKit = 0x0100001a,
5162 CylinderKit = 0x0100001b,
5163 DistantLightKit = 0x0100001c,
5164 EllipseKit = 0x0100001d,
5165 EllipticalArcKit = 0x0100001e,
5166 InfiniteLineKit = 0x0100001f,
5167 LineKit = 0x01000020,
5168 NURBSCurveKit = 0x01000021,
5169 MeshKit = 0x01000022,
5170 NURBSSurfaceKit = 0x01000023,
5171 PolygonKit = 0x01000024,
5172 SphereKit = 0x01000025,
5173 SpotlightKit = 0x01000026,
5174 ShellKit = 0x01000027,
5175 TextKit = 0x01000028,
5176 MaterialKit = 0x01000029,
5177 TrimKit = 0x0100002a,
5178 TextureOptionsKit = 0x0100002c,
5179 LinePatternKit = 0x0100002d,
5180 GlyphKit = 0x0100002e,
5181 ImageKit = 0x0100002f,
5182 LinePatternOptionsKit = 0x01000030,
5183 CameraKit = 0x01000031,
5184 BoundingKit = 0x01000032,
5185 CullingKit = 0x01000033,
5186 CurveAttributeKit = 0x01000034,
5187 CylinderAttributeKit = 0x01000035,
5188 EdgeAttributeKit = 0x01000036,
5189 LightingAttributeKit = 0x01000037,
5190 LineAttributeKit = 0x01000038,
5191 MarkerAttributeKit = 0x01000039,
5192 MaterialMappingKit = 0x0100003a,
5193 MatrixKit = 0x0100003b,
5194 NURBSSurfaceAttributeKit = 0x0100003c,
5195 PostProcessEffectsKit = 0x0100003d,
5196 SelectabilityKit = 0x0100003e,
5197 SelectionOptionsKit = 0x0100003f,
5198 StandAloneWindowOptionsKit = 0x01000040,
5199 OffScreenWindowOptionsKit = 0x01000041,
5200 ApplicationWindowOptionsKit = 0x01000042,
5201 HighlightOptionsKit = 0x01000043,
5202 LinePatternParallelKit = 0x01000044,
5203 SubwindowKit = 0x01000045,
5204 PerformanceKit = 0x01000046,
5205 HiddenLineAttributeKit = 0x01000047,
5206 DrawingAttributeKit = 0x01000048,
5207 ShaderKit = 0x01000049,
5208 DebuggingKit = 0x0100004a,
5209 ContourLineKit = 0x0100004b,
5210 StreamImportOptionsKit = 0x0100004c,
5211 StreamImportResultsKit = 0x0100004d,
5212 StreamExportOptionsKit = 0x0100004e,
5213 StreamExportResultsKit = 0x0100004f,
5214 WindowInfoKit = 0x01000050,
5215 ImageImportOptionsKit = 0x01000051,
5216 SearchOptionsKit = 0x01000052,
5217 ShaderImportOptionsKit = 0x01000053,
5218 HardcopyExportOptionsKit = 0x01000055,
5219 AttributeLockKit = 0x01000056,
5220 TransformMaskKit = 0x01000057,
5221 ColorInterpolationKit = 0x01000058,
5222 UpdateOptionsKit = 0x01000059,
5223 ImageExportOptionsKit = 0x0100005a,
5224 OBJImportOptionsKit = 0x0100005b,
5225 OBJImportResultsKit = 0x0100005c,
5226 STLImportOptionsKit = 0x0100005d,
5227 STLImportResultsKit = 0x0100005e,
5228 ShellOptimizationOptionsKit = 0x0100005f,
5229 ShellRelationOptionsKit = 0x01000060,
5230 ShellRelationResultsKit = 0x01000061,
5231 GridKit = 0x01000062,
5232 CutGeometryGatheringOptionsKit = 0x01000063,
5233 SegmentOptimizationOptionsKit = 0x01000064,
5236 LinePatternElement = 0x03000000,
5237 SolidLinePatternElement = 0x03000001,
5238 BlankLinePatternElement = 0x03000002,
5239 GlyphLinePatternElement = 0x03000003,
5241 GlyphElement = 0x05000000,
5242 DotGlyphElement = 0x05000001,
5243 LineGlyphElement = 0x05000002,
5244 EllipseGlyphElement = 0x05000003,
5245 CircularArcGlyphElement = 0x05000004,
5246 InfiniteLineGlyphElement = 0x05000005,
5247 SphereGlyphElement = 0x05000006,
5249 TrimElement = 0x07000000,
5251 ConditionalExpression = 0x09000000,
5252 NOTCondition = 0x09000001,
5253 ANDCondition = 0x09000002,
5254 ORCondition = 0x09000003,
5255 XORCondition = 0x09000004,
5256 EQCondition = 0x09000005,
5257 NEQCondition = 0x09000006,
5258 GTCondition = 0x09000007,
5259 LTCondition = 0x09000008,
5260 GTEQCondition = 0x09000009,
5261 LTEQCondition = 0x0900000A,
5263 MouseState = 0x01001001,
5264 TouchState = 0x01001002,
5265 KeyboardState = 0x01001003,
5266 FontInfoState = 0x01001004,
5268 KeyPath = 0x01000F01,
5271 IncludeKey = 0x10000001,
5272 PortfolioKey = 0x10000002,
5273 StyleKey = 0x10000003,
5275 SegmentKey = 0x10200000,
5276 WindowKey = 0x10600000,
5277 StandAloneWindowKey = 0x10600001,
5278 OffScreenWindowKey = 0x10600002,
5279 ApplicationWindowKey = 0x10600003,
5281 GeometryKey = 0x10100000,
5282 ReferenceKey = 0x10100001,
5283 CircleKey = 0x10100002,
5284 CircularArcKey = 0x10100003,
5285 CircularWedgeKey = 0x10100004,
5286 CuttingSectionKey = 0x10100005,
5287 CylinderKey = 0x10100006,
5288 EllipseKey = 0x10100007,
5289 EllipticalArcKey = 0x10100008,
5290 InfiniteLineKey = 0x10100009,
5291 LineKey = 0x1010000a,
5292 DistantLightKey = 0x1010000b,
5293 SpotlightKey = 0x1010000c,
5294 MarkerKey = 0x1010000d,
5295 MeshKey = 0x1010000e,
5296 NURBSCurveKey = 0x1010000f,
5297 NURBSSurfaceKey = 0x10100010,
5298 PolygonKey = 0x10100011,
5299 ShellKey = 0x10100012,
5300 SphereKey = 0x10100013,
5301 TextKey = 0x10100014,
5302 GridKey = 0x10100015,
5304 Definition = 0x20000000,
5305 NamedStyleDefinition = 0x20000001,
5306 TextureDefinition = 0x20000002,
5307 LinePatternDefinition = 0x20000003,
5308 GlyphDefinition = 0x20000004,
5309 CubeMapDefinition = 0x20000005,
5310 ImageDefinition = 0x20000006,
5311 MaterialPaletteDefinition = 0x20000007,
5312 ShaderDefinition = 0x20000008,
5314 Control = 0x50000000,
5315 CameraControl = 0x50000001,
5316 SelectabilityControl = 0x50000002,
5317 MarkerAttributeControl = 0x50000003,
5318 SphereAttributeControl = 0x50000004,
5319 LightingAttributeControl = 0x50000005,
5320 CylinderAttributeControl = 0x50000006,
5321 TextAttributeControl = 0x50000007,
5322 LineAttributeControl = 0x50000008,
5323 EdgeAttributeControl = 0x50000009,
5324 CurveAttributeControl = 0x5000000a,
5325 ModellingMatrixControl = 0x5000000b,
5326 TextureMatrixControl = 0x5000000c,
5327 CullingControl = 0x5000000d,
5328 TransparencyControl = 0x5000000e,
5329 MaterialMappingControl = 0x5000000f,
5330 NURBSSurfaceAttributeControl = 0x50000010,
5331 PostProcessEffectsControl = 0x50000011,
5332 BoundingControl = 0x50000012,
5333 VisualEffectsControl = 0x50000013,
5334 SelectionOptionsControl = 0x50000014,
5335 HighlightOptionsControl = 0x50000015,
5336 DefinitionControl = 0x50000016,
5337 SelectionControl = 0x50000017,
5338 HighlightControl = 0x50000018,
5339 StandAloneWindowOptionsControl = 0x50000019,
5340 OffScreenWindowOptionsControl = 0x5000001a,
5341 ApplicationWindowOptionsControl = 0x5000001b,
5342 VisibilityControl = 0x5000001c,
5343 SubwindowControl = 0x5000001d,
5344 PerformanceControl = 0x5000001e,
5345 HiddenLineAttributeControl = 0x5000001f,
5346 DrawingAttributeControl = 0x50000020,
5347 DebuggingControl = 0x50000021,
5348 ContourLineControl = 0x50000022,
5349 StyleControl = 0x50000023,
5350 ConditionControl = 0x50000024,
5351 PortfolioControl = 0x50000025,
5352 WindowInfoControl = 0x50000026,
5353 AttributeLockControl = 0x50000027,
5354 TransformMaskControl = 0x50000028,
5355 ColorInterpolationControl = 0x50000029,
5356 UpdateOptionsControl = 0x50000030,
5357 CuttingSectionAttributeControl = 0x50000031,
5359 LibraryMask = 0x80FF0000,
5361 Sprocket = 0x80000000,
5362 Canvas = 0x80000001,
5363 Layout = 0x80000002,
5366 Operator = 0x80000005,
5367 SprocketPath = 0x80000007,
5369 SprocketControl = 0xD0000000,
5370 OperatorControl = 0xD0000008,
5371 NavigationCubeControl = 0xD0000009,
5372 AxisTriadControl = 0xD000000A,
5374 Metadata = 0x80001000,
5375 IntegerMetadata = 0x80001001,
5376 UnsignedIntegerMetadata = 0x80001002,
5377 DoubleMetadata = 0x80001003,
5378 StringMetadata = 0x80001004,
5379 TimeMetadata = 0x80001005,
5380 BooleanMetadata = 0x80001006,
5382 Component = 0x80000200,
5383 Filter = 0x80000600,
5384 Capture = 0x80000a00,
5385 CADModel = 0x80000300,
5386 ComponentPath = 0x81001000,
5388 ExchangeMask = 0x80020000,
5389 ExchangeComponent = 0x80021200,
5390 ExchangeSheet = 0x80021201,
5391 ExchangeProductOccurrence = 0x80021202,
5392 ExchangeFilter = 0x80020601,
5393 ExchangeCapture = 0x80020a01,
5394 ExchangeCADModel = 0x80020301,
5395 ExchangeConfiguration = 0x81020001,
5396 ExchangeImportOptionsKit = 0x81020002,
5397 ExchangeExportACISOptionsKit = 0x81020003,
5398 ExchangeExportIGESOptionsKit = 0x81020004,
5399 ExchangeExportJTOptionsKit = 0x81020005,
5400 ExchangeExportParasolidOptionsKit = 0x81020006,
5401 ExchangeExportPRCOptionsKit = 0x81020007,
5402 ExchangeExportSTEPOptionsKit = 0x81020008,
5403 ExchangeExportSTLOptionsKit = 0x81020009,
5404 ExchangeExportU3DOptionsKit = 0x8102000a,
5405 ExchangeExportXMLOptionsKit = 0x8102000b,
5406 ExchangeTessellationOptionsKit = 0x8102000c,
5407 ExchangeModelFileImportOptionsKit = 0x8102000d,
5408 ExchangeTranslationOptionsKit = 0x8102000e,
5410 PublishMask = 0x80040000,
5411 PublishDocumentKit = 0x81040001,
5412 PublishPageKit = 0x81040002,
5413 PublishTemplateKit = 0x81040003,
5414 PublishAnnotationKit = 0x81040004,
5415 PublishArtworkKit = 0x81040005,
5416 PublishViewKit = 0x81040006,
5417 PublishTextKit = 0x81040007,
5418 PublishImageKit = 0x81040008,
5419 PublishTableKit = 0x81040009,
5420 PublishExportOptionsKit = 0x8104000a,
5421 PublishLinkKit = 0x8104000b,
5422 PublishButtonKit = 0x8104000c,
5423 PublishTextFieldKit = 0x8104000d,
5424 PublishSlideTableKit = 0x8104000e,
5425 PublishCheckBoxKit = 0x8104000f,
5426 PublishRadioButtonKit = 0x81040010,
5427 PublishListBoxKit = 0x81040011,
5428 PublishDropDownListKit = 0x81040012,
5429 PublishSignatureFieldKit = 0x81040013,
5431 PublishDocumentKey = 0x80040001,
5432 PublishPageControl = 0x80040002,
5434 ExchangeParasolidMask = 0x80080000,
5436 SceneTree = 0x80008001,
5437 SceneTreeItem = 0x80008002,
5439 ComponentTree = 0x80008003,
5440 ComponentTreeItem = 0x80008004,
5442 SketchupMask = 0x80100000,
5443 SketchupImportOptionsKit = 0x81100001,
5444 SketchupImportResultsKit = 0x81100002,
5446 ParasolidMask = 0x80200000,
5447 ParasolidComponent = 0x80201201,
5448 ParasolidCADModel = 0x80200302,
5449 ParasolidImportOptionsKit = 0x81200003,
5450 ParasolidFacetTessellationKit = 0x81200004,
5451 ParasolidLineTessellationKit = 0x81200005,
5452 ParasolidExportOptionsKit = 0x81200006,
5454 DWGMask = 0x80400000,
5455 DWGComponent = 0x80401201,
5456 DWGLayer = 0x80401202,
5457 DWGLayout = 0x80400a03,
5458 DWGCADModel = 0x80400304,
5459 DWGImportOptionsKit = 0x81400005,
5461 IONotifierData = 0x84000200,
5462 StreamImportNotifierData = 0x84000201,
5463 STLImportNotifierData = 0x84000202,
5464 OBJImportNotifierData = 0x84000203,
5465 ExchangeImportNotifierData = 0x84020204,
5466 SketchupImportNotifierData = 0x84100205,
5467 ParasolidImportNotifierData = 0x84200206,
5468 ExchangeTranslationNotifierData = 0x84020207,
5469 ExchangeExportNotifierData = 0x84020208,
5470 StreamExportNotifierData = 0x84000209,
5471 DWGImportNotifierData = 0x8440020a,
5472 ExchangeParasolidImportNotifierData = 0x8408020b,
5484 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5491 static void Free(
void * in_pointer);
5500 template <
typename T>
5501 class NO_HPS_API Allocator
5504 typedef T value_type;
5505 typedef value_type * pointer;
5506 typedef value_type
const * const_pointer;
5507 typedef value_type & reference;
5508 typedef value_type
const & const_reference;
5509 typedef size_t size_type;
5510 typedef ptrdiff_t difference_type;
5514 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5517 template <
typename U> Allocator(Allocator<U>
const &) {}
5519 template <
typename U>
5522 typedef Allocator<U> other;
5526 pointer address(reference x)
const {
return &x; }
5527 const_pointer address(const_reference x)
const {
return &x; }
5529 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5530 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5532 #if defined(_MSC_VER) || defined (__APPLE__)
5533 void construct(pointer p, const_reference x) {
new(p) T(x); }
5534 void construct(pointer p, value_type && x) {
new(p) T(std::move(x)); }
5536 template<
typename U,
typename... Args>
5537 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5539 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5541 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5544 template <
typename T,
typename U>
5545 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5547 template <
typename T,
typename U>
5548 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5554 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5562 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5572 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5644 HPS::Type Type()
const;
5653 virtual bool Empty()
const {
return (impl_ == 0);};
5656 virtual void Reset();
5661 bool HasType(HPS::Type in_mask)
const;
5665 intptr_t GetClassID()
const;
5670 intptr_t GetInstanceID()
const;
5674 template <
typename T>
5677 static const intptr_t ret = T().GetClassID();
5682 friend class HPSI::Impl;
5683 friend class HPSI::KeyImpl;
5684 friend class HPSI::TicketImpl;
5693 HPS::Type ObjectType()
const {
return HPS::Type::Control;}
5697 #if !defined(_MSC_VER) || _MSC_VER >= 1900
5714 this->Object::operator=(std::move(in_that));
6183 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6188 intptr_t GetClassID()
const;
6192 virtual Event * Clone()
const=0;
6195 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6210 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6211 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6218 friend class HPSI::EventDispatcherImpl;
6268 enum class KeyboardCode
6468 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6475 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6483 return !(*
this == in_that);
6492 typedef std::vector<Point, Allocator<Point> > PointArray;
6493 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6494 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6495 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6496 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6497 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6498 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6499 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6500 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6501 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6502 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6503 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6504 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6505 typedef std::vector<int, Allocator<int> > IntArray;
6506 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6507 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6508 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6509 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6510 typedef std::vector<float, Allocator<float> > FloatArray;
6511 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6512 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6513 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6514 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6515 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6516 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6517 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6518 typedef std::vector<bool, Allocator<bool> > BoolArray;
6519 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6520 typedef std::vector<Key, Allocator<Key> > KeyArray;
6521 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6522 typedef std::vector<char, Allocator<char> > CharArray;
6523 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6524 typedef std::vector<byte, Allocator<byte> > ByteArray;
6525 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6526 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6527 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6528 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6529 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6530 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6531 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6532 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6533 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6534 typedef std::vector<ConditionalExpression, Allocator<ConditionalExpression> > ConditionalExpressionArray;
6535 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6536 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6537 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6538 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6539 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6540 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6541 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6542 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6543 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6544 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6545 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6546 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6547 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6548 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6549 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6550 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6551 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6552 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6553 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6554 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6555 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6556 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6584 HPS::Type
ObjectType()
const {
return HPS::Type::SearchResultsIterator;}
6620 bool IsValid()
const;
6628 Key GetItem()
const;
6632 Key operator*()
const;
6636 SearchTypeArray GetResultTypes()
const;
6661 virtual void Reset();
6680 size_t GetCount()
const;
6719 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResultsIterator;}
6750 bool IsValid()
const;
6789 virtual void Reset();
6794 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResults;}
6809 size_t GetCount()
const;
6833 UTF8(
char const * in_string,
char const * in_locale = 0);
6837 UTF8(
wchar_t const * in_string);
6856 return Assign(std::move(in_utf8));
6863 size_t ToWStr(
wchar_t * out_wide_string)
const;
6868 size_t ToWStr(WCharArray & out_wide_string)
const;
6874 return (_length > 0);
6881 return (_length == 0);
6915 inline operator char const * ()
const
6922 char At(
size_t in_index)
const
6926 else if(in_index >= _length)
6929 return _text[in_index];
6935 UTF8 & Assign(
UTF8 const & in_utf8);
6942 return Assign(in_utf8);
6948 UTF8 & operator+= (
UTF8 const & in_utf8);
6953 UTF8 & operator+= (
char const * in_utf8);
6958 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6963 UTF8 operator+ (
char const * in_utf8)
const;
6968 bool operator== (
UTF8 const & in_utf8)
const;
6973 bool operator!= (
UTF8 const & in_utf8)
const
6975 return !(*
this == in_utf8);
6981 bool operator== (
char const * in_utf8)
const;
6986 bool operator!= (
char const * in_utf8)
const
6988 return !(*
this == in_utf8);
6997 return in_right == in_left;
7006 return in_right != in_left;
7015 return in_right ==
UTF8(in_left);
7024 return in_right !=
UTF8(in_left);
7031 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
7033 return UTF8(in_left) + in_right;
7040 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
7042 return UTF8(in_left) + in_right;
7048 size_t GetHash()
const;
7052 size_t internal_encode(
wchar_t const * in_wide_string);
7053 size_t internal_decode(
wchar_t * out_wide_string)
const;
7057 mutable size_t _hash_key;
7058 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
7059 char _buffer[_buffer_size];
7064 inline size_t operator()(
const HPS::UTF8 & in_utf8)
const
7105 HPS::Type
ObjectType()
const {
return HPS::Type::ConditionalExpression; }
7110 bool ShowCondition(
UTF8 & out_condition)
const;
7115 bool ShowNumber(
float & out_number)
const;
7120 bool ShowIntrinsic(Condition::Intrinsic & out_special)
const;
7125 bool ShowOperands(ConditionalExpressionArray & out_operands)
const;
7150 bool IsSatisfiedBy(UTF8Array
const & in_conditions)
const;
7155 bool IsSatisfiedBy(
char const * in_condition)
const;
7299 HPS_API ConditionalExpression NOT(ConditionalExpression
const & in_operand);
7305 HPS_API ConditionalExpression OR(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7311 HPS_API ConditionalExpression XOR(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7317 HPS_API ConditionalExpression AND(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7323 HPS_API ConditionalExpression EQ(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7329 HPS_API ConditionalExpression NEQ(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7335 HPS_API ConditionalExpression GT(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7341 HPS_API ConditionalExpression LT(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7347 HPS_API ConditionalExpression GTEQ(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7353 HPS_API ConditionalExpression LTEQ(ConditionalExpression
const & in_operand1, ConditionalExpression
const & in_operand2);
7368 Key(
Key const & in_that);
7381 Key & operator=(
Key && in_that);
7389 bool HasOwner()
const;
7401 void MoveTo(
SegmentKey const & in_new_owner);
7410 Key & operator=(
Key const & in_that);
7414 virtual void Assign(
Key const & in_that);
7417 bool Equals(
Key const & in_that)
const;
7420 bool operator!= (
Key const & in_that)
const;
7423 bool operator== (
Key const & in_that)
const;
7427 size_t GetHash()
const;
7432 inline size_t operator()(
const HPS::Key & in_key)
const
7480 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7484 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7542 size_t ShowSubsegments()
const;
7545 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7550 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7555 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7560 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7565 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7570 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7575 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7594 SegmentKey & SetCondition(
char const * in_condition);
7597 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7600 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7606 bool ShowConditions(UTF8Array & out_conditions)
const;
7616 SegmentKey & SetMaterialPalette(
char const * in_name);
7622 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7640 bool ShowPriority(
int & out_priority)
const;
7646 SegmentKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
7653 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7659 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7664 SegmentKey & UnsetUserData(intptr_t in_index);
7670 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7675 SegmentKey & UnsetUserData(HPS::IntPtrTArray
const & in_indices);
7682 size_t ShowUserDataCount()
const;
7688 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
7693 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7699 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7706 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7709 LineKey InsertLine(PointArray
const & in_pts);
7785 PolygonKey InsertPolygon(PointArray
const & in_points);
7795 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7798 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7801 ShellKey InsertShellByTristrips(PointArray
const & in_points, IntArray
const & in_tristrips);
7804 ShellKey InsertShellByTristrips(
size_t in_point_count,
Point const in_points [],
size_t in_tristrips_count,
int const in_tristrips []);
7810 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7813 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7861 NURBSCurveKey InsertNURBSCurve(
size_t in_degree, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_knots,
float in_start_u,
float in_end_u);
7864 NURBSCurveKey InsertNURBSCurve(
size_t in_degree,
size_t in_pcount,
Point const in_points [],
float const in_weights[],
size_t in_knot_count,
float const in_knots[],
float in_start_u,
float in_end_u);
7871 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots);
7874 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[]);
7877 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots, TrimKitArray
const & in_trims);
7880 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[],
size_t in_trim_count,
TrimKit const in_trims[]);
7890 TextKey InsertText(
Point const & in_position,
char const * in_text);
7908 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7935 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7953 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
8035 bool ShowCamera(
CameraKit & out_kit)
const;
8085 bool ShowCulling(
CullingKit & out_kit)
const;
8261 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8378 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8477 HPS::Type
ObjectType()
const {
return HPS::Type::SegmentOptimizationOptionsKit; }
8588 bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data)
const;
8590 bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix)
const;
8592 bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion)
const;
8594 bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope)
const;
8596 bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization)
const;
8598 bool ShowShellInstancing(
bool & out_shell_instancing)
const;
8600 bool ShowShellMerging(
bool & out_shell_merging)
const;
8602 bool ShowAttributeDelocalization(
bool & out_attribute_delocalization)
const;
8628 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateNotifier;};
8654 intptr_t GetClassID()
const;
8689 void DrawTexturedBackground(OpaqueHandle in_texture,
MatrixKit const & in_matrix,
Rectangle const & in_extent)
const;
8693 mutable HPS::FloatArray matrix_elements;
8701 HPS::Type
ObjectType() const OVERRIDE {
return HPS::Type::DriverEventHandler; };
8714 HPS_UNREFERENCED(in_event);
8787 WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8894 bool ShowSnapshot(
ImageKit & out_kit)
const;
8928 void MoveTo(
SegmentKey const & in_new_owner);
8947 KeyPath(KeyArray
const & in_path);
8952 KeyPath(
size_t in_path_count,
Key const in_path []);
8985 KeyPath & operator+=(KeyArray
const & in_key_array);
9000 KeyPath & Append(KeyArray
const & in_key_array);
9010 KeyPath & operator=(KeyArray
const & in_path);
9014 void Set(
KeyPath const & in_that);
9019 bool Equals(
KeyPath const & in_that)
const;
9024 bool operator!= (
KeyPath const & in_that)
const;
9029 bool operator== (
KeyPath const & in_that)
const;
9035 KeyPath & SetKeys(KeyArray
const & in_keys);
9041 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
9051 bool ShowKeys(KeyArray & out_keys)
const;
9075 bool ComputeTextExtent(
char const * in_text,
float & out_xfrac,
float & out_yfrac)
const;
9092 bool ShowNetBounding(
BoundingKit & out_kit)
const;
9096 bool ShowNetCamera(
CameraKit & out_kit)
const;
9160 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
9164 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
9168 bool ShowNetCulling(
CullingKit & out_kit)
const;
9200 bool ShowNetConditions(UTF8Array & out_conditions)
const;
9211 bool ShowNetMaterialPalette(
UTF8 & out_name)
const;
9223 bool ShowEffectiveGlyphDefinition(
char const * in_name,
GlyphDefinition & out_def)
const;
9229 bool ShowEffectiveLinePatternDefinition(
char const * in_name,
LinePatternDefinition & out_def)
const;
9235 bool ShowEffectiveShaderDefinition(
char const * in_name, ShaderDefinition & out_def)
const;
9241 bool ShowEffectiveTextureDefinition(
char const * in_name,
TextureDefinition & out_def)
const;
9247 bool ShowEffectiveImageDefinition(
char const * in_name,
ImageDefinition & out_def)
const;
9255 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
9264 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
9273 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
9282 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
9291 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
9300 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
9309 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
9318 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
9327 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
9394 bool operator==(
BoundingKit const & in_kit)
const;
9399 bool operator!=(
BoundingKit const & in_kit)
const;
9440 bool ShowExclusion(
bool & out_exclusion)
const;
9470 HPS::Type
ObjectType()
const {
return HPS::Type::BoundingControl;};
9521 bool ShowExclusion(
bool & out_exclusion)
const;
9856 bool ShowCuttingSections(
bool & out_state)
const;
9861 bool ShowCutEdges(
bool & out_state)
const;
9866 bool ShowCutFaces(
bool & out_state)
const;
9871 bool ShowWindows(
bool & out_state)
const;
9876 bool ShowText(
bool & out_state)
const;
9881 bool ShowLines(
bool & out_state)
const;
9886 bool ShowEdgeLights(
bool & out_state)
const;
9891 bool ShowMarkerLights(
bool & out_state)
const;
9896 bool ShowFaceLights(
bool & out_state)
const;
9901 bool ShowGenericEdges(
bool & out_state)
const;
9906 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9911 bool ShowAdjacentEdges(
bool & out_state)
const;
9916 bool ShowHardEdges(
bool & out_state)
const;
9921 bool ShowMeshQuadEdges(
bool & out_state)
const;
9926 bool ShowNonCulledEdges(
bool & out_state)
const;
9931 bool ShowPerimeterEdges(
bool & out_state)
const;
9936 bool ShowFaces(
bool & out_state)
const;
9941 bool ShowVertices(
bool & out_state)
const;
9946 bool ShowMarkers(
bool & out_state)
const;
9951 bool ShowShadowCasting(
bool & out_state)
const;
9956 bool ShowShadowReceiving(
bool & out_state)
const;
9961 bool ShowShadowEmitting(
bool & out_state)
const;
9993 HPS::Type
ObjectType()
const {
return HPS::Type::VisibilityControl;};
10259 bool ShowCuttingSections(
bool & out_state)
const;
10264 bool ShowCutEdges(
bool & out_state)
const;
10269 bool ShowCutFaces(
bool & out_state)
const;
10274 bool ShowWindows(
bool & out_state)
const;
10279 bool ShowText(
bool & out_state)
const;
10284 bool ShowLines(
bool & out_state)
const;
10289 bool ShowEdgeLights(
bool & out_state)
const;
10294 bool ShowMarkerLights(
bool & out_state)
const;
10299 bool ShowFaceLights(
bool & out_state)
const;
10304 bool ShowGenericEdges(
bool & out_state)
const;
10309 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
10314 bool ShowAdjacentEdges(
bool & out_state)
const;
10319 bool ShowHardEdges(
bool & out_state)
const;
10324 bool ShowMeshQuadEdges(
bool & out_state)
const;
10329 bool ShowNonCulledEdges(
bool & out_state)
const;
10334 bool ShowPerimeterEdges(
bool & out_state)
const;
10339 bool ShowFaces(
bool & out_state)
const;
10344 bool ShowVertices(
bool & out_state)
const;
10349 bool ShowMarkers(
bool & out_state)
const;
10354 bool ShowShadowCasting(
bool & out_state)
const;
10359 bool ShowShadowReceiving(
bool & out_state)
const;
10364 bool ShowShadowEmitting(
bool & out_state)
const;
10421 bool Empty()
const;
10426 bool Equals(
CameraKit const & in_kit)
const;
10431 bool operator==(
CameraKit const & in_kit)
const;
10436 bool operator!=(
CameraKit const & in_kit)
const;
10466 CameraKit & SetField(
float in_width,
float in_height);
10477 CameraKit & SetNearLimit(
float const in_limit);
10511 bool ShowUpVector(
Vector & out_up_vector)
const;
10516 bool ShowPosition(
Point & out_position)
const;
10521 bool ShowTarget(
Point & out_target)
const;
10533 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
10538 bool ShowWidth(
float & out_width)
const;
10543 bool ShowHeight(
float & out_height)
const;
10549 bool ShowField(
float & out_width,
float & out_height)
const;
10554 bool ShowNearLimit(
float & out_near_limit)
const;
10562 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10570 CameraKit & Orbit(
float in_theta,
float in_phi);
10578 CameraKit & Pan(
float in_theta,
float in_phi);
10681 bool ShowUpVector(
Vector & out_up_vector)
const;
10686 bool ShowPosition(
Point & out_position)
const;
10691 bool ShowTarget(
Point & out_target)
const;
10703 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10708 bool ShowWidth(
float & out_width)
const;
10713 bool ShowHeight(
float & out_height)
const;
10719 bool ShowField(
float & out_width,
float & out_height)
const;
10724 bool ShowNearLimit(
float & out_width)
const;
10732 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10818 bool Empty()
const;
11047 HPS::Type
ObjectType()
const {
return HPS::Type::SelectabilityControl;};
11289 bool Empty()
const;
11375 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11386 bool ShowDepthWriting(
bool & out_state)
const;
11417 HPS::Type
ObjectType()
const {
return HPS::Type::TransparencyControl;};
11492 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11503 bool ShowDepthWriting(
bool & out_state)
const;
11534 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationKit;};
11548 bool Empty()
const;
11623 bool ShowFaceColor(
bool & out_state)
const;
11628 bool ShowEdgeColor(
bool & out_state)
const;
11633 bool ShowVertexColor(
bool & out_state)
const;
11638 bool ShowFaceIndex(
bool & out_state)
const;
11643 bool ShowEdgeIndex(
bool & out_state)
const;
11648 bool ShowVertexIndex(
bool & out_state)
const;
11678 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationControl;};
11748 bool ShowFaceColor(
bool & out_state)
const;
11753 bool ShowEdgeColor(
bool & out_state)
const;
11758 bool ShowVertexColor(
bool & out_state)
const;
11763 bool ShowFaceIndex(
bool & out_state)
const;
11768 bool ShowEdgeIndex(
bool & out_state)
const;
11773 bool ShowVertexIndex(
bool & out_state)
const;
11828 bool Empty()
const;
11833 bool Equals(
CullingKit const & in_kit)
const;
11838 bool operator==(
CullingKit const & in_kit)
const;
11843 bool operator!=(
CullingKit const & in_kit)
const;
11849 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11855 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11861 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11867 CullingKit & SetExtent(
unsigned int in_pixels);
11908 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11947 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11953 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11958 bool ShowBackFace(
bool & out_state)
const;
11965 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11970 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11975 bool ShowFrustum(
bool & out_state)
const;
12017 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
12031 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
12079 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
12118 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
12124 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
12129 bool ShowBackFace(
bool & out_state)
const;
12136 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
12141 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
12146 bool ShowFrustum(
bool & out_state)
const;
12181 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeKit;};
12203 bool Empty()
const;
12249 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12286 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeControl;};
12321 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12360 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeKit;};
12382 bool Empty()
const;
12418 bool ShowTessellation(
size_t & out_facets)
const;
12447 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeControl;};
12473 bool ShowTessellation(
size_t & out_facets)
const;
12506 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeKit;};
12528 bool Empty()
const;
12597 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeControl;};
12656 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeKit;};
12678 bool Empty()
const;
12724 bool ShowTessellation(
size_t & out_facets)
const;
12760 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeControl;};
12795 bool ShowTessellation(
size_t & out_facets)
const;
12834 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeKit;};
12856 bool Empty()
const;
12951 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeControl;};
13060 bool Empty()
const;
13334 bool ShowBold(
bool & out_state)
const;
13339 bool ShowItalic(
bool & out_state)
const;
13344 bool ShowOverline(
bool & out_state)
const;
13349 bool ShowStrikethrough(
bool & out_state)
const;
13354 bool ShowUnderline(
bool & out_state)
const;
13359 bool ShowSlant(
float & out_angle)
const;
13364 bool ShowLineSpacing(
float & out_multiplier)
const;
13370 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13377 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13403 bool ShowFont(
UTF8 & out_name)
const;
13426 bool ShowPath(
Vector & out_path)
const;
13431 bool ShowSpacing(
float & out_multiplier)
const;
13462 HPS::Type
ObjectType()
const {
return HPS::Type::TextAttributeControl;};
13725 bool ShowBold(
bool & out_state)
const;
13730 bool ShowItalic(
bool & out_state)
const;
13735 bool ShowOverline(
bool & out_state)
const;
13740 bool ShowStrikethrough(
bool & out_state)
const;
13745 bool ShowUnderline(
bool & out_state)
const;
13750 bool ShowSlant(
float & out_angle)
const;
13755 bool ShowLineSpacing(
float & out_multiplier)
const;
13761 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13768 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13794 bool ShowFont(
UTF8 & out_name)
const;
13817 bool ShowPath(
Vector & out_path)
const;
13822 bool ShowSpacing(
float & out_multiplier)
const;
13880 bool Empty()
const;
13939 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13970 HPS::Type
ObjectType()
const {
return HPS::Type::LineAttributeControl;};
14018 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
14074 bool Empty()
const;
14129 bool ShowPattern(
UTF8 & out_pattern_name)
const;
14135 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
14140 bool ShowHardAngle(
float & out_angle)
const;
14172 HPS::Type
ObjectType()
const {
return HPS::Type::EdgeAttributeControl;};
14216 bool ShowPattern(
UTF8 & out_pattern_name)
const;
14222 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
14227 bool ShowHardAngle(
float & out_angle)
const;
14282 bool Empty()
const;
14377 bool ShowBudget(
size_t & out_budget)
const;
14383 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14388 bool ShowViewDependent(
bool & out_state)
const;
14394 bool ShowMaximumDeviation(
float & out_deviation)
const;
14400 bool ShowMaximumAngle(
float & out_degrees)
const;
14406 bool ShowMaximumLength(
float & out_length)
const;
14436 HPS::Type
ObjectType()
const {
return HPS::Type::CurveAttributeControl;};
14522 bool ShowBudget(
size_t & out_budget)
const;
14528 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14533 bool ShowViewDependent(
bool & out_state)
const;
14539 bool ShowMaximumDeviation(
float & out_deviation)
const;
14545 bool ShowMaximumAngle(
float & out_degrees)
const;
14551 bool ShowMaximumLength(
float & out_length)
const;
14586 MatrixKit(FloatArray
const & in_matrix_source);
14591 MatrixKit(
float const in_matrix_source []);
14621 bool Empty()
const;
14626 bool Equals(
MatrixKit const & in_kit)
const;
14631 bool operator==(
MatrixKit const & in_kit)
const;
14636 bool operator!=(
MatrixKit const & in_kit)
const;
14643 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
14649 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
14654 MatrixKit & SetElements(FloatArray
const & in_values);
14660 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
14673 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14679 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14684 bool ShowElements(FloatArray & out_matrix)
const;
14689 bool ShowDeterminant(
float & out_determinant)
const;
14694 bool ShowInverse(
MatrixKit & out_matrix)
const;
14700 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14708 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14721 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14728 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14762 MatrixKit Multiply(
float in_scalar)
const;
14767 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14782 MatrixKit operator*(
float in_scalar)
const;
14787 MatrixKit const & operator*=(
float in_scalar);
14793 Point Transform(
Point const & in_source)
const;
14798 PointArray Transform(PointArray
const & in_source)
const;
14804 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14814 VectorArray Transform(VectorArray
const & in_source)
const;
14820 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14825 Plane Transform(
Plane const & in_source)
const;
14830 PlaneArray Transform(PlaneArray
const & in_source)
const;
14836 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14878 HPS::Type
ObjectType()
const {
return HPS::Type::ModellingMatrixControl;};
14920 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14926 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14931 bool ShowElements(FloatArray & out_matrix)
const;
14936 bool ShowDeterminant(
float & out_determinant)
const;
14941 bool ShowInverse(
MatrixKit & out_matrix)
const;
14947 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
15024 HPS::Type
ObjectType()
const {
return HPS::Type::TextureMatrixControl;};
15066 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
15072 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
15077 bool ShowElements(FloatArray & out_matrix)
const;
15082 bool ShowDeterminant(
float & out_determinant)
const;
15087 bool ShowInverse(
MatrixKit & out_matrix)
const;
15093 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
15172 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingKit;};
15194 bool Empty()
const;
15798 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15805 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16024 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16056 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingControl;};
16651 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16659 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16877 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16908 HPS::Type
ObjectType()
const {
return HPS::Type::PortfolioControl; };
16916 size_t GetCount()
const;
16969 bool Show(PortfolioKeyArray & out_portfolios)
const;
17009 size_t GetCount()
const;
17012 StyleKey PushNamed(
char const * in_style_name);
17067 void Flush(
SegmentKey const & in_style_source);
17080 void Flush(
char const * in_style_name);
17093 StyleKey SetNamed(
char const * in_style_name);
17116 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionalExpressionArray
const & in_conditions);
17122 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
17138 void UnsetAllSegment();
17141 void UnsetAllNamed();
17144 void UnsetEverything();
17158 bool ShowTop(
StyleKey & out_style)
const;
17166 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionalExpressionArray & out_conditions)
const;
17171 bool Show(StyleKeyArray & out_styles)
const;
17177 bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionalExpressionArray & out_conditions)
const;
17182 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
17188 bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionalExpressionArray & out_conditions)
const;
17193 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
17225 HPS::Type
ObjectType()
const {
return HPS::Type::ConditionControl; };
17234 size_t GetCount()
const;
17272 bool ShowCondition(
char const * in_condition)
const;
17277 bool ShowConditions(UTF8Array & out_conditions)
const;
17328 bool Empty()
const;
17338 bool operator==(
MaterialKit const & in_kit)
const;
17343 bool operator!=(
MaterialKit const & in_kit)
const;
17380 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
17389 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
17395 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
17402 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
17410 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
17419 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
17425 MaterialKit & SetShader(
char const * in_shader_name);
17437 MaterialKit & SetSpecular(
char const * in_texture_name);
17443 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17455 MaterialKit & SetMirror(
char const * in_texture_name);
17468 MaterialKit & SetTransmission(
char const * in_texture_name);
17474 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17486 MaterialKit & SetEmission(
char const * in_texture_name);
17492 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17499 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
17505 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17510 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
17516 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
17526 MaterialKit & SetBump(
char const * in_texture_name);
17557 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
17598 bool ShowDiffuse()
const;
17603 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
17608 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
17613 bool ShowDiffuseAlpha(
float & out_alpha)
const;
17638 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
17643 bool ShowShader(
UTF8 & out_shader_name)
const;
17703 bool ShowBump(
UTF8 & out_texture_name)
const;
17709 bool ShowGloss(
float & out_gloss)
const;
17738 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeKit;};
17760 bool Empty()
const;
17842 bool ShowBudget(
size_t & out_budget)
const;
17847 bool ShowMaximumDeviation(
float & out_deviation)
const;
17852 bool ShowMaximumAngle(
float & out_degrees)
const;
17857 bool ShowMaximumWidth(
float & out_width)
const;
17862 bool ShowTrimBudget(
size_t & out_budget)
const;
17867 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17898 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeControl;};
17970 bool ShowBudget(
size_t & out_budget)
const;
17975 bool ShowMaximumDeviation(
float & out_deviation)
const;
17980 bool ShowMaximumAngle(
float & out_degrees)
const;
17985 bool ShowMaximumWidth(
float & out_width)
const;
17990 bool ShowTrimBudget(
size_t & out_budget)
const;
17995 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
18051 bool Empty()
const;
18133 HPS::Type
ObjectType()
const {
return HPS::Type::PerformanceControl;};
18207 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeKit;};
18229 bool Empty()
const;
18369 bool ShowColor(
RGBAColor & out_color)
const;
18374 bool ShowDimFactor(
float & out_zero_to_one)
const;
18379 bool ShowFaceDisplacement(
float & out_buckets)
const;
18384 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18389 bool ShowRenderFaces(
bool & out_state)
const;
18394 bool ShowRenderText(
bool & out_state)
const;
18404 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18409 bool ShowVisibility(
bool & out_state)
const;
18415 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18420 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18452 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeControl;};
18581 bool ShowColor(
RGBAColor & out_color)
const;
18586 bool ShowDimFactor(
float & out_zero_to_one)
const;
18591 bool ShowFaceDisplacement(
float & out_buckets)
const;
18596 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18601 bool ShowRenderFaces(
bool & out_state)
const;
18606 bool ShowRenderText(
bool & out_state)
const;
18616 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18621 bool ShowVisibility(
bool & out_state)
const;
18627 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18632 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18666 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeKit;};
18688 bool Empty()
const;
18872 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18878 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18884 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18890 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18900 bool ShowDeferral(
int & out_defer_batch)
const;
18946 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeControl;};
19114 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
19120 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
19126 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
19132 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
19142 bool ShowDeferral(
int & out_defer_batch)
const;
19182 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsKit;};
19204 bool Empty()
const;
19267 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
19276 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19293 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19301 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
19350 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19359 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19368 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19398 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsControl;};
19459 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19476 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19534 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19543 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19552 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19597 bool Empty()
const;
19741 bool ShowCameraRotation(
bool & out_state)
const;
19746 bool ShowCameraScale(
bool & out_state)
const;
19751 bool ShowCameraTranslation(
bool & out_state)
const;
19756 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19761 bool ShowCameraProjection(
bool & out_state)
const;
19766 bool ShowCameraOffset(
bool & out_state)
const;
19771 bool ShowCameraNearLimit(
bool & out_state)
const;
19776 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19781 bool ShowModellingMatrixScale(
bool & out_state)
const;
19786 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19791 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19822 HPS::Type
ObjectType()
const {
return HPS::Type::TransformMaskControl;};
19961 bool ShowCameraRotation(
bool & out_state)
const;
19966 bool ShowCameraScale(
bool & out_state)
const;
19971 bool ShowCameraTranslation(
bool & out_state)
const;
19976 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19981 bool ShowCameraProjection(
bool & out_state)
const;
19986 bool ShowCameraOffset(
bool & out_state)
const;
19991 bool ShowCameraNearLimit(
bool & out_state)
const;
19996 bool ShowModellingMatrixRotation(
bool & out_state)
const;
20001 bool ShowModellingMatrixScale(
bool & out_state)
const;
20006 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
20011 bool ShowModellingMatrixOffset(
bool & out_state)
const;
20067 bool Empty()
const;
20103 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
20113 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
20121 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20128 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20155 VisualEffectsKit & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
20166 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20226 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20231 bool ShowAntiAliasing(
bool & out_state)
const;
20240 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20248 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20253 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20258 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20263 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20273 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
20279 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20284 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20316 HPS::Type
ObjectType()
const {
return HPS::Type::VisualEffectsControl;};
20342 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
20352 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
20360 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20367 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20394 VisualEffectsControl & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
20405 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20466 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20471 bool ShowAntiAliasing(
bool & out_state)
const;
20480 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20488 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20493 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20498 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20503 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20513 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
20518 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20523 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20579 bool Empty()
const;
20606 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
20617 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
20655 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20708 bool ShowVisibility(
bool & out_state)
const;
20715 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20720 bool ShowColors(RGBColorArray & out_colors)
const;
20725 bool ShowPatterns(UTF8Array & out_patterns)
const;
20731 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20736 bool ShowLighting(
bool & out_state)
const;
20765 HPS::Type
ObjectType()
const {
return HPS::Type::ContourLineControl; };
20830 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20883 bool ShowVisibility(
bool & out_state)
const;
20890 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20895 bool ShowColors(RGBColorArray & out_colors)
const;
20900 bool ShowPatterns(UTF8Array & out_patterns)
const;
20906 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20911 bool ShowLighting(
bool & out_state)
const;
20966 bool Empty()
const;
21079 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
21217 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
21272 bool Empty()
const;
21308 bool ShowResourceMonitor(
bool & out_display)
const;
21353 bool ShowResourceMonitor(
bool & out_display)
const;
21402 bool Empty()
const;
21424 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
21430 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
21436 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
21442 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
21470 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21476 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21482 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21488 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21495 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21500 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21505 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21545 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21551 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21557 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21563 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21570 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21575 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21580 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21586 bool ShowMaxTextureSize(
unsigned int & out_width,
unsigned int & out_height)
const;
21592 bool ShowLastUpdateTime(Time & out_time)
const;
21597 bool ShowDepthPeelingLayers(
size_t & out_layers)
const;
21602 bool ShowVideoMemory(
size_t & out_video_memory)
const;
21607 bool ShowDepthBufferSize(
size_t & out_bits)
const;
21612 bool ShowMaxLights(
size_t & out_lights)
const;
21617 bool ShowColorBitPlanes(
size_t & out_planes)
const;
21622 bool ShowLastUpdateInfo(
UpdateInfo & out_info)
const;
21674 bool Empty()
const;
21693 UTF8 GetName()
const;
21697 bool GetShellConvertibility()
const;
21750 bool Empty()
const;
21778 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21792 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21809 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
21826 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21838 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21869 HPS::Type
ObjectType()
const {
return HPS::Type::AttributeLockControl;}
21887 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21901 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21935 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21947 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21996 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
22001 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
22020 bool ShowPriority(
int & out_priority)
const;
22028 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22034 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22040 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22051 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22056 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
22063 size_t ShowUserDataCount()
const;
22068 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22074 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22080 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22117 void Consume(
LineKit & in_kit);
22121 void Set(
LineKit const & in_kit);
22125 void Show(
LineKit & out_kit)
const;
22134 bool Empty()
const;
22139 bool Equals(
LineKit const & in_kit)
const;
22144 bool operator==(
LineKit const & in_kit)
const;
22149 bool operator!=(
LineKit const & in_kit)
const;
22153 size_t GetPointCount()
const;
22161 LineKit & SetPriority(
int in_priority);
22170 bool ShowPriority(
int & out_priority)
const;
22176 LineKit & SetPoints(PointArray
const & in_points);
22182 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
22197 bool ShowPoints(PointArray & out_points)
const;
22204 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22210 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22217 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22225 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22231 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22237 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22244 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22251 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22258 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22264 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22270 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22275 LineKit & UnsetUserData(intptr_t in_index);
22281 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22286 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
22290 LineKit & UnsetAllUserData();
22293 size_t ShowUserDataCount()
const;
22298 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22304 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22310 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22351 void Consume(
LineKit & in_kit);
22355 void Set(
LineKit const & in_kit);
22359 void Show(
LineKit & out_kit)
const;
22363 size_t GetPointCount()
const;
22368 LineKey & SetPoints(PointArray
const & in_points);
22374 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
22380 bool ShowPoints(PointArray & out_points)
const;
22387 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22393 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22400 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22408 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22414 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22420 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22427 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22434 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22483 bool Empty()
const;
22488 bool Equals(
MarkerKit const & in_kit)
const;
22493 bool operator==(
MarkerKit const & in_kit)
const;
22498 bool operator!=(
MarkerKit const & in_kit)
const;
22507 MarkerKit & SetPriority(
int in_priority);
22516 bool ShowPriority(
int & out_priority)
const;
22536 bool ShowPoint(
HPS::Point & out_point)
const;
22543 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22549 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22555 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22560 MarkerKit & UnsetUserData(intptr_t in_index);
22566 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22571 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
22578 size_t ShowUserDataCount()
const;
22583 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22589 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22595 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22655 bool ShowPoint(
Point & out_point)
const;
22704 bool Empty()
const;
22779 bool ShowPriority(
int & out_priority)
const;
22784 bool ShowDirection(
HPS::Vector & out_vector)
const;
22796 bool ShowCameraRelative(
bool & out_state)
const;
22803 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22809 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22815 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22826 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22838 size_t ShowUserDataCount()
const;
22843 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22849 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22855 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22938 bool ShowDirection(
HPS::Vector & out_vector)
const;
22950 bool ShowCameraRelative(
bool & out_state)
const;
23000 bool Empty()
const;
23010 bool operator==(
CylinderKit const & in_kit)
const;
23015 bool operator!=(
CylinderKit const & in_kit)
const;
23019 size_t GetPointCount()
const;
23036 bool ShowPriority(
int & out_priority)
const;
23042 CylinderKit & SetPoints(PointArray
const & in_points);
23053 CylinderKit & SetRadii(FloatArray
const & in_radii);
23059 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
23087 bool ShowPoints(PointArray & out_points)
const;
23094 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
23100 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
23107 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
23112 bool ShowRadii(FloatArray & out_radii)
const;
23238 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23243 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
23274 bool ShowVertexColors(
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23287 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23301 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23308 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23314 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23320 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23331 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23336 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
23343 size_t ShowUserDataCount()
const;
23348 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23354 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23360 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23414 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23420 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
23426 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
23433 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23440 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
23448 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23454 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
23460 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
23467 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23474 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
23483 size_t GetPointCount()
const;
23488 bool ShowPoints(PointArray & out_points)
const;
23495 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
23501 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
23508 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
23513 bool ShowRadii(FloatArray & out_radii)
const;
23579 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23602 bool ShowVertexColors(
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23615 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23629 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23679 bool Empty()
const;
23684 bool Equals(
SphereKit const & in_kit)
const;
23689 bool operator==(
SphereKit const & in_kit)
const;
23694 bool operator!=(
SphereKit const & in_kit)
const;
23702 SphereKit & SetPriority(
int in_priority);
23711 bool ShowPriority(
int & out_priority)
const;
23721 SphereKit & SetRadius(
float in_radius);
23750 bool ShowCenter(
Point & out_center)
const;
23755 bool ShowRadius(
float & out_radius)
const;
23761 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23768 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23774 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23780 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23785 SphereKit & UnsetUserData(intptr_t in_index);
23791 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23796 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
23803 size_t ShowUserDataCount()
const;
23808 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23814 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23820 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23879 SphereKey & SetRadius(
float in_radius);
23891 bool ShowCenter(
Point & out_center)
const;
23896 bool ShowRadius(
float & out_radius)
const;
23902 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23952 bool Empty()
const;
23957 bool Equals(
CircleKit const & in_kit)
const;
23962 bool operator==(
CircleKit const & in_kit)
const;
23967 bool operator!=(
CircleKit const & in_kit)
const;
23975 CircleKit & SetPriority(
int const in_priority);
23984 bool ShowPriority(
int & out_priority)
const;
23996 CircleKit & SetRadius(
float in_radius);
24024 bool ShowCenter(
Point & out_center)
const;
24029 bool ShowRadius(
float & out_radius)
const;
24034 bool ShowNormal(
Vector & out_normal)
const;
24041 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24047 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24053 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24058 CircleKit & UnsetUserData(intptr_t in_index);
24064 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24069 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
24076 size_t ShowUserDataCount()
const;
24081 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24087 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24093 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24155 CircleKey & SetRadius(
float in_radius);
24166 bool ShowCenter(
Point & out_center)
const;
24171 bool ShowRadius(
float & out_radius)
const;
24176 bool ShowNormal(
Vector & out_normal)
const;
24226 bool Empty()
const;
24258 bool ShowPriority(
int & out_priority)
const;
24297 bool ShowStart(
Point & out_start)
const;
24302 bool ShowMiddle(
Point & out_middle)
const;
24307 bool ShowEnd(
Point & out_end)
const;
24314 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24320 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24326 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24337 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24342 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
24349 size_t ShowUserDataCount()
const;
24354 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24360 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24366 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24438 bool ShowStart(
Point & out_start)
const;
24443 bool ShowMiddle(
Point & out_middle)
const;
24448 bool ShowEnd(
Point & out_end)
const;
24476 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKit; };
24497 bool Empty()
const;
24530 bool ShowPriority(
int & out_priority)
const;
24569 bool ShowStart(
Point & out_start)
const;
24574 bool ShowMiddle(
Point & out_middle)
const;
24579 bool ShowEnd(
Point & out_end)
const;
24586 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24592 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24598 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24609 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24621 size_t ShowUserDataCount()
const;
24626 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24632 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24638 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24677 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKey; };
24712 bool ShowStart(
Point & out_start)
const;
24717 bool ShowMiddle(
Point & out_middle)
const;
24722 bool ShowEnd(
Point & out_end)
const;
24750 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKit; };
24771 bool Empty()
const;
24803 bool ShowPriority(
int & out_priority)
const;
24845 size_t GetPlaneCount()
const;
24850 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24873 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24889 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24898 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24905 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24917 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24928 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24940 size_t ShowUserDataCount()
const;
24945 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24951 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24957 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24994 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKey; };
25036 size_t GetPlaneCount()
const;
25041 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
25064 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
25080 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
25087 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
25136 bool Empty()
const;
25168 bool ShowPriority(
int & out_priority)
const;
25207 bool ShowFirst(
Point & out_first)
const;
25212 bool ShowSecond(
Point & out_second)
const;
25224 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25230 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25236 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25247 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25259 size_t ShowUserDataCount()
const;
25264 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25270 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25276 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25347 bool ShowFirst(
Point & out_first)
const;
25352 bool ShowSecond(
Point & out_second)
const;
25413 bool Empty()
const;
25482 SpotlightKit & SetConcentration(
float in_concentration);
25532 bool ShowPriority(
int & out_priority)
const;
25537 bool ShowPosition(
HPS::Point & out_position)
const;
25542 bool ShowTarget(
HPS::Point & out_target)
const;
25566 bool ShowConcentration(
float & out_concentration)
const;
25571 bool ShowCameraRelative(
bool & out_state)
const;
25578 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25584 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25590 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25601 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25606 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
25613 size_t ShowUserDataCount()
const;
25618 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25624 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25630 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25725 SpotlightKey & SetConcentration(
float in_concentration);
25743 bool ShowPosition(
HPS::Point & out_position)
const;
25748 bool ShowTarget(
HPS::Point & out_target)
const;
25772 bool ShowConcentration(
float & out_concentration)
const;
25777 bool ShowCameraRelative(
bool & out_state)
const;
25826 bool Empty()
const;
25845 size_t GetPointCount()
const;
25862 bool ShowPriority(
int & out_priority)
const;
25889 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
25900 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
25906 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
25937 bool ShowDegree(
size_t & out_degree)
const;
25942 bool ShowPoints(PointArray & out_points)
const;
25949 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25955 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25962 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25967 bool ShowWeights(FloatArray & out_weights)
const;
25972 bool ShowKnots(FloatArray & out_knots)
const;
25978 bool ShowParameters(
float & out_start,
float & out_end)
const;
25987 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25994 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
26002 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
26010 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26018 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26028 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26036 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
26045 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
26053 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26061 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26069 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26075 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26082 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
26090 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26098 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26105 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26111 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26117 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26128 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26133 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
26140 size_t ShowUserDataCount()
const;
26145 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26151 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26157 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26210 size_t GetPointCount()
const;
26216 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
26221 bool ShowDegree(
size_t & out_degree)
const;
26226 bool ShowPoints(PointArray & out_points)
const;
26233 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26239 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26246 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26251 bool ShowWeights(FloatArray & out_weights)
const;
26256 bool ShowKnots(FloatArray & out_knots)
const;
26262 bool ShowParameters(
float & out_start,
float & out_end)
const;
26272 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26280 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26291 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26300 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26310 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26318 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26367 bool Empty()
const;
26386 size_t GetPointCount()
const;
26403 bool ShowPriority(
int & out_priority)
const;
26447 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
26460 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
26473 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
26536 bool ShowUDegree(
size_t & out_degree)
const;
26541 bool ShowVDegree(
size_t & out_degree)
const;
26546 bool ShowUCount(
size_t & out_count)
const;
26551 bool ShowVCount(
size_t & out_count)
const;
26556 bool ShowPoints(PointArray & out_points)
const;
26563 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26569 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26576 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26581 bool ShowWeights(FloatArray & out_weights)
const;
26586 bool ShowUKnots(FloatArray & out_knots)
const;
26591 bool ShowVKnots(FloatArray & out_knots)
const;
26596 bool ShowTrims(TrimKitArray & out_trims)
const;
26605 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26612 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
26620 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
26628 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26636 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26646 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26654 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
26663 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
26671 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26679 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26688 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26695 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26703 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
26711 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26719 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26728 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26735 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26743 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
26751 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26759 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26766 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26772 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26778 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26789 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26801 size_t ShowUserDataCount()
const;
26806 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26812 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26818 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26871 size_t GetPointCount()
const;
26898 bool ShowUDegree(
size_t & out_degree)
const;
26903 bool ShowVDegree(
size_t & out_degree)
const;
26908 bool ShowUCount(
size_t & out_count)
const;
26913 bool ShowVCount(
size_t & out_count)
const;
26918 bool ShowPoints(PointArray & out_points)
const;
26925 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26931 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26938 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26943 bool ShowWeights(FloatArray & out_weights)
const;
26948 bool ShowUKnots(FloatArray & out_knots)
const;
26953 bool ShowVKnots(FloatArray & out_knots)
const;
26958 bool ShowTrims(TrimKitArray & out_trims)
const;
26968 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26976 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26987 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26996 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
27006 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
27014 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
27024 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
27032 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
27089 bool operator==(
TrimElement const & in_that)
const;
27094 bool operator!=(
TrimElement const & in_that)
const;
27100 void SetCurve(
LineKit const & in_line);
27144 void Set(
TrimKit const & in_kit);
27148 void Show(
TrimKit & out_kit)
const;
27157 bool Empty()
const;
27162 bool Equals(
TrimKit const & in_kit)
const;
27167 bool operator==(
TrimKit const & in_kit)
const;
27172 bool operator!=(
TrimKit const & in_kit)
const;
27184 TrimKit & SetShape(TrimElementArray
const & in_shape);
27214 bool ShowShape(TrimElementArray & out_shape)
const;
27268 bool Empty()
const;
27273 bool Equals(
EllipseKit const & in_kit)
const;
27278 bool operator==(
EllipseKit const & in_kit)
const;
27283 bool operator!=(
EllipseKit const & in_kit)
const;
27300 bool ShowPriority(
int & out_priority)
const;
27339 bool ShowCenter(
Point & out_center)
const;
27344 bool ShowMajor(
Point & out_major)
const;
27349 bool ShowMinor(
Point & out_minor)
const;
27356 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27362 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27368 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27373 EllipseKit & UnsetUserData(intptr_t in_index);
27379 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27384 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
27391 size_t ShowUserDataCount()
const;
27396 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27402 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27408 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27480 bool ShowCenter(
Point & out_center)
const;
27485 bool ShowMajor(
Point & out_major)
const;
27490 bool ShowMinor(
Point & out_minor)
const;
27518 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKit; };
27539 bool Empty()
const;
27571 bool ShowPriority(
int & out_priority)
const;
27636 bool ShowCenter(
Point & out_center)
const;
27641 bool ShowMajor(
Point & out_major)
const;
27646 bool ShowMinor(
Point & out_minor)
const;
27651 bool ShowStart(
float & out_start)
const;
27656 bool ShowEnd(
float & out_end)
const;
27663 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27669 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27675 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27686 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27698 size_t ShowUserDataCount()
const;
27703 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27709 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27715 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27752 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKey; };
27805 bool ShowCenter(
Point & out_center)
const;
27810 bool ShowMajor(
Point & out_major)
const;
27815 bool ShowMinor(
Point & out_minor)
const;
27820 bool ShowStart(
float & out_start)
const;
27825 bool ShowEnd(
float & out_end)
const;
27857 void Consume(
TextKit & in_kit);
27861 void Set(
TextKit const & in_kit);
27865 void Show(
TextKit & out_kit)
const;
27874 bool Empty()
const;
27879 bool Equals(
TextKit const & in_kit)
const;
27884 bool operator==(
TextKit const & in_kit)
const;
27889 bool operator!=(
TextKit const & in_kit)
const;
27897 TextKit & SetPriority(
int in_priority);
27906 bool ShowPriority(
int & out_priority)
const;
27916 TextKit & SetText(
char const * in_string);
27926 TextKit & SetColorByIndex(
float in_index);
27943 TextKit & SetBold(
bool in_state);
27948 TextKit & SetItalic(
bool in_state);
27953 TextKit & SetOverline(
bool in_state);
27958 TextKit & SetStrikethrough(
bool in_state);
27963 TextKit & SetUnderline(
bool in_state);
27969 TextKit & SetSlant(
float in_angle);
27974 TextKit & SetLineSpacing(
float in_multiplier);
27986 TextKit & SetRotation(
float in_angle);
28046 TextKit & SetFont(
char const * in_name);
28081 TextKit & SetSpacing(
float in_multiplier);
28098 TextKit & UnsetModellingMatrix();
28118 TextKit & UnsetStrikethrough();
28130 TextKit & UnsetLineSpacing();
28146 TextKit & UnsetSizeTolerance();
28184 bool ShowPosition(
Point & out_position)
const;
28189 bool ShowText(
UTF8 & out_string)
const;
28201 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28213 bool ShowBold(
bool & out_state)
const;
28218 bool ShowItalic(
bool & out_state)
const;
28223 bool ShowOverline(
bool & out_state)
const;
28228 bool ShowStrikethrough(
bool & out_state)
const;
28233 bool ShowUnderline(
bool & out_state)
const;
28238 bool ShowSlant(
float & out_angle)
const;
28243 bool ShowLineSpacing(
float & out_multiplier)
const;
28249 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28256 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28282 bool ShowFont(
UTF8 & out_name)
const;
28305 bool ShowPath(
Vector & out_path)
const;
28310 bool ShowSpacing(
float & out_multiplier)
const;
28320 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28328 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28337 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28347 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
28361 TextKit & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28376 TextKit & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28383 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
28393 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
28399 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
28404 TextKit & UnsetUserData(intptr_t in_index);
28410 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
28415 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
28419 TextKit & UnsetAllUserData();
28422 size_t ShowUserDataCount()
const;
28427 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
28433 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
28439 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
28480 void Consume(
TextKit & in_kit);
28484 void Set(
TextKit const & in_kit);
28488 void Show(
TextKit & out_kit)
const;
28507 TextKey & SetText(
char const * in_string);
28517 TextKey & SetColorByIndex(
float in_index);
28534 TextKey & SetBold(
bool in_state);
28539 TextKey & SetItalic(
bool in_state);
28544 TextKey & SetOverline(
bool in_state);
28549 TextKey & SetStrikethrough(
bool in_state);
28554 TextKey & SetUnderline(
bool in_state);
28560 TextKey & SetSlant(
float in_angle);
28566 TextKey & SetLineSpacing(
float in_multiplier);
28578 TextKey & SetRotation(
float in_angle);
28638 TextKey & SetFont(
char const * in_name);
28675 TextKey & SetSpacing(
float in_multiplier);
28689 TextKey & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28704 TextKey & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28713 TextKey & UnsetModellingMatrix();
28733 TextKey & UnsetStrikethrough();
28745 TextKey & UnsetLineSpacing();
28761 TextKey & UnsetSizeTolerance();
28803 bool ShowPosition(
Point & out_position)
const;
28808 bool ShowText(
UTF8 & out_string)
const;
28820 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28832 bool ShowBold(
bool & out_state)
const;
28837 bool ShowItalic(
bool & out_state)
const;
28842 bool ShowOverline(
bool & out_state)
const;
28847 bool ShowStrikethrough(
bool & out_state)
const;
28852 bool ShowUnderline(
bool & out_state)
const;
28857 bool ShowSlant(
float & out_angle)
const;
28862 bool ShowLineSpacing(
float & out_multiplier)
const;
28868 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28875 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28901 bool ShowFont(
UTF8 & out_name)
const;
28924 bool ShowPath(
Vector & out_path)
const;
28929 bool ShowSpacing(
float & out_multiplier)
const;
28939 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
28949 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28957 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28966 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28988 HPS::Type
ObjectType()
const {
return HPS::Type::ShellOptimizationOptionsKit; };
29014 bool Empty()
const;
29085 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
29096 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
29131 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationOptionsKit; };
29157 bool Empty()
const;
29221 bool ShowTolerance(
float & out_tolerance)
const;
29231 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
29236 bool ShowNearestFaceCalculation(
bool & out_state)
const;
29262 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationResultsKit; };
29283 bool Empty()
const;
29304 bool ShowRelations(ShellRelationArray & out_results)
const;
29309 bool ShowNearestFaces(SizeTArray & out_faces)
const;
29314 bool ShowDistances(FloatArray & out_distances)
const;
29349 void Set(
ShellKit const & in_kit);
29353 void Show(
ShellKit & out_kit)
const;
29357 size_t GetPointCount()
const;
29361 size_t GetFaceCount()
const;
29370 bool Empty()
const;
29375 bool Equals(
ShellKit const & in_kit)
const;
29380 bool operator==(
ShellKit const & in_kit)
const;
29385 bool operator!=(
ShellKit const & in_kit)
const;
29393 ShellKit & SetPriority(
int in_priority);
29402 bool ShowPriority(
int & out_priority)
const;
29409 ShellKit & SetPoints(PointArray
const & in_points);
29415 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
29420 ShellKit & SetFacelist(IntArray
const & in_facelist);
29426 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
29431 ShellKit & SetTristrips(IntArray
const & in_tristrips);
29437 ShellKit & SetTristrips(
size_t in_count,
int const in_tristrips []);
29458 bool ShowPoints(PointArray & out_points)
const;
29465 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
29471 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
29478 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
29483 bool ShowFacelist(IntArray & out_facelist)
const;
29488 bool ShowTristrips(IntArray & out_tristrips)
const;
29668 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29674 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29681 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29688 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29694 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29701 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29707 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29716 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29724 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29734 ShellKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29743 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29751 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29757 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29764 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29771 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29777 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29784 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29790 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29795 ShellKit & UnsetMaterialMapping();
29806 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29811 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29841 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29846 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29851 ShellKit & UnsetVertexParameters();
29857 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29862 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29867 ShellKit & UnsetVertexVisibilities();
29873 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29878 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29883 ShellKit & UnsetVertexEverything();
29903 bool ShowVertexColors(
Shell::Component in_apply_to, MaterialTypeArray & out_types,
29904 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29919 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
29920 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29936 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
29937 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29945 bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
29955 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29965 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29975 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params)
const;
29984 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29995 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
30006 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30017 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
30028 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30037 bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
30047 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30057 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30066 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
30072 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
30079 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
30086 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
30092 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
30099 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
30105 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
30113 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
30119 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
30126 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
30133 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
30139 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
30146 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
30152 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
30160 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30166 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30173 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30180 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
30186 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
30193 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
30199 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
30207 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30213 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30220 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30227 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
30233 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
30240 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
30246 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
30257 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
30262 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
30273 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
30278 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
30283 ShellKit & UnsetFaceVisibilities();
30289 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
30294 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
30308 bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30319 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30331 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30340 bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
30350 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30360 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
30368 bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
30378 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30388 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30397 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30404 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
30411 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
30418 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30425 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
30434 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30441 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
30448 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
30458 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30467 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30496 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
30502 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
30508 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
30513 ShellKit & UnsetUserData(intptr_t in_index);
30519 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
30524 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
30531 size_t ShowUserDataCount()
const;
30536 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
30542 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
30548 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
30595 void Set(
ShellKit const & in_kit);
30599 void Show(
ShellKit & out_kit)
const;
30603 size_t GetPointCount()
const;
30607 size_t GetFaceCount()
const;
30613 ShellKey & SetPoints(PointArray
const & in_points);
30619 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
30624 ShellKey & SetFacelist(IntArray
const & in_facelist);
30630 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
30635 ShellKey & SetTristrips(IntArray
const & in_tristrips);
30641 ShellKey & SetTristrips(
size_t in_count,
int const in_tristrips []);
30663 ShellKey & UnsetMaterialMapping();
30672 bool ShowPoints(PointArray & out_points)
const;
30679 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
30685 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
30692 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
30697 bool ShowFacelist(IntArray & out_facelist)
const;
30702 bool ShowTristrips(IntArray & out_tristrips)
const;
30708 bool ShowTristrips(IntArray & out_tristrips, IntArray & out_face_indices)
const;
30889 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30896 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30903 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30910 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30916 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30923 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30929 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30939 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30947 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30957 ShellKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30966 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30974 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30981 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30988 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30995 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31001 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31008 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31014 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31025 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31030 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31060 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31065 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31070 ShellKey & UnsetVertexParameters();
31076 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31081 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31086 ShellKey & UnsetVertexVisibilities();
31092 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31097 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31102 ShellKey & UnsetVertexEverything();
31116 bool ShowVertexColors(
Shell::Component in_apply_to, MaterialTypeArray & out_types,
31117 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31132 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
31133 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31149 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
31150 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31159 bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
31169 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31179 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
31184 bool ShowNetVertexNormals(VectorArray & out_normals)
const;
31191 bool ShowNetVertexNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
31200 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params)
const;
31209 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31220 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
31231 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31242 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
31253 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31262 bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
31272 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31282 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31290 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31297 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31304 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
31311 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
31317 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
31324 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
31330 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
31338 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
31345 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
31352 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
31359 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
31365 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
31372 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
31378 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
31386 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31393 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31400 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31407 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
31413 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
31420 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
31426 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
31434 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31441 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31448 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31455 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
31461 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
31468 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
31474 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
31485 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
31490 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
31501 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
31506 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
31511 ShellKey & UnsetFaceVisibilities();
31517 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
31522 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
31536 bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31547 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31559 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31567 bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
31577 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31587 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31595 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
31603 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
31612 bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
31622 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31632 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31641 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31648 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
31655 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
31662 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31669 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
31678 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31685 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
31692 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
31702 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31711 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
31765 void Consume(
MeshKit & in_kit);
31769 void Set(
MeshKit const & in_kit);
31773 void Show(
MeshKit & out_kit)
const;
31782 bool Empty()
const;
31787 bool Equals(
MeshKit const & in_kit)
const;
31792 bool operator==(
MeshKit const & in_kit)
const;
31797 bool operator!=(
MeshKit const & in_kit)
const;
31801 size_t GetPointCount()
const;
31809 MeshKit & SetPriority(
int in_priority);
31818 bool ShowPriority(
int & out_priority)
const;
31823 MeshKit & SetPoints(PointArray
const & in_points);
31829 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
31836 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, HPS::PointArray
const & in_points);
31844 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31849 MeshKit & SetRows(
size_t in_rows);
31854 MeshKit & SetColumns(
size_t in_columns);
31875 bool ShowPoints(PointArray & out_points)
const;
31882 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
31888 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
31895 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
31902 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31907 bool ShowRows(
size_t & out_rows)
const;
31912 bool ShowColumns(
size_t & out_columns)
const;
32092 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32098 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32105 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32112 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
32118 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
32125 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
32131 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
32140 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32148 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
32158 MeshKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32167 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
32175 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32181 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32188 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32195 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
32201 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
32208 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
32214 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
32219 MeshKit & UnsetMaterialMapping();
32223 MeshKit & UnsetVertexColors();
32229 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
32234 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
32258 MeshKit & UnsetVertexNormals();
32264 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
32269 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
32274 MeshKit & UnsetVertexParameters();
32280 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
32285 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
32290 MeshKit & UnsetVertexVisibilities();
32296 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
32301 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
32306 MeshKit & UnsetVertexEverything();
32325 bool ShowVertexColors(
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32326 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32341 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32342 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32358 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32359 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32368 bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
32378 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32388 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32397 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params)
const;
32406 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32417 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32428 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32439 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32450 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32458 bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
32468 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32478 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32486 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32492 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
32499 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
32506 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32512 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32519 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32525 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32533 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32539 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32546 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32553 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32559 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32566 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32572 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32580 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32586 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32593 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32600 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
32606 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32613 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32619 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32627 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32633 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32640 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32647 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32653 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32660 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32666 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32677 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32682 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
32687 MeshKit & UnsetFaceNormals();
32693 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32698 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
32703 MeshKit & UnsetFaceVisibilities();
32709 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32714 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
32719 MeshKit & UnsetFaceEverything();
32728 bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32739 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32751 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32760 bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
32770 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32780 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32788 bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
32798 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32808 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32815 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32821 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32827 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32832 MeshKit & UnsetUserData(intptr_t in_index);
32838 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32843 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
32847 MeshKit & UnsetAllUserData();
32850 size_t ShowUserDataCount()
const;
32855 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32861 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32867 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32911 void Consume(
MeshKit & in_kit);
32915 void Set(
MeshKit const & in_kit);
32919 void Show(
MeshKit & out_kit)
const;
32923 size_t GetPointCount()
const;
32930 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
32938 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
32943 bool ShowPoints(PointArray & out_points)
const;
32950 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
32956 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
32963 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
32970 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
32975 bool ShowRows(
size_t & out_rows)
const;
32980 bool ShowColumns(
size_t & out_columns)
const;
32991 MeshKey & UnsetMaterialMapping();
33172 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
33179 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
33186 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
33193 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
33199 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
33206 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
33212 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
33222 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
33230 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
33240 MeshKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
33249 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
33257 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
33264 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
33271 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
33278 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
33284 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
33291 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
33297 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
33302 MeshKey & UnsetVertexColors();
33308 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
33313 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
33337 MeshKey & UnsetVertexNormals();
33343 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
33348 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
33353 MeshKey & UnsetVertexParameters();
33359 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
33364 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
33369 MeshKey & UnsetVertexVisibilities();
33375 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
33380 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
33385 MeshKey & UnsetVertexEverything();
33403 bool ShowVertexColors(
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33404 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
33419 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33420 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
33436 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33437 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
33446 bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
33456 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33466 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
33475 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params)
const;
33484 bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
33495 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
33506 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
33517 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
33528 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
33537 bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
33547 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33557 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33565 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
33572 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
33579 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
33586 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
33592 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
33599 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
33605 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
33613 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
33620 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
33627 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
33634 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
33640 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
33647 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
33653 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
33661 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
33668 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
33675 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
33682 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
33688 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
33695 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
33701 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
33709 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
33716 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
33723 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
33730 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
33736 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
33743 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
33749 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
33760 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
33765 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
33770 MeshKey & UnsetFaceNormals();
33776 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
33781 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
33786 MeshKey & UnsetFaceVisibilities();
33792 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
33797 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
33802 MeshKey & UnsetFaceEverything();
33811 bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33822 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33834 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33842 bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals)
const;
33852 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33862 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
33870 bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities)
const;
33880 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33890 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33900 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count,
size_t in_point_count,
Point const in_points[]);
33909 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count, PointArray
const & in_points);
33959 bool Empty()
const;
33964 bool Equals(
PolygonKit const & in_kit)
const;
33969 bool operator==(
PolygonKit const & in_kit)
const;
33974 bool operator!=(
PolygonKit const & in_kit)
const;
33978 size_t GetPointCount()
const;
33995 bool ShowPriority(
int & out_priority)
const;
34001 PolygonKit & SetPoints(PointArray
const & in_points);
34020 bool ShowPoints(PointArray & out_points)
const;
34027 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
34033 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
34040 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
34047 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
34053 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
34059 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
34066 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
34072 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
34079 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
34085 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
34091 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
34096 PolygonKit & UnsetUserData(intptr_t in_index);
34102 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
34107 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
34114 size_t ShowUserDataCount()
const;
34119 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
34125 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
34131 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
34186 size_t GetPointCount()
const;
34191 PolygonKey & SetPoints(PointArray
const & in_points);
34202 bool ShowPoints(PointArray & out_points)
const;
34209 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
34215 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
34222 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
34229 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
34235 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
34241 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
34248 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
34254 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
34281 void Consume(
GridKit & in_kit);
34285 void Set(
GridKit const & in_kit);
34289 void Show(
GridKit & out_kit)
const;
34303 bool Empty()
const;
34308 bool Equals(
GridKit const & in_kit)
const;
34313 bool operator==(
GridKit const & in_kit)
const;
34318 bool operator!=(
GridKit const & in_kit)
const;
34327 GridKit & SetPriority(
int in_priority);
34345 GridKit & SetFirstPoint(
Point const & in_first_point);
34354 GridKit & SetSecondPoint(
Point const & in_second_point);
34369 GridKit & SetFirstCount(
int in_first_count);
34381 GridKit & SetSecondCount(
int in_second_count);
34402 GridKit & UnsetSecondPoint();
34410 GridKit & UnsetSecondCount();
34420 bool ShowPriority(
int & out_priority)
const;
34430 bool ShowOrigin(
Point & out_origin)
const;
34435 bool ShowFirstPoint(
Point & out_first_point)
const;
34440 bool ShowSecondPoint(
Point & out_second_point)
const;
34445 bool ShowFirstCount(
int & out_first_count)
const;
34450 bool ShowSecondCount(
int & out_second_count)
const;
34457 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
34463 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
34469 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
34474 GridKit & UnsetUserData(intptr_t in_index);
34480 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
34485 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
34489 GridKit & UnsetAllUserData();
34492 size_t ShowUserDataCount()
const;
34497 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
34503 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
34509 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
34550 void Consume(
GridKit & in_kit);
34554 void Set(
GridKit const & in_kit);
34558 void Show(
GridKit & out_kit)
const;
34577 GridKey & SetFirstPoint(
Point const & in_first_point);
34586 GridKey & SetSecondPoint(
Point const & in_second_point);
34601 GridKey & SetFirstCount(
int in_first_count);
34613 GridKey & SetSecondCount(
int in_second_count);
34625 bool ShowOrigin(
Point & out_origin)
const;
34630 bool ShowFirstPoint(
Point & out_first_point)
const;
34635 bool ShowSecondPoint(
Point & out_second_point)
const;
34640 bool ShowFirstCount(
int & out_first_count)
const;
34645 bool ShowSecondCount(
int & out_second_count)
const;
34721 bool ShowPriority(
int & out_priority)
const;
34748 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
34770 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34777 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34846 StyleKey & UnsetConditionalExpression();
34875 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
34897 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34904 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34955 Key GetTarget()
const;
34960 size_t ShowTargets(
bool masked=
true)
const;
34966 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
34971 size_t ShowGeometryMask()
const;
34977 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
34982 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
34990 void SetModellingMatrix(
MatrixKit const & in_kit);
35004 void UnsetModellingMatrix();
35014 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
35058 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsKit; };
35080 bool Empty()
const;
35166 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35171 bool ShowTitle(
UTF8 & out_window_name)
const;
35176 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
35186 bool ShowFullScreen(
bool & out_state)
const;
35220 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsControl; };
35252 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35257 bool ShowTitle(
UTF8 & out_window_name)
const;
35262 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
35272 bool ShowFullScreen(
bool & out_state)
const;
35277 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
35310 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsKit; };
35332 bool Empty()
const;
35416 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35421 bool ShowHardwareResident(
bool & out_state)
const;
35433 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
35461 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsKit; };
35483 bool Empty()
const;
35550 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35555 bool ShowPlatformData(PlatformData & out_platform_data)
const;
35560 bool ShowFramebufferRetention(
bool & out_retain)
const;
35591 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsControl; };
35602 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35612 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
35617 bool ShowPlatformData(PlatformData & out_platform_data)
const;
35622 bool ShowFramebufferRetention(
bool & out_retain)
const;
35673 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowKey; };
35724 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowKey; };
35801 void SetIndexedColor(byte in_index);
35804 void SetNormalColor();
35808 void SetExplicitColor(
RGBAColor const & in_color);
35862 HPS::Type
ObjectType()
const {
return HPS::Type::LineGlyphElement; };
35866 void SetPoints(GlyphPointArray
const & in_points);
35871 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
35876 bool ShowPoints(GlyphPointArray & out_points)
const;
35921 bool ShowPoint(
GlyphPoint & out_point)
const;
35959 HPS::Type
ObjectType()
const {
return HPS::Type::EllipseGlyphElement; };
35963 void SetLowerLeft(
GlyphPoint const & in_point);
35967 void SetUpperRight(
GlyphPoint const & in_point);
35977 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
35982 bool ShowUpperRight(
GlyphPoint & out_point)
const;
36014 HPS::Type
ObjectType()
const {
return HPS::Type::SphereGlyphElement; };
36053 HPS::Type
ObjectType()
const {
return HPS::Type::CircularArcGlyphElement; };
36057 void SetStartPoint(
GlyphPoint const & in_point);
36061 void SetIntermediatePoint(
GlyphPoint const & in_point);
36065 void SetEndPoint(
GlyphPoint const & in_point);
36076 bool ShowStartPoint(
GlyphPoint & out_point)
const;
36081 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
36086 bool ShowEndPoint(
GlyphPoint & out_point)
const;
36126 HPS::Type
ObjectType()
const {
return HPS::Type::InfiniteLineGlyphElement; };
36130 void SetFirstPoint(
GlyphPoint const & in_point);
36134 void SetSecondPoint(
GlyphPoint const & in_point);
36148 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
36153 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
36195 void Set(
GlyphKit const & in_kit);
36199 void Show(
GlyphKit & out_kit)
const;
36208 bool Empty()
const;
36213 bool Equals(
GlyphKit const & in_kit)
const;
36218 bool operator==(
GlyphKit const & in_kit)
const;
36223 bool operator!=(
GlyphKit const & in_kit)
const;
36228 GlyphKit & SetRadius(sbyte in_radius);
36239 GlyphKit & SetElements(GlyphElementArray
const & in_def);
36271 bool ShowRadius(sbyte & out_radius)
const;
36276 bool ShowOffset(
GlyphPoint & out_point)
const;
36281 bool ShowElements(GlyphElementArray & out_def)
const;
36313 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternOptionsKit; };
36330 bool Empty()
const;
36456 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternElement; };
36528 HPS::Type
ObjectType()
const {
return HPS::Type::SolidLinePatternElement; };
36533 void SetColor(
RGBAColor const & in_color);
36538 void SetMaterialByIndex(
float in_material_index);
36583 HPS::Type
ObjectType()
const {
return HPS::Type::BlankLinePatternElement; };
36621 HPS::Type
ObjectType()
const {
return HPS::Type::GlyphLinePatternElement; };
36625 void SetSource(
char const * in_source);
36638 void SetMirror(
bool in_state);
36642 void SetFixed(
bool in_state);
36646 void SetRotation(
float in_degrees);
36651 bool ShowSource(
UTF8 & out_source)
const;
36667 bool ShowMirror(
bool & out_state)
const;
36672 bool ShowFixed(
bool & out_state)
const;
36677 bool ShowRotation(
float & out_degrees)
const;
36703 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternParallelKit; };
36720 bool Empty()
const;
36865 bool ShowBody(LinePatternElementArray & out_elements)
const;
36870 bool ShowAbsoluteLength(
bool & out_state)
const;
36875 bool ShowAbsoluteWeight(
bool & out_state)
const;
36899 bool ShowContinuous(
bool & out_state)
const;
36948 bool Empty()
const;
36968 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
37001 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
37059 virtual void Assign(
Definition const & in_that);
37064 bool Equals(
Definition const & in_that)
const;
37069 bool operator==(
Definition const & in_that)
const;
37074 bool operator!=(
Definition const & in_that)
const;
37220 ShaderDefinition DefineShader(
char const * in_name, ShaderKit
const & in_source);
37243 PortfolioKey & UndefineNamedStyle(
char const * in_name);
37248 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
37258 PortfolioKey & UndefineLinePattern(
char const * in_name);
37371 ShaderDefinition ImportShader(ShaderDefinition
const & in_definition);
37376 size_t GetDefinitionCount()
const;
37379 size_t GetTextureDefinitionCount()
const;
37382 size_t GetCubeMapDefinitionCount()
const;
37385 size_t GetImageDefinitionCount()
const;
37388 size_t GetNamedStyleDefinitionCount()
const;
37391 size_t GetMaterialPaletteDefinitionCount()
const;
37394 size_t GetGlyphDefinitionCount()
const;
37397 size_t GetLinePatternDefinitionCount()
const;
37401 size_t GetShaderDefinitionCount()
const;
37406 bool ShowTextureDefinition(
char const * in_name)
const;
37412 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
37417 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
37422 bool ShowCubeMapDefinition(
char const * in_name)
const;
37428 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
37433 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
37438 bool ShowImageDefinition(
char const * in_name)
const;
37444 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
37449 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
37454 bool ShowNamedStyleDefinition(
char const * in_name)
const;
37465 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
37470 bool ShowMaterialPaletteDefinition(
char const * in_name)
const;
37481 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
37486 bool ShowGlyphDefinition(
char const * in_name)
const;
37492 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
37497 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
37502 bool ShowLinePatternDefinition(
char const * in_name)
const;
37513 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
37518 bool ShowShaderDefinition(
char const * in_name)
const;
37524 bool ShowShaderDefinition(
char const * in_name, ShaderDefinition & out_found)
const;
37529 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
37533 void MoveTo(
SegmentKey const & in_new_owner);
37579 void Set(
GlyphKit const & in_kit);
37583 void Show(
GlyphKit & out_kit)
const;
37621 HPS::Type
ObjectType()
const {
return HPS::Type::TextureDefinition; };
37666 HPS::Type
ObjectType()
const {
return HPS::Type::TextureOptionsKit; };
37688 bool Empty()
const;
37794 bool ShowDecal(
bool & out_state)
const;
37799 bool ShowDownSampling(
bool & out_state)
const;
37804 bool ShowModulation(
bool & out_state)
const;
37809 bool ShowParameterOffset(
size_t & out_offset)
const;
37834 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37883 HPS::Type
ObjectType()
const {
return HPS::Type::ImageExportOptionsKit; };
37905 bool Empty()
const;
37926 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37950 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37981 HPS::Type
ObjectType()
const {
return HPS::Type::ImageImportOptionsKit; };
37998 bool Empty()
const;
38021 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
38064 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
38074 bool ShowDownSampling(
bool & out_state)
const;
38079 bool ShowCompressionQuality(
float & out_quality)
const;
38108 static void Export(
char const * in_file_name,
HPS::WindowKey const & in_window,
unsigned int in_width,
unsigned int in_height,
Format in_format = Format::Png);
38114 static void Export(
char const * in_file_name,
HPS::ImageKit const & in_image_kit);
38160 void Set(
ImageKit const & in_kit);
38164 void Show(
ImageKit & out_kit)
const;
38173 bool Empty()
const;
38178 bool Equals(
ImageKit const & in_kit)
const;
38183 bool operator==(
ImageKit const & in_kit)
const;
38188 bool operator!=(
ImageKit const & in_kit)
const;
38203 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
38208 ImageKit & SetData(ByteArray
const & in_image_data);
38214 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
38224 ImageKit & SetDownSampling(
bool in_state);
38229 ImageKit & SetCompressionQuality(
float in_quality);
38249 ImageKit & UnsetCompressionQuality();
38259 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
38264 bool ShowData(ByteArray & out_image_data)
const;
38274 bool ShowDownSampling(
bool & out_state)
const;
38279 bool ShowCompressionQuality(
float & out_quality)
const;
38311 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsControl; };
38339 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
38345 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
38357 bool ShowImage(ByteArray & out_bytes)
const;
38362 bool ShowHardwareResident(
bool & out_state)
const;
38368 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
38413 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowKey; };
38470 void Set(
ImageKit const & in_kit);
38474 void Show(
ImageKit & out_kit)
const;
38511 HPS::Type
ObjectType()
const {
return HPS::Type::CubeMapDefinition; };
38538 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
38584 HPS::Type
ObjectType()
const {
return HPS::Type::NamedStyleDefinition; };
38627 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialPaletteDefinition; };
38631 void Set(MaterialKitArray
const & in_source);
38636 void Set(
size_t in_count,
MaterialKit const in_source []);
38640 void Show(MaterialKitArray & out_source)
const;
38679 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternDefinition; };
38693 class HPS_API Shader
38698 enum class Parameterization
38703 PhysicalReflection,
38725 class HPS_API ImportOptionsKit :
public Object
38729 ImportOptionsKit();
38733 ImportOptionsKit(ImportOptionsKit
const & in_kit);
38738 ImportOptionsKit(ImportOptionsKit && in_that);
38743 ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38745 virtual ~ImportOptionsKit();
38747 HPS::Type ObjectType()
const {
return HPS::Type::ShaderImportOptionsKit; };
38751 void Set(ImportOptionsKit
const & in_kit);
38755 void Show(ImportOptionsKit & out_kit)
const;
38760 ImportOptionsKit & operator=(ImportOptionsKit
const & in_kit);
38764 bool Empty()
const;
38769 bool Equals(ImportOptionsKit
const & in_kit)
const;
38774 bool operator==(ImportOptionsKit
const & in_kit)
const;
38779 bool operator!=(ImportOptionsKit
const & in_kit)
const;
38787 ImportOptionsKit & SetMultitexture(
bool in_state);
38792 ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38797 ImportOptionsKit & SetTransformMatrix(MatrixKit
const & in_transform);
38802 ImportOptionsKit & UnsetMultitexture();
38806 ImportOptionsKit & UnsetParameterizationSource();
38810 ImportOptionsKit & UnsetTransformMatrix();
38814 ImportOptionsKit & UnsetEverything();
38821 bool ShowMultitexture(
bool & out_state)
const;
38826 bool ShowParameterizationSource(Parameterization & out_source)
const;
38831 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38843 static ShaderKit Import(
char const * in_file_name, ImportOptionsKit
const & in_options);
38857 class HPS_API ShaderKit :
public Object
38865 ShaderKit(ShaderKit
const & in_kit);
38870 ShaderKit(ShaderKit && in_that);
38875 ShaderKit & operator=(ShaderKit && in_that);
38877 virtual ~ShaderKit();
38879 HPS::Type ObjectType()
const {
return HPS::Type::ShaderKit; };
38883 void Set(ShaderKit
const & in_kit);
38887 void Show(ShaderKit & out_kit)
const;
38892 ShaderKit & operator=(ShaderKit
const & in_kit);
38896 bool Empty()
const;
38901 bool Equals(ShaderKit
const & in_kit)
const;
38906 bool operator==(ShaderKit
const & in_kit)
const;
38911 bool operator!=(ShaderKit
const & in_kit)
const;
38916 ShaderKit & SetSource(
char const * in_source);
38924 ShaderKit & SetMultitexture(
bool in_state);
38929 ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38934 ShaderKit & SetTransformMatrix(MatrixKit
const & in_transform);
38938 ShaderKit & UnsetSource();
38943 ShaderKit & UnsetMultitexture();
38947 ShaderKit & UnsetParameterizationSource();
38951 ShaderKit & UnsetTransformMatrix();
38955 ShaderKit & UnsetEverything();
38960 bool ShowSource(UTF8 & out_source)
const;
38967 bool ShowMultitexture(
bool & out_state)
const;
38972 bool ShowParameterizationSource(Shader::Parameterization & out_source)
const;
38977 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38982 class HPS_API ShaderDefinition :
public Definition
38986 ShaderDefinition();
38992 ShaderDefinition(Definition
const & in_that);
38996 ShaderDefinition(ShaderDefinition
const & in_that);
39001 ShaderDefinition & operator=(ShaderDefinition
const & in_that);
39006 ShaderDefinition(ShaderDefinition && in_that);
39011 ShaderDefinition & operator=(ShaderDefinition && in_that);
39013 ~ShaderDefinition();
39015 HPS::Type ObjectType()
const {
return HPS::Type::ShaderDefinition; };
39019 void Set(ShaderKit
const & in_kit);
39023 void Show(ShaderKit & out_kit)
const;
39055 HPS::Type
ObjectType()
const {
return HPS::Type::CutGeometryGatheringOptionsKit;};
39077 bool Empty()
const;
39136 bool ShowOffset(
size_t & out_offset)
const;
39189 bool Empty()
const;
39256 bool ShowCriteria(SearchTypeArray & out_types)
const;
39261 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
39306 bool operator==(
TreeContext const & in_that)
const;
39311 bool operator!=(
TreeContext const & in_that)
const;
39338 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsKit;};
39360 bool Empty()
const;
39568 bool ShowProximity(
float & out_proximity)
const;
39578 bool ShowInternalLimit(
size_t & out_limit)
const;
39583 bool ShowRelatedLimit(
size_t & out_limit)
const;
39588 bool ShowSorting(
bool & out_sorted)
const;
39603 bool ShowScope(
KeyPath & out_start_path)
const;
39608 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
39613 bool ShowExtentCullingRespected(
bool & out_state)
const;
39618 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
39623 bool ShowFrustumCullingRespected(
bool & out_state)
const;
39628 bool ShowVectorCullingRespected(
bool & out_state)
const;
39661 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsControl;};
39782 bool ShowProximity(
float & out_proximity)
const;
39792 bool ShowInternalLimit(
size_t & out_limit)
const;
39797 bool ShowRelatedLimit(
size_t & out_limit)
const;
39802 bool ShowSorting(
bool & out_sorted)
const;
39817 bool ShowExtentCullingRespected(
bool & out_state)
const;
39822 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
39827 bool ShowFrustumCullingRespected(
bool & out_state)
const;
39832 bool ShowVectorCullingRespected(
bool & out_state)
const;
39898 bool ShowSelectedItem(
Key & out_selection)
const;
39903 bool ShowPath(
KeyPath & out_path)
const;
39908 bool ShowFaces(SizeTArray & out_faces)
const;
39913 bool ShowVertices(SizeTArray & out_vertices)
const;
39919 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
39924 bool ShowCharacters(SizeTArray & out_characters)
const;
39929 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
39934 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
39939 bool ShowNormalizedSelectionPosition(
WindowPoint & out_location)
const;
39967 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionResultsIterator;}
40000 bool IsValid()
const;
40068 virtual void Reset();
40076 size_t GetCount()
const;
40182 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
40197 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
40210 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
40225 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
40327 HPS::Type
ObjectType()
const {
return HPS::Type::HighlightOptionsKit;};
40349 bool Empty()
const;
40417 bool ShowStyleName(
UTF8 & out_style_name)
const;
40422 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
40432 bool ShowNotification(
bool & out_state)
const;
40586 bool Empty()
const;
40634 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
40668 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateOptionsControl;};
40705 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
40720 World(
char const * in_license);
40731 World & SetMaterialLibraryDirectory(
char const * in_directory);
40737 World & SetFontDirectory(
char const * in_directory);
40744 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
40750 World & SetFontDirectories(UTF8Array
const & in_directories);
40757 World & SetDriverConfigFile(
char const * in_filename);
40764 World & SetExchangeLibraryDirectory(
char const * in_directory);
40771 World & SetPublishResourceDirectory(
char const * in_directory);
40777 World & SetParasolidSchemaDirectory(
char const * in_directory);
40783 World & SetRealDWGDirectory(
char const * in_directory);
40790 World & SetRealDWGDirectory(
char const * in_directory, UTF8Array
const & in_object_enabler_directories);
40797 World & SetParasolidBodyshopDirectory(
char const * in_directory);
40801 World & UnsetMaterialLibraryDirectory();
40805 World & UnsetFontDirectories();
40809 World & UnsetDriverConfigFile();
40813 World & UnsetExchangeLibraryDirectory();
40817 World & UnsetPublishResourceDirectory();
40821 World & UnsetParasolidSchemaDirectory();
40825 World & UnsetRealDWGDirectory();
40829 World & UnsetParasolidBodyshopDirectory();
40834 bool ShowLicense(
UTF8 & out_license)
const;
40839 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
40844 bool ShowFontDirectories(UTF8Array & out_directories)
const;
40849 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
40854 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
40859 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
40864 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
40870 bool ShowRealDWGDirectory(
UTF8 & out_directory, UTF8Array & out_object_enabler_directories)
const;
40875 bool ShowParasolidBodyshopDirectory(
UTF8 & out_directory)
const;
40883 virtual void Reset() {}
40912 intptr_t GetClassID()
const;
40919 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
40920 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
40933 static void Execute(
bool in_once=
true);
40937 static Time GetTime();
40940 static void Sleep(Time milliseconds);
40966 static void RelinquishMemory();
40994 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
41003 static void Reset();
41006 static void Synchronize();
41010 static WindowKeyArray GetWindowKeys();
41014 static SegmentKeyArray GetRootSegments();
41018 static PortfolioKeyArray GetPortfolios();
41024 static PortfolioKey const GetMaterialLibraryPortfolio();
41099 static size_t SelectByShell(
ShellKit const & in_shell,
41108 static size_t SelectByShell(
ShellKey const & in_shell,
41118 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
41128 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
41156 static bool SetInformationEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
41162 static bool SetWarningEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
41168 static bool SetErrorEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
41176 static void UnsetEmergencyHandler();
41180 static size_t GetSoftMemoryLimit();
41185 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
41254 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
41260 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
41266 bool UnSubscribe(
EventHandler const & in_handler)
const;
41271 bool UnSubscribe(intptr_t in_type)
const;
41276 bool InjectEvent(
Event const & in_event)
const;
41286 void Shutdown()
const;
41290 bool IsShutdown()
const;
41295 void SetName(
char const * in_name)
const;
41299 void ShowName(
UTF8 & out_name)
const;
41303 virtual void Reset() {}
41342 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
41348 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
41356 void UnSubscribeEverything()
const;
41359 virtual void Reset() { UnSubscribeEverything(); }
41389 channel = GetClassID();
41390 consumable =
false;
41398 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
41417 HPS_UNREFERENCED(in_that_event);
41422 return GetClassID();
41440 channel = GetClassID();
41441 consumable =
false;
41442 action = Action::None;
41446 :
Event(), action(in_action), results(in_results), options(in_options)
41448 channel = GetClassID();
41449 consumable =
false;
41456 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
41459 action = that.action;
41460 results = that.results;
41461 options = that.options;
41502 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
41506 code =
event->code;
41529 return message == in_that.
message && code == in_that.
code;
41537 return Equals(in_that);
41545 return !Equals(in_that);
41562 WarningEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
41573 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
41577 code =
event->code;
41600 return message == in_that.
message && code == in_that.
code;
41608 return Equals(in_that);
41616 return !Equals(in_that);
41633 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
41644 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
41648 code =
event->code;
41671 return message == in_that.
message && code == in_that.
code;
41679 return Equals(in_that);
41687 return !Equals(in_that);
41722 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
41748 return action == in_that.
action;
41756 return Equals(in_that);
41764 return !Equals(in_that);
41777 { channel = GetClassID(); }
41797 { channel = GetClassID(); }
41807 if(in_event.
GetChannel() == Object::ClassID<TextInputEvent>())
41810 text =
event->
text;
41823 return text == in_that.
text;
41831 return Equals(in_that);
41839 return !Equals(in_that);
41870 if(in_event.
GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41873 update_time =
event->update_time;
41901 , import_status_message(HPS::
UTF8())
41902 { channel = GetClassID(); }
41906 , import_status_message(in_message)
41907 { channel = GetClassID(); }
41913 if (in_event.
GetChannel() == Object::ClassID<ImportStatusEvent>())
41916 import_status_message =
event.import_status_message;
41942 { channel = GetClassID(); }
41948 if (in_event.
GetChannel() != Object::ClassID<ShowKeyboardEvent>())
41971 { channel = GetClassID(); }
41977 if (in_event.
GetChannel() != Object::ClassID<HideKeyboardEvent>())
42005 return modifiers == in_that.modifiers;
42013 return Equals(in_that);
42021 return !Equals(in_that);
42026 bool None()
const {
return modifiers == _key_none; }
42030 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
42034 bool Control()
const {
return (modifiers & _key_control) != 0; }
42038 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
42042 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
42048 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
42058 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
42062 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
42066 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
42070 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
42078 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
42088 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
42125 _key_none = 0x0000,
42126 _key_shift = 0x0001,
42127 _key_control = 0x0002,
42129 _key_meta = 0x0008,
42172 return Equals(in_that);
42180 return !Equals(in_that);
42187 return ModifierKeyState;
42214 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
42222 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
42231 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
42238 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
42241 channel = GetClassID();
42242 CurrentAction =
event->CurrentAction;
42243 Touches =
event->Touches;
42244 ModifierKeyState =
event->ModifierKeyState;
42274 return Equals(in_that);
42282 return !Equals(in_that);
42292 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
42293 && Touches.size() == that_touch_event->
Touches.size() )
42295 TouchArray these_touches = Touches;
42296 TouchArray those_touches = that_touch_event->
Touches;
42298 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
42299 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
42301 for (
size_t i = 0 ; i < these_touches.size() ; i++)
42303 if (these_touches[i].ID != those_touches[i].ID)
42321 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
42323 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
42340 return buttons == in_that.buttons;
42348 return Equals(in_that);
42356 return !Equals(in_that);
42361 bool None()
const {
return buttons == _button_none; }
42365 bool Left()
const {
return (buttons & _button_left) != 0; }
42369 bool Right()
const {
return (buttons & _button_right) != 0; }
42373 bool Middle()
const {
return (buttons & _button_middle) != 0; }
42377 bool X1()
const {
return (buttons & _button_x1) != 0; }
42381 bool X2()
const {
return (buttons & _button_x2) != 0; }
42387 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
42396 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
42400 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
42404 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
42408 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
42412 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
42420 ret.buttons = buttons | in_buttons_to_merge.buttons;
42430 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
42471 _button_none = 0x0000,
42472 _button_left = 0x0001,
42473 _button_right = 0x0002,
42474 _button_middle = 0x0004,
42475 _button_x1 = 0x0008,
42476 _button_x2 = 0x0010
42509 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
42519 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
42525 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
42528 channel = GetClassID();
42529 CurrentAction =
event->CurrentAction;
42530 Location =
event->Location;
42531 CurrentButton =
event->CurrentButton;
42532 WheelDelta =
event->WheelDelta;
42533 ClickCount =
event->ClickCount;
42566 return Equals(in_that);
42574 return !Equals(in_that);
42585 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
42594 if (CurrentAction == Action::Move)
42595 return GetClassID();
42628 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
42636 :
InputEvent(in_modifiers), CurrentAction(in_action)
42638 channel = GetClassID();
42639 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
42647 :
InputEvent(in_modifiers), CurrentAction(in_action)
42649 channel = GetClassID();
42650 KeyboardCodes = in_keyboardcodes;
42657 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
42660 channel = GetClassID();
42661 KeyboardCodes =
event->KeyboardCodes;
42662 CurrentAction =
event->CurrentAction;
42693 return Equals(in_that);
42701 return !Equals(in_that);
42709 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
42716 KeyboardCodes = in_keyboardcodes;
42761 bool Equals(
MouseState const & in_that)
const;
42766 bool operator== (
MouseState const & in_that)
const;
42771 bool operator!= (
MouseState const & in_that)
const;
42799 HPS::KeyArray GetEventPath()
const;
42815 void SetActiveEvent(
MouseEvent const & in_event);
42819 void SetEventPath(KeyArray
const & in_path);
42873 bool Equals(
TouchState const & in_that)
const;
42878 bool operator== (
TouchState const & in_that)
const;
42883 bool operator!= (
TouchState const & in_that)
const;
42904 HPS::KeyArray GetEventPath()
const;
42908 size_t GetTouchCount()
const;
42912 HPS::TouchArray GetTouches()
const;
42920 void SetActiveEvent(
TouchEvent const & in_event);
42924 void SetEventPath(KeyArray
const & in_path);
42928 void SetTouches(TouchArray
const & in_touches);
43005 HPS::KeyArray GetEventPath()
const;
43009 size_t GetKeyboardCodeCount()
const;
43013 HPS::KeyboardCodeArray GetKeyboardCodes()
const;
43018 bool GetKeyState(HPS::KeyboardCode in_key_code)
const;
43030 void SetEventPath(KeyArray
const & in_path);
43034 void SetKeyboardCodes(KeyboardCodeArray
const & in_keyboard_codes);
43086 IOResult Status()
const;
43091 IOResult Status(
float & out_percent_complete)
const;
43135 virtual void Restart();
43142 static Toolkit CreateToolkit();
43156 intptr_t GetClassID()
const;
43180 GeometryExportEvent & operator=(GeometryExportEvent
const &);
43182 GeometryExportEvent();
43183 virtual ~GeometryExportEvent();
43184 GeometryExportEvent(
HPS::Key & in_key);
43194 SegmentExportEvent & operator=(SegmentExportEvent
const &);
43196 SegmentExportEvent();
43197 virtual ~SegmentExportEvent();
43214 intptr_t GetClassID()
const;
43240 AttributeLockImportEvent & operator=(AttributeLockImportEvent
const &);
43242 AttributeLockImportEvent();
43243 virtual ~AttributeLockImportEvent();
43253 BoundingImportEvent & operator=(BoundingImportEvent
const &);
43255 BoundingImportEvent();
43256 virtual ~BoundingImportEvent();
43266 CameraImportEvent & operator=(CameraImportEvent
const &);
43268 CameraImportEvent();
43269 virtual ~CameraImportEvent();
43279 CircleImportEvent & operator=(CircleImportEvent
const &);
43281 CircleImportEvent();
43282 virtual ~CircleImportEvent();
43292 CircularArcImportEvent & operator=(CircularArcImportEvent
const &);
43294 CircularArcImportEvent();
43295 virtual ~CircularArcImportEvent();
43305 CircularWedgeImportEvent & operator=(CircularWedgeImportEvent
const &);
43307 CircularWedgeImportEvent();
43308 virtual ~CircularWedgeImportEvent();
43318 ColorInterpolationImportEvent & operator=(ColorInterpolationImportEvent
const &);
43320 ColorInterpolationImportEvent();
43321 virtual ~ColorInterpolationImportEvent();
43331 CommentImportEvent & operator=(CommentImportEvent
const &);
43333 CommentImportEvent();
43334 virtual ~CommentImportEvent();
43335 CommentImportEvent(
HPS::SegmentKey & in_segment_key,
const char* in_comment);
43344 ConditionImportEvent & operator=(ConditionImportEvent
const &);
43346 ConditionImportEvent();
43347 virtual ~ConditionImportEvent();
43351 HPS::UTF8Array conditions;
43357 ContourLineImportEvent & operator=(ContourLineImportEvent
const &);
43359 ContourLineImportEvent();
43360 virtual ~ContourLineImportEvent();
43370 CuttingSectionImportEvent & operator=(CuttingSectionImportEvent
const &);
43372 CuttingSectionImportEvent();
43373 virtual ~CuttingSectionImportEvent();
43383 CuttingSectionAttributeImportEvent & operator=(CuttingSectionAttributeImportEvent
const &);
43385 CuttingSectionAttributeImportEvent();
43386 virtual ~CuttingSectionAttributeImportEvent();
43396 CubeMapDefinitionImportEvent & operator=(CubeMapDefinitionImportEvent
const &);
43398 CubeMapDefinitionImportEvent();
43399 virtual ~CubeMapDefinitionImportEvent();
43420 CullingImportEvent & operator=(CullingImportEvent
const &);
43422 CullingImportEvent();
43423 virtual ~CullingImportEvent();
43433 CurveAttributeImportEvent & operator=(CurveAttributeImportEvent
const &);
43435 CurveAttributeImportEvent();
43436 virtual ~CurveAttributeImportEvent();
43446 CylinderAttributeImportEvent & operator=(CylinderAttributeImportEvent
const &);
43448 CylinderAttributeImportEvent();
43449 virtual ~CylinderAttributeImportEvent();
43459 CylinderImportEvent & operator=(CylinderImportEvent
const &);
43461 CylinderImportEvent();
43462 virtual ~CylinderImportEvent();
43472 DistantLightPropertyImportEvent & operator=(DistantLightPropertyImportEvent
const &);
43474 DistantLightPropertyImportEvent();
43475 virtual ~DistantLightPropertyImportEvent();
43485 DistantLightImportEvent & operator=(DistantLightImportEvent
const &);
43487 DistantLightImportEvent();
43488 virtual ~DistantLightImportEvent();
43498 DrawingAttributeImportEvent & operator=(DrawingAttributeImportEvent
const &);
43500 DrawingAttributeImportEvent();
43501 virtual ~DrawingAttributeImportEvent();
43511 EdgeAttributeImportEvent & operator=(EdgeAttributeImportEvent
const &);
43513 EdgeAttributeImportEvent();
43514 virtual ~EdgeAttributeImportEvent();
43524 EllipseImportEvent & operator=(EllipseImportEvent
const &);
43526 EllipseImportEvent();
43527 virtual ~EllipseImportEvent();
43537 EllipticalArcImportEvent & operator=(EllipticalArcImportEvent
const &);
43539 EllipticalArcImportEvent();
43540 virtual ~EllipticalArcImportEvent();
43550 GlyphDefinitionImportEvent & operator=(GlyphDefinitionImportEvent
const &);
43552 GlyphDefinitionImportEvent();
43553 virtual ~GlyphDefinitionImportEvent();
43564 GridImportEvent & operator=(GridImportEvent
const &);
43567 virtual ~GridImportEvent();
43577 HiddenLineAttributeImportEvent & operator=(HiddenLineAttributeImportEvent
const &);
43579 HiddenLineAttributeImportEvent();
43580 virtual ~HiddenLineAttributeImportEvent();
43590 ImageDefinitionImportEvent & operator=(ImageDefinitionImportEvent
const &);
43592 ImageDefinitionImportEvent();
43593 virtual ~ImageDefinitionImportEvent();
43604 IncludeSegmentImportEvent & operator=(IncludeSegmentImportEvent
const &);
43606 IncludeSegmentImportEvent();
43607 virtual ~IncludeSegmentImportEvent();
43613 HPS::AttributeLockTypeArray filter_types;
43619 InfiniteLineImportEvent & operator=(InfiniteLineImportEvent
const &);
43621 InfiniteLineImportEvent();
43622 virtual ~InfiniteLineImportEvent();
43632 LightingAttributeImportEvent & operator=(LightingAttributeImportEvent
const &);
43634 LightingAttributeImportEvent();
43635 virtual ~LightingAttributeImportEvent();
43645 LineAttributeImportEvent & operator=(LineAttributeImportEvent
const &);
43647 LineAttributeImportEvent();
43648 virtual ~LineAttributeImportEvent();
43658 LineImportEvent & operator=(LineImportEvent
const &);
43661 virtual ~LineImportEvent();
43671 LinePatternDefinitionImportEvent & operator=(LinePatternDefinitionImportEvent
const &);
43673 LinePatternDefinitionImportEvent();
43674 virtual ~LinePatternDefinitionImportEvent();
43685 MarkerImportEvent & operator=(MarkerImportEvent
const &);
43687 MarkerImportEvent();
43688 virtual ~MarkerImportEvent();
43698 MarkerAttributeImportEvent & operator=(MarkerAttributeImportEvent
const &);
43700 MarkerAttributeImportEvent();
43701 virtual ~MarkerAttributeImportEvent();
43711 MaterialImportEvent & operator=(MaterialImportEvent
const &);
43713 MaterialImportEvent();
43714 virtual ~MaterialImportEvent();
43724 MaterialPaletteDefinitionImportEvent & operator=(MaterialPaletteDefinitionImportEvent
const &);
43726 MaterialPaletteDefinitionImportEvent();
43727 virtual ~MaterialPaletteDefinitionImportEvent();
43728 MaterialPaletteDefinitionImportEvent(
HPS::PortfolioKey & in_portfolio_key,
HPS::UTF8 && in_name, HPS::MaterialKitArray & in_material_mapping_kit_array);
43732 HPS::MaterialKitArray & material_mapping_kit_array;
43738 MaterialPaletteImportEvent & operator=(MaterialPaletteImportEvent
const &);
43740 MaterialPaletteImportEvent();
43741 virtual ~MaterialPaletteImportEvent();
43751 MatrixImportEvent & operator=(MatrixImportEvent
const &);
43753 MatrixImportEvent();
43754 virtual ~MatrixImportEvent();
43764 MeshImportEvent & operator=(MeshImportEvent
const &);
43767 virtual ~MeshImportEvent();
43777 MeshInstanceImportEvent & operator=(MeshInstanceImportEvent
const &);
43779 MeshInstanceImportEvent();
43780 virtual ~MeshInstanceImportEvent();
43791 NamedStyleDefinitionImportEvent & operator=(NamedStyleDefinitionImportEvent
const &);
43793 NamedStyleDefinitionImportEvent();
43794 virtual ~NamedStyleDefinitionImportEvent();
43805 NamedStyleImportEvent & operator=(NamedStyleImportEvent
const &);
43807 NamedStyleImportEvent();
43808 virtual ~NamedStyleImportEvent();
43814 HPS::AttributeLockTypeArray filter_types;
43820 NURBSCurveImportEvent & operator=(NURBSCurveImportEvent
const &);
43822 NURBSCurveImportEvent();
43823 virtual ~NURBSCurveImportEvent();
43833 NURBSSurfaceImportEvent & operator=(NURBSSurfaceImportEvent
const &);
43835 NURBSSurfaceImportEvent();
43836 virtual ~NURBSSurfaceImportEvent();
43846 NURBSSurfaceAttributeImportEvent & operator=(NURBSSurfaceAttributeImportEvent
const &);
43848 NURBSSurfaceAttributeImportEvent();
43849 virtual ~NURBSSurfaceAttributeImportEvent();
43859 PerformanceImportEvent & operator=(PerformanceImportEvent
const &);
43861 PerformanceImportEvent();
43862 virtual ~PerformanceImportEvent();
43872 PolygonImportEvent & operator=(PolygonImportEvent
const &);
43874 PolygonImportEvent();
43875 virtual ~PolygonImportEvent();
43885 PriorityImportEvent & operator=(PriorityImportEvent
const &);
43887 PriorityImportEvent();
43888 virtual ~PriorityImportEvent();
43889 PriorityImportEvent(
HPS::Key & in_key,
int in_priority);
43898 ReferenceGeometryImportEvent & operator=(ReferenceGeometryImportEvent
const &);
43900 ReferenceGeometryImportEvent();
43901 virtual ~ReferenceGeometryImportEvent();
43905 HPS::Key & reference_geometry_key;
43912 SegmentImportEvent & operator=(SegmentImportEvent
const &);
43914 SegmentImportEvent();
43915 virtual ~SegmentImportEvent();
43925 SelectabilityImportEvent & operator=(SelectabilityImportEvent
const &);
43927 SelectabilityImportEvent();
43928 virtual ~SelectabilityImportEvent();
43938 ShaderDefinitionImportEvent & operator=(ShaderDefinitionImportEvent
const &);
43940 ShaderDefinitionImportEvent();
43941 virtual ~ShaderDefinitionImportEvent();
43946 HPS::ShaderKit & shader_kit;
43952 ShellImportEvent & operator=(ShellImportEvent
const &);
43954 ShellImportEvent();
43955 virtual ~ShellImportEvent();
43965 ShellInstanceImportEvent & operator=(ShellInstanceImportEvent
const &);
43967 ShellInstanceImportEvent();
43968 virtual ~ShellInstanceImportEvent();
43979 SphereImportEvent & operator=(SphereImportEvent
const &);
43981 SphereImportEvent();
43982 virtual ~SphereImportEvent();
43992 SphereAttributeImportEvent & operator=(SphereAttributeImportEvent
const &);
43994 SphereAttributeImportEvent();
43995 virtual ~SphereAttributeImportEvent();
44005 SpotlightImportEvent & operator=(SpotlightImportEvent
const &);
44007 SpotlightImportEvent();
44008 virtual ~SpotlightImportEvent();
44018 StyleSegmentImportEvent & operator=(StyleSegmentImportEvent
const &);
44020 StyleSegmentImportEvent();
44021 virtual ~StyleSegmentImportEvent();
44027 HPS::AttributeLockTypeArray filter_types;
44033 TextImportEvent & operator=(TextImportEvent
const &);
44036 virtual ~TextImportEvent();
44046 TextAttributeImportEvent & operator=(TextAttributeImportEvent
const &);
44048 TextAttributeImportEvent();
44049 virtual ~TextAttributeImportEvent();
44060 TextureDefinitionImportEvent & operator=(TextureDefinitionImportEvent
const &);
44062 TextureDefinitionImportEvent();
44063 virtual ~TextureDefinitionImportEvent();
44076 TransformMaskImportEvent & operator=(TransformMaskImportEvent
const &);
44078 TransformMaskImportEvent();
44079 virtual ~TransformMaskImportEvent();
44089 TransparencyImportEvent & operator=(TransparencyImportEvent
const &);
44091 TransparencyImportEvent();
44092 virtual ~TransparencyImportEvent();
44102 SubwindowImportEvent & operator=(SubwindowImportEvent
const &);
44104 SubwindowImportEvent();
44105 virtual ~SubwindowImportEvent();
44116 NonDBUserDataImportEvent & operator=(NonDBUserDataImportEvent
const &);
44118 NonDBUserDataImportEvent() {}
44119 virtual ~NonDBUserDataImportEvent();
44120 NonDBUserDataImportEvent(
size_t in_count, HPS::byte
const in_data[]);
44130 UserDataImportEvent & operator=(UserDataImportEvent
const &);
44132 virtual ~UserDataImportEvent();
44133 UserDataImportEvent();
44134 UserDataImportEvent(
HPS::Key & in_key, intptr_t in_index,
size_t in_count, HPS::byte
const in_data[]);
44146 VisibilityImportEvent & operator=(VisibilityImportEvent
const &);
44148 VisibilityImportEvent();
44149 virtual ~VisibilityImportEvent();
44159 VisualEffectsImportEvent & operator=(VisualEffectsImportEvent
const &);
44161 VisualEffectsImportEvent();
44162 virtual ~VisualEffectsImportEvent();
44195 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportOptionsKit; };
44212 bool Empty()
const;
44255 bool ShowSegment(
SegmentKey & out_segment)
const;
44270 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
44285 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
44330 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportResultsKit; };
44347 bool Empty()
const;
44379 bool ShowSegment(
SegmentKey & out_segment)
const;
44397 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
44415 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
44431 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
44439 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
44450 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
44486 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportOptionsKit; };
44503 bool Empty()
const;
44531 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
44540 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
44547 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
44556 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
44565 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
44589 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
44640 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
44646 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
44652 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
44658 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
44664 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
44669 bool ShowConnectivityCompression(
bool & out_state)
const;
44675 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
44680 bool ShowSerializeTristrips(
bool & out_state)
const;
44728 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportNotifier;};
44775 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportNotifier;};
44855 DotsPerCentimeter = DPCM,
44887 HPS::Type
ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
44904 bool Empty()
const;
44929 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
44969 bool ShowWYSIWYG(
bool & out_onoff)
const;
45012 static IOResult Export(
char const * in_filename, Driver in_driver_type,
HPS::WindowKey const & in_window, ExportOptionsKit
const & in_options);
45023 class HPS_API ExportOptionsKit :
public Object
45027 ExportOptionsKit();
45031 ExportOptionsKit(ExportOptionsKit
const & in_kit);
45036 ExportOptionsKit(ExportOptionsKit && in_that);
45041 ExportOptionsKit & operator=(ExportOptionsKit && in_that);
45043 virtual ~ExportOptionsKit();
45045 HPS::Type ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
45049 void Set(ExportOptionsKit
const & in_kit);
45053 void Show(ExportOptionsKit & out_kit)
const;
45058 ExportOptionsKit & operator=(ExportOptionsKit
const & in_kit);
45062 bool Empty()
const;
45067 bool Equals(ExportOptionsKit
const & in_kit)
const;
45072 bool operator==(ExportOptionsKit
const & in_kit)
const;
45077 bool operator!=(ExportOptionsKit
const & in_kit)
const;
45085 bool ShowResolution(
float & out_resolution)
const;
45090 ExportOptionsKit & SetResolution(
float in_resolution);
45094 ExportOptionsKit & UnsetResolution();
45101 bool ShowWYSIWYG(
bool & out_onoff)
const;
45106 ExportOptionsKit & SetWYSIWYG(
bool in_onoff);
45110 ExportOptionsKit & UnsetWYSIWYG();
45115 ExportOptionsKit & UnsetEverything();
45124 static IOResult Export(intptr_t hdc, intptr_t attribdc,
HPS::WindowKey const & window, ExportOptionsKit
const & options);
45167 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportOptionsKit; };
45184 bool Empty()
const;
45214 bool ShowSegment(
SegmentKey & out_segment)
const;
45229 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
45275 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportResultsKit; };
45292 bool Empty()
const;
45324 bool ShowSegment(
SegmentKey & out_segment)
const;
45342 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
45466 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportOptionsKit; };
45483 bool Empty()
const;
45545 bool ShowSegment(
SegmentKey & out_segment)
const;
45577 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportResultsKit; };
45594 bool Empty()
const;
45626 bool ShowSegment(
SegmentKey & out_segment)
const;
45704 # pragma warning(pop)
HPS::Type ObjectType() const
Definition: hps.h:40725
Rotation
Definition: hps.h:1569
HPS::Type ObjectType() const
Definition: hps.h:27247
bool Empty() const
Definition: hps.h:6879
CameraPoint(Point const &in_point)
Definition: hps.h:5830
Alignment
Definition: hps.h:1502
Space
Definition: hps.h:562
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:42601
Channel
Definition: hps.h:910
HPS::Type ObjectType() const
Definition: hps.h:24403
Handedness
Definition: hps.h:1257
ColorSource
Definition: hps.h:1895
HPS::Type ObjectType() const
Definition: hps.h:17311
HPS::Type ObjectType() const
Definition: hps.h:36926
Event(intptr_t in_channel=0)
Definition: hps.h:6183
HPS::Type ObjectType() const
Definition: hps.h:45396
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3778
HPS::ByteArray user_data
Definition: hps.h:44123
float alpha
Definition: hps.h:4317
HPS::Type ObjectType() const
Definition: hps.h:36528
bool operator==(Touch const &in_that) const
Definition: hps.h:6473
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:42058
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:41691
size_t display_list_tristrip_count
Number of tristrips drawn from display lists during the last update.
Definition: hps.h:4835
HPS::Type ObjectType() const
Definition: hps.h:34950
HPS::Type ObjectType() const
Definition: hps.h:22113
HPS::Type ObjectType() const
Definition: hps.h:23931
size_t extent_culled_segment_count
Number of segments culled because of extent culling during the last update.
Definition: hps.h:4841
HPS::Type ObjectType() const
Definition: hps.h:24677
Action
Definition: hps.h:42199
Orientation
Definition: hps.h:538
Code
Definition: hps.h:136
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1315
HPS::Type ObjectType() const
Definition: hps.h:15172
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:41746
HPS::Type ObjectType() const
Definition: hps.h:8628
HPS::Type ObjectType() const
Definition: hps.h:28476
Event * Clone() const
Definition: hps.h:41589
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:42518
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:41377
ImportStatusEvent()
Definition: hps.h:41899
HPS::Type ObjectType() const
Definition: hps.h:21728
HPS::Type ObjectType() const
Definition: hps.h:36703
HPS::Type ObjectType() const
Definition: hps.h:26194
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:42264
size_t frustum_culled_segment_count
Number of segments culled because of frustum culling during the last update.
Definition: hps.h:4840
HPS::Type ObjectType() const
Definition: hps.h:30587
HPS::Type ObjectType() const
Definition: hps.h:25805
HPS::Type ObjectType() const
Definition: hps.h:11806
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41638
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:42707
HPS::Type ObjectType() const
Definition: hps.h:38466
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5727
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5975
Driver
Definition: hps.h:159
HPS::Type ObjectType() const
Definition: hps.h:42747
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2219
HPS::Type ObjectType() const
Definition: hps.h:39864
CappingLevel
Definition: hps.h:1701
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8712
HPS::Type ObjectType() const
Definition: hps.h:23658
HPS::Type ObjectType() const
Definition: hps.h:36456
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12951
size_t dot_3d_count
Number of 3D dots drawn during the last update.
Definition: hps.h:4823
HPS::Type ObjectType() const
Definition: hps.h:42859
HPS::Type ObjectType() const
Definition: hps.h:20765
HPS::Type ObjectType() const
Definition: hps.h:13970
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5578
HPS::UTF8 text
The text for this TextInputEvent.
Definition: hps.h:41852
Multiline strings will be left justified.
HPS::Type ObjectType() const
Definition: hps.h:29262
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3885
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:42646
static ModifierKeys KeyMeta()
Definition: hps.h:42117
HPS::Type ObjectType() const
Definition: hps.h:36186
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:37621
HPS::Type ObjectType() const
Definition: hps.h:44775
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3764
HPS::Type ObjectType() const
Definition: hps.h:40041
HPS::Type ObjectType() const
Definition: hps.h:23856
HPS::Type ObjectType() const
Definition: hps.h:35724
HPS::Type ObjectType() const
Definition: hps.h:17001
HPS::Type ObjectType() const
Definition: hps.h:39055
Time GetTimeStamp() const
Definition: hps.h:6205
HPS::Type ObjectType() const
Definition: hps.h:22631
NormalizedPoint(Point const &in_point)
Definition: hps.h:5880
HPS::Type ObjectType() const
Definition: hps.h:24205
Event * Clone() const
Definition: hps.h:41406
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3813
Renderer
Definition: hps.h:1550
HPS::Type ObjectType() const
Definition: hps.h:34686
KeyboardEvent()
Definition: hps.h:42622
HPS::Type ObjectType() const
Definition: hps.h:7386
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:4006
ObjectPoint(Point const &in_point)
Definition: hps.h:5730
HPS::Type ObjectType() const
Definition: hps.h:17898
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3748
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:41720
static ModifierKeys KeyAlt()
Definition: hps.h:42113
bool IsConsumable() const
Definition: hps.h:6208
HPS::ByteArray user_data
Definition: hps.h:44140
MaterialPreference
Definition: hps.h:1718
size_t line_dc_count
Number of DC lines drawn during the last update.
Definition: hps.h:4824
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:42635
Mobility
Definition: hps.h:206
HPS::Type ObjectType() const
Definition: hps.h:13462
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5928
InterpolationAlgorithm
Definition: hps.h:1484
Fill
Definition: hps.h:1886
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3801
HPS::Type ObjectType() const
Definition: hps.h:27752
HPS::Type ObjectType() const
Definition: hps.h:19398
char At(size_t in_index) const
Definition: hps.h:6922
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:42053
HPS::Type ObjectType() const
Definition: hps.h:36583
HPS::Type ObjectType() const
Definition: hps.h:7105
ReferenceFrame
Definition: hps.h:1517
size_t polygon_dc_count
Number of DC polygons drawn during the last update.
Definition: hps.h:4828
HideKeyboardEvent()
Definition: hps.h:41969
HPS::Type ObjectType() const
Definition: hps.h:17225
GreekingUnits
Definition: hps.h:1604
HPS::Type ObjectType() const
Definition: hps.h:12360
InnerConeUnits
Definition: hps.h:493
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6024
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3918
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41861
OuterConeUnits
Definition: hps.h:479
HPS::Type ObjectType() const
Definition: hps.h:19182
HPS::Type ObjectType() const
Definition: hps.h:41228
size_t culled_display_list_tristrip_count
Number of tristrips from display lists culled during the last update.
Definition: hps.h:4837
HPS::Type ObjectType() const
Definition: hps.h:40138
HPS::Type ObjectType() const
Definition: hps.h:14600
HPS::Type ObjectType() const
Definition: hps.h:34169
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:42714
HPS::Type ObjectType() const
Definition: hps.h:27140
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:42288
HPS::Type ObjectType() const
Definition: hps.h:12834
HPS::Type ObjectType() const
Definition: hps.h:25387
HPS::Type ObjectType() const
Definition: hps.h:37044
Channel
Definition: hps.h:870
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:41620
AreaUnits
Definition: hps.h:1443
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3855
HPS::Type ObjectType() const
Definition: hps.h:12181
HPS::Type ObjectType() const
Definition: hps.h:35310
Action
Definition: hps.h:41702
HPS::Type ObjectType() const
Definition: hps.h:14436
HPS::Type ObjectType() const
Definition: hps.h:44486
HPS::Type ObjectType() const
Definition: hps.h:27853
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6488
HPS::Type ObjectType() const
Definition: hps.h:38584
HPS::Type ObjectType() const
Definition: hps.h:34823
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:42221
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3964
Border
Definition: hps.h:275
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:42048
Time update_time
Time taken by the last update.
Definition: hps.h:4845
size_t vector_culled_segment_count
Number of segments culled because of vector culling during the last update.
Definition: hps.h:4842
HPS::Type ObjectType() const
Definition: hps.h:23398
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:42683
HPS::Type ObjectType() const
Definition: hps.h:21653
WarningEvent(Event const &in_event)
Definition: hps.h:41571
HPS::Type ObjectType() const
Definition: hps.h:11678
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1905
static ModifierKeys KeyShift()
Definition: hps.h:42105
HPS::Type ObjectType() const
Definition: hps.h:28988
Shape
Definition: hps.h:1052
bool IsValid() const
Definition: hps.h:6872
Cuboid_3D()
Definition: hps.h:3756
ErrorEvent(Event const &in_event)
Definition: hps.h:41642
size_t GetWStrLength() const
Definition: hps.h:6901
Event * Clone() const
Definition: hps.h:41471
HPS::Type ObjectType() const
Definition: hps.h:11267
AppendMode
Definition: hps.h:341
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3949
void Meta(bool in_state)
Definition: hps.h:42070
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6123
HPS::Type ObjectType() const
Definition: hps.h:14878
UpdateStatus
Definition: hps.h:170
HPS_INLINE bool IsValid() const
Definition: hps.h:3806
HPS::Type ObjectType() const
Definition: hps.h:39167
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:41767
Quality
Definition: hps.h:1036
ResolutionUnits
Definition: hps.h:44851
TimerTickEvent(Event const &in_event)
Definition: hps.h:41396
Component
Definition: hps.h:360
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6074
HPS::Type ObjectType() const
Definition: hps.h:12447
Default
Definition: hps.h:1859
HPS::Type ObjectType() const
Definition: hps.h:10796
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5094
size_t triangle_3d_count
Number of 3D triangles drawn during the last update.
Definition: hps.h:4827
bool Shift() const
Definition: hps.h:42030
SizeToleranceUnits
Definition: hps.h:1591
HPS::Type ObjectType() const
Definition: hps.h:39291
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4035
Cap
Definition: hps.h:1811
Point_3D< F > max
Definition: hps.h:3750
HPS::Type ObjectType() const
Definition: hps.h:7469
HPS::Type ObjectType() const
Definition: hps.h:45167
HPS::Type ObjectType() const
Definition: hps.h:45275
MouseEvent()
Definition: hps.h:42500
HPS::Type ObjectType() const
Definition: hps.h:12286
HPS::Type ObjectType() const
Definition: hps.h:16908
HPS::Type ObjectType() const
Definition: hps.h:35769
Material Texture Channel.
static const float Infinity
Definition: hps.h:2214
InsetBehavior
Definition: hps.h:1792
HPS::Type ObjectType() const
Definition: hps.h:25313
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2227
HPS::Type ObjectType() const
Definition: hps.h:13858
HPS::Type ObjectType() const
Definition: hps.h:27446
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6487
HPS::Type ObjectType() const
Definition: hps.h:35959
HPS::Type ObjectType() const
Definition: hps.h:38311
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3928
Algorithm
Definition: hps.h:1430
Decimation
Definition: hps.h:990
Granularity
Definition: hps.h:1360
Search the current segment only.
size_t display_list_line_3d_count
Number of lines drawn from display lists during the last update.
Definition: hps.h:4832
KeyboardEvent(Event const &in_event)
Definition: hps.h:42655
ClipOperation
Definition: hps.h:1288
HPS::Type ObjectType() const
Definition: hps.h:8970
Method
Definition: hps.h:1421
HPS::Type ObjectType() const
Definition: hps.h:26855
Parameterization
Definition: hps.h:924
FocusLostEvent()
Definition: hps.h:41775
CuttingLevel
Definition: hps.h:1710
Channel
Definition: hps.h:891
HandleResult
Definition: hps.h:41367
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5106
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:41690
Value
Definition: hps.h:1402
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2235
Code
Definition: hps.h:105
HPS::Type ObjectType() const
Definition: hps.h:26346
Event * Clone() const
Definition: hps.h:41783
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:42554
ShowKeyboardEvent(Event const &in_event)
Definition: hps.h:41946
ErrorEvent()
Definition: hps.h:41629
Justification
Definition: hps.h:1525
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:14260
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5596
ErrorEvent(char const *in_message)
Definition: hps.h:41633
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41868
FrameSize
Definition: hps.h:216
Justification
Definition: hps.h:1828
HPS::Type ObjectType() const
Definition: hps.h:12004
HPS::Type ObjectType() const
Definition: hps.h:20045
TextInputEvent(Event const &in_event)
Definition: hps.h:41805
HPS::Type ObjectType() const
Definition: hps.h:22462
HPS::Type ObjectType() const
Definition: hps.h:8753
HPS::Type ObjectType() const
Definition: hps.h:37575
HPS::Type ObjectType() const
Definition: hps.h:35673
GreekingMode
Definition: hps.h:1616
HPS::Type ObjectType() const
Definition: hps.h:20557
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:42719
Operation
Definition: hps.h:461
HPS::Type ObjectType() const
Definition: hps.h:38156
Type
Definition: hps.h:1973
WorldPoint(Point const &in_point)
Definition: hps.h:5780
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:42313
HPS::Type ObjectType() const
Definition: hps.h:9993
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2506
HPS::Type ObjectType() const
Definition: hps.h:6719
TouchEvent(Event const &in_event)
Definition: hps.h:42236
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7004
size_t save_region_count
Number of framebuffer regions saved during the last update.
Definition: hps.h:4843
Relation
Definition: hps.h:386
Action
Definition: hps.h:42614
ChannelMapping
Definition: hps.h:1006
HPS::Type ObjectType() const
Definition: hps.h:22979
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5613
HPS::Type ObjectType() const
Definition: hps.h:39661
HPS::Type ObjectType() const
Definition: hps.h:40327
bool Alt() const
Definition: hps.h:42038
ToleranceUnits
Definition: hps.h:369
HPS::Type ObjectType() const
Definition: hps.h:12760
SizeUnits
Definition: hps.h:1779
Type
Definition: hps.h:2008
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:36014
RelationTest
Definition: hps.h:396
Type
Definition: hps.h:333
Event * Clone() const
Definition: hps.h:41985
HPS::Type ObjectType() const
Definition: hps.h:15024
Behavior
Definition: hps.h:571
Fastest ambient occlusion but lower quality.
HPS::Type ObjectType() const
Definition: hps.h:6794
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:42720
HPS::Type ObjectType() const
Definition: hps.h:18946
ImageFormat
Definition: hps.h:232
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5587
float blue
Definition: hps.h:4316
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:434
HPS::Type ObjectType() const
Definition: hps.h:21385
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7022
PixelPoint(Point const &in_point)
Definition: hps.h:6126
HPS::Type ObjectType() const
Definition: hps.h:6248
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:42580
size_t non_display_list_tristrip_count
Number of tristrips drawn during the last update.
Definition: hps.h:4836
HPS::Type ObjectType() const
Definition: hps.h:21990
size_t display_list_vertex_3d_count
Number of vertices drawn from display lists during the last update.
Definition: hps.h:4834
HPS::Type ObjectType() const
Definition: hps.h:21869
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
HPS::Type ObjectType() const
Definition: hps.h:35912
UpdateType
Definition: hps.h:181
HPS::Type ObjectType() const
Definition: hps.h:29131
HPS::Type ObjectType() const
Definition: hps.h:24476
HPS::Type ObjectType() const
Definition: hps.h:39967
HPS::Type ObjectType() const
Definition: hps.h:21250
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:42600
Event * Clone() const
Definition: hps.h:41926
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5100
HPS::Type ObjectType() const
Definition: hps.h:35220
HPS::Type ObjectType() const
Definition: hps.h:41336
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS::Type ObjectType() const
Definition: hps.h:16056
Infinite line which extends infinitely in both directions along a vector.
size_t line_3d_count
Number of 3D lines drawn during the last update.
Definition: hps.h:4825
intptr_t GetChannel() const
Definition: hps.h:6202
HPS::Type ObjectType() const
Definition: hps.h:9362
Algorithm
Definition: hps.h:1343
HPS::Type ObjectType() const
Definition: hps.h:31761
HPS::Type ObjectType() const
Definition: hps.h:38627
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3873
Driver
Definition: hps.h:45001
SizeUnits
Definition: hps.h:1645
StandAloneWindowEvent()
Definition: hps.h:41711
HPS::Type ObjectType() const
Definition: hps.h:37113
HPS::Type ObjectType() const
Definition: hps.h:35058
TextInputEvent(char const *in_text)
Definition: hps.h:41801
HPS::Type ObjectType() const
Definition: hps.h:12597
HPS::Type ObjectType() const
Definition: hps.h:11417
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:41598
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:42508
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5559
HPS::Type ObjectType() const
Definition: hps.h:17738
Level
Definition: hps.h:1334
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:42003
void Control(bool in_state)
Definition: hps.h:42062
HPS::Type ObjectType() const
Definition: hps.h:44728
HPS::Type ObjectType() const
Definition: hps.h:18452
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:4020
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:41619
The base class of all HPS exceptions.
Definition: hps.h:5551
RegionAlignment
Definition: hps.h:1625
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:42230
Event * Clone() const
Definition: hps.h:42545
HPS::Type ObjectType() const
Definition: hps.h:21534
void Invalidate()
Definition: hps.h:3818
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4812
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5610
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41864
HPS::Type ObjectType() const
Definition: hps.h:34546
size_t restore_region_count
Number of framebuffer regions restored during the last update.
Definition: hps.h:4844
HPS::Type ObjectType() const
Definition: hps.h:40564
HPS::ByteArray non_db_user_data
Definition: hps.h:43159
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6195
char const * GetBytes() const
Definition: hps.h:6908
virtual intptr_t Freshen() const
Definition: hps.h:42592
virtual bool Equals(TextInputEvent const &in_that) const
Definition: hps.h:41821
Event * Clone() const
Definition: hps.h:41846
HPS::Type ObjectType() const
Definition: hps.h:36053
float green
Definition: hps.h:4315
Action
Definition: hps.h:42489
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1668
HPS::Type ObjectType() const
Definition: hps.h:10399
HPS::Type ObjectType() const
Definition: hps.h:27518
HPS::Type ObjectType() const
Definition: hps.h:24994
size_t triangle_dc_count
Number of DC triangles drawn during the last update.
Definition: hps.h:4826
HPS::Type ObjectType() const
Definition: hps.h:24750
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:38679
HPS::Type ObjectType() const
Definition: hps.h:25115
InnerPixelPoint(Point const &in_point)
Definition: hps.h:6027
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41911
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5877
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6467
static const float NegativeInfinity
Definition: hps.h:2216
HighlightEvent(Event const &in_event)
Definition: hps.h:41454
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7013
SizeUnits
Definition: hps.h:1461
HPS::Type ObjectType() const
Definition: hps.h:13038
HPS::Type ObjectType() const
Definition: hps.h:20944
TextInputEvent()
Definition: hps.h:41795
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:42602
HPS::Type ObjectType() const
Definition: hps.h:10620
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5978
GatheringLevel
Definition: hps.h:1726
HPS::Type ObjectType() const
Definition: hps.h:29341
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3785
FrameOptions
Definition: hps.h:224
HPS::Type ObjectType() const
Definition: hps.h:35862
Space
Definition: hps.h:2074
void Alt(bool in_state)
Definition: hps.h:42066
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:42627
HPS::Type ObjectType() const
Definition: hps.h:37883
Type
Definition: hps.h:269
HideKeyboardEvent(Event const &in_event)
Definition: hps.h:41975
bool operator!=(Touch const &in_that) const
Definition: hps.h:6481
Type
Definition: hps.h:452
HPS::Type ObjectType() const
Definition: hps.h:44195
HPS::Type ObjectType() const
Definition: hps.h:45577
HPS::Type ObjectType() const
Definition: hps.h:45466
HPS::Type ObjectType() const
Definition: hps.h:34277
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5777
HPS::Type ObjectType() const
Definition: hps.h:9554
HPS::Type ObjectType() const
Definition: hps.h:45663
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6995
ShowKeyboardEvent()
Definition: hps.h:41940
HPS::SegmentKey & segment_key
Definition: hps.h:43201
Event * Clone() const
Definition: hps.h:42255
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:41669
Event * Clone() const
Definition: hps.h:41737
size_t GetLength() const
Definition: hps.h:6893
HPS::Type ObjectType() const
Definition: hps.h:21337
HPS::Type ObjectType() const
Definition: hps.h:27070
Type
Definition: hps.h:1114
HPS::Type ObjectType() const
Definition: hps.h:9470
bool None() const
Definition: hps.h:42026
size_t ClickCount
The number of clicks received.
Definition: hps.h:42604
virtual intptr_t Freshen() const
Definition: hps.h:6199
void Reset()
Definition: hps.h:6888
HPS::Type ObjectType() const
Definition: hps.h:38413
HPS::Type ObjectType() const
Definition: hps.h:24131
HPS::Type ObjectType() const
Definition: hps.h:40668
SizeUnits
Definition: hps.h:1579
Event * Clone() const
Definition: hps.h:41660
MouseEvent(Event const &in_event)
Definition: hps.h:42523
virtual bool Empty() const
Definition: hps.h:5653
Join
Definition: hps.h:1802
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3942
Modifier
Definition: hps.h:1839
size_t dot_dc_count
Number of DC dots drawn during the last update.
Definition: hps.h:4822
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:42213
static intptr_t ClassID()
Definition: hps.h:5675
HighlightEvent()
Definition: hps.h:41438
virtual HPS::Type ObjectType() const
Definition: hps.h:5649
HPS::Type ObjectType() const
Definition: hps.h:14052
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:42312
Type
Definition: hps.h:579
virtual intptr_t Freshen() const
Definition: hps.h:41421
Background
Definition: hps.h:250
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3862
static ModifierKeys KeyControl()
Definition: hps.h:42109
HPS::Type ObjectType() const
Definition: hps.h:18666
HPS::Type ObjectType() const
Definition: hps.h:36313
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5925
HPS::Type ObjectType() const
Definition: hps.h:40460
StandAloneWindowEvent(Action in_action)
Definition: hps.h:41716
Mode
Definition: hps.h:1691
size_t segment_count
Number of segments traversed during the last update.
Definition: hps.h:4839
Event * Clone() const
Definition: hps.h:41885
size_t polygon_3d_count
Number of 3D polygons drawn during the last update.
Definition: hps.h:4829
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4079
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3897
size_t display_list_triangle_3d_count
Number of triangles drawn from display lists during the last update.
Definition: hps.h:4833
Type
Definition: hps.h:853
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3850
Event * Clone() const
Definition: hps.h:41956
HPS::Type ObjectType() const
Definition: hps.h:12506
HPS::Type ObjectType() const
Definition: hps.h:32907
HPS::Type ObjectType() const
Definition: hps.h:38511
HPS::Type ObjectType() const
Definition: hps.h:44330
HPS::Type ObjectType() const
Definition: hps.h:42960
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3836
HPS::Type ObjectType() const
Definition: hps.h:37666
HPS::Type ObjectType() const
Definition: hps.h:12656
HPS::Type ObjectType() const
Definition: hps.h:18207
Mode
Definition: hps.h:1744
Event * Clone() const
Definition: hps.h:42674
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3908
Tiling
Definition: hps.h:960
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4064
WindowPoint(Point const &in_point)
Definition: hps.h:6077
Transform
Definition: hps.h:1534
HPS::Type ObjectType() const
Definition: hps.h:37981
HPS::Key & key
Definition: hps.h:43187
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:39338
ModifierKeys()
Definition: hps.h:41998
Preference
Definition: hps.h:1559
HPS::Type ObjectType() const
Definition: hps.h:25667
Capping
Definition: hps.h:528
HPS::Type ObjectType() const
Definition: hps.h:36126
TouchEvent()
Definition: hps.h:42207
Interpolation
Definition: hps.h:979
HPS::Type ObjectType() const
Definition: hps.h:20316
WarningEvent(char const *in_message)
Definition: hps.h:41562
HPS::Type ObjectType() const
Definition: hps.h:21112
Modifiers
Definition: hps.h:42123
Component
Definition: hps.h:520
HPS::Type ObjectType() const
Definition: hps.h:36621
HPS::Type ObjectType() const
Definition: hps.h:6584
HPS::Type ObjectType() const
Definition: hps.h:22893
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4049
HPS::Type ObjectType() const
Definition: hps.h:44887
HPS::Type ObjectType() const
Definition: hps.h:22683
Format
Definition: hps.h:37844
WarningEvent()
Definition: hps.h:41558
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41415
Touch()
Definition: hps.h:6461
size_t polyhedron_count
Number of polyhedra drawn during the last update.
Definition: hps.h:4830
Component
Definition: hps.h:415
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4314
ClipSpace
Definition: hps.h:1296
Control & operator=(Control &&in_that)
Definition: hps.h:5712
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41567
HPS::Type ObjectType() const
Definition: hps.h:14172
SizeUnits
Definition: hps.h:44844
virtual void Reset()
Definition: hps.h:41359
HPS::Type ObjectType() const
Definition: hps.h:11534
bool Meta() const
Definition: hps.h:42042
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4091
TimerTickEvent()
Definition: hps.h:41387
HPS::Type ObjectType() const
Definition: hps.h:22346
RenderingAlgorithm
Definition: hps.h:286
EmergencyHandler()
Definition: hps.h:40907
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5827
TouchID ID
TouchID for this Touch.
Definition: hps.h:6486
HPS::Type ObjectType() const
Definition: hps.h:11047
HPS::Type ObjectType() const
Definition: hps.h:33938
HPS::Type ObjectType() const
Definition: hps.h:8477
HandednessOptimization
Definition: hps.h:377
size_t raster_count
Number of rasters drawn during the last update.
Definition: hps.h:4838
size_t deleted_display_list_count
Number of deleted display lists during the last update.
Definition: hps.h:4831
Control(Control &&in_that)
Definition: hps.h:5707
bool Control() const
Definition: hps.h:42034
HPS::Type ObjectType() const
Definition: hps.h:35461
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8701
Overlay
Definition: hps.h:1266
Status
Definition: hps.h:6175
HPS::Type ObjectType() const
Definition: hps.h:35591
HPS::Type ObjectType() const
Definition: hps.h:6666
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:42603
Projection
Definition: hps.h:1382
HPS::Type ObjectType() const
Definition: hps.h:43070