16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
23 # define HPS_TEMPLATE_API __declspec (dllexport)
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
44 # define EXPIMP_TEMPLATE extern
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
60 # define ENUM_CLASS enum class
82 class EventDispatcherImpl;
245 GradientTopLeftToBottomRight,
246 GradientTopRightToBottomLeft,
247 GradientBottomLeftToTopRight,
248 GradientBottomRightToTopLeft,
357 FeatureSizePercentage
558 SubsegmentsAndIncludes
599 Everything = 0x00ffffff,
602 Include = 0x00000042,
603 Segment = 0x00000043,
605 Includer = 0x00000100,
608 Geometry = 0x10000000,
615 NURBSSurface = 0x1000002b,
618 Polygon = 0x1000002f,
621 CircularWedge = 0x10000032,
622 Ellipse = 0x10000033,
624 NURBSCurve = 0x10000037,
625 CircularArc = 0x10000038,
626 EllipticalArc = 0x10000039,
631 Reference = 0x10000040,
634 DistantLight = 0x10000100,
636 InfiniteRay = 0x10000102,
639 Attribute = 0x20000000,
641 Priority = 0x20000001,
646 ModellingMatrix = 0x20000010,
647 UserData = 0x20000021,
648 TextureMatrix = 0x20000023,
651 Culling = 0x20001000,
652 CullingBackFace = 0x20001001,
653 CullingExtent = 0x20001002,
654 CullingVector = 0x20001003,
655 CullingVectorTolerance = 0x20001004,
656 CullingFrustum = 0x20001005,
657 CullingDeferralExtent = 0x20001006,
659 CurveAttribute = 0x20002000,
660 CurveAttributeBudget = 0x20002001,
661 CurveAttributeContinuedBudget = 0x20002002,
662 CurveAttributeViewDependent = 0x20002003,
663 CurveAttributeMaximumDeviation = 0x20002004,
664 CurveAttributeMaximumAngle = 0x20002005,
665 CurveAttributeMaximumLength = 0x20002006,
667 CylinderAttribute = 0x20003000,
668 CylinderAttributeTessellation = 0x20003001,
669 CylinderAttributeOrientation = 0x20003002,
672 EdgeAttribute = 0x20004000,
673 EdgeAttributePattern = 0x20004015,
674 EdgeAttributeWeight = 0x20004016,
676 LightingAttribute = 0x20005000,
677 LightingAttributeInterpolation = 0x20005001,
680 LineAttribute = 0x20006000,
681 LineAttributePattern = 0x20006019,
682 LineAttributeWeight = 0x2000601a,
685 MarkerAttribute = 0x20007000,
686 MarkerAttributeSize = 0x2000701b,
687 MarkerAttributeSymbol = 0x2000701c,
689 SurfaceAttribute = 0x20008000,
690 SurfaceAttributeBudget = 0x20008001,
691 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
692 SurfaceAttributeMaximumFacetAngle = 0x20008003,
693 SurfaceAttributeMaximumFacetWidth = 0x20008004,
694 SurfaceAttributeTrimCurveBudget = 0x20008005,
695 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
698 SelectabilityWindows = 0x20009001,
699 SelectabilityEdges = 0x20009002,
700 SelectabilityFaces = 0x20009003,
701 SelectabilityLights = 0x20009004,
702 SelectabilityLines = 0x20009005,
703 SelectabilityMarkers = 0x20009006,
704 SelectabilityVertices = 0x20009007,
705 SelectabilityText = 0x20009008,
707 SphereAttribute = 0x2000a000,
708 SphereAttributeTessellation = 0x2000a001,
711 SubwindowEitherType = 0x2000b001,
712 SubwindowStandard = 0x2000b00d,
713 SubwindowLightweight = 0x2000b002,
714 SubwindowBackground = 0x2000b003,
715 SubwindowBorder = 0x2000b004,
716 SubwindowRenderingAlgorithm = 0x2000b005,
719 TextAttribute = 0x2000c000,
720 TextAttributeAlignment = 0x2000c01d,
721 TextAttributeBold = 0x2000c002,
722 TextAttributeItalic = 0x2000c003,
723 TextAttributeOverline = 0x2000c004,
724 TextAttributeStrikethrough = 0x2000c005,
725 TextAttributeUnderline = 0x2000c006,
726 TextAttributeSlant = 0x2000c007,
727 TextAttributeLineSpacing = 0x2000c008,
728 TextAttributeRotation = 0x2000c00a,
729 TextAttributeExtraSpace = 0x2000c00b,
730 TextAttributeGreeking = 0x2000c00c,
731 TextAttributeSizeTolerance = 0x2000c00d,
732 TextAttributeSize = 0x2000c00e,
733 TextAttributeFont = 0x2000c00f,
734 TextAttributeTransform = 0x2000c010,
735 TextAttributeRenderer = 0x2000c011,
736 TextAttributePreference = 0x2000c012,
737 TextAttributePath = 0x2000c01f,
738 TextAttributeSpacing = 0x2000c020,
741 TransparencyMethod = 0x2000d001,
742 TransparencyAlgorithm = 0x2000d002,
743 TransparencyDepthPeelingLayers = 0x2000d004,
744 TransparencyDepthPeelingMinimumArea = 0x2000d005,
745 TransparencyDepthWriting = 0x2000d006,
747 Visibility = 0x2000e000,
748 VisibilityCuttingSections = 0x2000e001,
749 VisibilityCutEdges = 0x2000e002,
750 VisibilityCutFaces = 0x2000e003,
751 VisibilityWindows = 0x2000e004,
752 VisibilityText = 0x2000e005,
753 VisibilityLines = 0x2000e006,
754 VisibilityEdgeLights = 0x2000e007,
755 VisibilityMarkerLights = 0x2000e008,
756 VisibilityFaceLights = 0x2000e009,
757 VisibilityGenericEdges = 0x2000e00a,
758 VisibilityHardEdges = 0x2000e00b,
759 VisibilityAdjacentEdges = 0x2000e00c,
760 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
761 VisibilityShadowEmitting = 0x2000e00e,
762 VisibilityShadowReceiving = 0x2000e00f,
763 VisibilityShadowCasting = 0x2000e010,
764 VisibilityMarkers = 0x2000e011,
765 VisibilityVertices = 0x2000e012,
766 VisibilityFaces = 0x2000e013,
767 VisibilityPerimeterEdges = 0x2000e014,
768 VisibilityNonCulledEdges = 0x2000e015,
769 VisibilityMeshQuadEdges = 0x2000e016,
771 VisualEffects = 0x2000f000,
772 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
773 VisualEffectsAntiAliasing = 0x2000f002,
774 VisualEffectsShadowMaps = 0x2000f003,
775 VisualEffectsSimpleShadow = 0x2000f004,
776 VisualEffectsSimpleShadowPlane = 0x2000f005,
777 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
778 VisualEffectsSimpleShadowColor = 0x2000f007,
779 VisualEffectsSimpleReflection = 0x2000f008,
780 VisualEffectsSimpleReflectionPlane = 0x2000f009,
781 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
784 PerformanceDisplayLists = 0x20010001,
785 PerformanceStaticModel = 0x20010002,
786 StaticModelSegment = 0x40000043,
789 DrawingAttribute = 0x20011000,
790 DrawingAttributePolygonHandedness = 0x20011001,
791 DrawingAttributeDepthRange = 0x20011002,
792 DrawingAttributeFaceDisplacement = 0x20011003,
793 DrawingAttributeGeneralDisplacement = 0x20011004,
794 DrawingAttributeVertexDisplacement = 0x20011005,
795 DrawingAttributeOverlay = 0x20011006,
796 DrawingAttributeDeferral = 0x20011007,
797 DrawingAttributeClipRegion = 0x20011012,
798 DrawingAttributeWorldHandedness = 0x20011018,
800 HiddenLineAttribute = 0x20012000,
801 HiddenLineAttributeColor = 0x20012001,
802 HiddenLineAttributeDimFactor = 0x20012002,
803 HiddenLineAttributeFaceDisplacement = 0x20012003,
804 HiddenLineAttributeLinePattern = 0x20012005,
805 HiddenLineAttributeRenderFaces = 0x20012006,
806 HiddenLineAttributeRenderText = 0x20012007,
807 HiddenLineAttributeAlgorithm = 0x20012008,
808 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
809 HiddenLineAttributeVisibility = 0x2001200a,
810 HiddenLineAttributeWeight = 0x2001200b,
811 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
813 SegmentStyle = 0x20013001,
814 NamedStyle = 0x20013002,
815 MaterialPalette = 0x20013003,
816 Portfolio = 0x20013004,
819 ContourLineVisibility = 0x20014001,
820 ContourLinePosition = 0x20014002,
821 ContourLineColor = 0x20014003,
822 ContourLinePattern = 0x20014004,
823 ContourLineWeight = 0x20014005,
824 ContourLineLighting = 0x20014006,
829 BoundingVolume = 0x20016001,
830 BoundingExclusion = 0x20016002,
833 AttributeLockSetting = 0x20017001,
834 AttributeLockSubsegmentOverride = 0x20017002,
836 TransformMask = 0x20018000,
837 TransformMaskCamera = 0x20018001,
838 TransformMaskCameraTranslation = 0x20018002,
839 TransformMaskCameraScale = 0x20018003,
840 TransformMaskCameraOffset = 0x20018004,
841 TransformMaskCameraRotation = 0x20018005,
842 TransformMaskCameraPerspectiveScale = 0x20018006,
843 TransformMaskCameraProjection = 0x20018007,
844 TransformMaskModellingMatrix = 0x20018008,
845 TransformMaskModellingMatrixTranslation = 0x20018009,
846 TransformMaskModellingMatrixScale = 0x20018010,
847 TransformMaskModellingMatrixOffset = 0x20018011,
848 TransformMaskModellingMatrixRotation = 0x20018012,
850 ColorInterpolation = 0x20019000,
851 ColorInterpolationFaceColor = 0x20019001,
852 ColorInterpolationEdgeColor = 0x20019002,
853 ColorInterpolationMarkerColor = 0x20019003,
854 ColorInterpolationFaceIndex = 0x20019004,
855 ColorInterpolationEdgeIndex = 0x20019005,
856 ColorInterpolationMarkerIndex = 0x20019006,
858 CuttingSectionAttribute = 0x2001a000,
859 CuttingSectionAttributeCuttingLevel = 0x2001a001,
860 CuttingSectionAttributeCappingLevel = 0x2001a002,
861 CuttingSectionAttributeMaterialPreference = 0x2001a003,
879 InvalidMaterialIndex = -1,
906 EnvironmentTexture = 8,
907 EnvironmentCubeMap = 9,
946 EnvironmentTexture = 8,
947 EnvironmentCubeMap = 9
1093 GeometryDisplayLists,
1112 AttributeStaticModel,
1113 AttributeSpatialStaticModel
1129 Everything = 0x01000000,
1131 Visibility = 0x02000000,
1133 VisibilityCuttingSections,
1139 VisibilityEdgeLights,
1140 VisibilityMarkerLights,
1141 VisibilityFaceLights,
1142 VisibilityGenericEdges,
1143 VisibilityHardEdges,
1144 VisibilityAdjacentEdges,
1145 VisibilityInteriorSilhouetteEdges,
1146 VisibilityShadowEmitting,
1147 VisibilityShadowReceiving,
1148 VisibilityShadowCasting,
1152 VisibilityPerimeterEdges,
1153 VisibilityNonCulledEdges,
1154 VisibilityMeshQuadEdges,
1155 VisibilityCutGeometry,
1164 MaterialCutGeometry,
1166 MaterialAmbientLightUpColor,
1167 MaterialAmbientLightDownColor,
1168 MaterialAmbientLightColor,
1170 MaterialWindowColor,
1171 MaterialWindowContrastColor,
1175 MaterialMarkerColor,
1177 MaterialCutEdgeColor,
1180 MaterialVertexDiffuse,
1181 MaterialVertexDiffuseColor,
1182 MaterialVertexDiffuseAlpha,
1183 MaterialVertexDiffuseTexture,
1184 MaterialVertexSpecular,
1185 MaterialVertexMirror,
1186 MaterialVertexTransmission,
1187 MaterialVertexEmission,
1188 MaterialVertexEnvironment,
1190 MaterialVertexGloss,
1193 MaterialEdgeDiffuse,
1194 MaterialEdgeDiffuseColor,
1195 MaterialEdgeDiffuseAlpha,
1196 MaterialEdgeDiffuseTexture,
1197 MaterialEdgeSpecular,
1199 MaterialEdgeTransmission,
1200 MaterialEdgeEmission,
1201 MaterialEdgeEnvironment,
1206 MaterialFaceDiffuse,
1207 MaterialFaceDiffuseColor,
1208 MaterialFaceDiffuseAlpha,
1209 MaterialFaceDiffuseTexture,
1210 MaterialFaceSpecular,
1212 MaterialFaceTransmission,
1213 MaterialFaceEmission,
1214 MaterialFaceEnvironment,
1219 MaterialBackFaceDiffuse,
1220 MaterialBackFaceDiffuseColor,
1221 MaterialBackFaceDiffuseAlpha,
1222 MaterialBackFaceDiffuseTexture,
1223 MaterialBackFaceSpecular,
1224 MaterialBackFaceMirror,
1225 MaterialBackFaceTransmission,
1226 MaterialBackFaceEmission,
1227 MaterialBackFaceEnvironment,
1228 MaterialBackFaceBump,
1229 MaterialBackFaceGloss,
1232 MaterialFrontFaceDiffuse,
1233 MaterialFrontFaceDiffuseColor,
1234 MaterialFrontFaceDiffuseAlpha,
1235 MaterialFrontFaceDiffuseTexture,
1236 MaterialFrontFaceSpecular,
1237 MaterialFrontFaceMirror,
1238 MaterialFrontFaceTransmission,
1239 MaterialFrontFaceEmission,
1240 MaterialFrontFaceEnvironment,
1241 MaterialFrontFaceBump,
1242 MaterialFrontFaceGloss,
1245 MaterialCutFaceDiffuse,
1246 MaterialCutFaceDiffuseColor,
1247 MaterialCutFaceDiffuseAlpha,
1248 MaterialCutFaceDiffuseTexture,
1249 MaterialCutFaceSpecular,
1250 MaterialCutFaceMirror,
1251 MaterialCutFaceTransmission,
1252 MaterialCutFaceEmission,
1253 MaterialCutFaceEnvironment,
1254 MaterialCutFaceBump,
1255 MaterialCutFaceGloss,
1561 CharacterPositionOnly,
1564 CharacterPositionAdjusted
1785 UnableToLoadLibraries,
1786 VersionIncompatibility,
1787 InitializationFailed,
1948 TriangleDownWithDot,
1951 TriangleRightWithDot,
1954 TriangleLeftWithDot,
1961 SolidTriangleRightV,
2035 SubsegmentsAndIncludes,
2038 enum class Expansion
2043 IncludesAndReferences,
2053 enum class Reorganization
2062 typedef double Time;
2066 # define HPS_INLINE __forceinline
2069 # define HPS_INLINE inline
2072 #ifndef HPS_UNREFERENCED
2073 #define HPS_UNREFERENCED(param) ((void)(param))
2077 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2079 template<
typename T>
2080 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2082 return degrees * (T)(PI / 180.0);
2085 template<
typename T>
2086 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2088 return radians * (T)(180.0 / PI);
2091 template<
typename T>
2092 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2093 T a = Degrees_To_Radians(angle);
2098 template<
typename T>
2099 HPS_INLINE T Cos(T
const & angle) {
2100 return cos (Degrees_To_Radians(angle));
2103 template<
typename T>
2104 HPS_INLINE T Sin(T
const & angle) {
2105 return sin (Degrees_To_Radians(angle));
2108 template<
typename T>
2109 HPS_INLINE T ACos(T
const & x) {
2114 return Radians_To_Degrees(acos(x));
2117 template<
typename T>
2118 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2119 if (x == 0 && y == 0)
2121 return Radians_To_Degrees(atan2(y, x));
2127 typedef double Alternative;
2128 static const int Type = 1;
2129 static float Epsilon () {
return 1.0e-30f; }
2132 typedef float Alternative;
2133 static const int Type = 2;
2134 static double Epsilon () {
return 1.0e-300; }
2143 # if HOOPS_BIGENDIAN
2151 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2152 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2153 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2154 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2156 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2157 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2158 return exp == 0x7F800000 && mantissa != 0;
2160 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2161 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2162 return exp == 0x7F800000 && mantissa != 0;
2164 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2165 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2166 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2168 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2169 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2170 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2173 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2174 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2175 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2176 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2185 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2186 static HPS_INLINE
bool IsInfinite(
double const & a) {
2188 memcpy (v, &a,
sizeof(
double));
2189 return is_infinite (v);
2193 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2194 static HPS_INLINE
bool IsNAN(
double const & a) {
2196 memcpy (v, &a,
sizeof(
double));
2201 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2202 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2204 memcpy (v, &a,
sizeof(
double));
2205 return is_special (v);
2210 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2211 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2213 #ifndef HOOPS_DEFINED
2214 template <
typename Alloc>
2215 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2217 if (a.size() != b.size())
2220 auto it1 = a.begin();
2221 auto it2 = b.begin();
2222 auto const end = a.end();
2223 for ( ; it1 != end; ++it1, ++it2)
2225 if (!Equals(*it1, *it2, tolerance))
2232 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2233 return extract_uint32_t(a) & 0x80000000;
2235 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2237 memcpy (v, &a,
sizeof(
double));
2238 return v[High] & 0x80000000;
2241 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2242 uint32_t v = extract_uint32_t(a);
2245 inject_uint32_t(a, v);
2247 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2249 memcpy (v, &a,
sizeof(
double));
2250 v[High] &= 0x7FFFFFFF;
2251 v[High] |= sign_bit;
2252 memcpy (&a, v,
sizeof(
double));
2256 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2257 uint32_t v = extract_uint32_t(a);
2265 uint32_t exp = v >> 23;
2266 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2268 return (
unsigned char) (man >> (16 + 126 - exp));
2271 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2272 uint32_t v = extract_uint32_t(a);
2280 uint32_t exp = v >> 23;
2281 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2283 uint32_t x = (man >> (16 + 126 - exp));
2285 return (
unsigned char) ((x * (mix+1)) >> 8);
2289 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2290 uint32_t va = extract_uint32_t(a);
2291 uint32_t vb = extract_uint32_t(b);
2293 if (((va | vb) & 0x7FFFFFFF) == 0)
2298 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2303 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2304 uint32_t va = extract_uint32_t(a);
2305 uint32_t vb = extract_uint32_t(b);
2307 uint32_t a_sign = va & 0x80000000;
2308 uint32_t b_sign = vb & 0x80000000;
2310 (int32_t&)a_sign >>= 31;
2311 (int32_t&)b_sign >>= 31;
2313 uint32_t mash = (a_sign&b_sign);
2318 if ((int32_t&)vb < (int32_t&)va)
2319 memcpy(&a, &b,
sizeof(
float));
2321 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2326 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2327 uint32_t va = extract_uint32_t(a);
2328 uint32_t vb = extract_uint32_t(b);
2330 uint32_t a_sign = va & 0x80000000;
2331 uint32_t b_sign = vb & 0x80000000;
2333 (int32_t&)a_sign >>= 31;
2334 (int32_t&)b_sign >>= 31;
2336 uint32_t mash = (a_sign&b_sign);
2341 if ((int32_t&)vb > (int32_t&)va)
2342 memcpy(&a, &b,
sizeof(
float));
2344 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2350 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2352 memcpy(&i, &a,
sizeof(
float));
2356 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2357 memcpy(&a, &i,
sizeof(
float));
2360 static HPS_INLINE
float C2F(
unsigned char x) {
2362 return char_to_float[x];
2367 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2368 memcpy(&m[0], &f,
sizeof(
float));
2369 memcpy(&m[1], &f,
sizeof(
float));
2370 memcpy(&m[2], &f,
sizeof(
float));
2371 memcpy(&m[3], &f,
sizeof(
float));
2374 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2375 memcpy(&m[0], &f0,
sizeof(
float));
2376 memcpy(&m[1], &f1,
sizeof(
float));
2377 memcpy(&m[2], &f2,
sizeof(
float));
2378 memcpy(&m[3], &f3,
sizeof(
float));
2381 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2382 memcpy(f0, m,
sizeof(
float)*4);
2385 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2386 memcpy(&f0, &m[0],
sizeof(
float));
2387 memcpy(&f1, &m[1],
sizeof(
float));
2388 memcpy(&f2, &m[2],
sizeof(
float));
2389 memcpy(&f3, &m[3],
sizeof(
float));
2393 static const float char_to_float[256];
2402 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2403 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2405 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2406 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2407 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2408 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2409 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2410 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2412 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2413 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2414 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d) {
return Min(Min(a, b, c),d); }
2415 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Min(Min(a,b,c,d),e); }
2416 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Min(Min(a,b,c,d,e),f); }
2418 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2419 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2420 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d) {
return Max(Max(a, b, c),d); }
2421 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Max(Max(a,b,c,d),e); }
2422 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Max(Max(a,b,c,d,e),f); }
2424 template <
typename T> HPS_INLINE T
const & Clamp(T
const & x, T
const & min, T
const & max) {
return x < min ? min : x > max ? max : x; }
2427 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2428 uint32_t v = Float::extract_uint32_t(a);
2431 Float::inject_uint32_t(f,v);
2435 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2436 uint32_t v = Float::extract_uint32_t(a);
2438 if ((v & 0x7FFFFFFF) == 0)
2441 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2444 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2445 int a_sign = Sign(a);
2446 int b_sign = Sign(b);
2448 if (a_sign != b_sign)
2449 return Compare(a_sign, b_sign);
2451 uint32_t v = Float::extract_uint32_t(a);
2452 uint32_t u = Float::extract_uint32_t(b);
2454 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2457 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2463 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2472 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2473 int32_t va = Float::extract_uint32_t(a);
2474 int32_t vb = Float::extract_uint32_t(b);
2476 if (is_special(va) || is_special(vb)) {
2477 if (is_infinite(va) || is_infinite(vb))
2479 if (is_nan(va) || is_nan(vb))
2483 int const close_to_zero = 0x36A00000;
2484 if ((va & 0x7FFFFFFF) == 0)
2485 return (vb & 0x7FFFFFFF) < close_to_zero;
2486 else if ((vb & 0x7FFFFFFF) == 0)
2487 return (va & 0x7FFFFFFF) < close_to_zero;
2489 uint32_t sign_mask = va ^ vb;
2490 (int32_t &)sign_mask >>= 31;
2492 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2493 int32_t v1 = tolerance + diff;
2494 int32_t v2 = tolerance - diff;
2495 return (v1|v2) >= 0;
2498 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2499 int32_t va[2], vb[2];
2500 memcpy (va, &a,
sizeof(
double));
2501 memcpy (vb, &b,
sizeof(
double));
2503 if (is_special(va) || is_special(vb)) {
2504 if (is_infinite(va) || is_infinite(vb))
2505 return va[High] == vb[High] && va[Low] == vb[Low];
2506 if (is_nan(va) || is_nan(vb))
2510 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2511 return Abs(a - b) < 0.000000000000005;
2513 if (extract_sign_bit(a) != extract_sign_bit(b))
2516 if (va[High] != vb[High])
2519 return Abs(va[Low] - vb[Low]) <= tolerance;
2526 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2528 template <
typename T>
2529 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2531 if (Is_Abnormal (*t++))
2536 template <
typename T>
2537 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2538 return count >= 0 && Is_Abnormal((
size_t)count, t);
2545 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2546 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2547 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2548 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2551 template <
typename F>
2559 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2561 template <
typename D>
2562 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2570 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2571 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2573 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2580 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2581 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2582 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2583 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2585 F & operator[] (
size_t i) {
return (&x)[i]; }
2586 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2619 template <
typename F,
typename S>
2622 template <
typename F>
2623 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2624 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2627 template <
typename F>
2628 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2629 return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2632 template <
typename F>
2633 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2634 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2638 template <
typename F>
2645 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2647 template <
typename D>
2655 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2656 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2658 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2663 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2664 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2666 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2668 F & operator[] (
size_t i) {
return (&x)[i]; }
2669 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2690 template <
typename F>
2693 template <
typename F,
typename S>
2694 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F>
const & a) {
return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2696 template <
typename F>
2697 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2698 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2701 template <
typename F>
2702 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2703 return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2706 template <
typename F>
2707 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2708 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2712 template <
typename F>
2720 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2721 template <
typename D>
2730 bool operator== (
Vector_3D const & v)
const {
2731 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2733 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2735 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2741 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2742 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2746 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2747 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2749 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2751 F & operator[] (
size_t i) {
return (&x)[i]; }
2752 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2754 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2756 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2758 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2760 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2764 F range = Max (Abs (x), Abs (y), Abs (z));
2765 if (range > F(1.0e10))
2769 F len = (F)Length();
2776 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2778 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2779 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2781 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2784 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2789 return Vector_3D (x * v.x, y * v.y, z * v.z);
2803 template <
typename F,
typename S>
2806 template <
typename F>
2807 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2808 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2812 template <
typename F>
2813 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2815 template <
typename F>
2816 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F>
const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2817 template <
typename F>
2818 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F>
const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2820 template <
typename F>
2821 HPS_INLINE Vector_3D<F>
const Point_3D<F>::operator- (Point_3D<F>
const & p)
const {
return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2823 template <
typename F>
2824 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2825 template <
typename F>
2826 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2828 template <
typename F>
2829 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F>
const & v) { x *= v.x; y *= v.y; z *= v.z;
return *
this; }
2830 template <
typename F>
2831 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F>
const & v) { x /= v.x; y /= v.y; z /= v.z;
return *
this; }
2832 template <
typename F>
2833 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2834 template <
typename F>
2835 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2839 template <
typename F>
2840 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2841 return a + (b - a) * t;
2844 template <
typename F>
2845 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2846 return Vector_3D<F>(a + (b - a) * t).Normalize();
2851 template <
typename F>
2852 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2853 return (p2 - p1).Length();
2856 template <
typename F>
2857 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2858 return (p2 - p1).LengthSquared();
2861 template <
typename F>
2862 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2863 F p =
static_cast<F
>((c - b).LengthSquared());
2864 F q =
static_cast<F
>((c - a).LengthSquared());
2865 F r =
static_cast<F
>((b - a).LengthSquared());
2868 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2869 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2874 template <
typename F>
2875 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2876 bool success =
true;
2877 for (
size_t i = 0; i < count; ++i) {
2878 if (vectors->Normalize() == Vector_3D<F>::Zero())
2886 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2888 template <
typename F>
2895 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2896 template <
typename D>
2905 bool operator== (
Vector_2D const & v)
const {
2906 return Float::match(x, v.x) && Float::match(y, v.y);
2908 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2910 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2919 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2920 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2922 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2924 F & operator[] (
size_t i) {
return (&x)[i]; }
2925 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2927 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2929 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2933 F range = Max (Abs (x), Abs (y));
2934 if (range > F(1.0e10))
2938 F len = (F)Length();
2945 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2947 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2948 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2950 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2953 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2954 return x * v.y - y * v.x;
2971 template <
typename F,
typename S>
2974 template <
typename F>
2975 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
2976 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2980 template <
typename F>
2981 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
2983 template <
typename F>
2984 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
2986 template <
typename F>
2987 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2988 template <
typename F>
2989 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
2991 template <
typename F>
2992 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z); }
2993 template <
typename F>
2994 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z); }
2996 template <
typename F>
2997 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
2998 template <
typename F>
2999 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3001 template <
typename F>
3002 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z); }
3003 template <
typename F>
3004 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z); }
3007 template <
typename F>
3008 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3009 template <
typename F>
3010 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3012 template <
typename F>
3013 HPS_INLINE Vector_2D<F>
const Point_2D<F>::operator- (Point_2D<F>
const & p)
const {
return Vector_2D<F> (x - p.x, y - p.y); }
3015 template <
typename F>
3016 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x + v.x, y + v.y); }
3017 template <
typename F>
3018 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x - v.x, y - v.y); }
3020 template <
typename F>
3021 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3022 template <
typename F>
3023 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3024 template <
typename F>
3025 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x * v.x, y * v.y); }
3026 template <
typename F>
3027 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x / v.x, y / v.y); }
3033 template <
typename F>
3042 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3046 template <
typename D>
3047 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3063 for (
size_t i=0; i<count; ++i) {
3066 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3067 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3068 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3078 double inv_count = 1.0 / (double)count;
3086 *
this = Plane_3D::Zero();
3092 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3093 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3095 F & operator[] (
size_t i) {
return (&a)[i]; }
3096 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3098 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3113 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3114 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3117 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3118 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3119 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3126 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3127 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3129 return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3132 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3136 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3137 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3138 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3139 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3146 template <
typename F>
3147 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3148 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3152 template <
typename F>
3153 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3154 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3156 template <
typename F>
3157 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3158 return plane * point;
3161 template <
typename F>
3162 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3163 return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3166 template <
typename F>
3167 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3174 template <
typename F>
3182 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3186 template <
typename D>
3187 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3191 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3192 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3194 F & operator[] (
size_t i) {
return (&a)[i]; }
3195 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3197 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3214 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3215 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3216 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3217 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3224 template <
typename F>
3225 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3226 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3230 template <
typename F>
3231 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3232 return plane.a * point.x + plane.b * point.y + plane.c;
3234 template <
typename F>
3235 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3236 return plane * point;
3239 template <
typename F>
3240 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3241 return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3244 template <
typename F>
3245 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3259 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3260 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3262 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3263 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3266 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3271 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3275 return !(*
this == rect);
3278 HPS_INLINE
int PixelWidth()
const {
3279 return right - left + 1;
3282 HPS_INLINE
int PixelHeight()
const {
3283 return top - bottom + 1;
3286 HPS_INLINE
int Width()
const {
3287 return right - left;
3290 HPS_INLINE
int Height()
const {
3291 return top - bottom;
3294 HPS_INLINE
int Area()
const {
3295 return Width() * Height();
3298 HPS_INLINE
Point2D Center()
const {
3299 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3302 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3303 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3306 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3307 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3320 right += rect.right;
3321 bottom -= rect.bottom;
3336 right -= rect.right;
3337 bottom += rect.bottom;
3343 left = Max(left, rect.left);
3344 right = Min(right, rect.right);
3345 bottom = Max(bottom, rect.bottom);
3346 top = Min(top, rect.top);
3351 left = Min(left, rect.left);
3352 right = Max(right, rect.right);
3353 bottom = Min(bottom, rect.bottom);
3354 top = Max(top, rect.top);
3371 return temp.Expand(border);
3374 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3375 IntRectangle temp = a;
3376 return temp.Expand(border);
3379 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3380 IntRectangle temp = a;
3381 return temp.Contract(border);
3384 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3385 IntRectangle temp = a;
3386 return temp.Contract(border);
3389 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3390 IntRectangle temp = a;
3391 return temp.Intersect(b);
3394 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3395 IntRectangle temp = a;
3396 return temp.Union(b);
3406 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3407 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3409 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3410 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3413 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3416 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3426 Merge(count, points);
3438 Merge(count, points);
3442 HPS_INLINE
float Width()
const {
3443 return right - left;
3446 HPS_INLINE
float Height()
const {
3447 return top - bottom;
3450 HPS_INLINE
float Area()
const {
3451 return Width() * Height();
3454 HPS_INLINE
Point2D Center()
const {
3455 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3458 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3461 if (Compare(points[0].x, points[1].x)>0) {
3462 Float::replace_if_smaller(left, points[1].x);
3463 Float::replace_if_larger(right, points[0].x);
3466 Float::replace_if_smaller(left, points[0].x);
3467 Float::replace_if_larger(right, points[1].x);
3470 if (Compare(points[0].y, points[1].y)>0) {
3471 Float::replace_if_smaller(bottom, points[1].y);
3472 Float::replace_if_larger(top, points[0].y);
3475 Float::replace_if_smaller(bottom, points[0].y);
3476 Float::replace_if_larger(top, points[1].y);
3487 HPS_INLINE
void Merge(
Point const & point) {
3488 Float::replace_if_smaller(left, point.x);
3489 Float::replace_if_smaller(bottom, point.y);
3490 Float::replace_if_larger(right, point.x);
3491 Float::replace_if_larger(top, point.y);
3494 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3497 if (Compare(points[0].x, points[1].x)>0) {
3498 Float::replace_if_smaller(left, points[1].x);
3499 Float::replace_if_larger(right, points[0].x);
3502 Float::replace_if_smaller(left, points[0].x);
3503 Float::replace_if_larger(right, points[1].x);
3506 if (Compare(points[0].y, points[1].y)>0) {
3507 Float::replace_if_smaller(bottom, points[1].y);
3508 Float::replace_if_larger(top, points[0].y);
3511 Float::replace_if_smaller(bottom, points[0].y);
3512 Float::replace_if_larger(top, points[1].y);
3523 HPS_INLINE
void Merge(
Point2D const & point) {
3524 Float::replace_if_smaller(left, point.x);
3525 Float::replace_if_smaller(bottom, point.y);
3526 Float::replace_if_larger(right, point.x);
3527 Float::replace_if_larger(top, point.y);
3530 bool operator==(
Rectangle const & rect)
const {
3531 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3534 bool operator!=(
Rectangle const & rect)
const {
3535 return !(*
this == rect);
3538 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3539 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3542 HPS_INLINE
bool Contains(
Point const & contained)
const {
3543 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3546 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3547 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3550 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3551 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3554 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3555 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3556 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3559 HPS_INLINE
Rectangle & Expand(
float border) {
3567 HPS_INLINE
Rectangle & Expand(
int border) {
3568 Expand((
float)border);
3574 right += rect.right;
3575 bottom -= rect.bottom;
3580 HPS_INLINE
Rectangle & Contract(
int border) {
3590 right -= rect.right;
3591 bottom += rect.bottom;
3597 left = Max(left, rect.left);
3598 right = Min(right, rect.right);
3599 bottom = Max(bottom, rect.bottom);
3600 top = Min(top, rect.top);
3605 left = Min(left, rect.left);
3606 right = Max(right, rect.right);
3607 bottom = Min(bottom, rect.bottom);
3608 top = Max(top, rect.top);
3613 float scale = (scope.right - scope.left) * 0.5f;
3614 float trans = (scope.right + scope.left) * 0.5f;
3616 left = left * scale + trans;
3617 right = right * scale + trans;
3619 scale = (scope.top - scope.bottom) * 0.5f;
3620 trans = (scope.top + scope.bottom) * 0.5f;
3622 bottom = bottom * scale + trans;
3623 top = top * scale + trans;
3628 float tmp = 2.0f/(scope.right - scope.left);
3629 right = (right - scope.left) * tmp - 1.0f;
3630 left = (left - scope.left) * tmp - 1.0f;
3632 tmp = 2.0f/(scope.top - scope.bottom);
3633 top = (top - scope.bottom) * tmp - 1.0f;
3634 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3638 static HPS_INLINE
Rectangle FullScope() {
3639 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3642 static HPS_INLINE
Rectangle InvalidScope() {
3643 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3655 temp.left = Floor (a.left);
3656 temp.right = Floor (a.right);
3657 temp.bottom = Floor (a.bottom);
3658 temp.top = Floor (a.top);
3662 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3664 return temp.Expand(border);
3667 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3669 return temp.Expand(border);
3672 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3674 return temp.Contract(border);
3677 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3679 return temp.Contract(border);
3682 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3684 return temp.Intersect(b);
3687 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3689 return temp.Union(b);
3692 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3694 return temp.Inscribe_Scope(scope);
3697 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3699 return temp.Circumscribe_Scope(scope);
3702 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3703 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3708 template <
typename F>
3711 template <
typename F>
3724 template <
typename D>
3753 min = Limit_Point();
3754 max = -Limit_Point();
3757 min = max = *points++;
3760 Merge(count, points);
3773 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3790 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3796 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3821 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3829 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3830 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3831 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3840 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3841 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3842 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3853 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3865 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3875 return LineIntersecting(start, direction,
true);
3886 return LineIntersecting(point1, direction,
false);
3895 Float::replace_if_smaller(min.x, cuboid.
min.x);
3896 Float::replace_if_smaller(min.y, cuboid.
min.y);
3897 Float::replace_if_smaller(min.z, cuboid.
min.z);
3898 Float::replace_if_larger(max.x, cuboid.
max.x);
3899 Float::replace_if_larger(max.y, cuboid.
max.y);
3900 Float::replace_if_larger(max.z, cuboid.
max.z);
3916 Float::replace_if_smaller(min.x, point.x);
3917 Float::replace_if_smaller(min.y, point.y);
3918 Float::replace_if_smaller(min.z, point.z);
3919 Float::replace_if_larger(max.x, point.x);
3920 Float::replace_if_larger(max.y, point.y);
3921 Float::replace_if_larger(max.z, point.z);
3932 if (Compare(points[0].x, points[1].x)>0) {
3933 Float::replace_if_smaller(min.x, points[1].x);
3934 Float::replace_if_larger(max.x, points[0].x);
3937 Float::replace_if_smaller(min.x, points[0].x);
3938 Float::replace_if_larger(max.x, points[1].x);
3941 if (Compare(points[0].y, points[1].y)>0) {
3942 Float::replace_if_smaller(min.y, points[1].y);
3943 Float::replace_if_larger(max.y, points[0].y);
3946 Float::replace_if_smaller(min.y, points[0].y);
3947 Float::replace_if_larger(max.y, points[1].y);
3950 if (Compare(points[0].z, points[1].z)>0) {
3951 Float::replace_if_smaller(min.z, points[1].z);
3952 Float::replace_if_larger(max.z, points[0].z);
3955 Float::replace_if_smaller(min.z, points[0].z);
3956 Float::replace_if_larger(max.z, points[1].z);
3973 return (contained.
min.x >= min.x &&
3974 contained.
min.y >= min.y &&
3975 contained.
min.z >= min.z &&
3976 contained.
max.x <= max.x &&
3977 contained.
max.y <= max.y &&
3978 contained.
max.z <= max.z);
3987 return (contained.x >= min.x &&
3988 contained.y >= min.y &&
3989 contained.z >= min.z &&
3990 contained.x <= max.x &&
3991 contained.y <= max.y &&
3992 contained.z <= max.z);
4002 return (contained.x >= min.x - epsilon &&
4003 contained.y >= min.y - epsilon &&
4004 contained.z >= min.z - epsilon &&
4005 contained.x <= max.x + epsilon &&
4006 contained.y <= max.y + epsilon &&
4007 contained.z <= max.z + epsilon);
4016 Float::replace_if_larger(min.x, cuboid.
min.x);
4017 Float::replace_if_larger(min.y, cuboid.
min.y);
4018 Float::replace_if_larger(min.z, cuboid.
min.z);
4019 Float::replace_if_smaller(max.x, cuboid.
max.x);
4020 Float::replace_if_smaller(max.y, cuboid.
max.y);
4021 Float::replace_if_smaller(max.z, cuboid.
max.z);
4031 Float::replace_if_smaller(min.x, cuboid.
min.x);
4032 Float::replace_if_smaller(min.y, cuboid.
min.y);
4033 Float::replace_if_smaller(min.z, cuboid.
min.z);
4034 Float::replace_if_larger(max.x, cuboid.
max.x);
4035 Float::replace_if_larger(max.y, cuboid.
max.y);
4036 Float::replace_if_larger(max.z, cuboid.
max.z);
4066 F
const limit = std::numeric_limits<F>::max();
4070 bool LineIntersecting (Point_3D<F>
const & start, Vector_3D<F>
const & direction,
bool is_ray)
const;
4073 typedef Cuboid_3D<float> SimpleCuboid;
4074 typedef Cuboid_3D<double> DSimpleCuboid;
4077 template <
typename F>
4078 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4079 Cuboid_3D<F> temp = a;
4080 return temp.Intersect(b);
4083 template <
typename F>
4084 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4085 Cuboid_3D<F> temp = a;
4086 return temp.Union(b);
4089 template <
typename F>
4090 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4091 Cuboid_3D<F> temp = a;
4092 return temp.Expand(border);
4095 template <
typename F>
4096 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4097 Cuboid_3D<F> temp = a;
4098 return temp.Contract(border);
4103 template <
typename F>
4104 struct HPS_TEMPLATE_API Sphere_3D {
4108 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4110 template <
typename D>
4111 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4113 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4114 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4116 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4118 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4119 Cuboid_3D<F> cuboid(count, points);
4120 center = Midpoint(cuboid.min, cuboid.max);
4121 Engulf (count, points);
4124 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4125 Engulf (count, points);
4128 HPS_INLINE
bool IsValid()
const {
4132 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4134 void Invalidate() {radius = -1;}
4136 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4137 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4139 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4141 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4142 Vector_3D<F> dir = point - center;
4143 F distance = (F)dir.Length();
4145 if (distance > radius) {
4146 F t = F(0.5) * (distance - radius);
4147 center += t * dir.Normalize();
4152 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4154 for (
size_t i = 0; i < count; ++i) {
4155 Vector_3D<F> dir = *points - center;
4156 F distance = (F)dir.Length();
4158 if (distance > radius) {
4159 F t = F(0.5) * (distance - radius);
4160 center += t * dir.Normalize();
4168 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4169 Vector_3D<F> dir = sphere.center - center;
4170 F distance = (F)dir.Length();
4172 if (distance + sphere.radius > radius) {
4173 if (distance + radius > sphere.radius) {
4174 F t = F(0.5 * (sphere.radius + distance - radius));
4175 center += t * dir.Normalize();
4179 center = sphere.center;
4180 radius = sphere.radius;
4185 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4189 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4190 for (
size_t i = 0; i < count; ++i) {
4191 double dsq = (*points++ - center).LengthSquared();
4192 if ((F)dsq > radius * radius)
4193 radius = (F)sqrt(dsq);
4198 typedef Sphere_3D<float> SimpleSphere;
4199 typedef Sphere_3D<double> DSimpleSphere;
4202 template <
typename F>
4204 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4205 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4223 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4224 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4225 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4226 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4227 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4228 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4230 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4231 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4232 float Distance(RGBColor
const & other_color)
const;
4233 HPS_INLINE
bool IsValid()
const {
4234 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4237 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4238 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4240 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4243 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4244 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4245 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4246 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4247 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4248 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4250 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4251 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4252 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4253 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4254 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4255 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4256 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4257 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4259 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4260 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4261 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4263 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4264 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4265 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4267 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4268 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4269 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4272 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4273 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4274 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4286 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4287 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4289 HPS_INLINE RGBAColor (RGBColor
const & c) {
4290 memcpy(
this, &c,
sizeof(RGBColor));
4292 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4294 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4295 memcpy(
this, &c,
sizeof(RGBColor));
4296 memcpy(&alpha, &a,
sizeof(
float));
4297 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4299 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4300 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4302 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4303 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4304 HPS_INLINE
bool IsValid()
const {
4305 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4322 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4324 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4329 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4330 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4331 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4332 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4333 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4334 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4336 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4337 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4338 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4339 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4340 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4341 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4342 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4343 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4345 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4346 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4347 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4348 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4349 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4350 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4352 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4353 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4354 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4355 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4369 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4370 unsigned char b, g, r, a;
4374 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4375 unsigned char r, g, b, a;
4379 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4380 unsigned char r, g, b, a;
4390 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4396 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4404 explicit HPS_INLINE RGBAS32Color (
RGBColor const & c)
4406 r = Float::unit_to_byte(c.red);
4407 g = Float::unit_to_byte(c.green);
4408 b = Float::unit_to_byte(c.blue);
4412 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4416 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4418 r = Float::unit_to_byte(c.red);
4419 g = Float::unit_to_byte(c.green);
4420 b = Float::unit_to_byte(c.blue);
4421 a = Float::unit_to_byte(alpha);
4423 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4425 r = Float::unit_to_byte(c.red);
4426 g = Float::unit_to_byte(c.green);
4427 b = Float::unit_to_byte(c.blue);
4430 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
4432 r = Float::unit_to_byte(c.
red);
4433 g = Float::unit_to_byte(c.
green);
4434 b = Float::unit_to_byte(c.
blue);
4435 a = Float::unit_to_byte(c.
alpha);
4437 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4439 r = Float::unit_to_byte(c.
red);
4440 g = Float::unit_to_byte(c.
green);
4441 b = Float::unit_to_byte(c.
blue);
4442 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4445 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4446 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4447 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4449 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4450 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4452 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4453 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4454 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4456 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4467 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4468 : r (gray), g (gray), b (gray), a (aa) {}
4469 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4470 : r (rr), g (gg), b (bb), a (aa) {}
4472 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4473 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4474 r = Float::unit_to_byte(c.red);
4475 g = Float::unit_to_byte(c.green);
4476 b = Float::unit_to_byte(c.blue);
4479 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4480 r = Float::unit_to_byte(c.red);
4481 g = Float::unit_to_byte(c.green);
4482 b = Float::unit_to_byte(c.blue);
4483 a = Float::unit_to_byte(alpha);
4485 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4486 r = Float::unit_to_byte(c.red);
4487 g = Float::unit_to_byte(c.green);
4488 b = Float::unit_to_byte(c.blue);
4491 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4492 r = Float::unit_to_byte(c.
red);
4493 g = Float::unit_to_byte(c.
green);
4494 b = Float::unit_to_byte(c.
blue);
4495 a = Float::unit_to_byte(c.
alpha);
4497 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4498 r = Float::unit_to_byte(c.
red);
4499 g = Float::unit_to_byte(c.
green);
4500 b = Float::unit_to_byte(c.
blue);
4501 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4504 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4505 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4507 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4508 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4510 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4511 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4513 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4525 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4526 : r (gray), g (gray), b (gray) {}
4527 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4528 : r (rr), g (gg), b (bb) {}
4529 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4530 r = Float::unit_to_byte(c.red);
4531 g = Float::unit_to_byte(c.green);
4532 b = Float::unit_to_byte(c.blue);
4535 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4536 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4538 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4539 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4542 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4543 red = Float::C2F(c32.r);
4544 green = Float::C2F(c32.g);
4545 blue = Float::C2F(c32.b);
4548 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4549 red = Float::C2F(c32.r);
4550 green = Float::C2F(c32.g);
4551 blue = Float::C2F(c32.b);
4554 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4560 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4561 red = Float::C2F(c24.r);
4562 green = Float::C2F(c24.g);
4563 blue = Float::C2F(c24.b);
4566 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4574 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4582 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
const & c32) {
4583 red = Float::C2F(c32.r);
4584 green = Float::C2F(c32.g);
4585 blue = Float::C2F(c32.b);
4586 alpha = Float::C2F(c32.a);
4589 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4590 red = Float::C2F(c32.r);
4591 green = Float::C2F(c32.g);
4592 blue = Float::C2F(c32.b);
4593 alpha = Float::C2F(c32.a);
4596 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4597 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4602 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4603 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4606 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4607 return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4610 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4611 return RGBAS32Color(
4612 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4613 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4614 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4615 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4618 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4620 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4621 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4622 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4623 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4626 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4628 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4629 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4630 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4642 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4644 Quaternion(
float in_w,
float in_x,
float in_y,
float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4662 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4663 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4664 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4665 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4668 Quaternion operator* (
float in_right)
const {
4669 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4673 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4676 Quaternion operator/ (
float in_right)
const {
4677 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4681 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4685 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4688 inline float Norm()
const {
4689 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4695 float mag_q = Norm();
4696 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4698 ret.w =
static_cast<float>(log(mag_q));
4701 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4708 ret.x = ret.y = ret.z = 0;
4715 float ea =
static_cast<float>(exp(w));
4716 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4717 float scale = ea * sin(mag_V) / mag_V;
4719 ret.w = ea * cos(mag_V);
4728 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4729 return ret.Normalize();
4733 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4735 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4737 if (in_shortest_path_only && dot < 0) {
4744 if (dot > -0.95f && dot < 0.95f) {
4745 float angle =
static_cast<float>(acos(dot));
4746 float sina =
static_cast<float>(sin(angle));
4747 float sinat =
static_cast<float>(sin(angle*in_fraction));
4748 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4750 return (*
this * sinaomt + q3 * sinat) / sina;
4753 return Lerp(q3, in_fraction);
4766 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4767 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4769 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4781 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4788 size_t dot_dc_count;
4789 size_t dot_3d_count;
4790 size_t line_dc_count;
4791 size_t line_3d_count;
4792 size_t triangle_dc_count;
4793 size_t triangle_3d_count;
4794 size_t polygon_dc_count;
4795 size_t polygon_3d_count;
4796 size_t polyhedron_count;
4797 size_t deleted_display_list_count;
4798 size_t display_list_line_3d_count;
4799 size_t display_list_triangle_3d_count;
4800 size_t display_list_vertex_3d_count;
4801 size_t display_list_tristrip_count;
4802 size_t non_display_list_tristrip_count;
4803 size_t culled_display_list_tristrip_count;
4804 size_t raster_count;
4805 size_t segment_count;
4806 size_t frustum_culled_segment_count;
4807 size_t extent_culled_segment_count;
4808 size_t vector_culled_segment_count;
4812 typedef unsigned char byte;
4813 typedef signed char sbyte;
4814 typedef intptr_t WindowHandle;
4815 typedef int64_t TouchID;
4816 typedef intptr_t PlatformData;
4849 class AttributesControl;
4865 class GeometryInsertControl;
5010 class FontInfoControl;
5077 enum class Type : uint32_t
5080 GenericMask = 0xffffff00,
5084 EventDispatcher = 0x00000003,
5085 EventHandler = 0x00000004,
5086 EventNotifier = 0x00000005,
5087 UpdateNotifier = 0x00000006,
5088 SearchResults = 0x00000008,
5089 FontSearchResults = 0x00000009,
5090 SearchResultsIterator = 0x0100000a,
5091 FontSearchResultsIterator = 0x0100000b,
5092 SelectionResults = 0x0000000c,
5093 SelectionResultsIterator = 0x0100000d,
5094 SelectionItem = 0x0000000e,
5095 TreeContext = 0x0000000f,
5096 StreamToolkit = 0x00000010,
5098 IONotifier = 0x04000100,
5099 StreamImportNotifier = 0x04000101,
5100 STLImportNotifier = 0x04000102,
5101 OBJImportNotifier = 0x04000103,
5102 ExchangeImportNotifier = 0x04000104,
5103 SketchupImportNotifier = 0x04000105,
5104 ParasolidImportNotifier = 0x04000106,
5105 ExchangeTranslationNotifier = 0x04000107,
5106 ExchangeExportNotifier = 0x04000108,
5107 StreamExportNotifier = 0x04000109,
5108 ExchangeReloadNotifier = 0x0400010a,
5111 MarkerKit = 0x01000010,
5112 SphereAttributeKit = 0x01000011,
5113 TextAttributeKit = 0x01000012,
5114 TransparencyKit = 0x01000013,
5115 VisibilityKit = 0x01000014,
5116 VisualEffectsKit = 0x01000015,
5117 CuttingSectionAttributeKit = 0x01000016,
5118 CircleKit = 0x01000017,
5119 CircularArcKit = 0x01000018,
5120 CircularWedgeKit = 0x01000019,
5121 CuttingSectionKit = 0x0100001a,
5122 CylinderKit = 0x0100001b,
5123 DistantLightKit = 0x0100001c,
5124 EllipseKit = 0x0100001d,
5125 EllipticalArcKit = 0x0100001e,
5126 InfiniteLineKit = 0x0100001f,
5127 LineKit = 0x01000020,
5128 NURBSCurveKit = 0x01000021,
5129 MeshKit = 0x01000022,
5130 NURBSSurfaceKit = 0x01000023,
5131 PolygonKit = 0x01000024,
5132 SphereKit = 0x01000025,
5133 SpotlightKit = 0x01000026,
5134 ShellKit = 0x01000027,
5135 TextKit = 0x01000028,
5136 MaterialKit = 0x01000029,
5137 TrimKit = 0x0100002a,
5138 TextureOptionsKit = 0x0100002c,
5139 LinePatternKit = 0x0100002d,
5140 GlyphKit = 0x0100002e,
5141 ImageKit = 0x0100002f,
5142 LinePatternOptionsKit = 0x01000030,
5143 CameraKit = 0x01000031,
5144 BoundingKit = 0x01000032,
5145 CullingKit = 0x01000033,
5146 CurveAttributeKit = 0x01000034,
5147 CylinderAttributeKit = 0x01000035,
5148 EdgeAttributeKit = 0x01000036,
5149 LightingAttributeKit = 0x01000037,
5150 LineAttributeKit = 0x01000038,
5151 MarkerAttributeKit = 0x01000039,
5152 MaterialMappingKit = 0x0100003a,
5153 MatrixKit = 0x0100003b,
5154 NURBSSurfaceAttributeKit = 0x0100003c,
5155 PostProcessEffectsKit = 0x0100003d,
5156 SelectabilityKit = 0x0100003e,
5157 SelectionOptionsKit = 0x0100003f,
5158 StandAloneWindowOptionsKit = 0x01000040,
5159 OffScreenWindowOptionsKit = 0x01000041,
5160 ApplicationWindowOptionsKit = 0x01000042,
5161 HighlightOptionsKit = 0x01000043,
5162 LinePatternParallelKit = 0x01000044,
5163 SubwindowKit = 0x01000045,
5164 PerformanceKit = 0x01000046,
5165 HiddenLineAttributeKit = 0x01000047,
5166 DrawingAttributeKit = 0x01000048,
5167 ShaderKit = 0x01000049,
5168 DebuggingKit = 0x0100004a,
5169 ContourLineKit = 0x0100004b,
5170 StreamImportOptionsKit = 0x0100004c,
5171 StreamImportResultsKit = 0x0100004d,
5172 StreamExportOptionsKit = 0x0100004e,
5173 StreamExportResultsKit = 0x0100004f,
5174 WindowInfoKit = 0x01000050,
5175 ImageImportOptionsKit = 0x01000051,
5176 SearchOptionsKit = 0x01000052,
5177 ShaderImportOptionsKit = 0x01000053,
5178 HardcopyExportOptionsKit = 0x01000055,
5179 AttributeLockKit = 0x01000056,
5180 TransformMaskKit = 0x01000057,
5181 ColorInterpolationKit = 0x01000058,
5182 UpdateOptionsKit = 0x01000059,
5183 ImageExportOptionsKit = 0x0100005a,
5184 OBJImportOptionsKit = 0x0100005b,
5185 OBJImportResultsKit = 0x0100005c,
5186 STLImportOptionsKit = 0x0100005d,
5187 STLImportResultsKit = 0x0100005e,
5188 ShellOptimizationOptionsKit = 0x0100005f,
5189 ShellRelationOptionsKit = 0x01000060,
5190 ShellRelationResultsKit = 0x01000061,
5191 GridKit = 0x01000062,
5192 CutGeometryGatheringOptionsKit = 0x01000063,
5193 SegmentOptimizationOptionsKit = 0x01000064,
5196 LinePatternElement = 0x03000000,
5197 SolidLinePatternElement = 0x03000001,
5198 BlankLinePatternElement = 0x03000002,
5199 GlyphLinePatternElement = 0x03000003,
5201 GlyphElement = 0x05000000,
5202 DotGlyphElement = 0x05000001,
5203 LineGlyphElement = 0x05000002,
5204 EllipseGlyphElement = 0x05000003,
5205 CircularArcGlyphElement = 0x05000004,
5206 InfiniteLineGlyphElement = 0x05000005,
5208 TrimElement = 0x07000000,
5210 Condition = 0x09000000,
5211 NOTCondition = 0x09000001,
5212 ANDCondition = 0x09000002,
5213 ORCondition = 0x09000003,
5214 XORCondition = 0x09000004,
5215 EQCondition = 0x09000005,
5216 NEQCondition = 0x09000006,
5217 GTCondition = 0x09000007,
5218 LTCondition = 0x09000008,
5219 GTEQCondition = 0x09000009,
5220 LTEQCondition = 0x0900000A,
5222 MouseState = 0x01001001,
5223 TouchState = 0x01001002,
5224 KeyboardState = 0x01001003,
5225 FontInfoState = 0x01001004,
5227 KeyPath = 0x01000F01,
5230 IncludeKey = 0x10000001,
5231 PortfolioKey = 0x10000002,
5232 StyleKey = 0x10000003,
5234 SegmentKey = 0x10200000,
5235 WindowKey = 0x10600000,
5236 StandAloneWindowKey = 0x10600001,
5237 OffScreenWindowKey = 0x10600002,
5238 ApplicationWindowKey = 0x10600003,
5240 GeometryKey = 0x10100000,
5241 ReferenceKey = 0x10100001,
5242 CircleKey = 0x10100002,
5243 CircularArcKey = 0x10100003,
5244 CircularWedgeKey = 0x10100004,
5245 CuttingSectionKey = 0x10100005,
5246 CylinderKey = 0x10100006,
5247 EllipseKey = 0x10100007,
5248 EllipticalArcKey = 0x10100008,
5249 InfiniteLineKey = 0x10100009,
5250 LineKey = 0x1010000a,
5251 DistantLightKey = 0x1010000b,
5252 SpotlightKey = 0x1010000c,
5253 MarkerKey = 0x1010000d,
5254 MeshKey = 0x1010000e,
5255 NURBSCurveKey = 0x1010000f,
5256 NURBSSurfaceKey = 0x10100010,
5257 PolygonKey = 0x10100011,
5258 ShellKey = 0x10100012,
5259 SphereKey = 0x10100013,
5260 TextKey = 0x10100014,
5261 GridKey = 0x10100015,
5263 Definition = 0x20000000,
5264 NamedStyleDefinition = 0x20000001,
5265 TextureDefinition = 0x20000002,
5266 LinePatternDefinition = 0x20000003,
5267 GlyphDefinition = 0x20000004,
5268 CubeMapDefinition = 0x20000005,
5269 ImageDefinition = 0x20000006,
5270 MaterialPaletteDefinition = 0x20000007,
5271 ShaderDefinition = 0x20000008,
5273 Control = 0x50000000,
5274 CameraControl = 0x50000001,
5275 SelectabilityControl = 0x50000002,
5276 MarkerAttributeControl = 0x50000003,
5277 SphereAttributeControl = 0x50000004,
5278 LightingAttributeControl = 0x50000005,
5279 CylinderAttributeControl = 0x50000006,
5280 TextAttributeControl = 0x50000007,
5281 LineAttributeControl = 0x50000008,
5282 EdgeAttributeControl = 0x50000009,
5283 CurveAttributeControl = 0x5000000a,
5284 ModellingMatrixControl = 0x5000000b,
5285 TextureMatrixControl = 0x5000000c,
5286 CullingControl = 0x5000000d,
5287 TransparencyControl = 0x5000000e,
5288 MaterialMappingControl = 0x5000000f,
5289 NURBSSurfaceAttributeControl = 0x50000010,
5290 PostProcessEffectsControl = 0x50000011,
5291 BoundingControl = 0x50000012,
5292 VisualEffectsControl = 0x50000013,
5293 SelectionOptionsControl = 0x50000014,
5294 HighlightOptionsControl = 0x50000015,
5295 DefinitionControl = 0x50000016,
5296 SelectionControl = 0x50000017,
5297 HighlightControl = 0x50000018,
5298 StandAloneWindowOptionsControl = 0x50000019,
5299 OffScreenWindowOptionsControl = 0x5000001a,
5300 ApplicationWindowOptionsControl = 0x5000001b,
5301 VisibilityControl = 0x5000001c,
5302 SubwindowControl = 0x5000001d,
5303 PerformanceControl = 0x5000001e,
5304 HiddenLineAttributeControl = 0x5000001f,
5305 DrawingAttributeControl = 0x50000020,
5306 DebuggingControl = 0x50000021,
5307 ContourLineControl = 0x50000022,
5308 StyleControl = 0x50000023,
5309 ConditionControl = 0x50000024,
5310 PortfolioControl = 0x50000025,
5311 WindowInfoControl = 0x50000026,
5312 AttributeLockControl = 0x50000027,
5313 TransformMaskControl = 0x50000028,
5314 ColorInterpolationControl = 0x50000029,
5315 UpdateOptionsControl = 0x50000030,
5316 CuttingSectionAttributeControl = 0x50000031,
5318 LibraryMask = 0x80FF0000,
5320 Sprocket = 0x80000000,
5321 Canvas = 0x80000001,
5322 Layout = 0x80000002,
5325 Operator = 0x80000005,
5326 SprocketPath = 0x80000007,
5328 SprocketControl = 0xD0000000,
5329 OperatorControl = 0xD0000008,
5330 NavigationCubeControl = 0xD0000009,
5331 AxisTriadControl = 0xD000000A,
5333 Metadata = 0x80001000,
5334 IntegerMetadata = 0x80001001,
5335 UnsignedIntegerMetadata = 0x80001002,
5336 DoubleMetadata = 0x80001003,
5337 StringMetadata = 0x80001004,
5338 TimeMetadata = 0x80001005,
5339 BooleanMetadata = 0x80001006,
5341 Component = 0x80000200,
5342 Filter = 0x80000600,
5343 Capture = 0x80000a00,
5344 CADModel = 0x80000300,
5345 ComponentPath = 0x81001000,
5347 ExchangeMask = 0x80020000,
5348 ExchangeComponent = 0x80021200,
5349 ExchangeFilter = 0x80020601,
5350 ExchangeCapture = 0x80020a01,
5351 ExchangeCADModel = 0x80020301,
5352 ExchangeConfiguration = 0x81020001,
5353 ExchangeImportOptionsKit = 0x81020002,
5354 ExchangeExportACISOptionsKit = 0x81020003,
5355 ExchangeExportIGESOptionsKit = 0x81020004,
5356 ExchangeExportJTOptionsKit = 0x81020005,
5357 ExchangeExportParasolidOptionsKit = 0x81020006,
5358 ExchangeExportPRCOptionsKit = 0x81020007,
5359 ExchangeExportSTEPOptionsKit = 0x81020008,
5360 ExchangeExportSTLOptionsKit = 0x81020009,
5361 ExchangeExportU3DOptionsKit = 0x8102000a,
5362 ExchangeExportXMLOptionsKit = 0x8102000b,
5363 ExchangeTessellationOptionsKit = 0x8102000c,
5364 ExchangeSheet = 0x80021201,
5365 ExchangeModelFileImportOptionsKit = 0x8102000d,
5367 PublishMask = 0x80040000,
5368 PublishDocumentKit = 0x81040001,
5369 PublishPageKit = 0x81040002,
5370 PublishTemplateKit = 0x81040003,
5371 PublishAnnotationKit = 0x81040004,
5372 PublishArtworkKit = 0x81040005,
5373 PublishViewKit = 0x81040006,
5374 PublishTextKit = 0x81040007,
5375 PublishImageKit = 0x81040008,
5376 PublishTableKit = 0x81040009,
5377 PublishExportOptionsKit = 0x8104000a,
5378 PublishLinkKit = 0x8104000b,
5379 PublishButtonKit = 0x8104000c,
5380 PublishTextFieldKit = 0x8104000d,
5381 PublishSlideTableKit = 0x8104000e,
5382 PublishCheckBoxKit = 0x8104000f,
5383 PublishRadioButtonKit = 0x81040010,
5384 PublishListBoxKit = 0x81040011,
5385 PublishDropDownListKit = 0x81040012,
5386 PublishSignatureFieldKit = 0x81040013,
5388 PublishDocumentKey = 0x80040001,
5389 PublishPageControl = 0x80040002,
5391 SceneTree = 0x80008001,
5392 SceneTreeItem = 0x80008002,
5394 ComponentTree = 0x80008003,
5395 ComponentTreeItem = 0x80008004,
5397 SketchupMask = 0x80100000,
5398 SketchupImportOptionsKit = 0x81100001,
5399 SketchupImportResultsKit = 0x81100002,
5401 ParasolidMask = 0x80200000,
5402 ParasolidComponent = 0x80201201,
5403 ParasolidCADModel = 0x80200302,
5404 ParasolidImportOptionsKit = 0x81200003,
5405 ParasolidFacetTessellationKit = 0x81200004,
5406 ParasolidLineTessellationKit = 0x81200005,
5407 ParasolidExportOptionsKit = 0x81200006,
5409 IONotifierData = 0x84000200,
5410 StreamImportNotifierData = 0x84000201,
5411 STLImportNotifierData = 0x84000202,
5412 OBJImportNotifierData = 0x84000203,
5413 ExchangeImportNotifierData = 0x84020204,
5414 SketchupImportNotifierData = 0x84100205,
5415 ParasolidImportNotifierData = 0x84200206,
5416 ExchangeTranslationNotifierData = 0x84020207,
5417 ExchangeExportNotifierData = 0x84020208,
5418 StreamExportNotifierData = 0x84000209,
5430 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5437 static void Free(
void * in_pointer);
5446 template <
typename T>
5447 class NO_HPS_API Allocator
5450 typedef T value_type;
5451 typedef value_type * pointer;
5452 typedef value_type
const * const_pointer;
5453 typedef value_type & reference;
5454 typedef value_type
const & const_reference;
5455 typedef size_t size_type;
5456 typedef ptrdiff_t difference_type;
5460 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5463 template <
typename U> Allocator(Allocator<U>
const &) {}
5465 template <
typename U>
5468 typedef Allocator<U> other;
5472 pointer address(reference x)
const {
return &x; }
5473 const_pointer address(const_reference x)
const {
return &x; }
5475 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5476 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5478 #if defined(_MSC_VER) || defined (__APPLE__)
5479 void construct(pointer p, const_reference x) {
new(p) T(x); }
5481 template<
typename U,
typename... Args>
5482 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5484 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5486 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5489 template <
typename T,
typename U>
5490 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5492 template <
typename T,
typename U>
5493 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5499 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5507 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5517 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5587 HPS::Type Type()
const;
5596 virtual bool Empty()
const {
return (impl_ == 0);};
5599 virtual void Reset();
5604 bool HasType(HPS::Type in_mask)
const;
5608 intptr_t GetClassID()
const;
5613 intptr_t GetInstanceID()
const;
5615 template <
typename T>
5616 static intptr_t ClassID()
5618 static const intptr_t ret = T().GetClassID();
5623 friend class HPSI::Impl;
5624 friend class HPSI::KeyImpl;
5625 friend class HPSI::TicketImpl;
5634 HPS::Type ObjectType()
const {
return HPS::Type::Control;}
5651 this->Object::operator=(std::move(in_that));
6119 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6124 intptr_t GetClassID()
const;
6128 virtual Event * Clone()
const=0;
6131 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6146 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6147 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6154 friend class HPSI::EventDispatcherImpl;
6204 enum class KeyboardCode
6404 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6411 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6419 return !(*
this == in_that);
6428 typedef std::vector<Point, Allocator<Point> > PointArray;
6429 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6430 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6431 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6432 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6433 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6434 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6435 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6436 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6437 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6438 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6439 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6440 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6441 typedef std::vector<int, Allocator<int> > IntArray;
6442 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6443 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6444 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6445 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6446 typedef std::vector<float, Allocator<float> > FloatArray;
6447 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6448 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6449 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6450 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6451 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6452 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6453 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6454 typedef std::vector<bool, Allocator<bool> > BoolArray;
6455 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6456 typedef std::vector<Key, Allocator<Key> > KeyArray;
6457 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6458 typedef std::vector<char, Allocator<char> > CharArray;
6459 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6460 typedef std::vector<byte, Allocator<byte> > ByteArray;
6461 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6462 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6463 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6464 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6465 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6466 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6467 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6468 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6469 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6470 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6471 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6472 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6473 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6474 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6475 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6476 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6477 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6478 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6479 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6480 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6481 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6482 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6483 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6484 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6485 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6486 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6487 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6488 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6489 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6490 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6491 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6492 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6520 HPS::Type
ObjectType()
const {
return HPS::Type::SearchResultsIterator;}
6556 bool IsValid()
const;
6564 Key GetItem()
const;
6568 Key operator*()
const;
6572 SearchTypeArray GetResultTypes()
const;
6597 virtual void Reset();
6616 size_t GetCount()
const;
6655 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResultsIterator;}
6686 bool IsValid()
const;
6725 virtual void Reset();
6730 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResults;}
6745 size_t GetCount()
const;
6769 UTF8(
char const * in_string,
char const * in_locale = 0);
6773 UTF8(
wchar_t const * in_string);
6792 return Assign(std::move(in_utf8));
6799 size_t ToWStr(
wchar_t * out_wide_string)
const;
6804 size_t ToWStr(WCharArray & out_wide_string)
const;
6810 return (_length > 0);
6817 return (_length == 0);
6851 inline operator char const * ()
const
6858 char At(
size_t in_index)
const
6862 else if(in_index >= _length)
6865 return _text[in_index];
6871 UTF8 & Assign(
UTF8 const & in_utf8);
6878 return Assign(in_utf8);
6884 UTF8 & operator+= (
UTF8 const & in_utf8);
6889 UTF8 & operator+= (
char const * in_utf8);
6894 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6899 UTF8 operator+ (
char const * in_utf8)
const;
6904 bool operator== (
UTF8 const & in_utf8)
const;
6909 bool operator!= (
UTF8 const & in_utf8)
const
6911 return !(*
this == in_utf8);
6917 bool operator== (
char const * in_utf8)
const;
6922 bool operator!= (
char const * in_utf8)
const
6924 return !(*
this == in_utf8);
6933 return in_right == in_left;
6942 return in_right != in_left;
6951 return in_right ==
UTF8(in_left);
6960 return in_right !=
UTF8(in_left);
6967 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
6969 return UTF8(in_left) + in_right;
6976 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
6978 return UTF8(in_left) + in_right;
6984 size_t GetHash()
const;
6988 size_t internal_encode(
wchar_t const * in_wide_string);
6989 size_t internal_decode(
wchar_t * out_wide_string)
const;
6993 mutable size_t _hash_key;
6994 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
6995 char _buffer[_buffer_size];
7000 inline size_t operator()(
const HPS::UTF8 & in_utf8)
const
7012 enum class Intrinsic
7031 Condition(HPS::Condition::Intrinsic in_special);
7052 bool ShowCondition(
UTF8 & out_condition)
const;
7057 bool ShowNumber(
float & out_number)
const;
7062 bool ShowIntrinsic(Condition::Intrinsic & out_special)
const;
7067 bool ShowOperands(ConditionArray & out_operands)
const;
7077 bool Equals(
Condition const & in_that)
const;
7082 bool operator==(
Condition const & in_that)
const;
7087 bool operator!=(
Condition const & in_that)
const;
7092 bool IsSatisfiedBy(UTF8Array
const & in_conditions)
const;
7097 bool IsSatisfiedBy(
char const * in_condition)
const;
7241 HPS_API Condition NOT(Condition
const & in_operand);
7247 HPS_API Condition OR(Condition
const & in_operand1, Condition
const & in_operand2);
7253 HPS_API Condition XOR(Condition
const & in_operand1, Condition
const & in_operand2);
7259 HPS_API Condition AND(Condition
const & in_operand1, Condition
const & in_operand2);
7265 HPS_API Condition EQ(Condition
const & in_operand1, Condition
const & in_operand2);
7271 HPS_API Condition NEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7277 HPS_API Condition GT(Condition
const & in_operand1, Condition
const & in_operand2);
7283 HPS_API Condition LT(Condition
const & in_operand1, Condition
const & in_operand2);
7289 HPS_API Condition GTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7295 HPS_API Condition LTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7310 Key(
Key const & in_that);
7323 Key & operator=(
Key && in_that);
7331 bool HasOwner()
const;
7343 void MoveTo(
SegmentKey const & in_new_owner);
7350 Key & operator=(
Key const & in_that);
7353 virtual void Assign(
Key const & in_that);
7356 bool Equals(
Key const & in_that)
const;
7359 bool operator!= (
Key const & in_that)
const;
7362 bool operator== (
Key const & in_that)
const;
7366 size_t GetHash()
const;
7371 inline size_t operator()(
const HPS::Key & in_key)
const
7419 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7423 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7481 size_t ShowSubsegments()
const;
7484 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7489 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7494 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7499 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7504 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7509 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7514 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7533 SegmentKey & SetCondition(
char const * in_condition);
7536 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7539 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7545 bool ShowConditions(UTF8Array & out_conditions)
const;
7555 SegmentKey & SetMaterialPalette(
char const * in_name);
7561 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7579 bool ShowPriority(
int & out_priority)
const;
7585 SegmentKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
7592 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7598 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7603 SegmentKey & UnsetUserData(intptr_t in_index);
7609 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7614 SegmentKey & UnsetUserData(HPS::IntPtrTArray
const & in_indices);
7621 size_t ShowUserDataCount()
const;
7627 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
7632 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7638 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7645 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7648 LineKey InsertLine(PointArray
const & in_pts);
7724 PolygonKey InsertPolygon(PointArray
const & in_pts);
7734 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7737 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7740 ShellKey InsertShellByTristrips(PointArray
const & in_points, IntArray
const & in_tristrips);
7743 ShellKey InsertShellByTristrips(
size_t in_point_count,
Point const in_points [],
size_t in_tristrips_count,
int const in_tristrips []);
7749 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7752 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7800 NURBSCurveKey InsertNURBSCurve(
size_t in_degree, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_knots,
float in_start_u,
float in_end_u);
7803 NURBSCurveKey InsertNURBSCurve(
size_t in_degree,
size_t in_pcount,
Point const in_points [],
float const in_weights[],
size_t in_knot_count,
float const in_knots[],
float in_start_u,
float in_end_u);
7810 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots);
7813 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[]);
7816 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots, TrimKitArray
const & in_trims);
7819 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[],
size_t in_trim_count,
TrimKit const in_trims[]);
7830 TextKey InsertText(
Point const & in_position,
char const * in_text);
7849 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7876 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7894 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
7976 bool ShowCamera(
CameraKit & out_kit)
const;
8025 bool ShowCulling(
CullingKit & out_kit)
const;
8054 SegmentKey & UnsetCuttingSectionAttributes();
8201 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8321 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8422 HPS::Type
ObjectType()
const {
return HPS::Type::SegmentOptimizationOptionsKit; }
8533 bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data)
const;
8535 bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix)
const;
8537 bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion)
const;
8539 bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope)
const;
8541 bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization)
const;
8543 bool ShowShellInstancing(
bool & out_shell_instancing)
const;
8545 bool ShowShellMerging(
bool & out_shell_merging)
const;
8547 bool ShowAttributeDelocalization(
bool & out_attribute_delocalization)
const;
8601 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateNotifier;};
8777 bool ShowSnapshot(
ImageKit & out_kit)
const;
8788 SegmentKey & UnsetCuttingSectionAttributes();
8811 void MoveTo(
SegmentKey const & in_new_owner);
8830 KeyPath(KeyArray
const & in_path);
8835 KeyPath(
size_t in_path_count,
Key const in_path []);
8868 KeyPath & operator+=(KeyArray
const & in_key_array);
8883 KeyPath & Append(KeyArray
const & in_key_array);
8893 KeyPath & operator=(KeyArray
const & in_path);
8897 void Set(
KeyPath const & in_that);
8902 bool Equals(
KeyPath const & in_that)
const;
8907 bool operator!= (
KeyPath const & in_that)
const;
8912 bool operator== (
KeyPath const & in_that)
const;
8918 KeyPath & SetKeys(KeyArray
const & in_keys);
8924 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
8934 bool ShowKeys(KeyArray & out_keys)
const;
8958 bool ComputeTextExtent(
const char* in_text,
float & out_xfrac,
float & out_yfrac)
const;
8975 bool ShowNetBounding(
BoundingKit & out_kit)
const;
8979 bool ShowNetCamera(
CameraKit & out_kit)
const;
9043 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
9047 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
9051 bool ShowNetCulling(
CullingKit & out_kit)
const;
9083 bool ShowNetConditions(UTF8Array & out_conditions)
const;
9099 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
9108 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
9117 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
9126 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
9135 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
9144 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
9153 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
9162 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
9171 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
9238 bool operator==(
BoundingKit const & in_kit)
const;
9243 bool operator!=(
BoundingKit const & in_kit)
const;
9284 bool ShowExclusion(
bool & out_exclusion)
const;
9314 HPS::Type
ObjectType()
const {
return HPS::Type::BoundingControl;};
9363 bool ShowExclusion(
bool & out_exclusion)
const;
9698 bool ShowCuttingSections(
bool & out_state)
const;
9703 bool ShowCutEdges(
bool & out_state)
const;
9708 bool ShowCutFaces(
bool & out_state)
const;
9713 bool ShowWindows(
bool & out_state)
const;
9718 bool ShowText(
bool & out_state)
const;
9723 bool ShowLines(
bool & out_state)
const;
9728 bool ShowEdgeLights(
bool & out_state)
const;
9733 bool ShowMarkerLights(
bool & out_state)
const;
9738 bool ShowFaceLights(
bool & out_state)
const;
9743 bool ShowGenericEdges(
bool & out_state)
const;
9748 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9753 bool ShowAdjacentEdges(
bool & out_state)
const;
9758 bool ShowHardEdges(
bool & out_state)
const;
9763 bool ShowMeshQuadEdges(
bool & out_state)
const;
9768 bool ShowNonCulledEdges(
bool & out_state)
const;
9773 bool ShowPerimeterEdges(
bool & out_state)
const;
9778 bool ShowFaces(
bool & out_state)
const;
9783 bool ShowVertices(
bool & out_state)
const;
9788 bool ShowMarkers(
bool & out_state)
const;
9793 bool ShowShadowCasting(
bool & out_state)
const;
9798 bool ShowShadowReceiving(
bool & out_state)
const;
9803 bool ShowShadowEmitting(
bool & out_state)
const;
9835 HPS::Type
ObjectType()
const {
return HPS::Type::VisibilityControl;};
10100 bool ShowCuttingSections(
bool & out_state)
const;
10105 bool ShowCutEdges(
bool & out_state)
const;
10110 bool ShowCutFaces(
bool & out_state)
const;
10115 bool ShowWindows(
bool & out_state)
const;
10120 bool ShowText(
bool & out_state)
const;
10125 bool ShowLines(
bool & out_state)
const;
10130 bool ShowEdgeLights(
bool & out_state)
const;
10135 bool ShowMarkerLights(
bool & out_state)
const;
10140 bool ShowFaceLights(
bool & out_state)
const;
10145 bool ShowGenericEdges(
bool & out_state)
const;
10150 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
10155 bool ShowAdjacentEdges(
bool & out_state)
const;
10160 bool ShowHardEdges(
bool & out_state)
const;
10165 bool ShowMeshQuadEdges(
bool & out_state)
const;
10170 bool ShowNonCulledEdges(
bool & out_state)
const;
10175 bool ShowPerimeterEdges(
bool & out_state)
const;
10180 bool ShowFaces(
bool & out_state)
const;
10185 bool ShowVertices(
bool & out_state)
const;
10190 bool ShowMarkers(
bool & out_state)
const;
10195 bool ShowShadowCasting(
bool & out_state)
const;
10200 bool ShowShadowReceiving(
bool & out_state)
const;
10205 bool ShowShadowEmitting(
bool & out_state)
const;
10262 bool Empty()
const;
10267 bool Equals(
CameraKit const & in_kit)
const;
10272 bool operator==(
CameraKit const & in_kit)
const;
10277 bool operator!=(
CameraKit const & in_kit)
const;
10307 CameraKit & SetField(
float in_width,
float in_height);
10318 CameraKit & SetNearLimit(
float const in_limit);
10352 bool ShowUpVector(
Vector & out_up)
const;
10357 bool ShowPosition(
Point & out_position)
const;
10362 bool ShowTarget(
Point & out_target)
const;
10374 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
10379 bool ShowWidth(
float & out_width)
const;
10384 bool ShowHeight(
float & out_height)
const;
10390 bool ShowField(
float & out_width,
float & out_height)
const;
10395 bool ShowNearLimit(
float & out_near_limit)
const;
10403 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10411 CameraKit & Orbit(
float in_theta,
float in_phi);
10419 CameraKit & Pan(
float in_theta,
float in_phi);
10521 bool ShowUpVector(
Vector & out_up)
const;
10526 bool ShowPosition(
Point & out_position)
const;
10531 bool ShowTarget(
Point & out_target)
const;
10543 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10548 bool ShowWidth(
float & out_width)
const;
10553 bool ShowHeight(
float & out_height)
const;
10559 bool ShowField(
float & out_width,
float & out_height)
const;
10564 bool ShowNearLimit(
float & out_width)
const;
10572 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10658 bool Empty()
const;
10837 HPS::Type
ObjectType()
const {
return HPS::Type::SelectabilityControl;};
11028 bool Empty()
const;
11114 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11125 bool ShowDepthWriting(
bool & out_state)
const;
11156 HPS::Type
ObjectType()
const {
return HPS::Type::TransparencyControl;};
11229 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11240 bool ShowDepthWriting(
bool & out_state)
const;
11271 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationKit;};
11285 bool Empty()
const;
11360 bool ShowFaceColor(
bool & out_state)
const;
11365 bool ShowEdgeColor(
bool & out_state)
const;
11370 bool ShowVertexColor(
bool & out_state)
const;
11375 bool ShowFaceIndex(
bool & out_state)
const;
11380 bool ShowEdgeIndex(
bool & out_state)
const;
11385 bool ShowVertexIndex(
bool & out_state)
const;
11415 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationControl;};
11481 bool ShowFaceColor(
bool & out_state)
const;
11486 bool ShowEdgeColor(
bool & out_state)
const;
11491 bool ShowVertexColor(
bool & out_state)
const;
11496 bool ShowFaceIndex(
bool & out_state)
const;
11501 bool ShowEdgeIndex(
bool & out_state)
const;
11506 bool ShowVertexIndex(
bool & out_state)
const;
11561 bool Empty()
const;
11566 bool Equals(
CullingKit const & in_kit)
const;
11571 bool operator==(
CullingKit const & in_kit)
const;
11576 bool operator!=(
CullingKit const & in_kit)
const;
11582 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11588 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11594 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11600 CullingKit & SetExtent(
unsigned int in_pixels);
11641 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11680 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11686 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11691 bool ShowBackFace(
bool & out_state)
const;
11698 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11703 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11708 bool ShowFrustum(
bool & out_state)
const;
11748 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11762 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
11810 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
11849 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11855 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11860 bool ShowBackFace(
bool & out_state)
const;
11867 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11872 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11877 bool ShowFrustum(
bool & out_state)
const;
11912 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeKit;};
11934 bool Empty()
const;
11980 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12017 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeControl;};
12050 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12089 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeKit;};
12111 bool Empty()
const;
12147 bool ShowTessellation(
size_t & out_facets)
const;
12176 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeControl;};
12201 bool ShowTessellation(
size_t & out_facets)
const;
12234 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeKit;};
12256 bool Empty()
const;
12325 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeControl;};
12383 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeKit;};
12405 bool Empty()
const;
12451 bool ShowTessellation(
size_t & out_facets)
const;
12487 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeControl;};
12521 bool ShowTessellation(
size_t & out_facets)
const;
12560 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeKit;};
12582 bool Empty()
const;
12677 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeControl;};
12785 bool Empty()
const;
13059 bool ShowBold(
bool & out_state)
const;
13064 bool ShowItalic(
bool & out_state)
const;
13069 bool ShowOverline(
bool & out_state)
const;
13074 bool ShowStrikethrough(
bool & out_state)
const;
13079 bool ShowUnderline(
bool & out_state)
const;
13084 bool ShowSlant(
float & out_angle)
const;
13089 bool ShowLineSpacing(
float & out_multiplier)
const;
13095 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13102 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13128 bool ShowFont(
UTF8 & out_name)
const;
13151 bool ShowPath(
Vector & out_path)
const;
13156 bool ShowSpacing(
float & out_multiplier)
const;
13187 HPS::Type
ObjectType()
const {
return HPS::Type::TextAttributeControl;};
13449 bool ShowBold(
bool & out_state)
const;
13454 bool ShowItalic(
bool & out_state)
const;
13459 bool ShowOverline(
bool & out_state)
const;
13464 bool ShowStrikethrough(
bool & out_state)
const;
13469 bool ShowUnderline(
bool & out_state)
const;
13474 bool ShowSlant(
float & out_angle)
const;
13479 bool ShowLineSpacing(
float & out_multiplier)
const;
13485 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13492 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13518 bool ShowFont(
UTF8 & out_name)
const;
13541 bool ShowPath(
Vector & out_path)
const;
13546 bool ShowSpacing(
float & out_multiplier)
const;
13604 bool Empty()
const;
13663 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13694 HPS::Type
ObjectType()
const {
return HPS::Type::LineAttributeControl;};
13741 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13797 bool Empty()
const;
13843 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13849 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13880 HPS::Type
ObjectType()
const {
return HPS::Type::EdgeAttributeControl;};
13913 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13919 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13974 bool Empty()
const;
14069 bool ShowBudget(
size_t & out_budget)
const;
14075 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14080 bool ShowViewDependent(
bool & out_state)
const;
14086 bool ShowMaximumDeviation(
float & out_deviation)
const;
14092 bool ShowMaximumAngle(
float & out_degrees)
const;
14098 bool ShowMaximumLength(
float & out_length)
const;
14128 HPS::Type
ObjectType()
const {
return HPS::Type::CurveAttributeControl;};
14212 bool ShowBudget(
size_t & out_budget)
const;
14218 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14223 bool ShowViewDependent(
bool & out_state)
const;
14229 bool ShowMaximumDeviation(
float & out_deviation)
const;
14235 bool ShowMaximumAngle(
float & out_degrees)
const;
14241 bool ShowMaximumLength(
float & out_length)
const;
14276 MatrixKit(FloatArray
const & in_matrix_source);
14281 MatrixKit(
float const in_matrix_source []);
14311 bool Empty()
const;
14316 bool Equals(
MatrixKit const & in_kit)
const;
14321 bool operator==(
MatrixKit const & in_kit)
const;
14326 bool operator!=(
MatrixKit const & in_kit)
const;
14333 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
14339 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
14344 MatrixKit & SetElements(FloatArray
const & in_matrix);
14350 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
14363 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14369 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14374 bool ShowElements(FloatArray & out_matrix)
const;
14379 bool ShowDeterminant(
float & out_determinant)
const;
14384 bool ShowInverse(
MatrixKit & out_matrix)
const;
14390 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14398 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14411 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14418 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14452 MatrixKit Multiply(
float in_scalar)
const;
14457 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14472 MatrixKit operator*(
float in_scalar)
const;
14477 MatrixKit const & operator*=(
float in_scalar);
14483 Point Transform(
Point const & in_source)
const;
14488 PointArray Transform(PointArray
const & in_source)
const;
14494 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14504 VectorArray Transform(VectorArray
const & in_source)
const;
14510 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14515 Plane Transform(
Plane const & in_source)
const;
14520 PlaneArray Transform(PlaneArray
const & in_source)
const;
14526 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14558 HPS::Type
ObjectType()
const {
return HPS::Type::ModellingMatrixControl;};
14598 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14604 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14609 bool ShowElements(FloatArray & out_matrix)
const;
14614 bool ShowDeterminant(
float & out_determinant)
const;
14619 bool ShowInverse(
MatrixKit & out_matrix)
const;
14625 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14702 HPS::Type
ObjectType()
const {
return HPS::Type::TextureMatrixControl;};
14743 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14749 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14754 bool ShowElements(FloatArray & out_matrix)
const;
14759 bool ShowDeterminant(
float & out_determinant)
const;
14764 bool ShowInverse(
MatrixKit & out_matrix)
const;
14770 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14849 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingKit;};
14871 bool Empty()
const;
15475 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15482 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15701 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15733 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingControl;};
16327 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16335 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16553 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16584 HPS::Type
ObjectType()
const {
return HPS::Type::PortfolioControl; };
16590 size_t GetCount()
const;
16643 bool Show(PortfolioKeyArray & out_portfolios)
const;
16681 size_t GetCount()
const;
16685 StyleKey PushNamed(
char const * in_style_name);
16688 StyleKey PushNamed(
char const * in_style_name,
Condition const & in_condition);
16724 void Flush(
SegmentKey const & in_style_source);
16737 void Flush(
char const * in_style_name);
16745 void Flush(
char const * in_style_name,
Condition const & in_condition);
16750 StyleKey SetNamed(
char const * in_style_name);
16773 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionArray
const & in_conditions);
16779 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
16795 void UnsetAllSegment();
16798 void UnsetAllNamed();
16801 void UnsetEverything();
16815 bool ShowTop(
StyleKey & out_style)
const;
16823 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions)
const;
16828 bool Show(StyleKeyArray & out_styles)
const;
16834 bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions)
const;
16839 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
16845 bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions)
const;
16850 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
16882 HPS::Type
ObjectType()
const {
return HPS::Type::ConditionControl; };
16889 size_t GetCount()
const;
16927 bool ShowCondition(
char const * in_condition)
const;
16932 bool ShowConditions(UTF8Array & out_conditions)
const;
16983 bool Empty()
const;
16993 bool operator==(
MaterialKit const & in_kit)
const;
16998 bool operator!=(
MaterialKit const & in_kit)
const;
17035 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
17044 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
17050 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
17057 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
17065 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
17074 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
17080 MaterialKit & SetShader(
char const * in_shader_name);
17092 MaterialKit & SetSpecular(
char const * in_texture_name);
17098 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17110 MaterialKit & SetMirror(
char const * in_texture_name);
17123 MaterialKit & SetTransmission(
char const * in_texture_name);
17129 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17141 MaterialKit & SetEmission(
char const * in_texture_name);
17147 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17154 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
17160 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17165 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
17171 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
17181 MaterialKit & SetBump(
char const * in_texture_name);
17212 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
17253 bool ShowDiffuse()
const;
17258 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
17263 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
17268 bool ShowDiffuseAlpha(
float & out_alpha)
const;
17293 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
17298 bool ShowShader(
UTF8 & out_shader_name)
const;
17358 bool ShowBump(
UTF8 & out_texture_name)
const;
17364 bool ShowGloss(
float & out_gloss)
const;
17393 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeKit;};
17415 bool Empty()
const;
17497 bool ShowBudget(
size_t & out_budget)
const;
17502 bool ShowMaximumDeviation(
float & out_deviation)
const;
17507 bool ShowMaximumAngle(
float & out_degrees)
const;
17512 bool ShowMaximumWidth(
float & out_width)
const;
17517 bool ShowTrimBudget(
size_t & out_budget)
const;
17522 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17553 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeControl;};
17623 bool ShowBudget(
size_t & out_budget)
const;
17628 bool ShowMaximumDeviation(
float & out_deviation)
const;
17633 bool ShowMaximumAngle(
float & out_degrees)
const;
17638 bool ShowMaximumWidth(
float & out_width)
const;
17643 bool ShowTrimBudget(
size_t & out_budget)
const;
17648 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17704 bool Empty()
const;
17786 HPS::Type
ObjectType()
const {
return HPS::Type::PerformanceControl;};
17859 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeKit;};
17881 bool Empty()
const;
18021 bool ShowColor(
RGBAColor & out_color)
const;
18026 bool ShowDimFactor(
float & out_zero_to_one)
const;
18031 bool ShowFaceDisplacement(
float & out_buckets)
const;
18036 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18041 bool ShowRenderFaces(
bool & out_state)
const;
18046 bool ShowRenderText(
bool & out_state)
const;
18056 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18061 bool ShowVisibility(
bool & out_state)
const;
18067 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18072 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18104 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeControl;};
18231 bool ShowColor(
RGBAColor & out_color)
const;
18236 bool ShowDimFactor(
float & out_zero_to_one)
const;
18241 bool ShowFaceDisplacement(
float & out_buckets)
const;
18246 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18251 bool ShowRenderFaces(
bool & out_state)
const;
18256 bool ShowRenderText(
bool & out_state)
const;
18266 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18271 bool ShowVisibility(
bool & out_state)
const;
18277 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18282 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18316 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeKit;};
18338 bool Empty()
const;
18522 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18528 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18534 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18540 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18550 bool ShowDeferral(
int & out_defer_batch)
const;
18596 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeControl;};
18762 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
18768 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18774 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18780 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18790 bool ShowDeferral(
int & out_defer_batch)
const;
18830 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsKit;};
18852 bool Empty()
const;
18915 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
18924 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
18941 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
18949 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
18998 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19007 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19016 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19046 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsControl;};
19106 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19122 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19180 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19189 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19198 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19243 bool Empty()
const;
19387 bool ShowCameraRotation(
bool & out_state)
const;
19392 bool ShowCameraScale(
bool & out_state)
const;
19397 bool ShowCameraTranslation(
bool & out_state)
const;
19402 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19407 bool ShowCameraProjection(
bool & out_state)
const;
19412 bool ShowCameraOffset(
bool & out_state)
const;
19417 bool ShowCameraNearLimit(
bool & out_state)
const;
19422 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19427 bool ShowModellingMatrixScale(
bool & out_state)
const;
19432 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19437 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19468 HPS::Type
ObjectType()
const {
return HPS::Type::TransformMaskControl;};
19603 bool ShowCameraRotation(
bool & out_state)
const;
19608 bool ShowCameraScale(
bool & out_state)
const;
19613 bool ShowCameraTranslation(
bool & out_state)
const;
19618 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19623 bool ShowCameraProjection(
bool & out_state)
const;
19628 bool ShowCameraOffset(
bool & out_state)
const;
19633 bool ShowCameraNearLimit(
bool & out_state)
const;
19638 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19643 bool ShowModellingMatrixScale(
bool & out_state)
const;
19648 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19653 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19709 bool Empty()
const;
19745 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19755 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19763 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19770 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19797 VisualEffectsKit & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
19808 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19868 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19873 bool ShowAntiAliasing(
bool & out_state)
const;
19882 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19890 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19895 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
19900 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
19905 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
19915 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
19921 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
19926 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
19958 HPS::Type
ObjectType()
const {
return HPS::Type::VisualEffectsControl;};
19982 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19992 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
20000 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20007 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20034 VisualEffectsControl & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
20045 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20106 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20111 bool ShowAntiAliasing(
bool & out_state)
const;
20120 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20128 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20133 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20138 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20143 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20153 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
20158 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20163 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20219 bool Empty()
const;
20246 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
20257 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
20295 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20348 bool ShowVisibility(
bool & out_state)
const;
20355 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20360 bool ShowColors(RGBColorArray & out_colors)
const;
20365 bool ShowPatterns(UTF8Array & out_patterns)
const;
20371 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20376 bool ShowLighting(
bool & out_state)
const;
20405 HPS::Type
ObjectType()
const {
return HPS::Type::ContourLineControl; };
20469 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20522 bool ShowVisibility(
bool & out_state)
const;
20529 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20534 bool ShowColors(RGBColorArray & out_colors)
const;
20539 bool ShowPatterns(UTF8Array & out_patterns)
const;
20545 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20550 bool ShowLighting(
bool & out_state)
const;
20605 bool Empty()
const;
20718 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
20854 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
20909 bool Empty()
const;
20945 bool ShowResourceMonitor(
bool & out_display)
const;
20988 bool ShowResourceMonitor(
bool & out_display)
const;
20993 bool ShowLastUpdateInfo(
UpdateInfo & out_info);
21042 bool Empty()
const;
21064 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
21070 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
21076 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
21082 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
21110 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21116 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21122 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21128 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21135 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21140 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21145 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21183 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21189 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21195 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21201 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21208 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21213 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21218 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21224 bool ShowMaxTextureSize(
unsigned int & out_width,
unsigned int & out_height)
const;
21230 bool ShowLastUpdateTime(Time & out_time)
const;
21235 bool ShowDepthPeelingLayers(
size_t & out_layers)
const;
21240 bool ShowVideoMemory(
size_t & out_video_memory)
const;
21245 bool ShowDepthBufferSize(
size_t & out_bits)
const;
21250 bool ShowMaxLights(
size_t & out_lights)
const;
21255 bool ShowColorBitPlanes(
size_t & out_planes)
const;
21307 bool Empty()
const;
21326 UTF8 GetName()
const;
21330 bool GetShellConvertibility()
const;
21383 bool Empty()
const;
21411 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21425 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21442 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
21459 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21471 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21502 HPS::Type
ObjectType()
const {
return HPS::Type::AttributeLockControl;}
21519 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21533 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21567 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21579 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21628 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
21633 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
21652 bool ShowPriority(
int & out_priority)
const;
21660 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21666 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21672 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21683 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21688 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
21695 size_t ShowUserDataCount()
const;
21700 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21706 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21712 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21748 void Consume(
LineKit & in_kit);
21752 void Set(
LineKit const & in_kit);
21756 void Show(
LineKit & out_kit)
const;
21765 bool Empty()
const;
21770 bool Equals(
LineKit const & in_kit)
const;
21775 bool operator==(
LineKit const & in_kit)
const;
21780 bool operator!=(
LineKit const & in_kit)
const;
21784 size_t GetPointCount()
const;
21792 LineKit & SetPriority(
int in_priority);
21801 bool ShowPriority(
int & out_priority)
const;
21807 LineKit & SetPoints(PointArray
const & in_points);
21813 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
21828 bool ShowPoints(PointArray & out_points)
const;
21835 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
21841 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
21848 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
21856 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21862 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21868 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21875 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21882 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21889 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21895 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21901 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21906 LineKit & UnsetUserData(intptr_t in_index);
21912 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21917 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
21921 LineKit & UnsetAllUserData();
21924 size_t ShowUserDataCount()
const;
21929 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21935 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21941 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21982 void Consume(
LineKit & in_kit);
21986 void Set(
LineKit const & in_kit);
21990 void Show(
LineKit & out_kit)
const;
21994 size_t GetPointCount()
const;
21999 LineKey & SetPoints(PointArray
const & in_points);
22005 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
22011 bool ShowPoints(PointArray & out_points)
const;
22018 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22024 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22031 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22039 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22045 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22051 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22058 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22065 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22114 bool Empty()
const;
22119 bool Equals(
MarkerKit const & in_kit)
const;
22124 bool operator==(
MarkerKit const & in_kit)
const;
22129 bool operator!=(
MarkerKit const & in_kit)
const;
22138 MarkerKit & SetPriority(
int in_priority);
22147 bool ShowPriority(
int & out_priority)
const;
22167 bool ShowPoint(
HPS::Point & out_point)
const;
22174 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22180 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22186 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22191 MarkerKit & UnsetUserData(intptr_t in_index);
22197 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22202 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
22209 size_t ShowUserDataCount()
const;
22214 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22220 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22226 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22286 bool ShowPoint(
Point & out_point)
const;
22335 bool Empty()
const;
22410 bool ShowPriority(
int & out_priority)
const;
22415 bool ShowDirection(
HPS::Vector & out_vector)
const;
22427 bool ShowCameraRelative(
bool & out_state)
const;
22434 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22440 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22446 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22457 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22469 size_t ShowUserDataCount()
const;
22474 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22480 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22486 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22570 bool ShowDirection(
HPS::Vector & out_vector)
const;
22582 bool ShowCameraRelative(
bool & out_state)
const;
22632 bool Empty()
const;
22642 bool operator==(
CylinderKit const & in_kit)
const;
22647 bool operator!=(
CylinderKit const & in_kit)
const;
22651 size_t GetPointCount()
const;
22668 bool ShowPriority(
int & out_priority)
const;
22674 CylinderKit & SetPoints(PointArray
const & in_points);
22685 CylinderKit & SetRadii(FloatArray
const & in_radii);
22691 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
22719 bool ShowPoints(PointArray & out_points)
const;
22726 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22732 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22739 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22744 bool ShowRadii(FloatArray & out_radii)
const;
22870 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22875 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
22908 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22922 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22929 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22935 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22941 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22952 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22957 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
22964 size_t ShowUserDataCount()
const;
22969 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22975 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22981 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23035 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23041 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
23047 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
23054 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23061 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
23069 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23075 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
23081 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
23088 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23095 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
23104 size_t GetPointCount()
const;
23109 bool ShowPoints(PointArray & out_points)
const;
23116 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
23122 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
23129 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
23134 bool ShowRadii(FloatArray & out_radii)
const;
23200 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23226 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23240 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23290 bool Empty()
const;
23295 bool Equals(
SphereKit const & in_kit)
const;
23300 bool operator==(
SphereKit const & in_kit)
const;
23305 bool operator!=(
SphereKit const & in_kit)
const;
23313 SphereKit & SetPriority(
int in_priority);
23322 bool ShowPriority(
int & out_priority)
const;
23332 SphereKit & SetRadius(
float in_radius);
23361 bool ShowCenter(
Point & out_center)
const;
23366 bool ShowRadius(
float & out_radius)
const;
23372 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23379 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23385 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23391 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23396 SphereKit & UnsetUserData(intptr_t in_index);
23402 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23407 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
23414 size_t ShowUserDataCount()
const;
23419 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23425 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23431 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23490 SphereKey & SetRadius(
float in_radius);
23502 bool ShowCenter(
Point & out_center)
const;
23507 bool ShowRadius(
float & out_radius)
const;
23513 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23563 bool Empty()
const;
23568 bool Equals(
CircleKit const & in_kit)
const;
23573 bool operator==(
CircleKit const & in_kit)
const;
23578 bool operator!=(
CircleKit const & in_kit)
const;
23586 CircleKit & SetPriority(
int const in_priority);
23595 bool ShowPriority(
int & out_priority)
const;
23607 CircleKit & SetRadius(
float in_radius);
23635 bool ShowCenter(
Point & out_center)
const;
23640 bool ShowRadius(
float & out_radius)
const;
23645 bool ShowNormal(
Vector & out_normal)
const;
23652 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23658 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23664 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23669 CircleKit & UnsetUserData(intptr_t in_index);
23675 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23680 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
23687 size_t ShowUserDataCount()
const;
23692 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23698 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23704 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23766 CircleKey & SetRadius(
float in_radius);
23777 bool ShowCenter(
Point & out_center)
const;
23782 bool ShowRadius(
float & out_radius)
const;
23787 bool ShowNormal(
Vector & out_normal)
const;
23837 bool Empty()
const;
23869 bool ShowPriority(
int & out_priority)
const;
23908 bool ShowStart(
Point & out_start)
const;
23913 bool ShowMiddle(
Point & out_middle)
const;
23918 bool ShowEnd(
Point & out_end)
const;
23925 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23931 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23937 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23948 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23953 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
23960 size_t ShowUserDataCount()
const;
23965 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23971 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23977 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24049 bool ShowStart(
Point & out_start)
const;
24054 bool ShowMiddle(
Point & out_middle)
const;
24059 bool ShowEnd(
Point & out_end)
const;
24087 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKit; };
24108 bool Empty()
const;
24141 bool ShowPriority(
int & out_priority)
const;
24180 bool ShowStart(
Point & out_start)
const;
24185 bool ShowMiddle(
Point & out_middle)
const;
24190 bool ShowEnd(
Point & out_end)
const;
24197 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24203 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24209 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24220 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24232 size_t ShowUserDataCount()
const;
24237 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24243 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24249 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24288 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKey; };
24323 bool ShowStart(
Point & out_start)
const;
24328 bool ShowMiddle(
Point & out_middle)
const;
24333 bool ShowEnd(
Point & out_end)
const;
24361 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKit; };
24382 bool Empty()
const;
24414 bool ShowPriority(
int & out_priority)
const;
24456 size_t GetPlaneCount()
const;
24461 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24484 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24500 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24509 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24516 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24528 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24539 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24551 size_t ShowUserDataCount()
const;
24556 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24562 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24568 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24605 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKey; };
24647 size_t GetPlaneCount()
const;
24652 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24675 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24691 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24700 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24749 bool Empty()
const;
24781 bool ShowPriority(
int & out_priority)
const;
24820 bool ShowFirst(
Point & out_first)
const;
24825 bool ShowSecond(
Point & out_second)
const;
24837 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24843 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24849 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24860 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24872 size_t ShowUserDataCount()
const;
24877 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24883 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24889 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24960 bool ShowFirst(
Point & out_first)
const;
24965 bool ShowSecond(
Point & out_second)
const;
25026 bool Empty()
const;
25095 SpotlightKit & SetConcentration(
float in_concentration);
25145 bool ShowPriority(
int & out_priority)
const;
25150 bool ShowPosition(
HPS::Point & out_position)
const;
25155 bool ShowTarget(
HPS::Point & out_target)
const;
25179 bool ShowConcentration(
float & out_concentration)
const;
25184 bool ShowCameraRelative(
bool & out_state)
const;
25191 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25197 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25203 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25214 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25219 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
25226 size_t ShowUserDataCount()
const;
25231 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25237 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25243 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25338 SpotlightKey & SetConcentration(
float in_concentration);
25356 bool ShowPosition(
HPS::Point & out_position)
const;
25361 bool ShowTarget(
HPS::Point & out_target)
const;
25385 bool ShowConcentration(
float & out_concentration)
const;
25390 bool ShowCameraRelative(
bool & out_state)
const;
25439 bool Empty()
const;
25458 size_t GetPointCount()
const;
25475 bool ShowPriority(
int & out_priority)
const;
25502 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
25513 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
25519 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
25550 bool ShowDegree(
size_t & out_degree)
const;
25555 bool ShowPoints(PointArray & out_points)
const;
25562 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25568 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25575 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25580 bool ShowWeights(FloatArray & out_weights)
const;
25585 bool ShowKnots(FloatArray & out_knots)
const;
25591 bool ShowParameters(
float & out_start,
float & out_end)
const;
25600 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25607 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25615 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25623 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25631 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25641 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25649 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25658 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25666 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25674 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25682 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25688 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25695 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
25703 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25711 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25718 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25724 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25730 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25741 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25746 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
25753 size_t ShowUserDataCount()
const;
25758 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25764 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25770 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25823 size_t GetPointCount()
const;
25829 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
25834 bool ShowDegree(
size_t & out_degree)
const;
25839 bool ShowPoints(PointArray & out_points)
const;
25846 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25852 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25859 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25864 bool ShowWeights(FloatArray & out_weights)
const;
25869 bool ShowKnots(FloatArray & out_knots)
const;
25875 bool ShowParameters(
float & out_start,
float & out_end)
const;
25885 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25893 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25904 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25913 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25923 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25931 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25980 bool Empty()
const;
25999 size_t GetPointCount()
const;
26016 bool ShowPriority(
int & out_priority)
const;
26060 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
26073 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
26086 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
26144 bool ShowUDegree(
size_t & out_degree)
const;
26149 bool ShowVDegree(
size_t & out_degree)
const;
26154 bool ShowUCount(
size_t & out_count)
const;
26159 bool ShowVCount(
size_t & out_count)
const;
26164 bool ShowPoints(PointArray & out_points)
const;
26171 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26177 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26184 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26189 bool ShowWeights(FloatArray & out_weights)
const;
26194 bool ShowUKnots(FloatArray & out_knots)
const;
26199 bool ShowVKnots(FloatArray & out_knots)
const;
26204 bool ShowTrims(TrimKitArray & out_trims)
const;
26213 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26220 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
26228 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
26236 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26244 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26254 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26262 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
26271 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
26279 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26287 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26296 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26303 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26311 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
26319 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26327 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26336 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26343 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26351 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
26359 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26367 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26374 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26380 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26386 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26397 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26409 size_t ShowUserDataCount()
const;
26414 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26420 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26426 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26479 size_t GetPointCount()
const;
26501 bool ShowUDegree(
size_t & out_degree)
const;
26506 bool ShowVDegree(
size_t & out_degree)
const;
26511 bool ShowUCount(
size_t & out_count)
const;
26516 bool ShowVCount(
size_t & out_count)
const;
26521 bool ShowPoints(PointArray & out_points)
const;
26528 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26534 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26541 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26546 bool ShowWeights(FloatArray & out_weights)
const;
26551 bool ShowUKnots(FloatArray & out_knots)
const;
26556 bool ShowVKnots(FloatArray & out_knots)
const;
26561 bool ShowTrims(TrimKitArray & out_trims)
const;
26571 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26579 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26590 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26599 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26609 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26617 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26627 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26635 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26692 bool operator==(
TrimElement const & in_that)
const;
26697 bool operator!=(
TrimElement const & in_that)
const;
26703 void SetCurve(
LineKit const & in_line);
26747 void Set(
TrimKit const & in_kit);
26751 void Show(
TrimKit & out_kit)
const;
26760 bool Empty()
const;
26765 bool Equals(
TrimKit const & in_kit)
const;
26770 bool operator==(
TrimKit const & in_kit)
const;
26775 bool operator!=(
TrimKit const & in_kit)
const;
26787 TrimKit & SetShape(TrimElementArray
const & in_shape);
26811 bool ShowShape(TrimElementArray & out_shape)
const;
26865 bool Empty()
const;
26870 bool Equals(
EllipseKit const & in_kit)
const;
26875 bool operator==(
EllipseKit const & in_kit)
const;
26880 bool operator!=(
EllipseKit const & in_kit)
const;
26897 bool ShowPriority(
int & out_priority)
const;
26936 bool ShowCenter(
Point & out_center)
const;
26941 bool ShowMajor(
Point & out_major)
const;
26946 bool ShowMinor(
Point & out_minor)
const;
26953 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26959 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26965 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26970 EllipseKit & UnsetUserData(intptr_t in_index);
26976 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26981 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
26988 size_t ShowUserDataCount()
const;
26993 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26999 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27005 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27077 bool ShowCenter(
Point & out_center)
const;
27082 bool ShowMajor(
Point & out_major)
const;
27087 bool ShowMinor(
Point & out_minor)
const;
27115 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKit; };
27136 bool Empty()
const;
27168 bool ShowPriority(
int & out_priority)
const;
27233 bool ShowCenter(
Point & out_center)
const;
27238 bool ShowMajor(
Point & out_major)
const;
27243 bool ShowMinor(
Point & out_minor)
const;
27248 bool ShowStart(
float & out_start)
const;
27253 bool ShowEnd(
float & out_end)
const;
27260 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27266 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27272 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27283 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27295 size_t ShowUserDataCount()
const;
27300 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27306 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27312 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27349 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKey; };
27402 bool ShowCenter(
Point & out_center)
const;
27407 bool ShowMajor(
Point & out_major)
const;
27412 bool ShowMinor(
Point & out_minor)
const;
27417 bool ShowStart(
float & out_start)
const;
27422 bool ShowEnd(
float & out_end)
const;
27454 void Consume(
TextKit & in_kit);
27458 void Set(
TextKit const & in_kit);
27462 void Show(
TextKit & out_kit)
const;
27471 bool Empty()
const;
27476 bool Equals(
TextKit const & in_kit)
const;
27481 bool operator==(
TextKit const & in_kit)
const;
27486 bool operator!=(
TextKit const & in_kit)
const;
27494 TextKit & SetPriority(
int in_priority);
27503 bool ShowPriority(
int & out_priority)
const;
27513 TextKit & SetText(
char const * in_string);
27523 TextKit & SetColorByIndex(
float in_index);
27540 TextKit & SetBold(
bool in_state);
27545 TextKit & SetItalic(
bool in_state);
27550 TextKit & SetOverline(
bool in_state);
27555 TextKit & SetStrikethrough(
bool in_state);
27560 TextKit & SetUnderline(
bool in_state);
27566 TextKit & SetSlant(
float in_angle);
27571 TextKit & SetLineSpacing(
float in_multiplier);
27583 TextKit & SetRotation(
float in_angle);
27643 TextKit & SetFont(
char const * in_name);
27678 TextKit & SetSpacing(
float in_multiplier);
27695 TextKit & UnsetModellingMatrix();
27715 TextKit & UnsetStrikethrough();
27727 TextKit & UnsetLineSpacing();
27743 TextKit & UnsetSizeTolerance();
27781 bool ShowPosition(
Point & out_position)
const;
27786 bool ShowText(
UTF8 & out_string)
const;
27798 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27810 bool ShowBold(
bool & out_state)
const;
27815 bool ShowItalic(
bool & out_state)
const;
27820 bool ShowOverline(
bool & out_state)
const;
27825 bool ShowStrikethrough(
bool & out_state)
const;
27830 bool ShowUnderline(
bool & out_state)
const;
27835 bool ShowSlant(
float & out_angle)
const;
27840 bool ShowLineSpacing(
float & out_multiplier)
const;
27846 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27853 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27879 bool ShowFont(
UTF8 & out_name)
const;
27902 bool ShowPath(
Vector & out_path)
const;
27907 bool ShowSpacing(
float & out_multiplier)
const;
27917 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27925 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
27933 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27943 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
27957 TextKit & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27972 TextKit & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27979 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27989 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27995 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
28000 TextKit & UnsetUserData(intptr_t in_index);
28006 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
28011 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
28015 TextKit & UnsetAllUserData();
28018 size_t ShowUserDataCount()
const;
28023 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
28029 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
28035 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
28076 void Consume(
TextKit & in_kit);
28080 void Set(
TextKit const & in_kit);
28084 void Show(
TextKit & out_kit)
const;
28103 TextKey & SetText(
char const * in_string);
28113 TextKey & SetColorByIndex(
float in_index);
28130 TextKey & SetBold(
bool in_state);
28135 TextKey & SetItalic(
bool in_state);
28140 TextKey & SetOverline(
bool in_state);
28145 TextKey & SetStrikethrough(
bool in_state);
28150 TextKey & SetUnderline(
bool in_state);
28156 TextKey & SetSlant(
float in_angle);
28162 TextKey & SetLineSpacing(
float in_multiplier);
28174 TextKey & SetRotation(
float in_angle);
28234 TextKey & SetFont(
char const * in_name);
28271 TextKey & SetSpacing(
float in_multiplier);
28285 TextKey & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28300 TextKey & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28309 TextKey & UnsetModellingMatrix();
28329 TextKey & UnsetStrikethrough();
28341 TextKey & UnsetLineSpacing();
28357 TextKey & UnsetSizeTolerance();
28399 bool ShowPosition(
Point & out_position)
const;
28404 bool ShowText(
UTF8 & out_string)
const;
28416 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28428 bool ShowBold(
bool & out_state)
const;
28433 bool ShowItalic(
bool & out_state)
const;
28438 bool ShowOverline(
bool & out_state)
const;
28443 bool ShowStrikethrough(
bool & out_state)
const;
28448 bool ShowUnderline(
bool & out_state)
const;
28453 bool ShowSlant(
float & out_angle)
const;
28458 bool ShowLineSpacing(
float & out_multiplier)
const;
28464 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28471 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28497 bool ShowFont(
UTF8 & out_name)
const;
28520 bool ShowPath(
Vector & out_path)
const;
28525 bool ShowSpacing(
float & out_multiplier)
const;
28535 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
28545 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28553 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28561 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28583 HPS::Type
ObjectType()
const {
return HPS::Type::ShellOptimizationOptionsKit; };
28609 bool Empty()
const;
28680 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
28691 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
28726 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationOptionsKit; };
28752 bool Empty()
const;
28816 bool ShowTolerance(
float & out_tolerance)
const;
28826 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
28831 bool ShowNearestFaceCalculation(
bool & out_state)
const;
28857 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationResultsKit; };
28878 bool Empty()
const;
28899 bool ShowRelations(ShellRelationArray & out_results)
const;
28904 bool ShowNearestFaces(SizeTArray & out_faces)
const;
28909 bool ShowDistances(FloatArray & out_distances)
const;
28944 void Set(
ShellKit const & in_kit);
28948 void Show(
ShellKit & out_kit)
const;
28952 size_t GetPointCount()
const;
28956 size_t GetFaceCount()
const;
28965 bool Empty()
const;
28970 bool Equals(
ShellKit const & in_kit)
const;
28975 bool operator==(
ShellKit const & in_kit)
const;
28980 bool operator!=(
ShellKit const & in_kit)
const;
28988 ShellKit & SetPriority(
int in_priority);
28997 bool ShowPriority(
int & out_priority)
const;
29004 ShellKit & SetPoints(PointArray
const & in_points);
29010 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
29015 ShellKit & SetFacelist(IntArray
const & in_facelist);
29021 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
29026 ShellKit & SetTristrips(IntArray
const & in_tristrips);
29032 ShellKit & SetTristrips(
size_t in_count,
int const in_tristrips []);
29053 bool ShowPoints(PointArray & out_points)
const;
29060 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
29066 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
29073 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
29078 bool ShowFacelist(IntArray & out_facelist)
const;
29083 bool ShowTristrips(IntArray & out_tristrips)
const;
29263 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29269 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29276 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29283 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29289 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29296 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29302 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29311 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29319 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29329 ShellKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29338 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29346 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29352 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29359 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29366 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29372 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29379 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29385 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29390 ShellKit & UnsetMaterialMapping();
29401 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29406 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29436 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29441 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29446 ShellKit & UnsetVertexParameters();
29452 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29457 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29462 ShellKit & UnsetVertexVisibilities();
29468 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29473 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29478 ShellKit & UnsetVertexEverything();
29500 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29501 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29517 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29518 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29529 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29539 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29551 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
29562 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29573 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
29584 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29595 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29605 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29614 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
29620 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
29627 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
29634 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
29640 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
29647 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
29653 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
29661 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
29667 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
29674 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
29681 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
29687 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
29694 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
29700 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
29708 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29714 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29721 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29728 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
29734 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
29741 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
29747 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
29755 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29761 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29768 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29775 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
29781 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
29788 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
29794 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
29805 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
29810 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
29821 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
29826 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
29831 ShellKit & UnsetFaceVisibilities();
29837 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
29842 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
29859 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29871 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29882 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29892 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
29903 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29913 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29922 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29929 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
29936 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
29943 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29950 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
29959 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
29966 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
29973 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
29983 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
29992 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30021 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
30027 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
30033 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
30038 ShellKit & UnsetUserData(intptr_t in_index);
30044 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
30049 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
30056 size_t ShowUserDataCount()
const;
30061 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
30067 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
30073 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
30120 void Set(
ShellKit const & in_kit);
30124 void Show(
ShellKit & out_kit)
const;
30128 size_t GetPointCount()
const;
30132 size_t GetFaceCount()
const;
30138 ShellKey & SetPoints(PointArray
const & in_points);
30144 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
30149 ShellKey & SetFacelist(IntArray
const & in_facelist);
30155 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
30160 ShellKey & SetTristrips(IntArray
const & in_tristrips);
30166 ShellKey & SetTristrips(
size_t in_count,
int const in_tristrips []);
30188 ShellKey & UnsetMaterialMapping();
30197 bool ShowPoints(PointArray & out_points)
const;
30204 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
30210 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
30217 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
30222 bool ShowFacelist(IntArray & out_facelist)
const;
30227 bool ShowTristrips(IntArray & out_tristrips)
const;
30408 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30415 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30422 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30429 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30435 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30442 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30448 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30458 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30466 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30476 ShellKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30485 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30493 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30500 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30507 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30514 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
30520 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
30527 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
30533 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
30544 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
30549 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
30579 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
30584 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
30589 ShellKey & UnsetVertexParameters();
30595 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
30600 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
30605 ShellKey & UnsetVertexVisibilities();
30611 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
30616 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
30621 ShellKey & UnsetVertexEverything();
30637 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30638 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30654 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30655 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30666 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30676 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
30688 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
30699 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30710 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
30721 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30732 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30742 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30750 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
30757 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
30764 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
30771 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
30777 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
30784 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
30790 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
30798 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
30805 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
30812 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
30819 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
30825 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
30832 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
30838 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
30846 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30853 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30860 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30867 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
30873 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
30880 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
30886 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
30894 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30901 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30908 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30915 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
30921 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
30928 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
30934 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
30945 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
30950 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
30961 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
30966 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
30971 ShellKey & UnsetFaceVisibilities();
30977 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
30982 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
30999 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31011 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31022 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31032 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31040 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
31048 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
31059 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31069 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31078 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31085 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
31092 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
31099 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31106 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
31115 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31122 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
31129 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
31139 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31148 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
31202 void Consume(
MeshKit & in_kit);
31206 void Set(
MeshKit const & in_kit);
31210 void Show(
MeshKit & out_kit)
const;
31219 bool Empty()
const;
31224 bool Equals(
MeshKit const & in_kit)
const;
31229 bool operator==(
MeshKit const & in_kit)
const;
31234 bool operator!=(
MeshKit const & in_kit)
const;
31238 size_t GetPointCount()
const;
31246 MeshKit & SetPriority(
int in_priority);
31255 bool ShowPriority(
int & out_priority)
const;
31260 MeshKit & SetPoints(PointArray
const & in_points);
31266 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
31273 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, HPS::PointArray
const & in_points);
31281 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31286 MeshKit & SetRows(
size_t in_rows);
31291 MeshKit & SetColumns(
size_t in_columns);
31312 bool ShowPoints(PointArray & out_points)
const;
31319 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
31325 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
31332 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
31339 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31344 bool ShowRows(
size_t & out_rows)
const;
31349 bool ShowColumns(
size_t & out_columns)
const;
31529 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31535 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31542 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31549 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
31555 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
31562 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
31568 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
31577 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31585 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
31595 MeshKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31604 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
31612 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31618 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31625 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31632 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31638 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31645 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31651 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31656 MeshKit & UnsetMaterialMapping();
31660 MeshKit & UnsetVertexColors();
31666 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31671 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31695 MeshKit & UnsetVertexNormals();
31701 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31706 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31711 MeshKit & UnsetVertexParameters();
31717 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31722 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31727 MeshKit & UnsetVertexVisibilities();
31733 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31738 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31743 MeshKit & UnsetVertexEverything();
31764 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31765 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31781 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31782 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31793 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31803 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
31815 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
31826 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31837 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
31848 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31859 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31869 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31877 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31883 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31890 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
31897 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
31903 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
31910 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
31916 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
31924 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
31930 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
31937 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
31944 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
31950 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
31957 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
31963 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
31971 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31977 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31984 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31991 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
31997 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32004 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32010 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32018 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32024 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32031 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32038 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32044 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32051 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32057 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32068 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32073 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
32078 MeshKit & UnsetFaceNormals();
32084 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32089 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
32094 MeshKit & UnsetFaceVisibilities();
32100 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32105 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
32110 MeshKit & UnsetFaceEverything();
32122 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32134 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32145 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32155 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32166 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32176 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32183 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32189 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32195 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32200 MeshKit & UnsetUserData(intptr_t in_index);
32206 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32211 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
32215 MeshKit & UnsetAllUserData();
32218 size_t ShowUserDataCount()
const;
32223 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32229 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32235 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32279 void Consume(
MeshKit & in_kit);
32283 void Set(
MeshKit const & in_kit);
32287 void Show(
MeshKit & out_kit)
const;
32291 size_t GetPointCount()
const;
32298 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
32306 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
32311 bool ShowPoints(PointArray & out_points)
const;
32318 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
32324 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
32331 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
32338 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
32343 bool ShowRows(
size_t & out_rows)
const;
32348 bool ShowColumns(
size_t & out_columns)
const;
32359 MeshKey & UnsetMaterialMapping();
32540 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32547 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32554 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32561 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
32567 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
32574 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
32580 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
32590 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32598 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
32608 MeshKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32617 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
32625 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32632 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32639 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32646 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
32652 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
32659 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
32665 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
32670 MeshKey & UnsetVertexColors();
32676 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
32681 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
32705 MeshKey & UnsetVertexNormals();
32711 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
32716 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
32721 MeshKey & UnsetVertexParameters();
32727 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
32732 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
32737 MeshKey & UnsetVertexVisibilities();
32743 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
32748 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
32753 MeshKey & UnsetVertexEverything();
32773 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32774 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32790 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32791 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32802 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32812 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32824 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32835 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32846 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32857 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32868 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32878 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32886 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32893 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
32900 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
32907 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32913 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32920 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32926 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32934 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32941 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32948 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32955 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32961 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32968 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32974 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32982 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32989 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32996 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
33003 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
33009 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
33016 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
33022 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
33030 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
33037 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
33044 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
33051 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
33057 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
33064 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
33070 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
33081 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
33086 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
33091 MeshKey & UnsetFaceNormals();
33097 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
33102 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
33107 MeshKey & UnsetFaceVisibilities();
33113 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
33118 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
33123 MeshKey & UnsetFaceEverything();
33135 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33147 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33158 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33168 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
33179 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33189 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33199 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count,
size_t in_point_count,
Point const in_points[]);
33208 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count, PointArray
const & in_points);
33258 bool Empty()
const;
33263 bool Equals(
PolygonKit const & in_kit)
const;
33268 bool operator==(
PolygonKit const & in_kit)
const;
33273 bool operator!=(
PolygonKit const & in_kit)
const;
33277 size_t GetPointCount()
const;
33294 bool ShowPriority(
int & out_priority)
const;
33300 PolygonKit & SetPoints(PointArray
const & in_points);
33319 bool ShowPoints(PointArray & out_points)
const;
33326 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33332 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33339 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33346 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33352 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33358 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33365 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33371 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33378 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33384 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33390 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33395 PolygonKit & UnsetUserData(intptr_t in_index);
33401 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33406 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
33413 size_t ShowUserDataCount()
const;
33418 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33424 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33430 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33485 size_t GetPointCount()
const;
33490 PolygonKey & SetPoints(PointArray
const & in_points);
33501 bool ShowPoints(PointArray & out_points)
const;
33508 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33514 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33521 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33528 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33534 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33540 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33547 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33553 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33580 void Consume(
GridKit & in_kit);
33584 void Set(
GridKit const & in_kit);
33588 void Show(
GridKit & out_kit)
const;
33602 bool Empty()
const;
33607 bool Equals(
GridKit const & in_kit)
const;
33612 bool operator==(
GridKit const & in_kit)
const;
33617 bool operator!=(
GridKit const & in_kit)
const;
33626 GridKit & SetPriority(
int in_priority);
33644 GridKit & SetFirstPoint(
Point const & in_first_point);
33653 GridKit & SetSecondPoint(
Point const & in_second_point);
33668 GridKit & SetFirstCount(
int in_first_count);
33680 GridKit & SetSecondCount(
int in_second_count);
33701 GridKit & UnsetSecondPoint();
33709 GridKit & UnsetSecondCount();
33719 bool ShowPriority(
int & out_priority)
const;
33729 bool ShowOrigin(
Point & out_origin)
const;
33734 bool ShowFirstPoint(
Point & out_first_point)
const;
33739 bool ShowSecondPoint(
Point & out_second_point)
const;
33744 bool ShowFirstCount(
int & out_first_count)
const;
33749 bool ShowSecondCount(
int & out_second_count)
const;
33756 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33762 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33768 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33773 GridKit & UnsetUserData(intptr_t in_index);
33779 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33784 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
33788 GridKit & UnsetAllUserData();
33791 size_t ShowUserDataCount()
const;
33796 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33802 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33808 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33849 void Consume(
GridKit & in_kit);
33853 void Set(
GridKit const & in_kit);
33857 void Show(
GridKit & out_kit)
const;
33876 GridKey & SetFirstPoint(
Point const & in_first_point);
33885 GridKey & SetSecondPoint(
Point const & in_second_point);
33900 GridKey & SetFirstCount(
int in_first_count);
33912 GridKey & SetSecondCount(
int in_second_count);
33924 bool ShowOrigin(
Point & out_origin)
const;
33929 bool ShowFirstPoint(
Point & out_first_point)
const;
33934 bool ShowSecondPoint(
Point & out_second_point)
const;
33939 bool ShowFirstCount(
int & out_first_count)
const;
33944 bool ShowSecondCount(
int & out_second_count)
const;
34020 bool ShowPriority(
int & out_priority)
const;
34025 bool ShowCondition(
Condition & out_condition)
const;
34047 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
34069 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34076 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34151 bool ShowCondition(
Condition & out_condition)
const;
34174 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
34196 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34203 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34254 Key GetTarget()
const;
34259 size_t ShowTargets(
bool masked=
true)
const;
34265 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
34270 size_t ShowGeometryMask()
const;
34276 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
34281 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
34289 void SetModellingMatrix(
MatrixKit const & in_kit);
34303 void UnsetModellingMatrix();
34313 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
34318 bool ShowCondition(
Condition & out_condition)
const;
34357 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsKit; };
34379 bool Empty()
const;
34465 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34470 bool ShowTitle(
UTF8 & out_window_name)
const;
34475 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34485 bool ShowFullScreen(
bool & out_state)
const;
34519 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsControl; };
34551 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34556 bool ShowTitle(
UTF8 & out_window_name)
const;
34561 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34571 bool ShowFullScreen(
bool & out_state)
const;
34605 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsKit; };
34627 bool Empty()
const;
34711 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34716 bool ShowHardwareResident(
bool & out_state)
const;
34728 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
34756 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsKit; };
34778 bool Empty()
const;
34845 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34850 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34855 bool ShowFramebufferRetention(
bool & out_retain)
const;
34886 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsControl; };
34897 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34907 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
34912 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34917 bool ShowFramebufferRetention(
bool & out_retain)
const;
34968 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowKey; };
35019 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowKey; };
35096 void SetIndexedColor(byte in_index);
35099 void SetNormalColor();
35103 void SetExplicitColor(
RGBAColor const & in_color);
35157 HPS::Type
ObjectType()
const {
return HPS::Type::LineGlyphElement; };
35161 void SetPoints(GlyphPointArray
const & in_points);
35166 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
35171 bool ShowPoints(GlyphPointArray & out_points)
const;
35216 bool ShowPoint(
GlyphPoint & out_point)
const;
35254 HPS::Type
ObjectType()
const {
return HPS::Type::EllipseGlyphElement; };
35258 void SetLowerLeft(
GlyphPoint const & in_point);
35262 void SetUpperRight(
GlyphPoint const & in_point);
35272 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
35277 bool ShowUpperRight(
GlyphPoint & out_point)
const;
35316 HPS::Type
ObjectType()
const {
return HPS::Type::CircularArcGlyphElement; };
35320 void SetStartPoint(
GlyphPoint const & in_point);
35324 void SetIntermediatePoint(
GlyphPoint const & in_point);
35328 void SetEndPoint(
GlyphPoint const & in_point);
35339 bool ShowStartPoint(
GlyphPoint & out_point)
const;
35344 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
35349 bool ShowEndPoint(
GlyphPoint & out_point)
const;
35388 HPS::Type
ObjectType()
const {
return HPS::Type::InfiniteLineGlyphElement; };
35392 void SetFirstPoint(
GlyphPoint const & in_point);
35396 void SetSecondPoint(
GlyphPoint const & in_point);
35410 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
35415 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
35457 void Set(
GlyphKit const & in_kit);
35461 void Show(
GlyphKit & out_kit)
const;
35470 bool Empty()
const;
35475 bool Equals(
GlyphKit const & in_kit)
const;
35480 bool operator==(
GlyphKit const & in_kit)
const;
35485 bool operator!=(
GlyphKit const & in_kit)
const;
35490 GlyphKit & SetRadius(sbyte in_radius);
35501 GlyphKit & SetElements(GlyphElementArray
const & in_def);
35528 bool ShowRadius(sbyte & out_radius)
const;
35533 bool ShowOffset(
GlyphPoint & out_point)
const;
35538 bool ShowElements(GlyphElementArray & out_def)
const;
35570 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternOptionsKit; };
35587 bool Empty()
const;
35713 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternElement; };
35785 HPS::Type
ObjectType()
const {
return HPS::Type::SolidLinePatternElement; };
35790 void SetColor(
RGBAColor const & in_color);
35795 void SetMaterialByIndex(
float in_material_index);
35840 HPS::Type
ObjectType()
const {
return HPS::Type::BlankLinePatternElement; };
35878 HPS::Type
ObjectType()
const {
return HPS::Type::GlyphLinePatternElement; };
35882 void SetSource(
char const * in_source);
35895 void SetMirror(
bool in_state);
35899 void SetFixed(
bool in_state);
35903 void SetRotation(
float in_degrees);
35908 bool ShowSource(
UTF8 & out_source)
const;
35924 bool ShowMirror(
bool & out_state)
const;
35929 bool ShowFixed(
bool & out_state)
const;
35934 bool ShowRotation(
float & out_degrees)
const;
35960 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternParallelKit; };
35977 bool Empty()
const;
36117 bool ShowBody(LinePatternElementArray & out_elements)
const;
36122 bool ShowAbsoluteLength(
bool & out_state)
const;
36127 bool ShowAbsoluteWeight(
bool & out_state)
const;
36151 bool ShowContinuous(
bool & out_state)
const;
36200 bool Empty()
const;
36220 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
36248 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
36306 virtual void Assign(
Definition const & in_that);
36311 bool Equals(
Definition const & in_that)
const;
36316 bool operator==(
Definition const & in_that)
const;
36321 bool operator!=(
Definition const & in_that)
const;
36490 PortfolioKey & UndefineNamedStyle(
char const * in_name);
36495 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
36505 PortfolioKey & UndefineLinePattern(
char const * in_name);
36623 size_t GetDefinitionCount()
const;
36626 size_t GetTextureDefinitionCount()
const;
36629 size_t GetCubeMapDefinitionCount()
const;
36632 size_t GetImageDefinitionCount()
const;
36635 size_t GetNamedStyleDefinitionCount()
const;
36638 size_t GetMaterialPaletteDefinitionCount()
const;
36641 size_t GetGlyphDefinitionCount()
const;
36644 size_t GetLinePatternDefinitionCount()
const;
36647 size_t GetShaderDefinitionCount()
const;
36653 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
36658 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
36664 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
36669 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
36675 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
36680 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
36691 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
36702 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
36708 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
36713 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
36724 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
36730 bool ShowShaderDefinition(
char const * in_name,
ShaderDefinition & out_found)
const;
36735 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
36739 void MoveTo(
SegmentKey const & in_new_owner);
36785 void Set(
GlyphKit const & in_kit);
36789 void Show(
GlyphKit & out_kit)
const;
36827 HPS::Type
ObjectType()
const {
return HPS::Type::TextureDefinition; };
36872 HPS::Type
ObjectType()
const {
return HPS::Type::TextureOptionsKit; };
36894 bool Empty()
const;
37000 bool ShowDecal(
bool & out_state)
const;
37005 bool ShowDownSampling(
bool & out_state)
const;
37010 bool ShowModulation(
bool & out_state)
const;
37015 bool ShowParameterOffset(
size_t & out_offset)
const;
37040 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37089 HPS::Type
ObjectType()
const {
return HPS::Type::ImageExportOptionsKit; };
37111 bool Empty()
const;
37132 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37156 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37187 HPS::Type
ObjectType()
const {
return HPS::Type::ImageImportOptionsKit; };
37204 bool Empty()
const;
37227 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37270 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37280 bool ShowDownSampling(
bool & out_state)
const;
37285 bool ShowCompressionQuality(
float & out_quality)
const;
37314 static void Export(
char const * in_file_name,
HPS::WindowKey const & in_window,
unsigned int in_width,
unsigned int in_height,
Format in_format = Format::Png);
37320 static void Export(
char const * in_file_name,
HPS::ImageKit const & in_image_kit);
37366 void Set(
ImageKit const & in_kit);
37370 void Show(
ImageKit & out_kit)
const;
37379 bool Empty()
const;
37384 bool Equals(
ImageKit const & in_kit)
const;
37389 bool operator==(
ImageKit const & in_kit)
const;
37394 bool operator!=(
ImageKit const & in_kit)
const;
37409 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37414 ImageKit & SetData(ByteArray
const & in_image_data);
37420 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
37430 ImageKit & SetDownSampling(
bool in_state);
37435 ImageKit & SetCompressionQuality(
float in_quality);
37455 ImageKit & UnsetCompressionQuality();
37465 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37470 bool ShowData(ByteArray & out_image_data)
const;
37480 bool ShowDownSampling(
bool & out_state)
const;
37485 bool ShowCompressionQuality(
float & out_quality)
const;
37517 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsControl; };
37545 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
37551 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37563 bool ShowImage(ByteArray & out_bytes)
const;
37568 bool ShowHardwareResident(
bool & out_state)
const;
37574 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
37619 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowKey; };
37676 void Set(
ImageKit const & in_kit);
37680 void Show(
ImageKit & out_kit)
const;
37717 HPS::Type
ObjectType()
const {
return HPS::Type::CubeMapDefinition; };
37744 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
37790 HPS::Type
ObjectType()
const {
return HPS::Type::NamedStyleDefinition; };
37833 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialPaletteDefinition; };
37837 void Set(MaterialKitArray
const & in_source);
37842 void Set(
size_t in_count,
MaterialKit const in_source []);
37846 void Show(MaterialKitArray & out_source)
const;
37885 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternDefinition; };
37909 PhysicalReflection,
37953 HPS::Type
ObjectType()
const {
return HPS::Type::ShaderImportOptionsKit; };
37970 bool Empty()
const;
38027 bool ShowMultitexture(
bool & out_state)
const;
38037 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
38102 bool Empty()
const;
38107 bool Equals(
ShaderKit const & in_kit)
const;
38112 bool operator==(
ShaderKit const & in_kit)
const;
38117 bool operator!=(
ShaderKit const & in_kit)
const;
38122 ShaderKit & SetSource(
char const * in_source);
38130 ShaderKit & SetMultitexture(
bool in_state);
38153 ShaderKit & UnsetParameterizationSource();
38166 bool ShowSource(
UTF8 & out_source)
const;
38173 bool ShowMultitexture(
bool & out_state)
const;
38183 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
38221 HPS::Type
ObjectType()
const {
return HPS::Type::ShaderDefinition; };
38261 HPS::Type
ObjectType()
const {
return HPS::Type::CutGeometryGatheringOptionsKit;};
38283 bool Empty()
const;
38342 bool ShowOffset(
size_t & out_offset)
const;
38395 bool Empty()
const;
38462 bool ShowCriteria(SearchTypeArray & out_types)
const;
38467 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
38512 bool operator==(
TreeContext const & in_that)
const;
38517 bool operator!=(
TreeContext const & in_that)
const;
38544 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsKit;};
38566 bool Empty()
const;
38748 bool ShowProximity(
float & out_proximity)
const;
38758 bool ShowInternalLimit(
size_t & out_limit)
const;
38763 bool ShowRelatedLimit(
size_t & out_limit)
const;
38768 bool ShowSorting(
bool & out_sorted)
const;
38783 bool ShowScope(
KeyPath & out_start_path)
const;
38788 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
38793 bool ShowExtentCullingRespected(
bool & out_state)
const;
38798 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
38803 bool ShowFrustumCullingRespected(
bool & out_state)
const;
38808 bool ShowVectorCullingRespected(
bool & out_state)
const;
38839 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsControl;};
38938 bool ShowProximity(
float & out_proximity)
const;
38948 bool ShowInternalLimit(
size_t & out_limit)
const;
38953 bool ShowRelatedLimit(
size_t & out_limit)
const;
38958 bool ShowSorting(
bool & out_sorted)
const;
38973 bool ShowExtentCullingRespected(
bool & out_state)
const;
38978 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
38983 bool ShowFrustumCullingRespected(
bool & out_state)
const;
38988 bool ShowVectorCullingRespected(
bool & out_state)
const;
39054 bool ShowSelectedItem(
Key & out_selection)
const;
39059 bool ShowPath(
KeyPath & out_path)
const;
39064 bool ShowFaces(SizeTArray & out_faces)
const;
39069 bool ShowVertices(SizeTArray & out_vertices)
const;
39075 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
39080 bool ShowCharacters(SizeTArray & out_characters)
const;
39085 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
39090 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
39118 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionResultsIterator;}
39151 bool IsValid()
const;
39219 virtual void Reset();
39227 size_t GetCount()
const;
39333 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
39348 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39361 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
39376 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39478 HPS::Type
ObjectType()
const {
return HPS::Type::HighlightOptionsKit;};
39500 bool Empty()
const;
39568 bool ShowStyleName(
UTF8 & out_style_name)
const;
39573 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
39583 bool ShowNotification(
bool & out_state)
const;
39737 bool Empty()
const;
39785 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39819 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateOptionsControl;};
39856 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39871 World(
char const * in_license);
39882 World & SetMaterialLibraryDirectory(
char const * in_directory);
39888 World & SetFontDirectory(
char const * in_directory);
39895 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
39901 World & SetFontDirectories(UTF8Array
const & in_directories);
39908 World & SetDriverConfigFile(
char const * in_filename);
39915 World & SetExchangeLibraryDirectory(
char const * in_directory);
39922 World & SetPublishResourceDirectory(
char const * in_directory);
39928 World & SetParasolidSchemaDirectory(
char const * in_directory);
39932 World & UnsetMaterialLibraryDirectory();
39936 World & UnsetFontDirectories();
39940 World & UnsetDriverConfigFile();
39944 World & UnsetExchangeLibraryDirectory();
39948 World & UnsetPublishResourceDirectory();
39952 World & UnsetParasolidSchemaDirectory();
39957 bool ShowLicense(
UTF8 & out_license)
const;
39962 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
39967 bool ShowFontDirectories(UTF8Array & out_directories)
const;
39972 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
39977 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
39982 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
39987 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
39995 virtual void Reset() {}
40024 intptr_t GetClassID()
const;
40035 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
40036 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
40049 static void Execute(
bool in_once=
true);
40053 static Time GetTime();
40056 static void Sleep(Time milliseconds);
40082 static void RelinquishMemory();
40110 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
40119 static void Reset();
40122 static void Synchronize();
40126 static WindowKeyArray GetWindowKeys();
40130 static SegmentKeyArray GetRootSegments();
40134 static PortfolioKeyArray GetPortfolios();
40140 static PortfolioKey const GetMaterialLibraryPortfolio();
40215 static size_t SelectByShell(
ShellKit const & in_shell,
40224 static size_t SelectByShell(
ShellKey const & in_shell,
40234 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
40244 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
40272 static bool SetInformationEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40278 static bool SetWarningEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40284 static bool SetErrorEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40292 static void UnsetEmergencyHandler();
40296 static size_t GetSoftMemoryLimit();
40301 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
40370 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40376 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40382 bool UnSubscribe(
EventHandler const & in_handler)
const;
40388 bool UnSubscribe(intptr_t in_type)
const;
40393 bool InjectEvent(
Event const & in_event)
const;
40403 void Shutdown()
const;
40407 bool IsShutdown()
const;
40412 void SetName(
char const * in_name)
const;
40416 void ShowName(
UTF8 & out_name)
const;
40420 virtual void Reset() {}
40459 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40465 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40473 void UnSubscribeEverything()
const;
40476 virtual void Reset() { UnSubscribeEverything(); }
40506 channel = GetClassID();
40507 consumable =
false;
40515 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
40534 HPS_UNREFERENCED(in_that_event);
40539 return GetClassID();
40557 channel = GetClassID();
40558 consumable =
false;
40559 action = Action::None;
40563 :
Event(), action(in_action), results(in_results), options(in_options)
40565 channel = GetClassID();
40566 consumable =
false;
40573 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
40576 action = that.action;
40577 results = that.results;
40578 options = that.options;
40619 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
40623 code =
event->code;
40646 return message == in_that.
message && code == in_that.
code;
40654 return Equals(in_that);
40662 return !Equals(in_that);
40679 WarningEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40690 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
40694 code =
event->code;
40717 return message == in_that.
message && code == in_that.
code;
40725 return Equals(in_that);
40733 return !Equals(in_that);
40750 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40761 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
40765 code =
event->code;
40788 return message == in_that.
message && code == in_that.
code;
40796 return Equals(in_that);
40804 return !Equals(in_that);
40839 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40865 return action == in_that.
action;
40873 return Equals(in_that);
40881 return !Equals(in_that);
40894 { channel = GetClassID(); }
40922 if(in_event.
GetChannel() == Object::ClassID<UpdateCompletedEvent>())
40925 update_time =
event->update_time;
40953 , import_status_message(HPS::
UTF8())
40954 { channel = GetClassID(); }
40958 , import_status_message(in_message)
40959 { channel = GetClassID(); }
40965 if (in_event.
GetChannel() == Object::ClassID<ImportStatusEvent>())
40968 import_status_message =
event.import_status_message;
40999 return modifiers == in_that.modifiers;
41007 return Equals(in_that);
41015 return !Equals(in_that);
41020 bool None()
const {
return modifiers == _key_none; }
41024 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
41028 bool Control()
const {
return (modifiers & _key_control) != 0; }
41032 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
41036 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
41042 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41052 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
41056 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
41060 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
41064 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
41072 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41082 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41119 _key_none = 0x0000,
41120 _key_shift = 0x0001,
41121 _key_control = 0x0002,
41123 _key_meta = 0x0008,
41166 return Equals(in_that);
41174 return !Equals(in_that);
41182 return ModifierKeyState;
41209 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41217 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41226 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41233 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
41236 channel = GetClassID();
41237 CurrentAction =
event->CurrentAction;
41238 Touches =
event->Touches;
41239 ModifierKeyState =
event->ModifierKeyState;
41269 return Equals(in_that);
41277 return !Equals(in_that);
41287 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
41288 && Touches.size() == that_touch_event->
Touches.size() )
41290 TouchArray these_touches = Touches;
41291 TouchArray those_touches = that_touch_event->
Touches;
41293 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41294 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41296 for (
size_t i = 0 ; i < these_touches.size() ; i++)
41298 if (these_touches[i].ID != those_touches[i].ID)
41312 Touches.assign(in_touches, in_touches + in_touch_count);
41319 Touches = in_touches;
41331 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
41333 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
41350 return buttons == in_that.buttons;
41358 return Equals(in_that);
41366 return !Equals(in_that);
41371 bool None()
const {
return buttons == _button_none; }
41375 bool Left()
const {
return (buttons & _button_left) != 0; }
41379 bool Right()
const {
return (buttons & _button_right) != 0; }
41383 bool Middle()
const {
return (buttons & _button_middle) != 0; }
41387 bool X1()
const {
return (buttons & _button_x1) != 0; }
41391 bool X2()
const {
return (buttons & _button_x2) != 0; }
41397 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41406 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
41410 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
41414 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
41418 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
41422 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
41430 ret.buttons = buttons | in_buttons_to_merge.buttons;
41440 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41481 _button_none = 0x0000,
41482 _button_left = 0x0001,
41483 _button_right = 0x0002,
41484 _button_middle = 0x0004,
41485 _button_x1 = 0x0008,
41486 _button_x2 = 0x0010
41519 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41529 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41535 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
41538 channel = GetClassID();
41539 CurrentAction =
event->CurrentAction;
41540 Location =
event->Location;
41541 CurrentButton =
event->CurrentButton;
41542 WheelDelta =
event->WheelDelta;
41543 ClickCount =
event->ClickCount;
41576 return Equals(in_that);
41584 return !Equals(in_that);
41595 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41604 if (CurrentAction == Action::Move)
41605 return GetClassID();
41638 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41646 :
InputEvent(in_modifiers), CurrentAction(in_action)
41648 channel = GetClassID();
41649 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41657 :
InputEvent(in_modifiers), CurrentAction(in_action)
41659 channel = GetClassID();
41660 KeyboardCodes = in_keyboardcodes;
41667 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
41670 channel = GetClassID();
41671 KeyboardCodes =
event->KeyboardCodes;
41672 CurrentAction =
event->CurrentAction;
41703 return Equals(in_that);
41711 return !Equals(in_that);
41719 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41726 KeyboardCodes = in_keyboardcodes;
41771 bool Equals(
MouseState const & in_that)
const;
41776 bool operator== (
MouseState const & in_that)
const;
41781 bool operator!= (
MouseState const & in_that)
const;
41809 HPS::KeyArray GetEventPath()
const;
41825 void SetActiveEvent(
MouseEvent const & in_event);
41829 void SetEventPath(KeyArray
const & in_path);
41883 bool Equals(
TouchState const & in_that)
const;
41888 bool operator== (
TouchState const & in_that)
const;
41893 bool operator!= (
TouchState const & in_that)
const;
41914 HPS::KeyArray GetEventPath()
const;
41918 size_t GetTouchCount()
const;
41922 HPS::TouchArray GetTouches()
const;
41930 void SetActiveEvent(
TouchEvent const & in_event);
41934 void SetEventPath(KeyArray
const & in_path);
41938 void SetTouches(TouchArray
const & in_touches);
42015 HPS::KeyArray GetEventPath()
const;
42019 size_t GetKeyboardCodeCount()
const;
42023 HPS::KeyboardCodeArray GetKeyboardCodes()
const;
42028 bool GetKeyState(HPS::KeyboardCode in_key_code)
const;
42040 void SetEventPath(KeyArray
const & in_path);
42044 void SetKeyboardCodes(KeyboardCodeArray
const & in_keyboard_codes);
42096 IOResult Status()
const;
42101 IOResult Status(
float & out_percent_complete)
const;
42142 virtual void Restart();
42147 static Toolkit CreateToolkit();
42172 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportOptionsKit; };
42189 bool Empty()
const;
42232 bool ShowSegment(
SegmentKey & out_segment)
const;
42247 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42262 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42292 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportResultsKit; };
42309 bool Empty()
const;
42341 bool ShowSegment(
SegmentKey & out_segment)
const;
42359 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42377 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42393 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
42401 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
42412 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
42448 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportOptionsKit; };
42465 bool Empty()
const;
42493 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
42502 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
42509 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
42518 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
42527 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
42551 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
42602 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
42608 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
42614 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
42620 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
42626 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
42631 bool ShowConnectivityCompression(
bool & out_state)
const;
42637 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
42642 bool ShowSerializeTristrips(
bool & out_state)
const;
42675 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportNotifier;};
42722 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportNotifier;};
42795 DotsPerCentimeter = DPCM,
42827 HPS::Type
ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
42844 bool Empty()
const;
42869 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
42909 bool ShowWYSIWYG(
bool & out_onoff)
const;
42952 static IOResult Export(
char const * in_filename, Driver in_driver_type,
HPS::WindowKey const & in_window, ExportOptionsKit
const & in_options);
42963 class HPS_API ExportOptionsKit :
public Object
42967 ExportOptionsKit();
42971 ExportOptionsKit(ExportOptionsKit
const & in_kit);
42976 ExportOptionsKit(ExportOptionsKit && in_that);
42981 ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42983 virtual ~ExportOptionsKit();
42985 HPS::Type ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
42989 void Set(ExportOptionsKit
const & in_kit);
42993 void Show(ExportOptionsKit & out_kit)
const;
42998 ExportOptionsKit & operator=(ExportOptionsKit
const & in_kit);
43002 bool Empty()
const;
43007 bool Equals(ExportOptionsKit
const & in_kit)
const;
43012 bool operator==(ExportOptionsKit
const & in_kit)
const;
43017 bool operator!=(ExportOptionsKit
const & in_kit)
const;
43025 bool ShowResolution(
float & out_resolution)
const;
43030 ExportOptionsKit & SetResolution(
float in_resolution);
43034 ExportOptionsKit & UnsetResolution();
43041 bool ShowWYSIWYG(
bool & out_onoff)
const;
43046 ExportOptionsKit & SetWYSIWYG(
bool in_onoff);
43050 ExportOptionsKit & UnsetWYSIWYG();
43055 ExportOptionsKit & UnsetEverything();
43064 static IOResult Export(intptr_t hdc, intptr_t attribdc,
HPS::WindowKey const & window, ExportOptionsKit
const & options);
43107 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportOptionsKit; };
43124 bool Empty()
const;
43154 bool ShowSegment(
SegmentKey & out_segment)
const;
43169 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43215 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportResultsKit; };
43232 bool Empty()
const;
43264 bool ShowSegment(
SegmentKey & out_segment)
const;
43282 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43406 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportOptionsKit; };
43423 bool Empty()
const;
43485 bool ShowSegment(
SegmentKey & out_segment)
const;
43517 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportResultsKit; };
43534 bool Empty()
const;
43566 bool ShowSegment(
SegmentKey & out_segment)
const;
43644 # pragma warning(pop)
HPS::Type ObjectType() const
Definition: hps.h:39876
Rotation
Definition: hps.h:1588
HPS::Type ObjectType() const
Definition: hps.h:26844
bool Empty() const
Definition: hps.h:6815
CameraPoint(Point const &in_point)
Definition: hps.h:5766
Alignment
Definition: hps.h:1521
Space
Definition: hps.h:554
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41611
Channel
Definition: hps.h:938
HPS::Type ObjectType() const
Definition: hps.h:24014
Handedness
Definition: hps.h:1269
ColorSource
Definition: hps.h:1914
HPS::Type ObjectType() const
Definition: hps.h:16966
HPS::Type ObjectType() const
Definition: hps.h:36178
Event(intptr_t in_channel=0)
Definition: hps.h:6119
HPS::Type ObjectType() const
Definition: hps.h:43336
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3744
float alpha
Definition: hps.h:4283
HPS::Type ObjectType() const
Definition: hps.h:35785
bool operator==(Touch const &in_that) const
Definition: hps.h:6409
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41052
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40808
HPS::Type ObjectType() const
Definition: hps.h:38221
HPS::Type ObjectType() const
Definition: hps.h:34249
HPS::Type ObjectType() const
Definition: hps.h:21744
HPS::Type ObjectType() const
Definition: hps.h:23542
HPS::Type ObjectType() const
Definition: hps.h:24288
Action
Definition: hps.h:41194
Orientation
Definition: hps.h:530
Code
Definition: hps.h:127
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1324
Multiline strings will be left justfied.
HPS::Type ObjectType() const
Definition: hps.h:14849
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40863
HPS::Type ObjectType() const
Definition: hps.h:8601
HPS::Type ObjectType() const
Definition: hps.h:28072
Event * Clone() const
Definition: hps.h:40706
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41528
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40494
ImportStatusEvent()
Definition: hps.h:40951
HPS::Type ObjectType() const
Definition: hps.h:21361
HPS::Type ObjectType() const
Definition: hps.h:35960
HPS::Type ObjectType() const
Definition: hps.h:25807
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41259
HPS::Type ObjectType() const
Definition: hps.h:30112
HPS::Type ObjectType() const
Definition: hps.h:25418
HPS::Type ObjectType() const
Definition: hps.h:11539
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40755
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41717
HPS::Type ObjectType() const
Definition: hps.h:37672
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5663
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5911
Driver
Definition: hps.h:147
HPS::Type ObjectType() const
Definition: hps.h:41757
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2185
HPS::Type ObjectType() const
Definition: hps.h:39020
CappingLevel
Definition: hps.h:1720
HPS::Type ObjectType() const
Definition: hps.h:23269
HPS::Type ObjectType() const
Definition: hps.h:35713
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12677
HPS::Type ObjectType() const
Definition: hps.h:41869
HPS::Type ObjectType() const
Definition: hps.h:20405
HPS::Type ObjectType() const
Definition: hps.h:13694
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5523
HPS::Type ObjectType() const
Definition: hps.h:28857
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3851
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41656
static ModifierKeys KeyMeta()
Definition: hps.h:41111
HPS::Type ObjectType() const
Definition: hps.h:35448
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:36827
HPS::Type ObjectType() const
Definition: hps.h:42722
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3730
HPS::Type ObjectType() const
Definition: hps.h:39192
HPS::Type ObjectType() const
Definition: hps.h:23467
HPS::Type ObjectType() const
Definition: hps.h:35019
HPS::Type ObjectType() const
Definition: hps.h:16675
HPS::Type ObjectType() const
Definition: hps.h:38261
Time GetTimeStamp() const
Definition: hps.h:6141
HPS::Type ObjectType() const
Definition: hps.h:22262
NormalizedPoint(Point const &in_point)
Definition: hps.h:5816
HPS::Type ObjectType() const
Definition: hps.h:23816
Event * Clone() const
Definition: hps.h:40523
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3779
Renderer
Definition: hps.h:1569
HPS::Type ObjectType() const
Definition: hps.h:33985
KeyboardEvent()
Definition: hps.h:41632
HPS::Type ObjectType() const
Definition: hps.h:7328
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3972
ObjectPoint(Point const &in_point)
Definition: hps.h:5666
HPS::Type ObjectType() const
Definition: hps.h:17553
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3714
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40837
static ModifierKeys KeyAlt()
Definition: hps.h:41107
bool IsConsumable() const
Definition: hps.h:6144
MaterialPreference
Definition: hps.h:1737
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41645
Mobility
Definition: hps.h:187
HPS::Type ObjectType() const
Definition: hps.h:13187
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5864
InterpolationAlgorithm
Definition: hps.h:1504
Fill
Definition: hps.h:1905
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3767
HPS::Type ObjectType() const
Definition: hps.h:27349
HPS::Type ObjectType() const
Definition: hps.h:19046
char At(size_t in_index) const
Definition: hps.h:6858
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41047
HPS::Type ObjectType() const
Definition: hps.h:35840
ReferenceFrame
Definition: hps.h:1536
HPS::Type ObjectType() const
Definition: hps.h:16882
GreekingUnits
Definition: hps.h:1623
HPS::Type ObjectType() const
Definition: hps.h:12089
InnerConeUnits
Definition: hps.h:479
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5960
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3884
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40913
OuterConeUnits
Definition: hps.h:465
HPS::Type ObjectType() const
Definition: hps.h:18830
HPS::Type ObjectType() const
Definition: hps.h:40344
HPS::Type ObjectType() const
Definition: hps.h:39289
HPS::Type ObjectType() const
Definition: hps.h:14290
HPS::Type ObjectType() const
Definition: hps.h:33468
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41724
HPS::Type ObjectType() const
Definition: hps.h:26743
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41283
HPS::Type ObjectType() const
Definition: hps.h:12560
HPS::Type ObjectType() const
Definition: hps.h:25000
HPS::Type ObjectType() const
Definition: hps.h:36291
Channel
Definition: hps.h:897
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40737
AreaUnits
Definition: hps.h:1450
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3821
HPS::Type ObjectType() const
Definition: hps.h:11912
HPS::Type ObjectType() const
Definition: hps.h:34605
Action
Definition: hps.h:40819
HPS::Type ObjectType() const
Definition: hps.h:14128
HPS::Type ObjectType() const
Definition: hps.h:42448
HPS::Type ObjectType() const
Definition: hps.h:27450
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6424
HPS::Type ObjectType() const
Definition: hps.h:37790
HPS::Type ObjectType() const
Definition: hps.h:34122
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41216
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3930
Border
Definition: hps.h:257
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41042
HPS::Type ObjectType() const
Definition: hps.h:23019
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41693
HPS::Type ObjectType() const
Definition: hps.h:21286
WarningEvent(Event const &in_event)
Definition: hps.h:40688
HPS::Type ObjectType() const
Definition: hps.h:11415
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1924
static ModifierKeys KeyShift()
Definition: hps.h:41099
HPS::Type ObjectType() const
Definition: hps.h:28583
Shape
Definition: hps.h:1066
bool IsValid() const
Definition: hps.h:6808
Cuboid_3D()
Definition: hps.h:3722
ErrorEvent(Event const &in_event)
Definition: hps.h:40759
size_t GetWStrLength() const
Definition: hps.h:6837
Event * Clone() const
Definition: hps.h:40588
HPS::Type ObjectType() const
Definition: hps.h:11006
AppendMode
Definition: hps.h:325
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3915
void Meta(bool in_state)
Definition: hps.h:41064
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6059
HPS::Type ObjectType() const
Definition: hps.h:14558
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3772
HPS::Type ObjectType() const
Definition: hps.h:38373
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40884
Quality
Definition: hps.h:1050
ResolutionUnits
Definition: hps.h:42791
TimerTickEvent(Event const &in_event)
Definition: hps.h:40513
Component
Definition: hps.h:345
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6010
HPS::Type ObjectType() const
Definition: hps.h:12176
Default
Definition: hps.h:1878
HPS::Type ObjectType() const
Definition: hps.h:10636
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5057
bool Shift() const
Definition: hps.h:41024
SizeToleranceUnits
Definition: hps.h:1610
HPS::Type ObjectType() const
Definition: hps.h:38497
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4001
Cap
Definition: hps.h:1829
Point_3D< F > max
Definition: hps.h:3716
HPS::Type ObjectType() const
Definition: hps.h:7408
HPS::Type ObjectType() const
Definition: hps.h:43107
HPS::Type ObjectType() const
Definition: hps.h:43215
MouseEvent()
Definition: hps.h:41510
HPS::Type ObjectType() const
Definition: hps.h:12017
HPS::Type ObjectType() const
Definition: hps.h:16584
HPS::Type ObjectType() const
Definition: hps.h:35064
Material Texture Channel.
static const float Infinity
Definition: hps.h:2180
InsetBehavior
Definition: hps.h:1810
HPS::Type ObjectType() const
Definition: hps.h:24926
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2193
HPS::Type ObjectType() const
Definition: hps.h:13582
HPS::Type ObjectType() const
Definition: hps.h:27043
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6423
HPS::Type ObjectType() const
Definition: hps.h:35254
HPS::Type ObjectType() const
Definition: hps.h:37517
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3894
Algorithm
Definition: hps.h:1438
Decimation
Definition: hps.h:1007
Granularity
Definition: hps.h:1359
Parameterization
Definition: hps.h:37904
Search the current segment only.
KeyboardEvent(Event const &in_event)
Definition: hps.h:41665
ClipOperation
Definition: hps.h:1298
HPS::Type ObjectType() const
Definition: hps.h:8853
Method
Definition: hps.h:1428
HPS::Type ObjectType() const
Definition: hps.h:26463
Parameterization
Definition: hps.h:952
FocusLostEvent()
Definition: hps.h:40892
CuttingLevel
Definition: hps.h:1729
Channel
Definition: hps.h:918
HandleResult
Definition: hps.h:40484
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5069
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40807
Value
Definition: hps.h:1409
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2201
HPS::Type ObjectType() const
Definition: hps.h:25959
Event * Clone() const
Definition: hps.h:40900
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41564
ErrorEvent()
Definition: hps.h:40746
Justification
Definition: hps.h:1544
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:13952
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5541
ErrorEvent(char const *in_message)
Definition: hps.h:40750
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:40920
FrameSize
Definition: hps.h:198
Justification
Definition: hps.h:1846
HPS::Type ObjectType() const
Definition: hps.h:11737
HPS::Type ObjectType() const
Definition: hps.h:19687
HPS::Type ObjectType() const
Definition: hps.h:22093
HPS::Type ObjectType() const
Definition: hps.h:8648
HPS::Type ObjectType() const
Definition: hps.h:36781
HPS::Type ObjectType() const
Definition: hps.h:34968
GreekingMode
Definition: hps.h:1635
HPS::Type ObjectType() const
Definition: hps.h:20197
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41729
Operation
Definition: hps.h:448
HPS::Type ObjectType() const
Definition: hps.h:37362
Type
Definition: hps.h:1992
WorldPoint(Point const &in_point)
Definition: hps.h:5716
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41323
HPS::Type ObjectType() const
Definition: hps.h:9835
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2472
HPS::Type ObjectType() const
Definition: hps.h:6655
TouchEvent(Event const &in_event)
Definition: hps.h:41231
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41317
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6940
Relation
Definition: hps.h:371
Action
Definition: hps.h:41624
ChannelMapping
Definition: hps.h:1021
HPS::Type ObjectType() const
Definition: hps.h:22611
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5558
HPS::Type ObjectType() const
Definition: hps.h:38839
HPS::Type ObjectType() const
Definition: hps.h:39478
bool Alt() const
Definition: hps.h:41032
ToleranceUnits
Definition: hps.h:354
HPS::Type ObjectType() const
Definition: hps.h:12487
SizeUnits
Definition: hps.h:1797
Type
Definition: hps.h:2009
The vertex colors applied to faces.
RelationTest
Definition: hps.h:381
Type
Definition: hps.h:316
HPS::Type ObjectType() const
Definition: hps.h:14702
Behavior
Definition: hps.h:563
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6730
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41730
HPS::Type ObjectType() const
Definition: hps.h:18596
ImageFormat
Definition: hps.h:213
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5532
float blue
Definition: hps.h:4282
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:421
HPS::Type ObjectType() const
Definition: hps.h:21025
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6958
PixelPoint(Point const &in_point)
Definition: hps.h:6062
HPS::Type ObjectType() const
Definition: hps.h:6184
HPS::Type ObjectType() const
Definition: hps.h:7047
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41590
HPS::Type ObjectType() const
Definition: hps.h:21622
HPS::Type ObjectType() const
Definition: hps.h:21502
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
HPS::Type ObjectType() const
Definition: hps.h:35207
HPS::Type ObjectType() const
Definition: hps.h:28726
HPS::Type ObjectType() const
Definition: hps.h:24087
HPS::Type ObjectType() const
Definition: hps.h:39118
HPS::Type ObjectType() const
Definition: hps.h:20887
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41610
Event * Clone() const
Definition: hps.h:40978
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5063
HPS::Type ObjectType() const
Definition: hps.h:34519
HPS::Type ObjectType() const
Definition: hps.h:40453
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS::Type ObjectType() const
Definition: hps.h:15733
Infinite line which extends infinitely in both directions along a vector.
intptr_t GetChannel() const
Definition: hps.h:6138
HPS::Type ObjectType() const
Definition: hps.h:9206
Algorithm
Definition: hps.h:1351
HPS::Type ObjectType() const
Definition: hps.h:31198
HPS::Type ObjectType() const
Definition: hps.h:37833
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3839
Driver
Definition: hps.h:42941
SizeUnits
Definition: hps.h:1665
StandAloneWindowEvent()
Definition: hps.h:40828
HPS::Type ObjectType() const
Definition: hps.h:36360
HPS::Type ObjectType() const
Definition: hps.h:34357
HPS::Type ObjectType() const
Definition: hps.h:12325
HPS::Type ObjectType() const
Definition: hps.h:11156
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40715
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41518
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5504
HPS::Type ObjectType() const
Definition: hps.h:17393
Level
Definition: hps.h:1342
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:40997
void Control(bool in_state)
Definition: hps.h:41056
HPS::Type ObjectType() const
Definition: hps.h:42675
HPS::Type ObjectType() const
Definition: hps.h:18104
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3986
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:40736
The base class of all HPS exceptions.
Definition: hps.h:5496
RegionAlignment
Definition: hps.h:1644
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41225
Event * Clone() const
Definition: hps.h:41555
HPS::Type ObjectType() const
Definition: hps.h:21174
void Invalidate()
Definition: hps.h:3784
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4778
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5555
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40916
HPS::Type ObjectType() const
Definition: hps.h:33845
HPS::Type ObjectType() const
Definition: hps.h:39715
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6131
char const * GetBytes() const
Definition: hps.h:6844
virtual intptr_t Freshen() const
Definition: hps.h:41602
HPS::Type ObjectType() const
Definition: hps.h:35316
float green
Definition: hps.h:4281
Action
Definition: hps.h:41499
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1689
HPS::Type ObjectType() const
Definition: hps.h:10240
HPS::Type ObjectType() const
Definition: hps.h:27115
HPS::Type ObjectType() const
Definition: hps.h:24605
HPS::Type ObjectType() const
Definition: hps.h:24361
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:37885
HPS::Type ObjectType() const
Definition: hps.h:24728
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5963
ImportStatusEvent(Event const &in_event)
Definition: hps.h:40963
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5813
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6403
static const float NegativeInfinity
Definition: hps.h:2182
HighlightEvent(Event const &in_event)
Definition: hps.h:40571
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6949
SizeUnits
Definition: hps.h:1470
HPS::Type ObjectType() const
Definition: hps.h:12763
HPS::Type ObjectType() const
Definition: hps.h:20583
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41612
HPS::Type ObjectType() const
Definition: hps.h:10461
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5914
GatheringLevel
Definition: hps.h:1745
HPS::Type ObjectType() const
Definition: hps.h:28936
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3751
FrameOptions
Definition: hps.h:207
HPS::Type ObjectType() const
Definition: hps.h:35157
Space
Definition: hps.h:8559
void Alt(bool in_state)
Definition: hps.h:41060
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41637
HPS::Type ObjectType() const
Definition: hps.h:37089
Type
Definition: hps.h:251
bool operator!=(Touch const &in_that) const
Definition: hps.h:6417
Type
Definition: hps.h:439
HPS::Type ObjectType() const
Definition: hps.h:42172
HPS::Type ObjectType() const
Definition: hps.h:43517
HPS::Type ObjectType() const
Definition: hps.h:38085
HPS::Type ObjectType() const
Definition: hps.h:43406
HPS::Type ObjectType() const
Definition: hps.h:33576
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5713
HPS::Type ObjectType() const
Definition: hps.h:9396
HPS::Type ObjectType() const
Definition: hps.h:43603
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6931
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41310
Event * Clone() const
Definition: hps.h:41250
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40786
Event * Clone() const
Definition: hps.h:40854
size_t GetLength() const
Definition: hps.h:6829
HPS::Type ObjectType() const
Definition: hps.h:20974
HPS::Type ObjectType() const
Definition: hps.h:26673
Type
Definition: hps.h:1127
HPS::Type ObjectType() const
Definition: hps.h:9314
bool None() const
Definition: hps.h:41020
size_t ClickCount
The number of clicks received.
Definition: hps.h:41614
virtual intptr_t Freshen() const
Definition: hps.h:6135
void Reset()
Definition: hps.h:6824
HPS::Type ObjectType() const
Definition: hps.h:37619
HPS::Type ObjectType() const
Definition: hps.h:23742
HPS::Type ObjectType() const
Definition: hps.h:39819
SizeUnits
Definition: hps.h:1598
Event * Clone() const
Definition: hps.h:40777
MouseEvent(Event const &in_event)
Definition: hps.h:41533
virtual bool Empty() const
Definition: hps.h:5596
Join
Definition: hps.h:1820
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3908
Modifier
Definition: hps.h:1857
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41208
HighlightEvent()
Definition: hps.h:40555
virtual HPS::Type ObjectType() const
Definition: hps.h:5592
HPS::Type ObjectType() const
Definition: hps.h:13775
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41322
Type
Definition: hps.h:574
virtual intptr_t Freshen() const
Definition: hps.h:40538
Background
Definition: hps.h:232
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3828
static ModifierKeys KeyControl()
Definition: hps.h:41103
HPS::Type ObjectType() const
Definition: hps.h:18316
HPS::Type ObjectType() const
Definition: hps.h:35570
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5861
HPS::Type ObjectType() const
Definition: hps.h:39611
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40833
Mode
Definition: hps.h:1710
Event * Clone() const
Definition: hps.h:40937
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4045
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3863
Type
Definition: hps.h:877
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3816
HPS::Type ObjectType() const
Definition: hps.h:12234
HPS::Type ObjectType() const
Definition: hps.h:32275
HPS::Type ObjectType() const
Definition: hps.h:37717
HPS::Type ObjectType() const
Definition: hps.h:42292
HPS::Type ObjectType() const
Definition: hps.h:41970
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3802
HPS::Type ObjectType() const
Definition: hps.h:36872
HPS::Type ObjectType() const
Definition: hps.h:12383
HPS::Type ObjectType() const
Definition: hps.h:17859
Mode
Definition: hps.h:1763
Event * Clone() const
Definition: hps.h:41684
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3874
Tiling
Definition: hps.h:980
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4030
WindowPoint(Point const &in_point)
Definition: hps.h:6013
Transform
Definition: hps.h:1553
HPS::Type ObjectType() const
Definition: hps.h:37187
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:38544
ModifierKeys()
Definition: hps.h:40992
Preference
Definition: hps.h:1578
HPS::Type ObjectType() const
Definition: hps.h:25280
Capping
Definition: hps.h:519
HPS::Type ObjectType() const
Definition: hps.h:35388
TouchEvent()
Definition: hps.h:41202
Interpolation
Definition: hps.h:996
HPS::Type ObjectType() const
Definition: hps.h:19958
WarningEvent(char const *in_message)
Definition: hps.h:40679
HPS::Type ObjectType() const
Definition: hps.h:20751
Modifiers
Definition: hps.h:41117
Component
Definition: hps.h:511
HPS::Type ObjectType() const
Definition: hps.h:35878
HPS::Type ObjectType() const
Definition: hps.h:6520
HPS::Type ObjectType() const
Definition: hps.h:22524
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4015
HPS::Type ObjectType() const
Definition: hps.h:42827
HPS::Type ObjectType() const
Definition: hps.h:22314
Format
Definition: hps.h:37050
WarningEvent()
Definition: hps.h:40675
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40532
Touch()
Definition: hps.h:6397
Component
Definition: hps.h:401
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4280
ClipSpace
Definition: hps.h:1306
Control & operator=(Control &&in_that)
Definition: hps.h:5649
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40684
HPS::Type ObjectType() const
Definition: hps.h:13880
SizeUnits
Definition: hps.h:42784
virtual void Reset()
Definition: hps.h:40476
HPS::Type ObjectType() const
Definition: hps.h:11271
bool Meta() const
Definition: hps.h:41036
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4057
TimerTickEvent()
Definition: hps.h:40504
HPS::Type ObjectType() const
Definition: hps.h:21977
RenderingAlgorithm
Definition: hps.h:268
EmergencyHandler()
Definition: hps.h:40019
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5763
TouchID ID
TouchID for this Touch.
Definition: hps.h:6422
HPS::Type ObjectType() const
Definition: hps.h:10837
HPS::Type ObjectType() const
Definition: hps.h:33237
HPS::Type ObjectType() const
Definition: hps.h:8422
HandednessOptimization
Definition: hps.h:362
Projection
Definition: hps.h:1388
Control(Control &&in_that)
Definition: hps.h:5644
bool Control() const
Definition: hps.h:41028
HPS::Type ObjectType() const
Definition: hps.h:34756
Overlay
Definition: hps.h:1278
HPS::Type ObjectType() const
Definition: hps.h:37953
Status
Definition: hps.h:6111
HPS::Type ObjectType() const
Definition: hps.h:34886
HPS::Type ObjectType() const
Definition: hps.h:6602
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:41613
HPS::Type ObjectType() const
Definition: hps.h:42080