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
76 # if !defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
80 # define OVERRIDE override
88 class EventDispatcherImpl;
252 GradientTopLeftToBottomRight,
253 GradientTopRightToBottomLeft,
254 GradientBottomLeftToTopRight,
255 GradientBottomRightToTopLeft,
364 FeatureSizePercentage
565 SubsegmentsAndIncludes
606 Everything = 0x00ffffff,
609 Include = 0x00000042,
610 Segment = 0x00000043,
612 Includer = 0x00000100,
615 Geometry = 0x10000000,
622 NURBSSurface = 0x1000002b,
625 Polygon = 0x1000002f,
628 CircularWedge = 0x10000032,
629 Ellipse = 0x10000033,
631 NURBSCurve = 0x10000037,
632 CircularArc = 0x10000038,
633 EllipticalArc = 0x10000039,
638 Reference = 0x10000040,
641 DistantLight = 0x10000100,
643 InfiniteRay = 0x10000102,
646 Attribute = 0x20000000,
648 Priority = 0x20000001,
653 ModellingMatrix = 0x20000010,
654 UserData = 0x20000021,
655 TextureMatrix = 0x20000023,
658 Culling = 0x20001000,
659 CullingBackFace = 0x20001001,
660 CullingExtent = 0x20001002,
661 CullingVector = 0x20001003,
662 CullingVectorTolerance = 0x20001004,
663 CullingFrustum = 0x20001005,
664 CullingDeferralExtent = 0x20001006,
666 CurveAttribute = 0x20002000,
667 CurveAttributeBudget = 0x20002001,
668 CurveAttributeContinuedBudget = 0x20002002,
669 CurveAttributeViewDependent = 0x20002003,
670 CurveAttributeMaximumDeviation = 0x20002004,
671 CurveAttributeMaximumAngle = 0x20002005,
672 CurveAttributeMaximumLength = 0x20002006,
674 CylinderAttribute = 0x20003000,
675 CylinderAttributeTessellation = 0x20003001,
676 CylinderAttributeOrientation = 0x20003002,
679 EdgeAttribute = 0x20004000,
680 EdgeAttributePattern = 0x20004015,
681 EdgeAttributeWeight = 0x20004016,
683 LightingAttribute = 0x20005000,
684 LightingAttributeInterpolation = 0x20005001,
687 LineAttribute = 0x20006000,
688 LineAttributePattern = 0x20006019,
689 LineAttributeWeight = 0x2000601a,
692 MarkerAttribute = 0x20007000,
693 MarkerAttributeSize = 0x2000701b,
694 MarkerAttributeSymbol = 0x2000701c,
696 SurfaceAttribute = 0x20008000,
697 SurfaceAttributeBudget = 0x20008001,
698 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
699 SurfaceAttributeMaximumFacetAngle = 0x20008003,
700 SurfaceAttributeMaximumFacetWidth = 0x20008004,
701 SurfaceAttributeTrimCurveBudget = 0x20008005,
702 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
705 SelectabilityWindows = 0x20009001,
706 SelectabilityEdges = 0x20009002,
707 SelectabilityFaces = 0x20009003,
708 SelectabilityLights = 0x20009004,
709 SelectabilityLines = 0x20009005,
710 SelectabilityMarkers = 0x20009006,
711 SelectabilityVertices = 0x20009007,
712 SelectabilityText = 0x20009008,
714 SphereAttribute = 0x2000a000,
715 SphereAttributeTessellation = 0x2000a001,
718 SubwindowEitherType = 0x2000b001,
719 SubwindowStandard = 0x2000b00d,
720 SubwindowLightweight = 0x2000b002,
721 SubwindowBackground = 0x2000b003,
722 SubwindowBorder = 0x2000b004,
723 SubwindowRenderingAlgorithm = 0x2000b005,
726 TextAttribute = 0x2000c000,
727 TextAttributeAlignment = 0x2000c01d,
728 TextAttributeBold = 0x2000c002,
729 TextAttributeItalic = 0x2000c003,
730 TextAttributeOverline = 0x2000c004,
731 TextAttributeStrikethrough = 0x2000c005,
732 TextAttributeUnderline = 0x2000c006,
733 TextAttributeSlant = 0x2000c007,
734 TextAttributeLineSpacing = 0x2000c008,
735 TextAttributeRotation = 0x2000c00a,
736 TextAttributeExtraSpace = 0x2000c00b,
737 TextAttributeGreeking = 0x2000c00c,
738 TextAttributeSizeTolerance = 0x2000c00d,
739 TextAttributeSize = 0x2000c00e,
740 TextAttributeFont = 0x2000c00f,
741 TextAttributeTransform = 0x2000c010,
742 TextAttributeRenderer = 0x2000c011,
743 TextAttributePreference = 0x2000c012,
744 TextAttributePath = 0x2000c01f,
745 TextAttributeSpacing = 0x2000c020,
748 TransparencyMethod = 0x2000d001,
749 TransparencyAlgorithm = 0x2000d002,
750 TransparencyDepthPeelingLayers = 0x2000d004,
751 TransparencyDepthPeelingMinimumArea = 0x2000d005,
752 TransparencyDepthWriting = 0x2000d006,
754 Visibility = 0x2000e000,
755 VisibilityCuttingSections = 0x2000e001,
756 VisibilityCutEdges = 0x2000e002,
757 VisibilityCutFaces = 0x2000e003,
758 VisibilityWindows = 0x2000e004,
759 VisibilityText = 0x2000e005,
760 VisibilityLines = 0x2000e006,
761 VisibilityEdgeLights = 0x2000e007,
762 VisibilityMarkerLights = 0x2000e008,
763 VisibilityFaceLights = 0x2000e009,
764 VisibilityGenericEdges = 0x2000e00a,
765 VisibilityHardEdges = 0x2000e00b,
766 VisibilityAdjacentEdges = 0x2000e00c,
767 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
768 VisibilityShadowEmitting = 0x2000e00e,
769 VisibilityShadowReceiving = 0x2000e00f,
770 VisibilityShadowCasting = 0x2000e010,
771 VisibilityMarkers = 0x2000e011,
772 VisibilityVertices = 0x2000e012,
773 VisibilityFaces = 0x2000e013,
774 VisibilityPerimeterEdges = 0x2000e014,
775 VisibilityNonCulledEdges = 0x2000e015,
776 VisibilityMeshQuadEdges = 0x2000e016,
778 VisualEffects = 0x2000f000,
779 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
780 VisualEffectsAntiAliasing = 0x2000f002,
781 VisualEffectsShadowMaps = 0x2000f003,
782 VisualEffectsSimpleShadow = 0x2000f004,
783 VisualEffectsSimpleShadowPlane = 0x2000f005,
784 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
785 VisualEffectsSimpleShadowColor = 0x2000f007,
786 VisualEffectsSimpleReflection = 0x2000f008,
787 VisualEffectsSimpleReflectionPlane = 0x2000f009,
788 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
791 PerformanceDisplayLists = 0x20010001,
792 PerformanceStaticModel = 0x20010002,
793 StaticModelSegment = 0x40000043,
796 DrawingAttribute = 0x20011000,
797 DrawingAttributePolygonHandedness = 0x20011001,
798 DrawingAttributeDepthRange = 0x20011002,
799 DrawingAttributeFaceDisplacement = 0x20011003,
800 DrawingAttributeGeneralDisplacement = 0x20011004,
801 DrawingAttributeVertexDisplacement = 0x20011005,
802 DrawingAttributeOverlay = 0x20011006,
803 DrawingAttributeDeferral = 0x20011007,
804 DrawingAttributeClipRegion = 0x20011012,
805 DrawingAttributeWorldHandedness = 0x20011018,
807 HiddenLineAttribute = 0x20012000,
808 HiddenLineAttributeColor = 0x20012001,
809 HiddenLineAttributeDimFactor = 0x20012002,
810 HiddenLineAttributeFaceDisplacement = 0x20012003,
811 HiddenLineAttributeLinePattern = 0x20012005,
812 HiddenLineAttributeRenderFaces = 0x20012006,
813 HiddenLineAttributeRenderText = 0x20012007,
814 HiddenLineAttributeAlgorithm = 0x20012008,
815 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
816 HiddenLineAttributeVisibility = 0x2001200a,
817 HiddenLineAttributeWeight = 0x2001200b,
818 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
820 SegmentStyle = 0x20013001,
821 NamedStyle = 0x20013002,
822 MaterialPalette = 0x20013003,
823 Portfolio = 0x20013004,
826 ContourLineVisibility = 0x20014001,
827 ContourLinePosition = 0x20014002,
828 ContourLineColor = 0x20014003,
829 ContourLinePattern = 0x20014004,
830 ContourLineWeight = 0x20014005,
831 ContourLineLighting = 0x20014006,
836 BoundingVolume = 0x20016001,
837 BoundingExclusion = 0x20016002,
840 AttributeLockSetting = 0x20017001,
841 AttributeLockSubsegmentOverride = 0x20017002,
843 TransformMask = 0x20018000,
844 TransformMaskCamera = 0x20018001,
845 TransformMaskCameraTranslation = 0x20018002,
846 TransformMaskCameraScale = 0x20018003,
847 TransformMaskCameraOffset = 0x20018004,
848 TransformMaskCameraRotation = 0x20018005,
849 TransformMaskCameraPerspectiveScale = 0x20018006,
850 TransformMaskCameraProjection = 0x20018007,
851 TransformMaskModellingMatrix = 0x20018008,
852 TransformMaskModellingMatrixTranslation = 0x20018009,
853 TransformMaskModellingMatrixScale = 0x20018010,
854 TransformMaskModellingMatrixOffset = 0x20018011,
855 TransformMaskModellingMatrixRotation = 0x20018012,
857 ColorInterpolation = 0x20019000,
858 ColorInterpolationFaceColor = 0x20019001,
859 ColorInterpolationEdgeColor = 0x20019002,
860 ColorInterpolationMarkerColor = 0x20019003,
861 ColorInterpolationFaceIndex = 0x20019004,
862 ColorInterpolationEdgeIndex = 0x20019005,
863 ColorInterpolationMarkerIndex = 0x20019006,
865 CuttingSectionAttribute = 0x2001a000,
866 CuttingSectionAttributeCuttingLevel = 0x2001a001,
867 CuttingSectionAttributeCappingLevel = 0x2001a002,
868 CuttingSectionAttributeMaterialPreference = 0x2001a003,
886 InvalidMaterialIndex = -1,
913 EnvironmentTexture = 8,
914 EnvironmentCubeMap = 9,
953 EnvironmentTexture = 8,
954 EnvironmentCubeMap = 9
1100 GeometryDisplayLists,
1119 AttributeStaticModel,
1120 AttributeSpatialStaticModel
1136 Everything = 0x01000000,
1138 Visibility = 0x02000000,
1140 VisibilityCuttingSections,
1146 VisibilityEdgeLights,
1147 VisibilityMarkerLights,
1148 VisibilityFaceLights,
1149 VisibilityGenericEdges,
1150 VisibilityHardEdges,
1151 VisibilityAdjacentEdges,
1152 VisibilityInteriorSilhouetteEdges,
1153 VisibilityShadowEmitting,
1154 VisibilityShadowReceiving,
1155 VisibilityShadowCasting,
1159 VisibilityPerimeterEdges,
1160 VisibilityNonCulledEdges,
1161 VisibilityMeshQuadEdges,
1162 VisibilityCutGeometry,
1171 MaterialCutGeometry,
1173 MaterialAmbientLightUpColor,
1174 MaterialAmbientLightDownColor,
1175 MaterialAmbientLightColor,
1177 MaterialWindowColor,
1178 MaterialWindowContrastColor,
1182 MaterialMarkerColor,
1184 MaterialCutEdgeColor,
1187 MaterialVertexDiffuse,
1188 MaterialVertexDiffuseColor,
1189 MaterialVertexDiffuseAlpha,
1190 MaterialVertexDiffuseTexture,
1191 MaterialVertexSpecular,
1192 MaterialVertexMirror,
1193 MaterialVertexTransmission,
1194 MaterialVertexEmission,
1195 MaterialVertexEnvironment,
1197 MaterialVertexGloss,
1200 MaterialEdgeDiffuse,
1201 MaterialEdgeDiffuseColor,
1202 MaterialEdgeDiffuseAlpha,
1203 MaterialEdgeDiffuseTexture,
1204 MaterialEdgeSpecular,
1206 MaterialEdgeTransmission,
1207 MaterialEdgeEmission,
1208 MaterialEdgeEnvironment,
1213 MaterialFaceDiffuse,
1214 MaterialFaceDiffuseColor,
1215 MaterialFaceDiffuseAlpha,
1216 MaterialFaceDiffuseTexture,
1217 MaterialFaceSpecular,
1219 MaterialFaceTransmission,
1220 MaterialFaceEmission,
1221 MaterialFaceEnvironment,
1226 MaterialBackFaceDiffuse,
1227 MaterialBackFaceDiffuseColor,
1228 MaterialBackFaceDiffuseAlpha,
1229 MaterialBackFaceDiffuseTexture,
1230 MaterialBackFaceSpecular,
1231 MaterialBackFaceMirror,
1232 MaterialBackFaceTransmission,
1233 MaterialBackFaceEmission,
1234 MaterialBackFaceEnvironment,
1235 MaterialBackFaceBump,
1236 MaterialBackFaceGloss,
1239 MaterialFrontFaceDiffuse,
1240 MaterialFrontFaceDiffuseColor,
1241 MaterialFrontFaceDiffuseAlpha,
1242 MaterialFrontFaceDiffuseTexture,
1243 MaterialFrontFaceSpecular,
1244 MaterialFrontFaceMirror,
1245 MaterialFrontFaceTransmission,
1246 MaterialFrontFaceEmission,
1247 MaterialFrontFaceEnvironment,
1248 MaterialFrontFaceBump,
1249 MaterialFrontFaceGloss,
1252 MaterialCutFaceDiffuse,
1253 MaterialCutFaceDiffuseColor,
1254 MaterialCutFaceDiffuseAlpha,
1255 MaterialCutFaceDiffuseTexture,
1256 MaterialCutFaceSpecular,
1257 MaterialCutFaceMirror,
1258 MaterialCutFaceTransmission,
1259 MaterialCutFaceEmission,
1260 MaterialCutFaceEnvironment,
1261 MaterialCutFaceBump,
1262 MaterialCutFaceGloss,
1568 CharacterPositionOnly,
1571 CharacterPositionAdjusted
1792 UnableToLoadLibraries,
1793 VersionIncompatibility,
1794 InitializationFailed,
1955 TriangleDownWithDot,
1958 TriangleRightWithDot,
1961 TriangleLeftWithDot,
1968 SolidTriangleRightV,
2042 SubsegmentsAndIncludes,
2045 enum class Expansion
2050 IncludesAndReferences,
2060 enum class Reorganization
2069 typedef double Time;
2073 # define HPS_INLINE __forceinline
2076 # define HPS_INLINE inline
2079 #ifndef HPS_UNREFERENCED
2080 #define HPS_UNREFERENCED(param) ((void)(param))
2084 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2086 template<
typename T>
2087 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2089 return degrees * (T)(PI / 180.0);
2092 template<
typename T>
2093 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2095 return radians * (T)(180.0 / PI);
2098 template<
typename T>
2099 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2100 T a = Degrees_To_Radians(angle);
2105 template<
typename T>
2106 HPS_INLINE T Cos(T
const & angle) {
2107 return cos (Degrees_To_Radians(angle));
2110 template<
typename T>
2111 HPS_INLINE T Sin(T
const & angle) {
2112 return sin (Degrees_To_Radians(angle));
2115 template<
typename T>
2116 HPS_INLINE T ACos(T
const & x) {
2121 return Radians_To_Degrees(acos(x));
2124 template<
typename T>
2125 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2126 if (x == 0 && y == 0)
2128 return Radians_To_Degrees(atan2(y, x));
2134 typedef double Alternative;
2135 static const int Type = 1;
2136 static float Epsilon () {
return 1.0e-30f; }
2139 typedef float Alternative;
2140 static const int Type = 2;
2141 static double Epsilon () {
return 1.0e-300; }
2150 # if HOOPS_BIGENDIAN
2158 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2159 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2160 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2161 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2163 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2164 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2165 return exp == 0x7F800000 && mantissa != 0;
2167 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2168 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2169 return exp == 0x7F800000 && mantissa != 0;
2171 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2172 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2173 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2175 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2176 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2177 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2180 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2181 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2182 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2183 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2192 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2193 static HPS_INLINE
bool IsInfinite(
double const & a) {
2195 memcpy (v, &a,
sizeof(
double));
2196 return is_infinite (v);
2200 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2201 static HPS_INLINE
bool IsNAN(
double const & a) {
2203 memcpy (v, &a,
sizeof(
double));
2208 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2209 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2211 memcpy (v, &a,
sizeof(
double));
2212 return is_special (v);
2217 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2218 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2220 #ifndef HOOPS_DEFINED
2221 template <
typename Alloc>
2222 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2224 if (a.size() != b.size())
2227 auto it1 = a.begin();
2228 auto it2 = b.begin();
2229 auto const end = a.end();
2230 for ( ; it1 != end; ++it1, ++it2)
2232 if (!Equals(*it1, *it2, tolerance))
2239 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2240 return extract_uint32_t(a) & 0x80000000;
2242 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2244 memcpy (v, &a,
sizeof(
double));
2245 return v[High] & 0x80000000;
2248 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2249 uint32_t v = extract_uint32_t(a);
2252 inject_uint32_t(a, v);
2254 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2256 memcpy (v, &a,
sizeof(
double));
2257 v[High] &= 0x7FFFFFFF;
2258 v[High] |= sign_bit;
2259 memcpy (&a, v,
sizeof(
double));
2263 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2264 uint32_t v = extract_uint32_t(a);
2272 uint32_t exp = v >> 23;
2273 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2275 return (
unsigned char) (man >> (16 + 126 - exp));
2278 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2279 uint32_t v = extract_uint32_t(a);
2287 uint32_t exp = v >> 23;
2288 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2290 uint32_t x = (man >> (16 + 126 - exp));
2292 return (
unsigned char) ((x * (mix+1)) >> 8);
2296 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2297 uint32_t va = extract_uint32_t(a);
2298 uint32_t vb = extract_uint32_t(b);
2300 if (((va | vb) & 0x7FFFFFFF) == 0)
2305 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2310 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2311 uint32_t va = extract_uint32_t(a);
2312 uint32_t vb = extract_uint32_t(b);
2314 uint32_t a_sign = va & 0x80000000;
2315 uint32_t b_sign = vb & 0x80000000;
2317 (int32_t&)a_sign >>= 31;
2318 (int32_t&)b_sign >>= 31;
2320 uint32_t mash = (a_sign&b_sign);
2325 if ((int32_t&)vb < (int32_t&)va)
2326 memcpy(&a, &b,
sizeof(
float));
2328 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2333 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2334 uint32_t va = extract_uint32_t(a);
2335 uint32_t vb = extract_uint32_t(b);
2337 uint32_t a_sign = va & 0x80000000;
2338 uint32_t b_sign = vb & 0x80000000;
2340 (int32_t&)a_sign >>= 31;
2341 (int32_t&)b_sign >>= 31;
2343 uint32_t mash = (a_sign&b_sign);
2348 if ((int32_t&)vb > (int32_t&)va)
2349 memcpy(&a, &b,
sizeof(
float));
2351 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2357 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2359 memcpy(&i, &a,
sizeof(
float));
2363 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2364 memcpy(&a, &i,
sizeof(
float));
2367 static HPS_INLINE
float C2F(
unsigned char x) {
2369 return char_to_float[x];
2374 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2375 memcpy(&m[0], &f,
sizeof(
float));
2376 memcpy(&m[1], &f,
sizeof(
float));
2377 memcpy(&m[2], &f,
sizeof(
float));
2378 memcpy(&m[3], &f,
sizeof(
float));
2381 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2382 memcpy(&m[0], &f0,
sizeof(
float));
2383 memcpy(&m[1], &f1,
sizeof(
float));
2384 memcpy(&m[2], &f2,
sizeof(
float));
2385 memcpy(&m[3], &f3,
sizeof(
float));
2388 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2389 memcpy(f0, m,
sizeof(
float)*4);
2392 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2393 memcpy(&f0, &m[0],
sizeof(
float));
2394 memcpy(&f1, &m[1],
sizeof(
float));
2395 memcpy(&f2, &m[2],
sizeof(
float));
2396 memcpy(&f3, &m[3],
sizeof(
float));
2400 static const float char_to_float[256];
2409 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2410 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2412 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2413 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2414 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2415 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2416 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2417 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2419 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2420 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2421 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d) {
return Min(Min(a, b, c),d); }
2422 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Min(Min(a,b,c,d),e); }
2423 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Min(Min(a,b,c,d,e),f); }
2425 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2426 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2427 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d) {
return Max(Max(a, b, c),d); }
2428 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Max(Max(a,b,c,d),e); }
2429 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Max(Max(a,b,c,d,e),f); }
2431 template <
typename T> HPS_INLINE T
const & Clamp(T
const & x, T
const & min, T
const & max) {
return x < min ? min : x > max ? max : x; }
2434 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2435 uint32_t v = Float::extract_uint32_t(a);
2438 Float::inject_uint32_t(f,v);
2442 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2443 uint32_t v = Float::extract_uint32_t(a);
2445 if ((v & 0x7FFFFFFF) == 0)
2448 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2451 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2452 int a_sign = Sign(a);
2453 int b_sign = Sign(b);
2455 if (a_sign != b_sign)
2456 return Compare(a_sign, b_sign);
2458 uint32_t v = Float::extract_uint32_t(a);
2459 uint32_t u = Float::extract_uint32_t(b);
2461 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2464 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2470 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2479 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2480 int32_t va = Float::extract_uint32_t(a);
2481 int32_t vb = Float::extract_uint32_t(b);
2483 if (is_special(va) || is_special(vb)) {
2484 if (is_infinite(va) || is_infinite(vb))
2486 if (is_nan(va) || is_nan(vb))
2490 int const close_to_zero = 0x36A00000;
2491 if ((va & 0x7FFFFFFF) == 0)
2492 return (vb & 0x7FFFFFFF) < close_to_zero;
2493 else if ((vb & 0x7FFFFFFF) == 0)
2494 return (va & 0x7FFFFFFF) < close_to_zero;
2496 uint32_t sign_mask = va ^ vb;
2497 (int32_t &)sign_mask >>= 31;
2499 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2500 int32_t v1 = tolerance + diff;
2501 int32_t v2 = tolerance - diff;
2502 return (v1|v2) >= 0;
2505 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2506 int32_t va[2], vb[2];
2507 memcpy (va, &a,
sizeof(
double));
2508 memcpy (vb, &b,
sizeof(
double));
2510 if (is_special(va) || is_special(vb)) {
2511 if (is_infinite(va) || is_infinite(vb))
2512 return va[High] == vb[High] && va[Low] == vb[Low];
2513 if (is_nan(va) || is_nan(vb))
2517 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2518 return Abs(a - b) < 0.000000000000005;
2520 if (extract_sign_bit(a) != extract_sign_bit(b))
2523 if (va[High] != vb[High])
2526 return Abs(va[Low] - vb[Low]) <= tolerance;
2533 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2535 template <
typename T>
2536 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2538 if (Is_Abnormal (*t++))
2543 template <
typename T>
2544 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2545 return count >= 0 && Is_Abnormal((
size_t)count, t);
2552 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2553 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2554 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2555 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2558 template <
typename F>
2566 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2568 template <
typename D>
2569 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2577 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2578 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2580 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2587 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2588 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2589 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2590 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2592 F & operator[] (
size_t i) {
return (&x)[i]; }
2593 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2626 template <
typename F,
typename S>
2629 template <
typename F>
2630 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2631 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2634 template <
typename F>
2635 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2636 return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2639 template <
typename F>
2640 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2641 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2645 template <
typename F>
2652 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2654 template <
typename D>
2662 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2663 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2665 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2670 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2671 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2673 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2675 F & operator[] (
size_t i) {
return (&x)[i]; }
2676 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2697 template <
typename F>
2700 template <
typename F,
typename S>
2701 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F>
const & a) {
return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2703 template <
typename F>
2704 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2705 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2708 template <
typename F>
2709 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2710 return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2713 template <
typename F>
2714 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2715 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2719 template <
typename F>
2727 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2728 template <
typename D>
2737 bool operator== (
Vector_3D const & v)
const {
2738 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2740 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2742 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2748 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2749 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2753 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2754 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2756 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2758 F & operator[] (
size_t i) {
return (&x)[i]; }
2759 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2761 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2763 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2765 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2767 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2771 F range = Max (Abs (x), Abs (y), Abs (z));
2772 if (range > F(1.0e10))
2776 F len = (F)Length();
2783 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2785 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2786 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2788 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2791 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2796 return Vector_3D (x * v.x, y * v.y, z * v.z);
2810 template <
typename F,
typename S>
2813 template <
typename F>
2814 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2815 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2819 template <
typename F>
2820 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2822 template <
typename F>
2823 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F>
const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2824 template <
typename F>
2825 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F>
const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2827 template <
typename F>
2828 HPS_INLINE Vector_3D<F>
const Point_3D<F>::operator- (Point_3D<F>
const & p)
const {
return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2830 template <
typename F>
2831 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2832 template <
typename F>
2833 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2835 template <
typename F>
2836 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F>
const & v) { x *= v.x; y *= v.y; z *= v.z;
return *
this; }
2837 template <
typename F>
2838 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F>
const & v) { x /= v.x; y /= v.y; z /= v.z;
return *
this; }
2839 template <
typename F>
2840 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2841 template <
typename F>
2842 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2846 template <
typename F>
2847 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2848 return a + (b - a) * t;
2851 template <
typename F>
2852 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2853 return Vector_3D<F>(a + (b - a) * t).Normalize();
2858 template <
typename F>
2859 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2860 return (p2 - p1).Length();
2863 template <
typename F>
2864 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2865 return (p2 - p1).LengthSquared();
2868 template <
typename F>
2869 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2870 F p =
static_cast<F
>((c - b).LengthSquared());
2871 F q =
static_cast<F
>((c - a).LengthSquared());
2872 F r =
static_cast<F
>((b - a).LengthSquared());
2875 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2876 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2881 template <
typename F>
2882 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2883 bool success =
true;
2884 for (
size_t i = 0; i < count; ++i) {
2885 if (vectors->Normalize() == Vector_3D<F>::Zero())
2893 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2895 template <
typename F>
2902 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2903 template <
typename D>
2912 bool operator== (
Vector_2D const & v)
const {
2913 return Float::match(x, v.x) && Float::match(y, v.y);
2915 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2917 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2926 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2927 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2929 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2931 F & operator[] (
size_t i) {
return (&x)[i]; }
2932 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2934 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2936 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2940 F range = Max (Abs (x), Abs (y));
2941 if (range > F(1.0e10))
2945 F len = (F)Length();
2952 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2954 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2955 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2957 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2960 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2961 return x * v.y - y * v.x;
2978 template <
typename F,
typename S>
2981 template <
typename F>
2982 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
2983 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2987 template <
typename F>
2988 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
2990 template <
typename F>
2991 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
2993 template <
typename F>
2994 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2995 template <
typename F>
2996 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
2998 template <
typename F>
2999 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z); }
3000 template <
typename F>
3001 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z); }
3003 template <
typename F>
3004 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3005 template <
typename F>
3006 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3008 template <
typename F>
3009 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z); }
3010 template <
typename F>
3011 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z); }
3014 template <
typename F>
3015 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3016 template <
typename F>
3017 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3019 template <
typename F>
3020 HPS_INLINE Vector_2D<F>
const Point_2D<F>::operator- (Point_2D<F>
const & p)
const {
return Vector_2D<F> (x - p.x, y - p.y); }
3022 template <
typename F>
3023 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x + v.x, y + v.y); }
3024 template <
typename F>
3025 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x - v.x, y - v.y); }
3027 template <
typename F>
3028 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3029 template <
typename F>
3030 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3031 template <
typename F>
3032 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x * v.x, y * v.y); }
3033 template <
typename F>
3034 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x / v.x, y / v.y); }
3040 template <
typename F>
3049 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3053 template <
typename D>
3054 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3070 for (
size_t i=0; i<count; ++i) {
3073 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3074 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3075 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3085 double inv_count = 1.0 / (double)count;
3093 *
this = Plane_3D::Zero();
3099 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3100 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3102 F & operator[] (
size_t i) {
return (&a)[i]; }
3103 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3105 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3120 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3121 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3124 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3125 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3126 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3133 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3134 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3136 return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3139 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3143 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3144 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3145 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3146 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3153 template <
typename F>
3154 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3155 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3159 template <
typename F>
3160 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3161 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3163 template <
typename F>
3164 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3165 return plane * point;
3168 template <
typename F>
3169 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3170 return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3173 template <
typename F>
3174 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3181 template <
typename F>
3189 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3193 template <
typename D>
3194 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3198 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3199 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3201 F & operator[] (
size_t i) {
return (&a)[i]; }
3202 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3204 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3221 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3222 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3223 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3224 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3231 template <
typename F>
3232 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3233 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3237 template <
typename F>
3238 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3239 return plane.a * point.x + plane.b * point.y + plane.c;
3241 template <
typename F>
3242 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3243 return plane * point;
3246 template <
typename F>
3247 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3248 return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3251 template <
typename F>
3252 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3266 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3267 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3269 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3270 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3273 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3278 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3282 return !(*
this == rect);
3285 HPS_INLINE
int PixelWidth()
const {
3286 return right - left + 1;
3289 HPS_INLINE
int PixelHeight()
const {
3290 return top - bottom + 1;
3293 HPS_INLINE
int Width()
const {
3294 return right - left;
3297 HPS_INLINE
int Height()
const {
3298 return top - bottom;
3301 HPS_INLINE
int Area()
const {
3302 return Width() * Height();
3305 HPS_INLINE
Point2D Center()
const {
3306 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3309 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3310 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3313 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3314 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3327 right += rect.right;
3328 bottom -= rect.bottom;
3343 right -= rect.right;
3344 bottom += rect.bottom;
3350 left = Max(left, rect.left);
3351 right = Min(right, rect.right);
3352 bottom = Max(bottom, rect.bottom);
3353 top = Min(top, rect.top);
3358 left = Min(left, rect.left);
3359 right = Max(right, rect.right);
3360 bottom = Min(bottom, rect.bottom);
3361 top = Max(top, rect.top);
3378 return temp.Expand(border);
3381 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3382 IntRectangle temp = a;
3383 return temp.Expand(border);
3386 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3387 IntRectangle temp = a;
3388 return temp.Contract(border);
3391 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3392 IntRectangle temp = a;
3393 return temp.Contract(border);
3396 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3397 IntRectangle temp = a;
3398 return temp.Intersect(b);
3401 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3402 IntRectangle temp = a;
3403 return temp.Union(b);
3413 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3414 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3416 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3417 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3420 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3423 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3433 Merge(count, points);
3445 Merge(count, points);
3449 HPS_INLINE
float Width()
const {
3450 return right - left;
3453 HPS_INLINE
float Height()
const {
3454 return top - bottom;
3457 HPS_INLINE
float Area()
const {
3458 return Width() * Height();
3461 HPS_INLINE
Point2D Center()
const {
3462 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3465 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3468 if (Compare(points[0].x, points[1].x)>0) {
3469 Float::replace_if_smaller(left, points[1].x);
3470 Float::replace_if_larger(right, points[0].x);
3473 Float::replace_if_smaller(left, points[0].x);
3474 Float::replace_if_larger(right, points[1].x);
3477 if (Compare(points[0].y, points[1].y)>0) {
3478 Float::replace_if_smaller(bottom, points[1].y);
3479 Float::replace_if_larger(top, points[0].y);
3482 Float::replace_if_smaller(bottom, points[0].y);
3483 Float::replace_if_larger(top, points[1].y);
3494 HPS_INLINE
void Merge(
Point const & point) {
3495 Float::replace_if_smaller(left, point.x);
3496 Float::replace_if_smaller(bottom, point.y);
3497 Float::replace_if_larger(right, point.x);
3498 Float::replace_if_larger(top, point.y);
3501 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3504 if (Compare(points[0].x, points[1].x)>0) {
3505 Float::replace_if_smaller(left, points[1].x);
3506 Float::replace_if_larger(right, points[0].x);
3509 Float::replace_if_smaller(left, points[0].x);
3510 Float::replace_if_larger(right, points[1].x);
3513 if (Compare(points[0].y, points[1].y)>0) {
3514 Float::replace_if_smaller(bottom, points[1].y);
3515 Float::replace_if_larger(top, points[0].y);
3518 Float::replace_if_smaller(bottom, points[0].y);
3519 Float::replace_if_larger(top, points[1].y);
3530 HPS_INLINE
void Merge(
Point2D const & point) {
3531 Float::replace_if_smaller(left, point.x);
3532 Float::replace_if_smaller(bottom, point.y);
3533 Float::replace_if_larger(right, point.x);
3534 Float::replace_if_larger(top, point.y);
3537 bool operator==(
Rectangle const & rect)
const {
3538 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3541 bool operator!=(
Rectangle const & rect)
const {
3542 return !(*
this == rect);
3545 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3546 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3549 HPS_INLINE
bool Contains(
Point const & contained)
const {
3550 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3553 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3554 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3557 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3558 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3561 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3562 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3563 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3566 HPS_INLINE
Rectangle & Expand(
float border) {
3574 HPS_INLINE
Rectangle & Expand(
int border) {
3575 Expand((
float)border);
3581 right += rect.right;
3582 bottom -= rect.bottom;
3587 HPS_INLINE
Rectangle & Contract(
int border) {
3597 right -= rect.right;
3598 bottom += rect.bottom;
3604 left = Max(left, rect.left);
3605 right = Min(right, rect.right);
3606 bottom = Max(bottom, rect.bottom);
3607 top = Min(top, rect.top);
3612 left = Min(left, rect.left);
3613 right = Max(right, rect.right);
3614 bottom = Min(bottom, rect.bottom);
3615 top = Max(top, rect.top);
3620 float scale = (scope.right - scope.left) * 0.5f;
3621 float trans = (scope.right + scope.left) * 0.5f;
3623 left = left * scale + trans;
3624 right = right * scale + trans;
3626 scale = (scope.top - scope.bottom) * 0.5f;
3627 trans = (scope.top + scope.bottom) * 0.5f;
3629 bottom = bottom * scale + trans;
3630 top = top * scale + trans;
3635 float tmp = 2.0f/(scope.right - scope.left);
3636 right = (right - scope.left) * tmp - 1.0f;
3637 left = (left - scope.left) * tmp - 1.0f;
3639 tmp = 2.0f/(scope.top - scope.bottom);
3640 top = (top - scope.bottom) * tmp - 1.0f;
3641 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3645 static HPS_INLINE
Rectangle FullScope() {
3646 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3649 static HPS_INLINE
Rectangle InvalidScope() {
3650 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3662 temp.left = Floor (a.left);
3663 temp.right = Floor (a.right);
3664 temp.bottom = Floor (a.bottom);
3665 temp.top = Floor (a.top);
3669 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3671 return temp.Expand(border);
3674 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3676 return temp.Expand(border);
3679 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3681 return temp.Contract(border);
3684 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3686 return temp.Contract(border);
3689 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3691 return temp.Intersect(b);
3694 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3696 return temp.Union(b);
3699 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3701 return temp.Inscribe_Scope(scope);
3704 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3706 return temp.Circumscribe_Scope(scope);
3709 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3710 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3715 template <
typename F>
3718 template <
typename F>
3731 template <
typename D>
3760 min = Limit_Point();
3761 max = -Limit_Point();
3764 min = max = *points++;
3767 Merge(count, points);
3780 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3797 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3803 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3828 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3836 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3837 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3838 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3847 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3848 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3849 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3860 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3872 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3882 return LineIntersecting(start, direction,
true);
3893 return LineIntersecting(point1, direction,
false);
3902 Float::replace_if_smaller(min.x, cuboid.
min.x);
3903 Float::replace_if_smaller(min.y, cuboid.
min.y);
3904 Float::replace_if_smaller(min.z, cuboid.
min.z);
3905 Float::replace_if_larger(max.x, cuboid.
max.x);
3906 Float::replace_if_larger(max.y, cuboid.
max.y);
3907 Float::replace_if_larger(max.z, cuboid.
max.z);
3923 Float::replace_if_smaller(min.x, point.x);
3924 Float::replace_if_smaller(min.y, point.y);
3925 Float::replace_if_smaller(min.z, point.z);
3926 Float::replace_if_larger(max.x, point.x);
3927 Float::replace_if_larger(max.y, point.y);
3928 Float::replace_if_larger(max.z, point.z);
3939 if (Compare(points[0].x, points[1].x)>0) {
3940 Float::replace_if_smaller(min.x, points[1].x);
3941 Float::replace_if_larger(max.x, points[0].x);
3944 Float::replace_if_smaller(min.x, points[0].x);
3945 Float::replace_if_larger(max.x, points[1].x);
3948 if (Compare(points[0].y, points[1].y)>0) {
3949 Float::replace_if_smaller(min.y, points[1].y);
3950 Float::replace_if_larger(max.y, points[0].y);
3953 Float::replace_if_smaller(min.y, points[0].y);
3954 Float::replace_if_larger(max.y, points[1].y);
3957 if (Compare(points[0].z, points[1].z)>0) {
3958 Float::replace_if_smaller(min.z, points[1].z);
3959 Float::replace_if_larger(max.z, points[0].z);
3962 Float::replace_if_smaller(min.z, points[0].z);
3963 Float::replace_if_larger(max.z, points[1].z);
3980 return (contained.
min.x >= min.x &&
3981 contained.
min.y >= min.y &&
3982 contained.
min.z >= min.z &&
3983 contained.
max.x <= max.x &&
3984 contained.
max.y <= max.y &&
3985 contained.
max.z <= max.z);
3994 return (contained.x >= min.x &&
3995 contained.y >= min.y &&
3996 contained.z >= min.z &&
3997 contained.x <= max.x &&
3998 contained.y <= max.y &&
3999 contained.z <= max.z);
4009 return (contained.x >= min.x - epsilon &&
4010 contained.y >= min.y - epsilon &&
4011 contained.z >= min.z - epsilon &&
4012 contained.x <= max.x + epsilon &&
4013 contained.y <= max.y + epsilon &&
4014 contained.z <= max.z + epsilon);
4023 Float::replace_if_larger(min.x, cuboid.
min.x);
4024 Float::replace_if_larger(min.y, cuboid.
min.y);
4025 Float::replace_if_larger(min.z, cuboid.
min.z);
4026 Float::replace_if_smaller(max.x, cuboid.
max.x);
4027 Float::replace_if_smaller(max.y, cuboid.
max.y);
4028 Float::replace_if_smaller(max.z, cuboid.
max.z);
4038 Float::replace_if_smaller(min.x, cuboid.
min.x);
4039 Float::replace_if_smaller(min.y, cuboid.
min.y);
4040 Float::replace_if_smaller(min.z, cuboid.
min.z);
4041 Float::replace_if_larger(max.x, cuboid.
max.x);
4042 Float::replace_if_larger(max.y, cuboid.
max.y);
4043 Float::replace_if_larger(max.z, cuboid.
max.z);
4073 F
const limit = std::numeric_limits<F>::max();
4077 bool LineIntersecting (Point_3D<F>
const & start, Vector_3D<F>
const & direction,
bool is_ray)
const;
4080 typedef Cuboid_3D<float> SimpleCuboid;
4081 typedef Cuboid_3D<double> DSimpleCuboid;
4084 template <
typename F>
4085 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4086 Cuboid_3D<F> temp = a;
4087 return temp.Intersect(b);
4090 template <
typename F>
4091 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4092 Cuboid_3D<F> temp = a;
4093 return temp.Union(b);
4096 template <
typename F>
4097 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4098 Cuboid_3D<F> temp = a;
4099 return temp.Expand(border);
4102 template <
typename F>
4103 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4104 Cuboid_3D<F> temp = a;
4105 return temp.Contract(border);
4110 template <
typename F>
4111 struct HPS_TEMPLATE_API Sphere_3D {
4115 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4117 template <
typename D>
4118 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4120 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4121 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4123 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4125 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4126 Cuboid_3D<F> cuboid(count, points);
4127 center = Midpoint(cuboid.min, cuboid.max);
4128 Engulf (count, points);
4131 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4132 Engulf (count, points);
4135 HPS_INLINE
bool IsValid()
const {
4139 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4141 void Invalidate() {radius = -1;}
4143 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4144 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4146 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4148 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4149 Vector_3D<F> dir = point - center;
4150 F distance = (F)dir.Length();
4152 if (distance > radius) {
4153 F t = F(0.5) * (distance - radius);
4154 center += t * dir.Normalize();
4159 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4161 for (
size_t i = 0; i < count; ++i) {
4162 Vector_3D<F> dir = *points - center;
4163 F distance = (F)dir.Length();
4165 if (distance > radius) {
4166 F t = F(0.5) * (distance - radius);
4167 center += t * dir.Normalize();
4175 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4176 Vector_3D<F> dir = sphere.center - center;
4177 F distance = (F)dir.Length();
4179 if (distance + sphere.radius > radius) {
4180 if (distance + radius > sphere.radius) {
4181 F t = F(0.5 * (sphere.radius + distance - radius));
4182 center += t * dir.Normalize();
4186 center = sphere.center;
4187 radius = sphere.radius;
4192 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4196 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4197 for (
size_t i = 0; i < count; ++i) {
4198 double dsq = (*points++ - center).LengthSquared();
4199 if ((F)dsq > radius * radius)
4200 radius = (F)sqrt(dsq);
4205 typedef Sphere_3D<float> SimpleSphere;
4206 typedef Sphere_3D<double> DSimpleSphere;
4209 template <
typename F>
4211 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4212 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4230 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4231 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4232 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4233 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4234 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4235 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4237 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4238 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4239 float Distance(RGBColor
const & other_color)
const;
4240 HPS_INLINE
bool IsValid()
const {
4241 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4244 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4245 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4247 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4250 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4251 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4252 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4253 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4254 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4255 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4257 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4258 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4259 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4260 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4261 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4262 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4263 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4264 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4266 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4267 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4268 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4270 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4271 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4272 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4274 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4275 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4276 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4279 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4280 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4281 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4293 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4294 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4296 HPS_INLINE RGBAColor (RGBColor
const & c) {
4297 memcpy(
this, &c,
sizeof(RGBColor));
4299 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4301 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4302 memcpy(
this, &c,
sizeof(RGBColor));
4303 memcpy(&alpha, &a,
sizeof(
float));
4304 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4306 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4307 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4309 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4310 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4311 HPS_INLINE
bool IsValid()
const {
4312 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4329 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4331 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4336 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4337 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4338 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4339 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4340 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4341 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4343 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4344 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4345 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4346 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4347 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4348 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4349 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4350 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4352 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4353 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4354 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4355 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4356 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4357 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4359 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4360 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4361 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4362 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4376 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4377 unsigned char b, g, r, a;
4381 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4382 unsigned char r, g, b, a;
4386 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4387 unsigned char r, g, b, a;
4397 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4403 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4411 explicit HPS_INLINE RGBAS32Color (
RGBColor const & c)
4413 r = Float::unit_to_byte(c.red);
4414 g = Float::unit_to_byte(c.green);
4415 b = Float::unit_to_byte(c.blue);
4419 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4423 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4425 r = Float::unit_to_byte(c.red);
4426 g = Float::unit_to_byte(c.green);
4427 b = Float::unit_to_byte(c.blue);
4428 a = Float::unit_to_byte(alpha);
4430 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4432 r = Float::unit_to_byte(c.red);
4433 g = Float::unit_to_byte(c.green);
4434 b = Float::unit_to_byte(c.blue);
4437 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
4439 r = Float::unit_to_byte(c.
red);
4440 g = Float::unit_to_byte(c.
green);
4441 b = Float::unit_to_byte(c.
blue);
4442 a = Float::unit_to_byte(c.
alpha);
4444 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4446 r = Float::unit_to_byte(c.
red);
4447 g = Float::unit_to_byte(c.
green);
4448 b = Float::unit_to_byte(c.
blue);
4449 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4452 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4453 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4454 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4456 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4457 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4459 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4460 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4461 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4463 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4474 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4475 : r (gray), g (gray), b (gray), a (aa) {}
4476 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4477 : r (rr), g (gg), b (bb), a (aa) {}
4479 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4480 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4481 r = Float::unit_to_byte(c.red);
4482 g = Float::unit_to_byte(c.green);
4483 b = Float::unit_to_byte(c.blue);
4486 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4487 r = Float::unit_to_byte(c.red);
4488 g = Float::unit_to_byte(c.green);
4489 b = Float::unit_to_byte(c.blue);
4490 a = Float::unit_to_byte(alpha);
4492 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4493 r = Float::unit_to_byte(c.red);
4494 g = Float::unit_to_byte(c.green);
4495 b = Float::unit_to_byte(c.blue);
4498 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4499 r = Float::unit_to_byte(c.
red);
4500 g = Float::unit_to_byte(c.
green);
4501 b = Float::unit_to_byte(c.
blue);
4502 a = Float::unit_to_byte(c.
alpha);
4504 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4505 r = Float::unit_to_byte(c.
red);
4506 g = Float::unit_to_byte(c.
green);
4507 b = Float::unit_to_byte(c.
blue);
4508 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4511 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4512 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4514 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4515 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4517 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4518 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4520 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4532 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4533 : r (gray), g (gray), b (gray) {}
4534 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4535 : r (rr), g (gg), b (bb) {}
4536 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4537 r = Float::unit_to_byte(c.red);
4538 g = Float::unit_to_byte(c.green);
4539 b = Float::unit_to_byte(c.blue);
4542 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4543 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4545 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4546 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4549 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4550 red = Float::C2F(c32.r);
4551 green = Float::C2F(c32.g);
4552 blue = Float::C2F(c32.b);
4555 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4556 red = Float::C2F(c32.r);
4557 green = Float::C2F(c32.g);
4558 blue = Float::C2F(c32.b);
4561 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4567 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4568 red = Float::C2F(c24.r);
4569 green = Float::C2F(c24.g);
4570 blue = Float::C2F(c24.b);
4573 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4581 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4589 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
const & c32) {
4590 red = Float::C2F(c32.r);
4591 green = Float::C2F(c32.g);
4592 blue = Float::C2F(c32.b);
4593 alpha = Float::C2F(c32.a);
4596 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4597 red = Float::C2F(c32.r);
4598 green = Float::C2F(c32.g);
4599 blue = Float::C2F(c32.b);
4600 alpha = Float::C2F(c32.a);
4603 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4604 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4609 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4610 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4613 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4614 return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4617 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4618 return RGBAS32Color(
4619 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4620 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4621 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4622 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4625 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4627 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4628 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4629 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4630 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4633 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4635 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4636 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4637 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4649 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4651 Quaternion(
float in_w,
float in_x,
float in_y,
float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4669 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4670 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4671 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4672 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4675 Quaternion operator* (
float in_right)
const {
4676 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4680 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4683 Quaternion operator/ (
float in_right)
const {
4684 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4688 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4692 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4695 inline float Norm()
const {
4696 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4702 float mag_q = Norm();
4703 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4705 ret.w =
static_cast<float>(log(mag_q));
4708 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4715 ret.x = ret.y = ret.z = 0;
4722 float ea =
static_cast<float>(exp(w));
4723 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4724 float scale = ea * sin(mag_V) / mag_V;
4726 ret.w = ea * cos(mag_V);
4735 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4736 return ret.Normalize();
4740 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4742 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4744 if (in_shortest_path_only && dot < 0) {
4751 if (dot > -0.95f && dot < 0.95f) {
4752 float angle =
static_cast<float>(acos(dot));
4753 float sina =
static_cast<float>(sin(angle));
4754 float sinat =
static_cast<float>(sin(angle*in_fraction));
4755 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4757 return (*
this * sinaomt + q3 * sinat) / sina;
4760 return Lerp(q3, in_fraction);
4773 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4774 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4776 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4788 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4795 size_t dot_dc_count;
4796 size_t dot_3d_count;
4797 size_t line_dc_count;
4798 size_t line_3d_count;
4799 size_t triangle_dc_count;
4800 size_t triangle_3d_count;
4801 size_t polygon_dc_count;
4802 size_t polygon_3d_count;
4803 size_t polyhedron_count;
4804 size_t deleted_display_list_count;
4805 size_t display_list_line_3d_count;
4806 size_t display_list_triangle_3d_count;
4807 size_t display_list_vertex_3d_count;
4808 size_t display_list_tristrip_count;
4809 size_t non_display_list_tristrip_count;
4810 size_t culled_display_list_tristrip_count;
4811 size_t raster_count;
4812 size_t segment_count;
4813 size_t frustum_culled_segment_count;
4814 size_t extent_culled_segment_count;
4815 size_t vector_culled_segment_count;
4819 typedef unsigned char byte;
4820 typedef signed char sbyte;
4821 typedef intptr_t WindowHandle;
4822 typedef int64_t TouchID;
4823 typedef intptr_t PlatformData;
4824 typedef intptr_t OpaqueHandle;
4857 class AttributesControl;
4873 class GeometryInsertControl;
4970 class ShaderDefinition;
5018 class FontInfoControl;
5085 enum class Type : uint32_t
5088 GenericMask = 0xffffff00,
5092 EventDispatcher = 0x00000003,
5093 EventHandler = 0x00000004,
5094 EventNotifier = 0x00000005,
5095 UpdateNotifier = 0x00000006,
5096 SearchResults = 0x00000008,
5097 FontSearchResults = 0x00000009,
5098 SearchResultsIterator = 0x0100000a,
5099 FontSearchResultsIterator = 0x0100000b,
5100 SelectionResults = 0x0000000c,
5101 SelectionResultsIterator = 0x0100000d,
5102 SelectionItem = 0x0000000e,
5103 TreeContext = 0x0000000f,
5104 StreamToolkit = 0x00000010,
5105 DriverEventHandler = 0x00000011,
5107 IONotifier = 0x04000100,
5108 StreamImportNotifier = 0x04000101,
5109 STLImportNotifier = 0x04000102,
5110 OBJImportNotifier = 0x04000103,
5111 ExchangeImportNotifier = 0x04000104,
5112 SketchupImportNotifier = 0x04000105,
5113 ParasolidImportNotifier = 0x04000106,
5114 ExchangeTranslationNotifier = 0x04000107,
5115 ExchangeExportNotifier = 0x04000108,
5116 StreamExportNotifier = 0x04000109,
5117 ExchangeReloadNotifier = 0x0400010a,
5120 MarkerKit = 0x01000010,
5121 SphereAttributeKit = 0x01000011,
5122 TextAttributeKit = 0x01000012,
5123 TransparencyKit = 0x01000013,
5124 VisibilityKit = 0x01000014,
5125 VisualEffectsKit = 0x01000015,
5126 CuttingSectionAttributeKit = 0x01000016,
5127 CircleKit = 0x01000017,
5128 CircularArcKit = 0x01000018,
5129 CircularWedgeKit = 0x01000019,
5130 CuttingSectionKit = 0x0100001a,
5131 CylinderKit = 0x0100001b,
5132 DistantLightKit = 0x0100001c,
5133 EllipseKit = 0x0100001d,
5134 EllipticalArcKit = 0x0100001e,
5135 InfiniteLineKit = 0x0100001f,
5136 LineKit = 0x01000020,
5137 NURBSCurveKit = 0x01000021,
5138 MeshKit = 0x01000022,
5139 NURBSSurfaceKit = 0x01000023,
5140 PolygonKit = 0x01000024,
5141 SphereKit = 0x01000025,
5142 SpotlightKit = 0x01000026,
5143 ShellKit = 0x01000027,
5144 TextKit = 0x01000028,
5145 MaterialKit = 0x01000029,
5146 TrimKit = 0x0100002a,
5147 TextureOptionsKit = 0x0100002c,
5148 LinePatternKit = 0x0100002d,
5149 GlyphKit = 0x0100002e,
5150 ImageKit = 0x0100002f,
5151 LinePatternOptionsKit = 0x01000030,
5152 CameraKit = 0x01000031,
5153 BoundingKit = 0x01000032,
5154 CullingKit = 0x01000033,
5155 CurveAttributeKit = 0x01000034,
5156 CylinderAttributeKit = 0x01000035,
5157 EdgeAttributeKit = 0x01000036,
5158 LightingAttributeKit = 0x01000037,
5159 LineAttributeKit = 0x01000038,
5160 MarkerAttributeKit = 0x01000039,
5161 MaterialMappingKit = 0x0100003a,
5162 MatrixKit = 0x0100003b,
5163 NURBSSurfaceAttributeKit = 0x0100003c,
5164 PostProcessEffectsKit = 0x0100003d,
5165 SelectabilityKit = 0x0100003e,
5166 SelectionOptionsKit = 0x0100003f,
5167 StandAloneWindowOptionsKit = 0x01000040,
5168 OffScreenWindowOptionsKit = 0x01000041,
5169 ApplicationWindowOptionsKit = 0x01000042,
5170 HighlightOptionsKit = 0x01000043,
5171 LinePatternParallelKit = 0x01000044,
5172 SubwindowKit = 0x01000045,
5173 PerformanceKit = 0x01000046,
5174 HiddenLineAttributeKit = 0x01000047,
5175 DrawingAttributeKit = 0x01000048,
5176 ShaderKit = 0x01000049,
5177 DebuggingKit = 0x0100004a,
5178 ContourLineKit = 0x0100004b,
5179 StreamImportOptionsKit = 0x0100004c,
5180 StreamImportResultsKit = 0x0100004d,
5181 StreamExportOptionsKit = 0x0100004e,
5182 StreamExportResultsKit = 0x0100004f,
5183 WindowInfoKit = 0x01000050,
5184 ImageImportOptionsKit = 0x01000051,
5185 SearchOptionsKit = 0x01000052,
5186 ShaderImportOptionsKit = 0x01000053,
5187 HardcopyExportOptionsKit = 0x01000055,
5188 AttributeLockKit = 0x01000056,
5189 TransformMaskKit = 0x01000057,
5190 ColorInterpolationKit = 0x01000058,
5191 UpdateOptionsKit = 0x01000059,
5192 ImageExportOptionsKit = 0x0100005a,
5193 OBJImportOptionsKit = 0x0100005b,
5194 OBJImportResultsKit = 0x0100005c,
5195 STLImportOptionsKit = 0x0100005d,
5196 STLImportResultsKit = 0x0100005e,
5197 ShellOptimizationOptionsKit = 0x0100005f,
5198 ShellRelationOptionsKit = 0x01000060,
5199 ShellRelationResultsKit = 0x01000061,
5200 GridKit = 0x01000062,
5201 CutGeometryGatheringOptionsKit = 0x01000063,
5202 SegmentOptimizationOptionsKit = 0x01000064,
5205 LinePatternElement = 0x03000000,
5206 SolidLinePatternElement = 0x03000001,
5207 BlankLinePatternElement = 0x03000002,
5208 GlyphLinePatternElement = 0x03000003,
5210 GlyphElement = 0x05000000,
5211 DotGlyphElement = 0x05000001,
5212 LineGlyphElement = 0x05000002,
5213 EllipseGlyphElement = 0x05000003,
5214 CircularArcGlyphElement = 0x05000004,
5215 InfiniteLineGlyphElement = 0x05000005,
5217 TrimElement = 0x07000000,
5219 Condition = 0x09000000,
5220 NOTCondition = 0x09000001,
5221 ANDCondition = 0x09000002,
5222 ORCondition = 0x09000003,
5223 XORCondition = 0x09000004,
5224 EQCondition = 0x09000005,
5225 NEQCondition = 0x09000006,
5226 GTCondition = 0x09000007,
5227 LTCondition = 0x09000008,
5228 GTEQCondition = 0x09000009,
5229 LTEQCondition = 0x0900000A,
5231 MouseState = 0x01001001,
5232 TouchState = 0x01001002,
5233 KeyboardState = 0x01001003,
5234 FontInfoState = 0x01001004,
5236 KeyPath = 0x01000F01,
5239 IncludeKey = 0x10000001,
5240 PortfolioKey = 0x10000002,
5241 StyleKey = 0x10000003,
5243 SegmentKey = 0x10200000,
5244 WindowKey = 0x10600000,
5245 StandAloneWindowKey = 0x10600001,
5246 OffScreenWindowKey = 0x10600002,
5247 ApplicationWindowKey = 0x10600003,
5249 GeometryKey = 0x10100000,
5250 ReferenceKey = 0x10100001,
5251 CircleKey = 0x10100002,
5252 CircularArcKey = 0x10100003,
5253 CircularWedgeKey = 0x10100004,
5254 CuttingSectionKey = 0x10100005,
5255 CylinderKey = 0x10100006,
5256 EllipseKey = 0x10100007,
5257 EllipticalArcKey = 0x10100008,
5258 InfiniteLineKey = 0x10100009,
5259 LineKey = 0x1010000a,
5260 DistantLightKey = 0x1010000b,
5261 SpotlightKey = 0x1010000c,
5262 MarkerKey = 0x1010000d,
5263 MeshKey = 0x1010000e,
5264 NURBSCurveKey = 0x1010000f,
5265 NURBSSurfaceKey = 0x10100010,
5266 PolygonKey = 0x10100011,
5267 ShellKey = 0x10100012,
5268 SphereKey = 0x10100013,
5269 TextKey = 0x10100014,
5270 GridKey = 0x10100015,
5272 Definition = 0x20000000,
5273 NamedStyleDefinition = 0x20000001,
5274 TextureDefinition = 0x20000002,
5275 LinePatternDefinition = 0x20000003,
5276 GlyphDefinition = 0x20000004,
5277 CubeMapDefinition = 0x20000005,
5278 ImageDefinition = 0x20000006,
5279 MaterialPaletteDefinition = 0x20000007,
5280 ShaderDefinition = 0x20000008,
5282 Control = 0x50000000,
5283 CameraControl = 0x50000001,
5284 SelectabilityControl = 0x50000002,
5285 MarkerAttributeControl = 0x50000003,
5286 SphereAttributeControl = 0x50000004,
5287 LightingAttributeControl = 0x50000005,
5288 CylinderAttributeControl = 0x50000006,
5289 TextAttributeControl = 0x50000007,
5290 LineAttributeControl = 0x50000008,
5291 EdgeAttributeControl = 0x50000009,
5292 CurveAttributeControl = 0x5000000a,
5293 ModellingMatrixControl = 0x5000000b,
5294 TextureMatrixControl = 0x5000000c,
5295 CullingControl = 0x5000000d,
5296 TransparencyControl = 0x5000000e,
5297 MaterialMappingControl = 0x5000000f,
5298 NURBSSurfaceAttributeControl = 0x50000010,
5299 PostProcessEffectsControl = 0x50000011,
5300 BoundingControl = 0x50000012,
5301 VisualEffectsControl = 0x50000013,
5302 SelectionOptionsControl = 0x50000014,
5303 HighlightOptionsControl = 0x50000015,
5304 DefinitionControl = 0x50000016,
5305 SelectionControl = 0x50000017,
5306 HighlightControl = 0x50000018,
5307 StandAloneWindowOptionsControl = 0x50000019,
5308 OffScreenWindowOptionsControl = 0x5000001a,
5309 ApplicationWindowOptionsControl = 0x5000001b,
5310 VisibilityControl = 0x5000001c,
5311 SubwindowControl = 0x5000001d,
5312 PerformanceControl = 0x5000001e,
5313 HiddenLineAttributeControl = 0x5000001f,
5314 DrawingAttributeControl = 0x50000020,
5315 DebuggingControl = 0x50000021,
5316 ContourLineControl = 0x50000022,
5317 StyleControl = 0x50000023,
5318 ConditionControl = 0x50000024,
5319 PortfolioControl = 0x50000025,
5320 WindowInfoControl = 0x50000026,
5321 AttributeLockControl = 0x50000027,
5322 TransformMaskControl = 0x50000028,
5323 ColorInterpolationControl = 0x50000029,
5324 UpdateOptionsControl = 0x50000030,
5325 CuttingSectionAttributeControl = 0x50000031,
5327 LibraryMask = 0x80FF0000,
5329 Sprocket = 0x80000000,
5330 Canvas = 0x80000001,
5331 Layout = 0x80000002,
5334 Operator = 0x80000005,
5335 SprocketPath = 0x80000007,
5337 SprocketControl = 0xD0000000,
5338 OperatorControl = 0xD0000008,
5339 NavigationCubeControl = 0xD0000009,
5340 AxisTriadControl = 0xD000000A,
5342 Metadata = 0x80001000,
5343 IntegerMetadata = 0x80001001,
5344 UnsignedIntegerMetadata = 0x80001002,
5345 DoubleMetadata = 0x80001003,
5346 StringMetadata = 0x80001004,
5347 TimeMetadata = 0x80001005,
5348 BooleanMetadata = 0x80001006,
5350 Component = 0x80000200,
5351 Filter = 0x80000600,
5352 Capture = 0x80000a00,
5353 CADModel = 0x80000300,
5354 ComponentPath = 0x81001000,
5356 ExchangeMask = 0x80020000,
5357 ExchangeComponent = 0x80021200,
5358 ExchangeFilter = 0x80020601,
5359 ExchangeCapture = 0x80020a01,
5360 ExchangeCADModel = 0x80020301,
5361 ExchangeConfiguration = 0x81020001,
5362 ExchangeImportOptionsKit = 0x81020002,
5363 ExchangeExportACISOptionsKit = 0x81020003,
5364 ExchangeExportIGESOptionsKit = 0x81020004,
5365 ExchangeExportJTOptionsKit = 0x81020005,
5366 ExchangeExportParasolidOptionsKit = 0x81020006,
5367 ExchangeExportPRCOptionsKit = 0x81020007,
5368 ExchangeExportSTEPOptionsKit = 0x81020008,
5369 ExchangeExportSTLOptionsKit = 0x81020009,
5370 ExchangeExportU3DOptionsKit = 0x8102000a,
5371 ExchangeExportXMLOptionsKit = 0x8102000b,
5372 ExchangeTessellationOptionsKit = 0x8102000c,
5373 ExchangeSheet = 0x80021201,
5374 ExchangeModelFileImportOptionsKit = 0x8102000d,
5375 ExchangeTranslationOptionsKit = 0x8102000e,
5377 PublishMask = 0x80040000,
5378 PublishDocumentKit = 0x81040001,
5379 PublishPageKit = 0x81040002,
5380 PublishTemplateKit = 0x81040003,
5381 PublishAnnotationKit = 0x81040004,
5382 PublishArtworkKit = 0x81040005,
5383 PublishViewKit = 0x81040006,
5384 PublishTextKit = 0x81040007,
5385 PublishImageKit = 0x81040008,
5386 PublishTableKit = 0x81040009,
5387 PublishExportOptionsKit = 0x8104000a,
5388 PublishLinkKit = 0x8104000b,
5389 PublishButtonKit = 0x8104000c,
5390 PublishTextFieldKit = 0x8104000d,
5391 PublishSlideTableKit = 0x8104000e,
5392 PublishCheckBoxKit = 0x8104000f,
5393 PublishRadioButtonKit = 0x81040010,
5394 PublishListBoxKit = 0x81040011,
5395 PublishDropDownListKit = 0x81040012,
5396 PublishSignatureFieldKit = 0x81040013,
5398 PublishDocumentKey = 0x80040001,
5399 PublishPageControl = 0x80040002,
5401 SceneTree = 0x80008001,
5402 SceneTreeItem = 0x80008002,
5404 ComponentTree = 0x80008003,
5405 ComponentTreeItem = 0x80008004,
5407 SketchupMask = 0x80100000,
5408 SketchupImportOptionsKit = 0x81100001,
5409 SketchupImportResultsKit = 0x81100002,
5411 ParasolidMask = 0x80200000,
5412 ParasolidComponent = 0x80201201,
5413 ParasolidCADModel = 0x80200302,
5414 ParasolidImportOptionsKit = 0x81200003,
5415 ParasolidFacetTessellationKit = 0x81200004,
5416 ParasolidLineTessellationKit = 0x81200005,
5417 ParasolidExportOptionsKit = 0x81200006,
5419 IONotifierData = 0x84000200,
5420 StreamImportNotifierData = 0x84000201,
5421 STLImportNotifierData = 0x84000202,
5422 OBJImportNotifierData = 0x84000203,
5423 ExchangeImportNotifierData = 0x84020204,
5424 SketchupImportNotifierData = 0x84100205,
5425 ParasolidImportNotifierData = 0x84200206,
5426 ExchangeTranslationNotifierData = 0x84020207,
5427 ExchangeExportNotifierData = 0x84020208,
5428 StreamExportNotifierData = 0x84000209,
5440 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5447 static void Free(
void * in_pointer);
5456 template <
typename T>
5457 class NO_HPS_API Allocator
5460 typedef T value_type;
5461 typedef value_type * pointer;
5462 typedef value_type
const * const_pointer;
5463 typedef value_type & reference;
5464 typedef value_type
const & const_reference;
5465 typedef size_t size_type;
5466 typedef ptrdiff_t difference_type;
5470 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5473 template <
typename U> Allocator(Allocator<U>
const &) {}
5475 template <
typename U>
5478 typedef Allocator<U> other;
5482 pointer address(reference x)
const {
return &x; }
5483 const_pointer address(const_reference x)
const {
return &x; }
5485 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5486 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5488 #if defined(_MSC_VER) || defined (__APPLE__)
5489 void construct(pointer p, const_reference x) {
new(p) T(x); }
5491 template<
typename U,
typename... Args>
5492 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5494 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5496 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5499 template <
typename T,
typename U>
5500 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5502 template <
typename T,
typename U>
5503 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5509 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5517 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5527 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5597 HPS::Type Type()
const;
5606 virtual bool Empty()
const {
return (impl_ == 0);};
5609 virtual void Reset();
5614 bool HasType(HPS::Type in_mask)
const;
5618 intptr_t GetClassID()
const;
5623 intptr_t GetInstanceID()
const;
5625 template <
typename T>
5626 static intptr_t ClassID()
5628 static const intptr_t ret = T().GetClassID();
5633 friend class HPSI::Impl;
5634 friend class HPSI::KeyImpl;
5635 friend class HPSI::TicketImpl;
5644 HPS::Type ObjectType()
const {
return HPS::Type::Control;}
5661 this->Object::operator=(std::move(in_that));
6129 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6134 intptr_t GetClassID()
const;
6138 virtual Event * Clone()
const=0;
6141 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6156 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6157 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6164 friend class HPSI::EventDispatcherImpl;
6214 enum class KeyboardCode
6414 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6421 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6429 return !(*
this == in_that);
6438 typedef std::vector<Point, Allocator<Point> > PointArray;
6439 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6440 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6441 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6442 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6443 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6444 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6445 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6446 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6447 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6448 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6449 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6450 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6451 typedef std::vector<int, Allocator<int> > IntArray;
6452 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6453 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6454 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6455 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6456 typedef std::vector<float, Allocator<float> > FloatArray;
6457 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6458 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6459 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6460 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6461 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6462 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6463 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6464 typedef std::vector<bool, Allocator<bool> > BoolArray;
6465 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6466 typedef std::vector<Key, Allocator<Key> > KeyArray;
6467 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6468 typedef std::vector<char, Allocator<char> > CharArray;
6469 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6470 typedef std::vector<byte, Allocator<byte> > ByteArray;
6471 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6472 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6473 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6474 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6475 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6476 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6477 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6478 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6479 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6480 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6481 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6482 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6483 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6484 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6485 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6486 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6487 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6488 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6489 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6490 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6491 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6492 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6493 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6494 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6495 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6496 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6497 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6498 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6499 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6500 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6501 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6502 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6530 HPS::Type
ObjectType()
const {
return HPS::Type::SearchResultsIterator;}
6566 bool IsValid()
const;
6574 Key GetItem()
const;
6578 Key operator*()
const;
6582 SearchTypeArray GetResultTypes()
const;
6607 virtual void Reset();
6626 size_t GetCount()
const;
6665 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResultsIterator;}
6696 bool IsValid()
const;
6735 virtual void Reset();
6740 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResults;}
6755 size_t GetCount()
const;
6779 UTF8(
char const * in_string,
char const * in_locale = 0);
6783 UTF8(
wchar_t const * in_string);
6802 return Assign(std::move(in_utf8));
6809 size_t ToWStr(
wchar_t * out_wide_string)
const;
6814 size_t ToWStr(WCharArray & out_wide_string)
const;
6820 return (_length > 0);
6827 return (_length == 0);
6861 inline operator char const * ()
const
6868 char At(
size_t in_index)
const
6872 else if(in_index >= _length)
6875 return _text[in_index];
6881 UTF8 & Assign(
UTF8 const & in_utf8);
6888 return Assign(in_utf8);
6894 UTF8 & operator+= (
UTF8 const & in_utf8);
6899 UTF8 & operator+= (
char const * in_utf8);
6904 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6909 UTF8 operator+ (
char const * in_utf8)
const;
6914 bool operator== (
UTF8 const & in_utf8)
const;
6919 bool operator!= (
UTF8 const & in_utf8)
const
6921 return !(*
this == in_utf8);
6927 bool operator== (
char const * in_utf8)
const;
6932 bool operator!= (
char const * in_utf8)
const
6934 return !(*
this == in_utf8);
6943 return in_right == in_left;
6952 return in_right != in_left;
6961 return in_right ==
UTF8(in_left);
6970 return in_right !=
UTF8(in_left);
6977 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
6979 return UTF8(in_left) + in_right;
6986 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
6988 return UTF8(in_left) + in_right;
6994 size_t GetHash()
const;
6998 size_t internal_encode(
wchar_t const * in_wide_string);
6999 size_t internal_decode(
wchar_t * out_wide_string)
const;
7003 mutable size_t _hash_key;
7004 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
7005 char _buffer[_buffer_size];
7010 inline size_t operator()(
const HPS::UTF8 & in_utf8)
const
7022 enum class Intrinsic
7041 Condition(HPS::Condition::Intrinsic in_special);
7062 bool ShowCondition(
UTF8 & out_condition)
const;
7067 bool ShowNumber(
float & out_number)
const;
7072 bool ShowIntrinsic(Condition::Intrinsic & out_special)
const;
7077 bool ShowOperands(ConditionArray & out_operands)
const;
7087 bool Equals(
Condition const & in_that)
const;
7092 bool operator==(
Condition const & in_that)
const;
7097 bool operator!=(
Condition const & in_that)
const;
7102 bool IsSatisfiedBy(UTF8Array
const & in_conditions)
const;
7107 bool IsSatisfiedBy(
char const * in_condition)
const;
7251 HPS_API Condition NOT(Condition
const & in_operand);
7257 HPS_API Condition OR(Condition
const & in_operand1, Condition
const & in_operand2);
7263 HPS_API Condition XOR(Condition
const & in_operand1, Condition
const & in_operand2);
7269 HPS_API Condition AND(Condition
const & in_operand1, Condition
const & in_operand2);
7275 HPS_API Condition EQ(Condition
const & in_operand1, Condition
const & in_operand2);
7281 HPS_API Condition NEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7287 HPS_API Condition GT(Condition
const & in_operand1, Condition
const & in_operand2);
7293 HPS_API Condition LT(Condition
const & in_operand1, Condition
const & in_operand2);
7299 HPS_API Condition GTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7305 HPS_API Condition LTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7320 Key(
Key const & in_that);
7333 Key & operator=(
Key && in_that);
7341 bool HasOwner()
const;
7353 void MoveTo(
SegmentKey const & in_new_owner);
7360 Key & operator=(
Key const & in_that);
7363 virtual void Assign(
Key const & in_that);
7366 bool Equals(
Key const & in_that)
const;
7369 bool operator!= (
Key const & in_that)
const;
7372 bool operator== (
Key const & in_that)
const;
7376 size_t GetHash()
const;
7381 inline size_t operator()(
const HPS::Key & in_key)
const
7429 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7433 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7491 size_t ShowSubsegments()
const;
7494 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7499 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7504 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7509 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7514 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7519 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7524 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7543 SegmentKey & SetCondition(
char const * in_condition);
7546 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7549 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7555 bool ShowConditions(UTF8Array & out_conditions)
const;
7565 SegmentKey & SetMaterialPalette(
char const * in_name);
7571 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7589 bool ShowPriority(
int & out_priority)
const;
7595 SegmentKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
7602 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7608 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7613 SegmentKey & UnsetUserData(intptr_t in_index);
7619 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7624 SegmentKey & UnsetUserData(HPS::IntPtrTArray
const & in_indices);
7631 size_t ShowUserDataCount()
const;
7637 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
7642 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7648 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7655 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7658 LineKey InsertLine(PointArray
const & in_pts);
7734 PolygonKey InsertPolygon(PointArray
const & in_pts);
7744 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7747 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7750 ShellKey InsertShellByTristrips(PointArray
const & in_points, IntArray
const & in_tristrips);
7753 ShellKey InsertShellByTristrips(
size_t in_point_count,
Point const in_points [],
size_t in_tristrips_count,
int const in_tristrips []);
7759 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7762 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7810 NURBSCurveKey InsertNURBSCurve(
size_t in_degree, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_knots,
float in_start_u,
float in_end_u);
7813 NURBSCurveKey InsertNURBSCurve(
size_t in_degree,
size_t in_pcount,
Point const in_points [],
float const in_weights[],
size_t in_knot_count,
float const in_knots[],
float in_start_u,
float in_end_u);
7820 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots);
7823 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[]);
7826 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots, TrimKitArray
const & in_trims);
7829 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[],
size_t in_trim_count,
TrimKit const in_trims[]);
7840 TextKey InsertText(
Point const & in_position,
char const * in_text);
7859 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7886 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7904 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
7986 bool ShowCamera(
CameraKit & out_kit)
const;
8035 bool ShowCulling(
CullingKit & out_kit)
const;
8064 SegmentKey & UnsetCuttingSectionAttributes();
8211 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8331 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8432 HPS::Type
ObjectType()
const {
return HPS::Type::SegmentOptimizationOptionsKit; }
8543 bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data)
const;
8545 bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix)
const;
8547 bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion)
const;
8549 bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope)
const;
8551 bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization)
const;
8553 bool ShowShellInstancing(
bool & out_shell_instancing)
const;
8555 bool ShowShellMerging(
bool & out_shell_merging)
const;
8557 bool ShowAttributeDelocalization(
bool & out_attribute_delocalization)
const;
8611 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateNotifier;};
8634 intptr_t GetClassID()
const;
8669 void DrawTexturedBackground(OpaqueHandle in_texture,
MatrixKit const & in_matrix,
Rectangle const & in_extent)
const;
8673 mutable HPS::FloatArray matrix_elements;
8681 HPS::Type
ObjectType() const OVERRIDE {
return HPS::Type::DriverEventHandler; };
8694 HPS_UNREFERENCED(in_event);
8765 WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8872 bool ShowSnapshot(
ImageKit & out_kit)
const;
8883 SegmentKey & UnsetCuttingSectionAttributes();
8906 void MoveTo(
SegmentKey const & in_new_owner);
8925 KeyPath(KeyArray
const & in_path);
8930 KeyPath(
size_t in_path_count,
Key const in_path []);
8963 KeyPath & operator+=(KeyArray
const & in_key_array);
8978 KeyPath & Append(KeyArray
const & in_key_array);
8988 KeyPath & operator=(KeyArray
const & in_path);
8992 void Set(
KeyPath const & in_that);
8997 bool Equals(
KeyPath const & in_that)
const;
9002 bool operator!= (
KeyPath const & in_that)
const;
9007 bool operator== (
KeyPath const & in_that)
const;
9013 KeyPath & SetKeys(KeyArray
const & in_keys);
9019 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
9029 bool ShowKeys(KeyArray & out_keys)
const;
9053 bool ComputeTextExtent(
const char* in_text,
float & out_xfrac,
float & out_yfrac)
const;
9070 bool ShowNetBounding(
BoundingKit & out_kit)
const;
9074 bool ShowNetCamera(
CameraKit & out_kit)
const;
9138 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
9142 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
9146 bool ShowNetCulling(
CullingKit & out_kit)
const;
9178 bool ShowNetConditions(UTF8Array & out_conditions)
const;
9194 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
9203 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
9212 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
9221 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
9230 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
9239 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
9248 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
9257 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
9266 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
9333 bool operator==(
BoundingKit const & in_kit)
const;
9338 bool operator!=(
BoundingKit const & in_kit)
const;
9379 bool ShowExclusion(
bool & out_exclusion)
const;
9409 HPS::Type
ObjectType()
const {
return HPS::Type::BoundingControl;};
9458 bool ShowExclusion(
bool & out_exclusion)
const;
9793 bool ShowCuttingSections(
bool & out_state)
const;
9798 bool ShowCutEdges(
bool & out_state)
const;
9803 bool ShowCutFaces(
bool & out_state)
const;
9808 bool ShowWindows(
bool & out_state)
const;
9813 bool ShowText(
bool & out_state)
const;
9818 bool ShowLines(
bool & out_state)
const;
9823 bool ShowEdgeLights(
bool & out_state)
const;
9828 bool ShowMarkerLights(
bool & out_state)
const;
9833 bool ShowFaceLights(
bool & out_state)
const;
9838 bool ShowGenericEdges(
bool & out_state)
const;
9843 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9848 bool ShowAdjacentEdges(
bool & out_state)
const;
9853 bool ShowHardEdges(
bool & out_state)
const;
9858 bool ShowMeshQuadEdges(
bool & out_state)
const;
9863 bool ShowNonCulledEdges(
bool & out_state)
const;
9868 bool ShowPerimeterEdges(
bool & out_state)
const;
9873 bool ShowFaces(
bool & out_state)
const;
9878 bool ShowVertices(
bool & out_state)
const;
9883 bool ShowMarkers(
bool & out_state)
const;
9888 bool ShowShadowCasting(
bool & out_state)
const;
9893 bool ShowShadowReceiving(
bool & out_state)
const;
9898 bool ShowShadowEmitting(
bool & out_state)
const;
9930 HPS::Type
ObjectType()
const {
return HPS::Type::VisibilityControl;};
10195 bool ShowCuttingSections(
bool & out_state)
const;
10200 bool ShowCutEdges(
bool & out_state)
const;
10205 bool ShowCutFaces(
bool & out_state)
const;
10210 bool ShowWindows(
bool & out_state)
const;
10215 bool ShowText(
bool & out_state)
const;
10220 bool ShowLines(
bool & out_state)
const;
10225 bool ShowEdgeLights(
bool & out_state)
const;
10230 bool ShowMarkerLights(
bool & out_state)
const;
10235 bool ShowFaceLights(
bool & out_state)
const;
10240 bool ShowGenericEdges(
bool & out_state)
const;
10245 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
10250 bool ShowAdjacentEdges(
bool & out_state)
const;
10255 bool ShowHardEdges(
bool & out_state)
const;
10260 bool ShowMeshQuadEdges(
bool & out_state)
const;
10265 bool ShowNonCulledEdges(
bool & out_state)
const;
10270 bool ShowPerimeterEdges(
bool & out_state)
const;
10275 bool ShowFaces(
bool & out_state)
const;
10280 bool ShowVertices(
bool & out_state)
const;
10285 bool ShowMarkers(
bool & out_state)
const;
10290 bool ShowShadowCasting(
bool & out_state)
const;
10295 bool ShowShadowReceiving(
bool & out_state)
const;
10300 bool ShowShadowEmitting(
bool & out_state)
const;
10357 bool Empty()
const;
10362 bool Equals(
CameraKit const & in_kit)
const;
10367 bool operator==(
CameraKit const & in_kit)
const;
10372 bool operator!=(
CameraKit const & in_kit)
const;
10402 CameraKit & SetField(
float in_width,
float in_height);
10413 CameraKit & SetNearLimit(
float const in_limit);
10447 bool ShowUpVector(
Vector & out_up_vector)
const;
10452 bool ShowPosition(
Point & out_position)
const;
10457 bool ShowTarget(
Point & out_target)
const;
10469 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
10474 bool ShowWidth(
float & out_width)
const;
10479 bool ShowHeight(
float & out_height)
const;
10485 bool ShowField(
float & out_width,
float & out_height)
const;
10490 bool ShowNearLimit(
float & out_near_limit)
const;
10498 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10506 CameraKit & Orbit(
float in_theta,
float in_phi);
10514 CameraKit & Pan(
float in_theta,
float in_phi);
10616 bool ShowUpVector(
Vector & out_up_vector)
const;
10621 bool ShowPosition(
Point & out_position)
const;
10626 bool ShowTarget(
Point & out_target)
const;
10638 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10643 bool ShowWidth(
float & out_width)
const;
10648 bool ShowHeight(
float & out_height)
const;
10654 bool ShowField(
float & out_width,
float & out_height)
const;
10659 bool ShowNearLimit(
float & out_width)
const;
10667 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10753 bool Empty()
const;
10932 HPS::Type
ObjectType()
const {
return HPS::Type::SelectabilityControl;};
11123 bool Empty()
const;
11209 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11220 bool ShowDepthWriting(
bool & out_state)
const;
11251 HPS::Type
ObjectType()
const {
return HPS::Type::TransparencyControl;};
11324 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11335 bool ShowDepthWriting(
bool & out_state)
const;
11366 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationKit;};
11380 bool Empty()
const;
11455 bool ShowFaceColor(
bool & out_state)
const;
11460 bool ShowEdgeColor(
bool & out_state)
const;
11465 bool ShowVertexColor(
bool & out_state)
const;
11470 bool ShowFaceIndex(
bool & out_state)
const;
11475 bool ShowEdgeIndex(
bool & out_state)
const;
11480 bool ShowVertexIndex(
bool & out_state)
const;
11510 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationControl;};
11576 bool ShowFaceColor(
bool & out_state)
const;
11581 bool ShowEdgeColor(
bool & out_state)
const;
11586 bool ShowVertexColor(
bool & out_state)
const;
11591 bool ShowFaceIndex(
bool & out_state)
const;
11596 bool ShowEdgeIndex(
bool & out_state)
const;
11601 bool ShowVertexIndex(
bool & out_state)
const;
11656 bool Empty()
const;
11661 bool Equals(
CullingKit const & in_kit)
const;
11666 bool operator==(
CullingKit const & in_kit)
const;
11671 bool operator!=(
CullingKit const & in_kit)
const;
11677 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11683 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11689 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11695 CullingKit & SetExtent(
unsigned int in_pixels);
11736 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11775 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11781 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11786 bool ShowBackFace(
bool & out_state)
const;
11793 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11798 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11803 bool ShowFrustum(
bool & out_state)
const;
11843 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11857 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
11905 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
11944 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11950 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11955 bool ShowBackFace(
bool & out_state)
const;
11962 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11967 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11972 bool ShowFrustum(
bool & out_state)
const;
12007 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeKit;};
12029 bool Empty()
const;
12075 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12112 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeControl;};
12145 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12184 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeKit;};
12206 bool Empty()
const;
12242 bool ShowTessellation(
size_t & out_facets)
const;
12271 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeControl;};
12296 bool ShowTessellation(
size_t & out_facets)
const;
12329 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeKit;};
12351 bool Empty()
const;
12420 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeControl;};
12478 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeKit;};
12500 bool Empty()
const;
12546 bool ShowTessellation(
size_t & out_facets)
const;
12582 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeControl;};
12616 bool ShowTessellation(
size_t & out_facets)
const;
12655 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeKit;};
12677 bool Empty()
const;
12772 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeControl;};
12880 bool Empty()
const;
13154 bool ShowBold(
bool & out_state)
const;
13159 bool ShowItalic(
bool & out_state)
const;
13164 bool ShowOverline(
bool & out_state)
const;
13169 bool ShowStrikethrough(
bool & out_state)
const;
13174 bool ShowUnderline(
bool & out_state)
const;
13179 bool ShowSlant(
float & out_angle)
const;
13184 bool ShowLineSpacing(
float & out_multiplier)
const;
13190 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13197 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13223 bool ShowFont(
UTF8 & out_name)
const;
13246 bool ShowPath(
Vector & out_path)
const;
13251 bool ShowSpacing(
float & out_multiplier)
const;
13282 HPS::Type
ObjectType()
const {
return HPS::Type::TextAttributeControl;};
13544 bool ShowBold(
bool & out_state)
const;
13549 bool ShowItalic(
bool & out_state)
const;
13554 bool ShowOverline(
bool & out_state)
const;
13559 bool ShowStrikethrough(
bool & out_state)
const;
13564 bool ShowUnderline(
bool & out_state)
const;
13569 bool ShowSlant(
float & out_angle)
const;
13574 bool ShowLineSpacing(
float & out_multiplier)
const;
13580 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13587 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13613 bool ShowFont(
UTF8 & out_name)
const;
13636 bool ShowPath(
Vector & out_path)
const;
13641 bool ShowSpacing(
float & out_multiplier)
const;
13699 bool Empty()
const;
13758 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13789 HPS::Type
ObjectType()
const {
return HPS::Type::LineAttributeControl;};
13836 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13892 bool Empty()
const;
13938 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13944 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13975 HPS::Type
ObjectType()
const {
return HPS::Type::EdgeAttributeControl;};
14008 bool ShowPattern(
UTF8 & out_pattern_name)
const;
14014 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
14069 bool Empty()
const;
14164 bool ShowBudget(
size_t & out_budget)
const;
14170 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14175 bool ShowViewDependent(
bool & out_state)
const;
14181 bool ShowMaximumDeviation(
float & out_deviation)
const;
14187 bool ShowMaximumAngle(
float & out_degrees)
const;
14193 bool ShowMaximumLength(
float & out_length)
const;
14223 HPS::Type
ObjectType()
const {
return HPS::Type::CurveAttributeControl;};
14307 bool ShowBudget(
size_t & out_budget)
const;
14313 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14318 bool ShowViewDependent(
bool & out_state)
const;
14324 bool ShowMaximumDeviation(
float & out_deviation)
const;
14330 bool ShowMaximumAngle(
float & out_degrees)
const;
14336 bool ShowMaximumLength(
float & out_length)
const;
14371 MatrixKit(FloatArray
const & in_matrix_source);
14376 MatrixKit(
float const in_matrix_source []);
14406 bool Empty()
const;
14411 bool Equals(
MatrixKit const & in_kit)
const;
14416 bool operator==(
MatrixKit const & in_kit)
const;
14421 bool operator!=(
MatrixKit const & in_kit)
const;
14428 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
14434 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
14439 MatrixKit & SetElements(FloatArray
const & in_matrix);
14445 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
14458 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14464 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14469 bool ShowElements(FloatArray & out_matrix)
const;
14474 bool ShowDeterminant(
float & out_determinant)
const;
14479 bool ShowInverse(
MatrixKit & out_matrix)
const;
14485 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14493 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14506 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14513 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14547 MatrixKit Multiply(
float in_scalar)
const;
14552 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14567 MatrixKit operator*(
float in_scalar)
const;
14572 MatrixKit const & operator*=(
float in_scalar);
14578 Point Transform(
Point const & in_source)
const;
14583 PointArray Transform(PointArray
const & in_source)
const;
14589 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14599 VectorArray Transform(VectorArray
const & in_source)
const;
14605 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14610 Plane Transform(
Plane const & in_source)
const;
14615 PlaneArray Transform(PlaneArray
const & in_source)
const;
14621 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14663 HPS::Type
ObjectType()
const {
return HPS::Type::ModellingMatrixControl;};
14703 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14709 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14714 bool ShowElements(FloatArray & out_matrix)
const;
14719 bool ShowDeterminant(
float & out_determinant)
const;
14724 bool ShowInverse(
MatrixKit & out_matrix)
const;
14730 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14807 HPS::Type
ObjectType()
const {
return HPS::Type::TextureMatrixControl;};
14848 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14854 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14859 bool ShowElements(FloatArray & out_matrix)
const;
14864 bool ShowDeterminant(
float & out_determinant)
const;
14869 bool ShowInverse(
MatrixKit & out_matrix)
const;
14875 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14954 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingKit;};
14976 bool Empty()
const;
15580 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15587 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15806 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15838 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingControl;};
16431 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16439 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16657 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16688 HPS::Type
ObjectType()
const {
return HPS::Type::PortfolioControl; };
16694 size_t GetCount()
const;
16747 bool Show(PortfolioKeyArray & out_portfolios)
const;
16785 size_t GetCount()
const;
16789 StyleKey PushNamed(
char const * in_style_name);
16792 StyleKey PushNamed(
char const * in_style_name,
Condition const & in_condition);
16828 void Flush(
SegmentKey const & in_style_source);
16841 void Flush(
char const * in_style_name);
16849 void Flush(
char const * in_style_name,
Condition const & in_condition);
16854 StyleKey SetNamed(
char const * in_style_name);
16877 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionArray
const & in_conditions);
16883 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
16899 void UnsetAllSegment();
16902 void UnsetAllNamed();
16905 void UnsetEverything();
16919 bool ShowTop(
StyleKey & out_style)
const;
16927 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions)
const;
16932 bool Show(StyleKeyArray & out_styles)
const;
16938 bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions)
const;
16943 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
16949 bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions)
const;
16954 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
16986 HPS::Type
ObjectType()
const {
return HPS::Type::ConditionControl; };
16993 size_t GetCount()
const;
17031 bool ShowCondition(
char const * in_condition)
const;
17036 bool ShowConditions(UTF8Array & out_conditions)
const;
17087 bool Empty()
const;
17097 bool operator==(
MaterialKit const & in_kit)
const;
17102 bool operator!=(
MaterialKit const & in_kit)
const;
17139 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
17148 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
17154 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
17161 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
17169 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
17178 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
17184 MaterialKit & SetShader(
char const * in_shader_name);
17196 MaterialKit & SetSpecular(
char const * in_texture_name);
17202 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17214 MaterialKit & SetMirror(
char const * in_texture_name);
17227 MaterialKit & SetTransmission(
char const * in_texture_name);
17233 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17245 MaterialKit & SetEmission(
char const * in_texture_name);
17251 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17258 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
17264 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17269 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
17275 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
17285 MaterialKit & SetBump(
char const * in_texture_name);
17316 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
17357 bool ShowDiffuse()
const;
17362 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
17367 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
17372 bool ShowDiffuseAlpha(
float & out_alpha)
const;
17397 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
17402 bool ShowShader(
UTF8 & out_shader_name)
const;
17462 bool ShowBump(
UTF8 & out_texture_name)
const;
17468 bool ShowGloss(
float & out_gloss)
const;
17497 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeKit;};
17519 bool Empty()
const;
17601 bool ShowBudget(
size_t & out_budget)
const;
17606 bool ShowMaximumDeviation(
float & out_deviation)
const;
17611 bool ShowMaximumAngle(
float & out_degrees)
const;
17616 bool ShowMaximumWidth(
float & out_width)
const;
17621 bool ShowTrimBudget(
size_t & out_budget)
const;
17626 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17657 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeControl;};
17727 bool ShowBudget(
size_t & out_budget)
const;
17732 bool ShowMaximumDeviation(
float & out_deviation)
const;
17737 bool ShowMaximumAngle(
float & out_degrees)
const;
17742 bool ShowMaximumWidth(
float & out_width)
const;
17747 bool ShowTrimBudget(
size_t & out_budget)
const;
17752 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17808 bool Empty()
const;
17890 HPS::Type
ObjectType()
const {
return HPS::Type::PerformanceControl;};
17963 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeKit;};
17985 bool Empty()
const;
18125 bool ShowColor(
RGBAColor & out_color)
const;
18130 bool ShowDimFactor(
float & out_zero_to_one)
const;
18135 bool ShowFaceDisplacement(
float & out_buckets)
const;
18140 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18145 bool ShowRenderFaces(
bool & out_state)
const;
18150 bool ShowRenderText(
bool & out_state)
const;
18160 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18165 bool ShowVisibility(
bool & out_state)
const;
18171 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18176 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18208 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeControl;};
18335 bool ShowColor(
RGBAColor & out_color)
const;
18340 bool ShowDimFactor(
float & out_zero_to_one)
const;
18345 bool ShowFaceDisplacement(
float & out_buckets)
const;
18350 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18355 bool ShowRenderFaces(
bool & out_state)
const;
18360 bool ShowRenderText(
bool & out_state)
const;
18370 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18375 bool ShowVisibility(
bool & out_state)
const;
18381 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18386 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18420 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeKit;};
18442 bool Empty()
const;
18626 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18632 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18638 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18644 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18654 bool ShowDeferral(
int & out_defer_batch)
const;
18700 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeControl;};
18866 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
18872 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18878 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18884 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18894 bool ShowDeferral(
int & out_defer_batch)
const;
18934 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsKit;};
18956 bool Empty()
const;
19019 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
19028 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19045 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19053 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
19102 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19111 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19120 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19150 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsControl;};
19210 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19226 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19284 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19293 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19302 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19347 bool Empty()
const;
19491 bool ShowCameraRotation(
bool & out_state)
const;
19496 bool ShowCameraScale(
bool & out_state)
const;
19501 bool ShowCameraTranslation(
bool & out_state)
const;
19506 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19511 bool ShowCameraProjection(
bool & out_state)
const;
19516 bool ShowCameraOffset(
bool & out_state)
const;
19521 bool ShowCameraNearLimit(
bool & out_state)
const;
19526 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19531 bool ShowModellingMatrixScale(
bool & out_state)
const;
19536 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19541 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19572 HPS::Type
ObjectType()
const {
return HPS::Type::TransformMaskControl;};
19707 bool ShowCameraRotation(
bool & out_state)
const;
19712 bool ShowCameraScale(
bool & out_state)
const;
19717 bool ShowCameraTranslation(
bool & out_state)
const;
19722 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19727 bool ShowCameraProjection(
bool & out_state)
const;
19732 bool ShowCameraOffset(
bool & out_state)
const;
19737 bool ShowCameraNearLimit(
bool & out_state)
const;
19742 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19747 bool ShowModellingMatrixScale(
bool & out_state)
const;
19752 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19757 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19813 bool Empty()
const;
19849 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19859 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19867 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19874 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19901 VisualEffectsKit & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
19912 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19972 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19977 bool ShowAntiAliasing(
bool & out_state)
const;
19986 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19994 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19999 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20004 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20009 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20019 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
20025 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20030 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20062 HPS::Type
ObjectType()
const {
return HPS::Type::VisualEffectsControl;};
20086 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
20096 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
20104 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20111 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20138 VisualEffectsControl & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
20149 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20210 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20215 bool ShowAntiAliasing(
bool & out_state)
const;
20224 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20232 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20237 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20242 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20247 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20257 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
20262 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20267 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20323 bool Empty()
const;
20350 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
20361 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
20399 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20452 bool ShowVisibility(
bool & out_state)
const;
20459 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20464 bool ShowColors(RGBColorArray & out_colors)
const;
20469 bool ShowPatterns(UTF8Array & out_patterns)
const;
20475 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20480 bool ShowLighting(
bool & out_state)
const;
20509 HPS::Type
ObjectType()
const {
return HPS::Type::ContourLineControl; };
20573 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20626 bool ShowVisibility(
bool & out_state)
const;
20633 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20638 bool ShowColors(RGBColorArray & out_colors)
const;
20643 bool ShowPatterns(UTF8Array & out_patterns)
const;
20649 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20654 bool ShowLighting(
bool & out_state)
const;
20709 bool Empty()
const;
20822 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
20958 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
21013 bool Empty()
const;
21049 bool ShowResourceMonitor(
bool & out_display)
const;
21092 bool ShowResourceMonitor(
bool & out_display)
const;
21097 bool ShowLastUpdateInfo(
UpdateInfo & out_info);
21146 bool Empty()
const;
21168 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
21174 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
21180 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
21186 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
21214 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21220 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21226 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21232 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21239 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21244 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21249 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21287 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21293 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21299 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21305 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21312 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21317 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21322 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21328 bool ShowMaxTextureSize(
unsigned int & out_width,
unsigned int & out_height)
const;
21334 bool ShowLastUpdateTime(Time & out_time)
const;
21339 bool ShowDepthPeelingLayers(
size_t & out_layers)
const;
21344 bool ShowVideoMemory(
size_t & out_video_memory)
const;
21349 bool ShowDepthBufferSize(
size_t & out_bits)
const;
21354 bool ShowMaxLights(
size_t & out_lights)
const;
21359 bool ShowColorBitPlanes(
size_t & out_planes)
const;
21411 bool Empty()
const;
21430 UTF8 GetName()
const;
21434 bool GetShellConvertibility()
const;
21487 bool Empty()
const;
21515 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21529 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21546 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
21563 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21575 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21606 HPS::Type
ObjectType()
const {
return HPS::Type::AttributeLockControl;}
21623 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21637 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21671 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21683 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21732 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
21737 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
21756 bool ShowPriority(
int & out_priority)
const;
21764 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21770 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21776 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21787 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21792 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
21799 size_t ShowUserDataCount()
const;
21804 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21810 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21816 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21853 void Consume(
LineKit & in_kit);
21857 void Set(
LineKit const & in_kit);
21861 void Show(
LineKit & out_kit)
const;
21870 bool Empty()
const;
21875 bool Equals(
LineKit const & in_kit)
const;
21880 bool operator==(
LineKit const & in_kit)
const;
21885 bool operator!=(
LineKit const & in_kit)
const;
21889 size_t GetPointCount()
const;
21897 LineKit & SetPriority(
int in_priority);
21906 bool ShowPriority(
int & out_priority)
const;
21912 LineKit & SetPoints(PointArray
const & in_points);
21918 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
21933 bool ShowPoints(PointArray & out_points)
const;
21940 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
21946 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
21953 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
21961 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21967 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21973 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21980 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21987 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21994 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22000 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22006 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22011 LineKit & UnsetUserData(intptr_t in_index);
22017 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22022 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
22026 LineKit & UnsetAllUserData();
22029 size_t ShowUserDataCount()
const;
22034 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22040 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22046 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22087 void Consume(
LineKit & in_kit);
22091 void Set(
LineKit const & in_kit);
22095 void Show(
LineKit & out_kit)
const;
22099 size_t GetPointCount()
const;
22104 LineKey & SetPoints(PointArray
const & in_points);
22110 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
22116 bool ShowPoints(PointArray & out_points)
const;
22123 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22129 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22136 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22144 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22150 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22156 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22163 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22170 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22219 bool Empty()
const;
22224 bool Equals(
MarkerKit const & in_kit)
const;
22229 bool operator==(
MarkerKit const & in_kit)
const;
22234 bool operator!=(
MarkerKit const & in_kit)
const;
22243 MarkerKit & SetPriority(
int in_priority);
22252 bool ShowPriority(
int & out_priority)
const;
22272 bool ShowPoint(
HPS::Point & out_point)
const;
22279 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22285 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22291 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22296 MarkerKit & UnsetUserData(intptr_t in_index);
22302 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22307 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
22314 size_t ShowUserDataCount()
const;
22319 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22325 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22331 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22391 bool ShowPoint(
Point & out_point)
const;
22440 bool Empty()
const;
22515 bool ShowPriority(
int & out_priority)
const;
22520 bool ShowDirection(
HPS::Vector & out_vector)
const;
22532 bool ShowCameraRelative(
bool & out_state)
const;
22539 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22545 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22551 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22562 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22574 size_t ShowUserDataCount()
const;
22579 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22585 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22591 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22675 bool ShowDirection(
HPS::Vector & out_vector)
const;
22687 bool ShowCameraRelative(
bool & out_state)
const;
22737 bool Empty()
const;
22747 bool operator==(
CylinderKit const & in_kit)
const;
22752 bool operator!=(
CylinderKit const & in_kit)
const;
22756 size_t GetPointCount()
const;
22773 bool ShowPriority(
int & out_priority)
const;
22779 CylinderKit & SetPoints(PointArray
const & in_points);
22790 CylinderKit & SetRadii(FloatArray
const & in_radii);
22796 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
22824 bool ShowPoints(PointArray & out_points)
const;
22831 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22837 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22844 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22849 bool ShowRadii(FloatArray & out_radii)
const;
22975 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22980 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
23013 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23027 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23034 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23040 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23046 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23057 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23062 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
23069 size_t ShowUserDataCount()
const;
23074 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23080 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23086 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23140 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23146 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
23152 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
23159 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23166 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
23174 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23180 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
23186 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
23193 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23200 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
23209 size_t GetPointCount()
const;
23214 bool ShowPoints(PointArray & out_points)
const;
23221 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
23227 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
23234 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
23239 bool ShowRadii(FloatArray & out_radii)
const;
23305 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23331 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23345 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23395 bool Empty()
const;
23400 bool Equals(
SphereKit const & in_kit)
const;
23405 bool operator==(
SphereKit const & in_kit)
const;
23410 bool operator!=(
SphereKit const & in_kit)
const;
23418 SphereKit & SetPriority(
int in_priority);
23427 bool ShowPriority(
int & out_priority)
const;
23437 SphereKit & SetRadius(
float in_radius);
23466 bool ShowCenter(
Point & out_center)
const;
23471 bool ShowRadius(
float & out_radius)
const;
23477 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23484 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23490 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23496 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23501 SphereKit & UnsetUserData(intptr_t in_index);
23507 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23512 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
23519 size_t ShowUserDataCount()
const;
23524 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23530 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23536 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23595 SphereKey & SetRadius(
float in_radius);
23607 bool ShowCenter(
Point & out_center)
const;
23612 bool ShowRadius(
float & out_radius)
const;
23618 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23668 bool Empty()
const;
23673 bool Equals(
CircleKit const & in_kit)
const;
23678 bool operator==(
CircleKit const & in_kit)
const;
23683 bool operator!=(
CircleKit const & in_kit)
const;
23691 CircleKit & SetPriority(
int const in_priority);
23700 bool ShowPriority(
int & out_priority)
const;
23712 CircleKit & SetRadius(
float in_radius);
23740 bool ShowCenter(
Point & out_center)
const;
23745 bool ShowRadius(
float & out_radius)
const;
23750 bool ShowNormal(
Vector & out_normal)
const;
23757 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23763 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23769 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23774 CircleKit & UnsetUserData(intptr_t in_index);
23780 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23785 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
23792 size_t ShowUserDataCount()
const;
23797 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23803 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23809 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23871 CircleKey & SetRadius(
float in_radius);
23882 bool ShowCenter(
Point & out_center)
const;
23887 bool ShowRadius(
float & out_radius)
const;
23892 bool ShowNormal(
Vector & out_normal)
const;
23942 bool Empty()
const;
23974 bool ShowPriority(
int & out_priority)
const;
24013 bool ShowStart(
Point & out_start)
const;
24018 bool ShowMiddle(
Point & out_middle)
const;
24023 bool ShowEnd(
Point & out_end)
const;
24030 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24036 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24042 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24053 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24058 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
24065 size_t ShowUserDataCount()
const;
24070 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24076 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24082 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24154 bool ShowStart(
Point & out_start)
const;
24159 bool ShowMiddle(
Point & out_middle)
const;
24164 bool ShowEnd(
Point & out_end)
const;
24192 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKit; };
24213 bool Empty()
const;
24246 bool ShowPriority(
int & out_priority)
const;
24285 bool ShowStart(
Point & out_start)
const;
24290 bool ShowMiddle(
Point & out_middle)
const;
24295 bool ShowEnd(
Point & out_end)
const;
24302 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24308 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24314 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24325 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24337 size_t ShowUserDataCount()
const;
24342 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24348 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24354 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24393 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKey; };
24428 bool ShowStart(
Point & out_start)
const;
24433 bool ShowMiddle(
Point & out_middle)
const;
24438 bool ShowEnd(
Point & out_end)
const;
24466 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKit; };
24487 bool Empty()
const;
24519 bool ShowPriority(
int & out_priority)
const;
24561 size_t GetPlaneCount()
const;
24566 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24589 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24605 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24614 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24621 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24633 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24644 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24656 size_t ShowUserDataCount()
const;
24661 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24667 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24673 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24710 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKey; };
24752 size_t GetPlaneCount()
const;
24757 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24780 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24796 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24803 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24852 bool Empty()
const;
24884 bool ShowPriority(
int & out_priority)
const;
24923 bool ShowFirst(
Point & out_first)
const;
24928 bool ShowSecond(
Point & out_second)
const;
24940 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24946 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24952 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24963 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24975 size_t ShowUserDataCount()
const;
24980 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24986 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24992 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25063 bool ShowFirst(
Point & out_first)
const;
25068 bool ShowSecond(
Point & out_second)
const;
25129 bool Empty()
const;
25198 SpotlightKit & SetConcentration(
float in_concentration);
25248 bool ShowPriority(
int & out_priority)
const;
25253 bool ShowPosition(
HPS::Point & out_position)
const;
25258 bool ShowTarget(
HPS::Point & out_target)
const;
25282 bool ShowConcentration(
float & out_concentration)
const;
25287 bool ShowCameraRelative(
bool & out_state)
const;
25294 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25300 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25306 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25317 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25322 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
25329 size_t ShowUserDataCount()
const;
25334 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25340 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25346 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25441 SpotlightKey & SetConcentration(
float in_concentration);
25459 bool ShowPosition(
HPS::Point & out_position)
const;
25464 bool ShowTarget(
HPS::Point & out_target)
const;
25488 bool ShowConcentration(
float & out_concentration)
const;
25493 bool ShowCameraRelative(
bool & out_state)
const;
25542 bool Empty()
const;
25561 size_t GetPointCount()
const;
25578 bool ShowPriority(
int & out_priority)
const;
25605 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
25616 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
25622 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
25653 bool ShowDegree(
size_t & out_degree)
const;
25658 bool ShowPoints(PointArray & out_points)
const;
25665 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25671 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25678 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25683 bool ShowWeights(FloatArray & out_weights)
const;
25688 bool ShowKnots(FloatArray & out_knots)
const;
25694 bool ShowParameters(
float & out_start,
float & out_end)
const;
25703 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25710 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25718 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25726 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25734 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25744 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25752 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25761 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25769 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25777 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25785 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25791 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25798 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
25806 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25814 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25821 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25827 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25833 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25844 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25849 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
25856 size_t ShowUserDataCount()
const;
25861 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25867 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25873 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25926 size_t GetPointCount()
const;
25932 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
25937 bool ShowDegree(
size_t & out_degree)
const;
25942 bool ShowPoints(PointArray & out_points)
const;
25949 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25955 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25962 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25967 bool ShowWeights(FloatArray & out_weights)
const;
25972 bool ShowKnots(FloatArray & out_knots)
const;
25978 bool ShowParameters(
float & out_start,
float & out_end)
const;
25988 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25996 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26007 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26016 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26026 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26034 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26083 bool Empty()
const;
26102 size_t GetPointCount()
const;
26119 bool ShowPriority(
int & out_priority)
const;
26163 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
26176 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
26189 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
26247 bool ShowUDegree(
size_t & out_degree)
const;
26252 bool ShowVDegree(
size_t & out_degree)
const;
26257 bool ShowUCount(
size_t & out_count)
const;
26262 bool ShowVCount(
size_t & out_count)
const;
26267 bool ShowPoints(PointArray & out_points)
const;
26274 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26280 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26287 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26292 bool ShowWeights(FloatArray & out_weights)
const;
26297 bool ShowUKnots(FloatArray & out_knots)
const;
26302 bool ShowVKnots(FloatArray & out_knots)
const;
26307 bool ShowTrims(TrimKitArray & out_trims)
const;
26316 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26323 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
26331 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
26339 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26347 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26357 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26365 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
26374 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
26382 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26390 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26399 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26406 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26414 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
26422 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26430 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26439 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26446 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26454 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
26462 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26470 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26477 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26483 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26489 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26500 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26512 size_t ShowUserDataCount()
const;
26517 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26523 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26529 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26582 size_t GetPointCount()
const;
26604 bool ShowUDegree(
size_t & out_degree)
const;
26609 bool ShowVDegree(
size_t & out_degree)
const;
26614 bool ShowUCount(
size_t & out_count)
const;
26619 bool ShowVCount(
size_t & out_count)
const;
26624 bool ShowPoints(PointArray & out_points)
const;
26631 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26637 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26644 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26649 bool ShowWeights(FloatArray & out_weights)
const;
26654 bool ShowUKnots(FloatArray & out_knots)
const;
26659 bool ShowVKnots(FloatArray & out_knots)
const;
26664 bool ShowTrims(TrimKitArray & out_trims)
const;
26674 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26682 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26693 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26702 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26712 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26720 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26730 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26738 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26795 bool operator==(
TrimElement const & in_that)
const;
26800 bool operator!=(
TrimElement const & in_that)
const;
26806 void SetCurve(
LineKit const & in_line);
26850 void Set(
TrimKit const & in_kit);
26854 void Show(
TrimKit & out_kit)
const;
26863 bool Empty()
const;
26868 bool Equals(
TrimKit const & in_kit)
const;
26873 bool operator==(
TrimKit const & in_kit)
const;
26878 bool operator!=(
TrimKit const & in_kit)
const;
26890 TrimKit & SetShape(TrimElementArray
const & in_shape);
26914 bool ShowShape(TrimElementArray & out_shape)
const;
26968 bool Empty()
const;
26973 bool Equals(
EllipseKit const & in_kit)
const;
26978 bool operator==(
EllipseKit const & in_kit)
const;
26983 bool operator!=(
EllipseKit const & in_kit)
const;
27000 bool ShowPriority(
int & out_priority)
const;
27039 bool ShowCenter(
Point & out_center)
const;
27044 bool ShowMajor(
Point & out_major)
const;
27049 bool ShowMinor(
Point & out_minor)
const;
27056 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27062 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27068 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27073 EllipseKit & UnsetUserData(intptr_t in_index);
27079 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27084 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
27091 size_t ShowUserDataCount()
const;
27096 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27102 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27108 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27180 bool ShowCenter(
Point & out_center)
const;
27185 bool ShowMajor(
Point & out_major)
const;
27190 bool ShowMinor(
Point & out_minor)
const;
27218 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKit; };
27239 bool Empty()
const;
27271 bool ShowPriority(
int & out_priority)
const;
27336 bool ShowCenter(
Point & out_center)
const;
27341 bool ShowMajor(
Point & out_major)
const;
27346 bool ShowMinor(
Point & out_minor)
const;
27351 bool ShowStart(
float & out_start)
const;
27356 bool ShowEnd(
float & out_end)
const;
27363 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27369 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27375 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27386 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27398 size_t ShowUserDataCount()
const;
27403 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27409 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27415 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27452 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKey; };
27505 bool ShowCenter(
Point & out_center)
const;
27510 bool ShowMajor(
Point & out_major)
const;
27515 bool ShowMinor(
Point & out_minor)
const;
27520 bool ShowStart(
float & out_start)
const;
27525 bool ShowEnd(
float & out_end)
const;
27557 void Consume(
TextKit & in_kit);
27561 void Set(
TextKit const & in_kit);
27565 void Show(
TextKit & out_kit)
const;
27574 bool Empty()
const;
27579 bool Equals(
TextKit const & in_kit)
const;
27584 bool operator==(
TextKit const & in_kit)
const;
27589 bool operator!=(
TextKit const & in_kit)
const;
27597 TextKit & SetPriority(
int in_priority);
27606 bool ShowPriority(
int & out_priority)
const;
27616 TextKit & SetText(
char const * in_string);
27626 TextKit & SetColorByIndex(
float in_index);
27643 TextKit & SetBold(
bool in_state);
27648 TextKit & SetItalic(
bool in_state);
27653 TextKit & SetOverline(
bool in_state);
27658 TextKit & SetStrikethrough(
bool in_state);
27663 TextKit & SetUnderline(
bool in_state);
27669 TextKit & SetSlant(
float in_angle);
27674 TextKit & SetLineSpacing(
float in_multiplier);
27686 TextKit & SetRotation(
float in_angle);
27746 TextKit & SetFont(
char const * in_name);
27781 TextKit & SetSpacing(
float in_multiplier);
27798 TextKit & UnsetModellingMatrix();
27818 TextKit & UnsetStrikethrough();
27830 TextKit & UnsetLineSpacing();
27846 TextKit & UnsetSizeTolerance();
27884 bool ShowPosition(
Point & out_position)
const;
27889 bool ShowText(
UTF8 & out_string)
const;
27901 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27913 bool ShowBold(
bool & out_state)
const;
27918 bool ShowItalic(
bool & out_state)
const;
27923 bool ShowOverline(
bool & out_state)
const;
27928 bool ShowStrikethrough(
bool & out_state)
const;
27933 bool ShowUnderline(
bool & out_state)
const;
27938 bool ShowSlant(
float & out_angle)
const;
27943 bool ShowLineSpacing(
float & out_multiplier)
const;
27949 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27956 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27982 bool ShowFont(
UTF8 & out_name)
const;
28005 bool ShowPath(
Vector & out_path)
const;
28010 bool ShowSpacing(
float & out_multiplier)
const;
28020 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28028 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28036 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28046 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
28060 TextKit & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28075 TextKit & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28082 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
28092 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
28098 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
28103 TextKit & UnsetUserData(intptr_t in_index);
28109 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
28114 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
28118 TextKit & UnsetAllUserData();
28121 size_t ShowUserDataCount()
const;
28126 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
28132 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
28138 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
28179 void Consume(
TextKit & in_kit);
28183 void Set(
TextKit const & in_kit);
28187 void Show(
TextKit & out_kit)
const;
28206 TextKey & SetText(
char const * in_string);
28216 TextKey & SetColorByIndex(
float in_index);
28233 TextKey & SetBold(
bool in_state);
28238 TextKey & SetItalic(
bool in_state);
28243 TextKey & SetOverline(
bool in_state);
28248 TextKey & SetStrikethrough(
bool in_state);
28253 TextKey & SetUnderline(
bool in_state);
28259 TextKey & SetSlant(
float in_angle);
28265 TextKey & SetLineSpacing(
float in_multiplier);
28277 TextKey & SetRotation(
float in_angle);
28337 TextKey & SetFont(
char const * in_name);
28374 TextKey & SetSpacing(
float in_multiplier);
28388 TextKey & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28403 TextKey & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
28412 TextKey & UnsetModellingMatrix();
28432 TextKey & UnsetStrikethrough();
28444 TextKey & UnsetLineSpacing();
28460 TextKey & UnsetSizeTolerance();
28502 bool ShowPosition(
Point & out_position)
const;
28507 bool ShowText(
UTF8 & out_string)
const;
28519 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28531 bool ShowBold(
bool & out_state)
const;
28536 bool ShowItalic(
bool & out_state)
const;
28541 bool ShowOverline(
bool & out_state)
const;
28546 bool ShowStrikethrough(
bool & out_state)
const;
28551 bool ShowUnderline(
bool & out_state)
const;
28556 bool ShowSlant(
float & out_angle)
const;
28561 bool ShowLineSpacing(
float & out_multiplier)
const;
28567 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28574 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28600 bool ShowFont(
UTF8 & out_name)
const;
28623 bool ShowPath(
Vector & out_path)
const;
28628 bool ShowSpacing(
float & out_multiplier)
const;
28638 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
28648 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28656 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28664 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28686 HPS::Type
ObjectType()
const {
return HPS::Type::ShellOptimizationOptionsKit; };
28712 bool Empty()
const;
28783 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
28794 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
28829 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationOptionsKit; };
28855 bool Empty()
const;
28919 bool ShowTolerance(
float & out_tolerance)
const;
28929 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
28934 bool ShowNearestFaceCalculation(
bool & out_state)
const;
28960 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationResultsKit; };
28981 bool Empty()
const;
29002 bool ShowRelations(ShellRelationArray & out_results)
const;
29007 bool ShowNearestFaces(SizeTArray & out_faces)
const;
29012 bool ShowDistances(FloatArray & out_distances)
const;
29047 void Set(
ShellKit const & in_kit);
29051 void Show(
ShellKit & out_kit)
const;
29055 size_t GetPointCount()
const;
29059 size_t GetFaceCount()
const;
29068 bool Empty()
const;
29073 bool Equals(
ShellKit const & in_kit)
const;
29078 bool operator==(
ShellKit const & in_kit)
const;
29083 bool operator!=(
ShellKit const & in_kit)
const;
29091 ShellKit & SetPriority(
int in_priority);
29100 bool ShowPriority(
int & out_priority)
const;
29107 ShellKit & SetPoints(PointArray
const & in_points);
29113 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
29118 ShellKit & SetFacelist(IntArray
const & in_facelist);
29124 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
29129 ShellKit & SetTristrips(IntArray
const & in_tristrips);
29135 ShellKit & SetTristrips(
size_t in_count,
int const in_tristrips []);
29156 bool ShowPoints(PointArray & out_points)
const;
29163 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
29169 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
29176 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
29181 bool ShowFacelist(IntArray & out_facelist)
const;
29186 bool ShowTristrips(IntArray & out_tristrips)
const;
29366 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29372 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29379 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29386 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29392 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29399 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29405 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29414 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29422 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29432 ShellKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29441 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29449 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29455 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29462 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29469 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29475 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29482 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29488 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29493 ShellKit & UnsetMaterialMapping();
29504 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29509 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29539 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29544 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29549 ShellKit & UnsetVertexParameters();
29555 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29560 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29565 ShellKit & UnsetVertexVisibilities();
29571 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29576 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29581 ShellKit & UnsetVertexEverything();
29603 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29604 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29620 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29621 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29632 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29642 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29654 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
29665 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29676 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
29687 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29698 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29708 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29717 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
29723 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
29730 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
29737 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
29743 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
29750 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
29756 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
29764 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
29770 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
29777 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
29784 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
29790 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
29797 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
29803 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
29811 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29817 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29824 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29831 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
29837 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
29844 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
29850 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
29858 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29864 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29871 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29878 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
29884 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
29891 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
29897 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
29908 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
29913 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
29924 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
29929 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
29934 ShellKit & UnsetFaceVisibilities();
29940 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
29945 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
29962 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29974 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29985 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29995 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
30006 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30016 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30025 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30032 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
30039 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
30046 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30053 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
30062 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30069 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
30076 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
30086 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30095 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30124 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
30130 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
30136 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
30141 ShellKit & UnsetUserData(intptr_t in_index);
30147 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
30152 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
30159 size_t ShowUserDataCount()
const;
30164 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
30170 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
30176 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
30223 void Set(
ShellKit const & in_kit);
30227 void Show(
ShellKit & out_kit)
const;
30231 size_t GetPointCount()
const;
30235 size_t GetFaceCount()
const;
30241 ShellKey & SetPoints(PointArray
const & in_points);
30247 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
30252 ShellKey & SetFacelist(IntArray
const & in_facelist);
30258 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
30263 ShellKey & SetTristrips(IntArray
const & in_tristrips);
30269 ShellKey & SetTristrips(
size_t in_count,
int const in_tristrips []);
30291 ShellKey & UnsetMaterialMapping();
30300 bool ShowPoints(PointArray & out_points)
const;
30307 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
30313 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
30320 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
30325 bool ShowFacelist(IntArray & out_facelist)
const;
30330 bool ShowTristrips(IntArray & out_tristrips)
const;
30511 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30518 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30525 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30532 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30538 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30545 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30551 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30561 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30569 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30579 ShellKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30588 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30596 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30603 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30610 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30617 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
30623 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
30630 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
30636 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
30647 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
30652 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
30682 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
30687 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
30692 ShellKey & UnsetVertexParameters();
30698 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
30703 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
30708 ShellKey & UnsetVertexVisibilities();
30714 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
30719 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
30724 ShellKey & UnsetVertexEverything();
30740 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30741 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30757 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30758 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30769 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30779 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
30791 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
30802 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30813 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
30824 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30835 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30845 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30853 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
30860 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
30867 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
30874 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
30880 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
30887 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
30893 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
30901 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
30908 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
30915 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
30922 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
30928 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
30935 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
30941 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
30949 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30956 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30963 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30970 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
30976 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
30983 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
30989 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
30997 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31004 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31011 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31018 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
31024 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
31031 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
31037 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
31048 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
31053 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
31064 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
31069 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
31074 ShellKey & UnsetFaceVisibilities();
31080 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
31085 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
31102 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31114 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31125 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31135 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31143 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
31151 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
31162 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31172 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31181 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31188 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
31195 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
31202 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31209 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
31218 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31225 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
31232 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
31242 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31251 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
31305 void Consume(
MeshKit & in_kit);
31309 void Set(
MeshKit const & in_kit);
31313 void Show(
MeshKit & out_kit)
const;
31322 bool Empty()
const;
31327 bool Equals(
MeshKit const & in_kit)
const;
31332 bool operator==(
MeshKit const & in_kit)
const;
31337 bool operator!=(
MeshKit const & in_kit)
const;
31341 size_t GetPointCount()
const;
31349 MeshKit & SetPriority(
int in_priority);
31358 bool ShowPriority(
int & out_priority)
const;
31363 MeshKit & SetPoints(PointArray
const & in_points);
31369 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
31376 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, HPS::PointArray
const & in_points);
31384 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31389 MeshKit & SetRows(
size_t in_rows);
31394 MeshKit & SetColumns(
size_t in_columns);
31415 bool ShowPoints(PointArray & out_points)
const;
31422 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
31428 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
31435 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
31442 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31447 bool ShowRows(
size_t & out_rows)
const;
31452 bool ShowColumns(
size_t & out_columns)
const;
31632 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31638 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31645 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31652 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
31658 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
31665 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
31671 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
31680 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31688 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
31698 MeshKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31707 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
31715 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31721 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31728 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31735 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31741 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31748 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31754 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31759 MeshKit & UnsetMaterialMapping();
31763 MeshKit & UnsetVertexColors();
31769 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31774 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31798 MeshKit & UnsetVertexNormals();
31804 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31809 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31814 MeshKit & UnsetVertexParameters();
31820 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31825 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31830 MeshKit & UnsetVertexVisibilities();
31836 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31841 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31846 MeshKit & UnsetVertexEverything();
31867 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31868 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31884 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31885 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31896 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31906 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
31918 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
31929 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31940 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
31951 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31962 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31972 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31980 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31986 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31993 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
32000 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32006 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32013 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32019 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32027 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32033 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32040 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32047 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32053 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32060 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32066 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32074 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32080 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32087 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32094 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
32100 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32107 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32113 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32121 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32127 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32134 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32141 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32147 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32154 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32160 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32171 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32176 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
32181 MeshKit & UnsetFaceNormals();
32187 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32192 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
32197 MeshKit & UnsetFaceVisibilities();
32203 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32208 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
32213 MeshKit & UnsetFaceEverything();
32225 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32237 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32248 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32258 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32269 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32279 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32286 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32292 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32298 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32303 MeshKit & UnsetUserData(intptr_t in_index);
32309 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32314 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
32318 MeshKit & UnsetAllUserData();
32321 size_t ShowUserDataCount()
const;
32326 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32332 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32338 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32382 void Consume(
MeshKit & in_kit);
32386 void Set(
MeshKit const & in_kit);
32390 void Show(
MeshKit & out_kit)
const;
32394 size_t GetPointCount()
const;
32401 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
32409 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
32414 bool ShowPoints(PointArray & out_points)
const;
32421 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
32427 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
32434 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
32441 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
32446 bool ShowRows(
size_t & out_rows)
const;
32451 bool ShowColumns(
size_t & out_columns)
const;
32462 MeshKey & UnsetMaterialMapping();
32643 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32650 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32657 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32664 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
32670 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
32677 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
32683 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
32693 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32701 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
32711 MeshKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32720 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
32728 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32735 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32742 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32749 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
32755 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
32762 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
32768 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
32773 MeshKey & UnsetVertexColors();
32779 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
32784 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
32808 MeshKey & UnsetVertexNormals();
32814 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
32819 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
32824 MeshKey & UnsetVertexParameters();
32830 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
32835 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
32840 MeshKey & UnsetVertexVisibilities();
32846 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
32851 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
32856 MeshKey & UnsetVertexEverything();
32876 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32877 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32893 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32894 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32905 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32915 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32927 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32938 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32949 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32960 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32971 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32981 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32989 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32996 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
33003 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
33010 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
33016 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
33023 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
33029 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
33037 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
33044 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
33051 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
33058 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
33064 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
33071 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
33077 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
33085 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
33092 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
33099 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
33106 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
33112 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
33119 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
33125 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
33133 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
33140 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
33147 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
33154 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
33160 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
33167 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
33173 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
33184 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
33189 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
33194 MeshKey & UnsetFaceNormals();
33200 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
33205 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
33210 MeshKey & UnsetFaceVisibilities();
33216 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
33221 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
33226 MeshKey & UnsetFaceEverything();
33238 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33250 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33261 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33271 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
33282 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33292 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33302 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count,
size_t in_point_count,
Point const in_points[]);
33311 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count, PointArray
const & in_points);
33361 bool Empty()
const;
33366 bool Equals(
PolygonKit const & in_kit)
const;
33371 bool operator==(
PolygonKit const & in_kit)
const;
33376 bool operator!=(
PolygonKit const & in_kit)
const;
33380 size_t GetPointCount()
const;
33397 bool ShowPriority(
int & out_priority)
const;
33403 PolygonKit & SetPoints(PointArray
const & in_points);
33422 bool ShowPoints(PointArray & out_points)
const;
33429 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33435 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33442 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33449 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33455 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33461 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33468 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33474 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33481 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33487 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33493 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33498 PolygonKit & UnsetUserData(intptr_t in_index);
33504 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33509 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
33516 size_t ShowUserDataCount()
const;
33521 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33527 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33533 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33588 size_t GetPointCount()
const;
33593 PolygonKey & SetPoints(PointArray
const & in_points);
33604 bool ShowPoints(PointArray & out_points)
const;
33611 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33617 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33624 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33631 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33637 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33643 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33650 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33656 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33683 void Consume(
GridKit & in_kit);
33687 void Set(
GridKit const & in_kit);
33691 void Show(
GridKit & out_kit)
const;
33705 bool Empty()
const;
33710 bool Equals(
GridKit const & in_kit)
const;
33715 bool operator==(
GridKit const & in_kit)
const;
33720 bool operator!=(
GridKit const & in_kit)
const;
33729 GridKit & SetPriority(
int in_priority);
33747 GridKit & SetFirstPoint(
Point const & in_first_point);
33756 GridKit & SetSecondPoint(
Point const & in_second_point);
33771 GridKit & SetFirstCount(
int in_first_count);
33783 GridKit & SetSecondCount(
int in_second_count);
33804 GridKit & UnsetSecondPoint();
33812 GridKit & UnsetSecondCount();
33822 bool ShowPriority(
int & out_priority)
const;
33832 bool ShowOrigin(
Point & out_origin)
const;
33837 bool ShowFirstPoint(
Point & out_first_point)
const;
33842 bool ShowSecondPoint(
Point & out_second_point)
const;
33847 bool ShowFirstCount(
int & out_first_count)
const;
33852 bool ShowSecondCount(
int & out_second_count)
const;
33859 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33865 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33871 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33876 GridKit & UnsetUserData(intptr_t in_index);
33882 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33887 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
33891 GridKit & UnsetAllUserData();
33894 size_t ShowUserDataCount()
const;
33899 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33905 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33911 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33952 void Consume(
GridKit & in_kit);
33956 void Set(
GridKit const & in_kit);
33960 void Show(
GridKit & out_kit)
const;
33979 GridKey & SetFirstPoint(
Point const & in_first_point);
33988 GridKey & SetSecondPoint(
Point const & in_second_point);
34003 GridKey & SetFirstCount(
int in_first_count);
34015 GridKey & SetSecondCount(
int in_second_count);
34027 bool ShowOrigin(
Point & out_origin)
const;
34032 bool ShowFirstPoint(
Point & out_first_point)
const;
34037 bool ShowSecondPoint(
Point & out_second_point)
const;
34042 bool ShowFirstCount(
int & out_first_count)
const;
34047 bool ShowSecondCount(
int & out_second_count)
const;
34123 bool ShowPriority(
int & out_priority)
const;
34128 bool ShowCondition(
Condition & out_condition)
const;
34150 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
34172 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34179 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34254 bool ShowCondition(
Condition & out_condition)
const;
34277 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
34299 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34306 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34357 Key GetTarget()
const;
34362 size_t ShowTargets(
bool masked=
true)
const;
34368 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
34373 size_t ShowGeometryMask()
const;
34379 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
34384 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
34392 void SetModellingMatrix(
MatrixKit const & in_kit);
34406 void UnsetModellingMatrix();
34416 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
34421 bool ShowCondition(
Condition & out_condition)
const;
34460 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsKit; };
34482 bool Empty()
const;
34568 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34573 bool ShowTitle(
UTF8 & out_window_name)
const;
34578 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34588 bool ShowFullScreen(
bool & out_state)
const;
34622 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsControl; };
34654 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34659 bool ShowTitle(
UTF8 & out_window_name)
const;
34664 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34674 bool ShowFullScreen(
bool & out_state)
const;
34708 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsKit; };
34730 bool Empty()
const;
34814 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34819 bool ShowHardwareResident(
bool & out_state)
const;
34831 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
34859 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsKit; };
34881 bool Empty()
const;
34948 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34953 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34958 bool ShowFramebufferRetention(
bool & out_retain)
const;
34989 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsControl; };
35000 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35010 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
35015 bool ShowPlatformData(PlatformData & out_platform_data)
const;
35020 bool ShowFramebufferRetention(
bool & out_retain)
const;
35071 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowKey; };
35122 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowKey; };
35199 void SetIndexedColor(byte in_index);
35202 void SetNormalColor();
35206 void SetExplicitColor(
RGBAColor const & in_color);
35260 HPS::Type
ObjectType()
const {
return HPS::Type::LineGlyphElement; };
35264 void SetPoints(GlyphPointArray
const & in_points);
35269 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
35274 bool ShowPoints(GlyphPointArray & out_points)
const;
35319 bool ShowPoint(
GlyphPoint & out_point)
const;
35357 HPS::Type
ObjectType()
const {
return HPS::Type::EllipseGlyphElement; };
35361 void SetLowerLeft(
GlyphPoint const & in_point);
35365 void SetUpperRight(
GlyphPoint const & in_point);
35375 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
35380 bool ShowUpperRight(
GlyphPoint & out_point)
const;
35419 HPS::Type
ObjectType()
const {
return HPS::Type::CircularArcGlyphElement; };
35423 void SetStartPoint(
GlyphPoint const & in_point);
35427 void SetIntermediatePoint(
GlyphPoint const & in_point);
35431 void SetEndPoint(
GlyphPoint const & in_point);
35442 bool ShowStartPoint(
GlyphPoint & out_point)
const;
35447 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
35452 bool ShowEndPoint(
GlyphPoint & out_point)
const;
35492 HPS::Type
ObjectType()
const {
return HPS::Type::InfiniteLineGlyphElement; };
35496 void SetFirstPoint(
GlyphPoint const & in_point);
35500 void SetSecondPoint(
GlyphPoint const & in_point);
35514 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
35519 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
35561 void Set(
GlyphKit const & in_kit);
35565 void Show(
GlyphKit & out_kit)
const;
35574 bool Empty()
const;
35579 bool Equals(
GlyphKit const & in_kit)
const;
35584 bool operator==(
GlyphKit const & in_kit)
const;
35589 bool operator!=(
GlyphKit const & in_kit)
const;
35594 GlyphKit & SetRadius(sbyte in_radius);
35605 GlyphKit & SetElements(GlyphElementArray
const & in_def);
35632 bool ShowRadius(sbyte & out_radius)
const;
35637 bool ShowOffset(
GlyphPoint & out_point)
const;
35642 bool ShowElements(GlyphElementArray & out_def)
const;
35674 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternOptionsKit; };
35691 bool Empty()
const;
35817 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternElement; };
35889 HPS::Type
ObjectType()
const {
return HPS::Type::SolidLinePatternElement; };
35894 void SetColor(
RGBAColor const & in_color);
35899 void SetMaterialByIndex(
float in_material_index);
35944 HPS::Type
ObjectType()
const {
return HPS::Type::BlankLinePatternElement; };
35982 HPS::Type
ObjectType()
const {
return HPS::Type::GlyphLinePatternElement; };
35986 void SetSource(
char const * in_source);
35999 void SetMirror(
bool in_state);
36003 void SetFixed(
bool in_state);
36007 void SetRotation(
float in_degrees);
36012 bool ShowSource(
UTF8 & out_source)
const;
36028 bool ShowMirror(
bool & out_state)
const;
36033 bool ShowFixed(
bool & out_state)
const;
36038 bool ShowRotation(
float & out_degrees)
const;
36064 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternParallelKit; };
36081 bool Empty()
const;
36221 bool ShowBody(LinePatternElementArray & out_elements)
const;
36226 bool ShowAbsoluteLength(
bool & out_state)
const;
36231 bool ShowAbsoluteWeight(
bool & out_state)
const;
36255 bool ShowContinuous(
bool & out_state)
const;
36304 bool Empty()
const;
36324 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
36352 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
36410 virtual void Assign(
Definition const & in_that);
36415 bool Equals(
Definition const & in_that)
const;
36420 bool operator==(
Definition const & in_that)
const;
36425 bool operator!=(
Definition const & in_that)
const;
36571 ShaderDefinition DefineShader(
char const * in_name, ShaderKit
const & in_source);
36594 PortfolioKey & UndefineNamedStyle(
char const * in_name);
36599 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
36609 PortfolioKey & UndefineLinePattern(
char const * in_name);
36722 ShaderDefinition ImportShader(ShaderDefinition
const & in_definition);
36727 size_t GetDefinitionCount()
const;
36730 size_t GetTextureDefinitionCount()
const;
36733 size_t GetCubeMapDefinitionCount()
const;
36736 size_t GetImageDefinitionCount()
const;
36739 size_t GetNamedStyleDefinitionCount()
const;
36742 size_t GetMaterialPaletteDefinitionCount()
const;
36745 size_t GetGlyphDefinitionCount()
const;
36748 size_t GetLinePatternDefinitionCount()
const;
36751 size_t GetShaderDefinitionCount()
const;
36757 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
36762 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
36768 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
36773 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
36779 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
36784 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
36795 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
36806 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
36812 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
36817 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
36828 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
36834 bool ShowShaderDefinition(
char const * in_name, ShaderDefinition & out_found)
const;
36839 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
36843 void MoveTo(
SegmentKey const & in_new_owner);
36889 void Set(
GlyphKit const & in_kit);
36893 void Show(
GlyphKit & out_kit)
const;
36931 HPS::Type
ObjectType()
const {
return HPS::Type::TextureDefinition; };
36976 HPS::Type
ObjectType()
const {
return HPS::Type::TextureOptionsKit; };
36998 bool Empty()
const;
37104 bool ShowDecal(
bool & out_state)
const;
37109 bool ShowDownSampling(
bool & out_state)
const;
37114 bool ShowModulation(
bool & out_state)
const;
37119 bool ShowParameterOffset(
size_t & out_offset)
const;
37144 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37193 HPS::Type
ObjectType()
const {
return HPS::Type::ImageExportOptionsKit; };
37215 bool Empty()
const;
37236 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37260 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37291 HPS::Type
ObjectType()
const {
return HPS::Type::ImageImportOptionsKit; };
37308 bool Empty()
const;
37331 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37374 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37384 bool ShowDownSampling(
bool & out_state)
const;
37389 bool ShowCompressionQuality(
float & out_quality)
const;
37418 static void Export(
char const * in_file_name,
HPS::WindowKey const & in_window,
unsigned int in_width,
unsigned int in_height,
Format in_format = Format::Png);
37424 static void Export(
char const * in_file_name,
HPS::ImageKit const & in_image_kit);
37470 void Set(
ImageKit const & in_kit);
37474 void Show(
ImageKit & out_kit)
const;
37483 bool Empty()
const;
37488 bool Equals(
ImageKit const & in_kit)
const;
37493 bool operator==(
ImageKit const & in_kit)
const;
37498 bool operator!=(
ImageKit const & in_kit)
const;
37513 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37518 ImageKit & SetData(ByteArray
const & in_image_data);
37524 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
37534 ImageKit & SetDownSampling(
bool in_state);
37539 ImageKit & SetCompressionQuality(
float in_quality);
37559 ImageKit & UnsetCompressionQuality();
37569 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37574 bool ShowData(ByteArray & out_image_data)
const;
37584 bool ShowDownSampling(
bool & out_state)
const;
37589 bool ShowCompressionQuality(
float & out_quality)
const;
37621 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsControl; };
37649 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
37655 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37667 bool ShowImage(ByteArray & out_bytes)
const;
37672 bool ShowHardwareResident(
bool & out_state)
const;
37678 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
37723 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowKey; };
37780 void Set(
ImageKit const & in_kit);
37784 void Show(
ImageKit & out_kit)
const;
37821 HPS::Type
ObjectType()
const {
return HPS::Type::CubeMapDefinition; };
37848 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
37894 HPS::Type
ObjectType()
const {
return HPS::Type::NamedStyleDefinition; };
37937 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialPaletteDefinition; };
37941 void Set(MaterialKitArray
const & in_source);
37946 void Set(
size_t in_count,
MaterialKit const in_source []);
37950 void Show(MaterialKitArray & out_source)
const;
37989 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternDefinition; };
38003 class HPS_API Shader
38008 enum class Parameterization
38013 PhysicalReflection,
38035 class HPS_API ImportOptionsKit :
public Object
38039 ImportOptionsKit();
38043 ImportOptionsKit(ImportOptionsKit
const & in_kit);
38048 ImportOptionsKit(ImportOptionsKit && in_that);
38053 ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38055 virtual ~ImportOptionsKit();
38057 HPS::Type ObjectType()
const {
return HPS::Type::ShaderImportOptionsKit; };
38061 void Set(ImportOptionsKit
const & in_kit);
38065 void Show(ImportOptionsKit & out_kit)
const;
38070 ImportOptionsKit & operator=(ImportOptionsKit
const & in_kit);
38074 bool Empty()
const;
38079 bool Equals(ImportOptionsKit
const & in_kit)
const;
38084 bool operator==(ImportOptionsKit
const & in_kit)
const;
38089 bool operator!=(ImportOptionsKit
const & in_kit)
const;
38097 ImportOptionsKit & SetMultitexture(
bool in_state);
38102 ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38107 ImportOptionsKit & SetTransformMatrix(MatrixKit
const & in_transform);
38112 ImportOptionsKit & UnsetMultitexture();
38116 ImportOptionsKit & UnsetParameterizationSource();
38120 ImportOptionsKit & UnsetTransformMatrix();
38124 ImportOptionsKit & UnsetEverything();
38131 bool ShowMultitexture(
bool & out_state)
const;
38136 bool ShowParameterizationSource(Parameterization & out_source)
const;
38141 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38153 static ShaderKit Import(
char const * in_file_name, ImportOptionsKit
const & in_options);
38167 class HPS_API ShaderKit :
public Object
38175 ShaderKit(ShaderKit
const & in_kit);
38180 ShaderKit(ShaderKit && in_that);
38185 ShaderKit & operator=(ShaderKit && in_that);
38187 virtual ~ShaderKit();
38189 HPS::Type ObjectType()
const {
return HPS::Type::ShaderKit; };
38193 void Set(ShaderKit
const & in_kit);
38197 void Show(ShaderKit & out_kit)
const;
38202 ShaderKit & operator=(ShaderKit
const & in_kit);
38206 bool Empty()
const;
38211 bool Equals(ShaderKit
const & in_kit)
const;
38216 bool operator==(ShaderKit
const & in_kit)
const;
38221 bool operator!=(ShaderKit
const & in_kit)
const;
38226 ShaderKit & SetSource(
char const * in_source);
38234 ShaderKit & SetMultitexture(
bool in_state);
38239 ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38244 ShaderKit & SetTransformMatrix(MatrixKit
const & in_transform);
38248 ShaderKit & UnsetSource();
38253 ShaderKit & UnsetMultitexture();
38257 ShaderKit & UnsetParameterizationSource();
38261 ShaderKit & UnsetTransformMatrix();
38265 ShaderKit & UnsetEverything();
38270 bool ShowSource(UTF8 & out_source)
const;
38277 bool ShowMultitexture(
bool & out_state)
const;
38282 bool ShowParameterizationSource(Shader::Parameterization & out_source)
const;
38287 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38292 class HPS_API ShaderDefinition :
public Definition
38296 ShaderDefinition();
38302 ShaderDefinition(Definition
const & in_that);
38306 ShaderDefinition(ShaderDefinition
const & in_that);
38311 ShaderDefinition & operator=(ShaderDefinition
const & in_that);
38316 ShaderDefinition(ShaderDefinition && in_that);
38321 ShaderDefinition & operator=(ShaderDefinition && in_that);
38323 ~ShaderDefinition();
38325 HPS::Type ObjectType()
const {
return HPS::Type::ShaderDefinition; };
38329 void Set(ShaderKit
const & in_kit);
38333 void Show(ShaderKit & out_kit)
const;
38365 HPS::Type
ObjectType()
const {
return HPS::Type::CutGeometryGatheringOptionsKit;};
38387 bool Empty()
const;
38446 bool ShowOffset(
size_t & out_offset)
const;
38499 bool Empty()
const;
38566 bool ShowCriteria(SearchTypeArray & out_types)
const;
38571 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
38616 bool operator==(
TreeContext const & in_that)
const;
38621 bool operator!=(
TreeContext const & in_that)
const;
38648 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsKit;};
38670 bool Empty()
const;
38852 bool ShowProximity(
float & out_proximity)
const;
38862 bool ShowInternalLimit(
size_t & out_limit)
const;
38867 bool ShowRelatedLimit(
size_t & out_limit)
const;
38872 bool ShowSorting(
bool & out_sorted)
const;
38887 bool ShowScope(
KeyPath & out_start_path)
const;
38892 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
38897 bool ShowExtentCullingRespected(
bool & out_state)
const;
38902 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
38907 bool ShowFrustumCullingRespected(
bool & out_state)
const;
38912 bool ShowVectorCullingRespected(
bool & out_state)
const;
38943 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsControl;};
39042 bool ShowProximity(
float & out_proximity)
const;
39052 bool ShowInternalLimit(
size_t & out_limit)
const;
39057 bool ShowRelatedLimit(
size_t & out_limit)
const;
39062 bool ShowSorting(
bool & out_sorted)
const;
39077 bool ShowExtentCullingRespected(
bool & out_state)
const;
39082 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
39087 bool ShowFrustumCullingRespected(
bool & out_state)
const;
39092 bool ShowVectorCullingRespected(
bool & out_state)
const;
39158 bool ShowSelectedItem(
Key & out_selection)
const;
39163 bool ShowPath(
KeyPath & out_path)
const;
39168 bool ShowFaces(SizeTArray & out_faces)
const;
39173 bool ShowVertices(SizeTArray & out_vertices)
const;
39179 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
39184 bool ShowCharacters(SizeTArray & out_characters)
const;
39189 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
39194 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
39222 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionResultsIterator;}
39255 bool IsValid()
const;
39323 virtual void Reset();
39331 size_t GetCount()
const;
39437 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
39452 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39465 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
39480 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39582 HPS::Type
ObjectType()
const {
return HPS::Type::HighlightOptionsKit;};
39604 bool Empty()
const;
39672 bool ShowStyleName(
UTF8 & out_style_name)
const;
39677 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
39687 bool ShowNotification(
bool & out_state)
const;
39841 bool Empty()
const;
39889 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39923 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateOptionsControl;};
39960 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39975 World(
char const * in_license);
39986 World & SetMaterialLibraryDirectory(
char const * in_directory);
39992 World & SetFontDirectory(
char const * in_directory);
39999 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
40005 World & SetFontDirectories(UTF8Array
const & in_directories);
40012 World & SetDriverConfigFile(
char const * in_filename);
40019 World & SetExchangeLibraryDirectory(
char const * in_directory);
40026 World & SetPublishResourceDirectory(
char const * in_directory);
40032 World & SetParasolidSchemaDirectory(
char const * in_directory);
40039 World & SetParasolidBodyshopDirectory(
char const * in_directory);
40043 World & UnsetMaterialLibraryDirectory();
40047 World & UnsetFontDirectories();
40051 World & UnsetDriverConfigFile();
40055 World & UnsetExchangeLibraryDirectory();
40059 World & UnsetPublishResourceDirectory();
40063 World & UnsetParasolidSchemaDirectory();
40067 World & UnsetParasolidBodyshopDirectory();
40072 bool ShowLicense(
UTF8 & out_license)
const;
40077 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
40082 bool ShowFontDirectories(UTF8Array & out_directories)
const;
40087 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
40092 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
40097 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
40102 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
40108 bool ShowParasolidBodyshopDirectory(
UTF8 & out_directory)
const;
40114 virtual void Reset() {}
40143 intptr_t GetClassID()
const;
40154 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
40155 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
40168 static void Execute(
bool in_once=
true);
40172 static Time GetTime();
40175 static void Sleep(Time milliseconds);
40201 static void RelinquishMemory();
40229 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
40238 static void Reset();
40241 static void Synchronize();
40245 static WindowKeyArray GetWindowKeys();
40249 static SegmentKeyArray GetRootSegments();
40253 static PortfolioKeyArray GetPortfolios();
40259 static PortfolioKey const GetMaterialLibraryPortfolio();
40334 static size_t SelectByShell(
ShellKit const & in_shell,
40343 static size_t SelectByShell(
ShellKey const & in_shell,
40353 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
40363 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
40391 static bool SetInformationEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40397 static bool SetWarningEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40403 static bool SetErrorEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40411 static void UnsetEmergencyHandler();
40415 static size_t GetSoftMemoryLimit();
40420 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
40489 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40495 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40501 bool UnSubscribe(
EventHandler const & in_handler)
const;
40506 bool UnSubscribe(intptr_t in_type)
const;
40511 bool InjectEvent(
Event const & in_event)
const;
40521 void Shutdown()
const;
40525 bool IsShutdown()
const;
40530 void SetName(
char const * in_name)
const;
40534 void ShowName(
UTF8 & out_name)
const;
40538 virtual void Reset() {}
40577 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40583 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40591 void UnSubscribeEverything()
const;
40594 virtual void Reset() { UnSubscribeEverything(); }
40624 channel = GetClassID();
40625 consumable =
false;
40633 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
40652 HPS_UNREFERENCED(in_that_event);
40657 return GetClassID();
40675 channel = GetClassID();
40676 consumable =
false;
40677 action = Action::None;
40681 :
Event(), action(in_action), results(in_results), options(in_options)
40683 channel = GetClassID();
40684 consumable =
false;
40691 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
40694 action = that.action;
40695 results = that.results;
40696 options = that.options;
40737 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
40741 code =
event->code;
40764 return message == in_that.
message && code == in_that.
code;
40772 return Equals(in_that);
40780 return !Equals(in_that);
40797 WarningEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40808 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
40812 code =
event->code;
40835 return message == in_that.
message && code == in_that.
code;
40843 return Equals(in_that);
40851 return !Equals(in_that);
40868 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40879 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
40883 code =
event->code;
40906 return message == in_that.
message && code == in_that.
code;
40914 return Equals(in_that);
40922 return !Equals(in_that);
40957 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40983 return action == in_that.
action;
40991 return Equals(in_that);
40999 return !Equals(in_that);
41012 { channel = GetClassID(); }
41040 if(in_event.
GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41043 update_time =
event->update_time;
41071 , import_status_message(HPS::
UTF8())
41072 { channel = GetClassID(); }
41076 , import_status_message(in_message)
41077 { channel = GetClassID(); }
41083 if (in_event.
GetChannel() == Object::ClassID<ImportStatusEvent>())
41086 import_status_message =
event.import_status_message;
41117 return modifiers == in_that.modifiers;
41125 return Equals(in_that);
41133 return !Equals(in_that);
41138 bool None()
const {
return modifiers == _key_none; }
41142 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
41146 bool Control()
const {
return (modifiers & _key_control) != 0; }
41150 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
41154 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
41160 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41170 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
41174 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
41178 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
41182 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
41190 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41200 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41237 _key_none = 0x0000,
41238 _key_shift = 0x0001,
41239 _key_control = 0x0002,
41241 _key_meta = 0x0008,
41284 return Equals(in_that);
41292 return !Equals(in_that);
41299 return ModifierKeyState;
41326 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41334 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41343 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41350 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
41353 channel = GetClassID();
41354 CurrentAction =
event->CurrentAction;
41355 Touches =
event->Touches;
41356 ModifierKeyState =
event->ModifierKeyState;
41386 return Equals(in_that);
41394 return !Equals(in_that);
41404 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
41405 && Touches.size() == that_touch_event->
Touches.size() )
41407 TouchArray these_touches = Touches;
41408 TouchArray those_touches = that_touch_event->
Touches;
41410 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41411 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41413 for (
size_t i = 0 ; i < these_touches.size() ; i++)
41415 if (these_touches[i].ID != those_touches[i].ID)
41429 Touches.assign(in_touches, in_touches + in_touch_count);
41436 Touches = in_touches;
41448 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
41450 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
41467 return buttons == in_that.buttons;
41475 return Equals(in_that);
41483 return !Equals(in_that);
41488 bool None()
const {
return buttons == _button_none; }
41492 bool Left()
const {
return (buttons & _button_left) != 0; }
41496 bool Right()
const {
return (buttons & _button_right) != 0; }
41500 bool Middle()
const {
return (buttons & _button_middle) != 0; }
41504 bool X1()
const {
return (buttons & _button_x1) != 0; }
41508 bool X2()
const {
return (buttons & _button_x2) != 0; }
41514 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41523 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
41527 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
41531 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
41535 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
41539 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
41547 ret.buttons = buttons | in_buttons_to_merge.buttons;
41557 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41598 _button_none = 0x0000,
41599 _button_left = 0x0001,
41600 _button_right = 0x0002,
41601 _button_middle = 0x0004,
41602 _button_x1 = 0x0008,
41603 _button_x2 = 0x0010
41636 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41646 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41652 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
41655 channel = GetClassID();
41656 CurrentAction =
event->CurrentAction;
41657 Location =
event->Location;
41658 CurrentButton =
event->CurrentButton;
41659 WheelDelta =
event->WheelDelta;
41660 ClickCount =
event->ClickCount;
41693 return Equals(in_that);
41701 return !Equals(in_that);
41712 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41721 if (CurrentAction == Action::Move)
41722 return GetClassID();
41755 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41763 :
InputEvent(in_modifiers), CurrentAction(in_action)
41765 channel = GetClassID();
41766 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41774 :
InputEvent(in_modifiers), CurrentAction(in_action)
41776 channel = GetClassID();
41777 KeyboardCodes = in_keyboardcodes;
41784 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
41787 channel = GetClassID();
41788 KeyboardCodes =
event->KeyboardCodes;
41789 CurrentAction =
event->CurrentAction;
41820 return Equals(in_that);
41828 return !Equals(in_that);
41836 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41843 KeyboardCodes = in_keyboardcodes;
41888 bool Equals(
MouseState const & in_that)
const;
41893 bool operator== (
MouseState const & in_that)
const;
41898 bool operator!= (
MouseState const & in_that)
const;
41926 HPS::KeyArray GetEventPath()
const;
41942 void SetActiveEvent(
MouseEvent const & in_event);
41946 void SetEventPath(KeyArray
const & in_path);
42000 bool Equals(
TouchState const & in_that)
const;
42005 bool operator== (
TouchState const & in_that)
const;
42010 bool operator!= (
TouchState const & in_that)
const;
42031 HPS::KeyArray GetEventPath()
const;
42035 size_t GetTouchCount()
const;
42039 HPS::TouchArray GetTouches()
const;
42047 void SetActiveEvent(
TouchEvent const & in_event);
42051 void SetEventPath(KeyArray
const & in_path);
42055 void SetTouches(TouchArray
const & in_touches);
42132 HPS::KeyArray GetEventPath()
const;
42136 size_t GetKeyboardCodeCount()
const;
42140 HPS::KeyboardCodeArray GetKeyboardCodes()
const;
42145 bool GetKeyState(HPS::KeyboardCode in_key_code)
const;
42157 void SetEventPath(KeyArray
const & in_path);
42161 void SetKeyboardCodes(KeyboardCodeArray
const & in_keyboard_codes);
42213 IOResult Status()
const;
42218 IOResult Status(
float & out_percent_complete)
const;
42259 virtual void Restart();
42264 static Toolkit CreateToolkit();
42289 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportOptionsKit; };
42306 bool Empty()
const;
42349 bool ShowSegment(
SegmentKey & out_segment)
const;
42364 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42379 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42409 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportResultsKit; };
42426 bool Empty()
const;
42458 bool ShowSegment(
SegmentKey & out_segment)
const;
42476 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42494 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42510 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
42518 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
42529 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
42565 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportOptionsKit; };
42582 bool Empty()
const;
42610 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
42619 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
42626 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
42635 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
42644 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
42668 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
42719 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
42725 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
42731 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
42737 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
42743 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
42748 bool ShowConnectivityCompression(
bool & out_state)
const;
42754 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
42759 bool ShowSerializeTristrips(
bool & out_state)
const;
42792 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportNotifier;};
42839 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportNotifier;};
42912 DotsPerCentimeter = DPCM,
42944 HPS::Type
ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
42961 bool Empty()
const;
42986 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
43026 bool ShowWYSIWYG(
bool & out_onoff)
const;
43069 static IOResult Export(
char const * in_filename, Driver in_driver_type,
HPS::WindowKey const & in_window, ExportOptionsKit
const & in_options);
43080 class HPS_API ExportOptionsKit :
public Object
43084 ExportOptionsKit();
43088 ExportOptionsKit(ExportOptionsKit
const & in_kit);
43093 ExportOptionsKit(ExportOptionsKit && in_that);
43098 ExportOptionsKit & operator=(ExportOptionsKit && in_that);
43100 virtual ~ExportOptionsKit();
43102 HPS::Type ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
43106 void Set(ExportOptionsKit
const & in_kit);
43110 void Show(ExportOptionsKit & out_kit)
const;
43115 ExportOptionsKit & operator=(ExportOptionsKit
const & in_kit);
43119 bool Empty()
const;
43124 bool Equals(ExportOptionsKit
const & in_kit)
const;
43129 bool operator==(ExportOptionsKit
const & in_kit)
const;
43134 bool operator!=(ExportOptionsKit
const & in_kit)
const;
43142 bool ShowResolution(
float & out_resolution)
const;
43147 ExportOptionsKit & SetResolution(
float in_resolution);
43151 ExportOptionsKit & UnsetResolution();
43158 bool ShowWYSIWYG(
bool & out_onoff)
const;
43163 ExportOptionsKit & SetWYSIWYG(
bool in_onoff);
43167 ExportOptionsKit & UnsetWYSIWYG();
43172 ExportOptionsKit & UnsetEverything();
43181 static IOResult Export(intptr_t hdc, intptr_t attribdc,
HPS::WindowKey const & window, ExportOptionsKit
const & options);
43224 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportOptionsKit; };
43241 bool Empty()
const;
43271 bool ShowSegment(
SegmentKey & out_segment)
const;
43286 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43332 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportResultsKit; };
43349 bool Empty()
const;
43381 bool ShowSegment(
SegmentKey & out_segment)
const;
43399 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43523 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportOptionsKit; };
43540 bool Empty()
const;
43602 bool ShowSegment(
SegmentKey & out_segment)
const;
43634 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportResultsKit; };
43651 bool Empty()
const;
43683 bool ShowSegment(
SegmentKey & out_segment)
const;
43761 # pragma warning(pop)
HPS::Type ObjectType() const
Definition: hps.h:39980
Rotation
Definition: hps.h:1595
HPS::Type ObjectType() const
Definition: hps.h:26947
bool Empty() const
Definition: hps.h:6825
CameraPoint(Point const &in_point)
Definition: hps.h:5776
Alignment
Definition: hps.h:1528
Space
Definition: hps.h:561
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41728
Channel
Definition: hps.h:945
HPS::Type ObjectType() const
Definition: hps.h:24119
Handedness
Definition: hps.h:1276
ColorSource
Definition: hps.h:1921
HPS::Type ObjectType() const
Definition: hps.h:17070
HPS::Type ObjectType() const
Definition: hps.h:36282
Event(intptr_t in_channel=0)
Definition: hps.h:6129
HPS::Type ObjectType() const
Definition: hps.h:43453
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3751
float alpha
Definition: hps.h:4290
HPS::Type ObjectType() const
Definition: hps.h:35889
bool operator==(Touch const &in_that) const
Definition: hps.h:6419
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41170
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40926
HPS::Type ObjectType() const
Definition: hps.h:34352
HPS::Type ObjectType() const
Definition: hps.h:21849
HPS::Type ObjectType() const
Definition: hps.h:23647
HPS::Type ObjectType() const
Definition: hps.h:24393
Action
Definition: hps.h:41311
Orientation
Definition: hps.h:537
Code
Definition: hps.h:134
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1331
Multiline strings will be left justfied.
HPS::Type ObjectType() const
Definition: hps.h:14954
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40981
HPS::Type ObjectType() const
Definition: hps.h:8611
HPS::Type ObjectType() const
Definition: hps.h:28175
Event * Clone() const
Definition: hps.h:40824
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41645
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40612
ImportStatusEvent()
Definition: hps.h:41069
HPS::Type ObjectType() const
Definition: hps.h:21465
HPS::Type ObjectType() const
Definition: hps.h:36064
HPS::Type ObjectType() const
Definition: hps.h:25910
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41376
HPS::Type ObjectType() const
Definition: hps.h:30215
HPS::Type ObjectType() const
Definition: hps.h:25521
HPS::Type ObjectType() const
Definition: hps.h:11634
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40873
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41834
HPS::Type ObjectType() const
Definition: hps.h:37776
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5673
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5921
Driver
Definition: hps.h:154
HPS::Type ObjectType() const
Definition: hps.h:41874
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2192
HPS::Type ObjectType() const
Definition: hps.h:39124
CappingLevel
Definition: hps.h:1727
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8692
HPS::Type ObjectType() const
Definition: hps.h:23374
HPS::Type ObjectType() const
Definition: hps.h:35817
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12772
HPS::Type ObjectType() const
Definition: hps.h:41986
HPS::Type ObjectType() const
Definition: hps.h:20509
HPS::Type ObjectType() const
Definition: hps.h:13789
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5533
HPS::Type ObjectType() const
Definition: hps.h:28960
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3858
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41773
static ModifierKeys KeyMeta()
Definition: hps.h:41229
HPS::Type ObjectType() const
Definition: hps.h:35552
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:36931
HPS::Type ObjectType() const
Definition: hps.h:42839
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3737
HPS::Type ObjectType() const
Definition: hps.h:39296
HPS::Type ObjectType() const
Definition: hps.h:23572
HPS::Type ObjectType() const
Definition: hps.h:35122
HPS::Type ObjectType() const
Definition: hps.h:16779
HPS::Type ObjectType() const
Definition: hps.h:38365
Time GetTimeStamp() const
Definition: hps.h:6151
HPS::Type ObjectType() const
Definition: hps.h:22367
NormalizedPoint(Point const &in_point)
Definition: hps.h:5826
HPS::Type ObjectType() const
Definition: hps.h:23921
Event * Clone() const
Definition: hps.h:40641
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3786
Renderer
Definition: hps.h:1576
HPS::Type ObjectType() const
Definition: hps.h:34088
KeyboardEvent()
Definition: hps.h:41749
HPS::Type ObjectType() const
Definition: hps.h:7338
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3979
ObjectPoint(Point const &in_point)
Definition: hps.h:5676
HPS::Type ObjectType() const
Definition: hps.h:17657
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3721
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40955
static ModifierKeys KeyAlt()
Definition: hps.h:41225
bool IsConsumable() const
Definition: hps.h:6154
MaterialPreference
Definition: hps.h:1744
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41762
Mobility
Definition: hps.h:194
HPS::Type ObjectType() const
Definition: hps.h:13282
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5874
InterpolationAlgorithm
Definition: hps.h:1511
Fill
Definition: hps.h:1912
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3774
HPS::Type ObjectType() const
Definition: hps.h:27452
HPS::Type ObjectType() const
Definition: hps.h:19150
char At(size_t in_index) const
Definition: hps.h:6868
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41165
HPS::Type ObjectType() const
Definition: hps.h:35944
ReferenceFrame
Definition: hps.h:1543
HPS::Type ObjectType() const
Definition: hps.h:16986
GreekingUnits
Definition: hps.h:1630
HPS::Type ObjectType() const
Definition: hps.h:12184
InnerConeUnits
Definition: hps.h:486
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5970
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3891
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41031
OuterConeUnits
Definition: hps.h:472
HPS::Type ObjectType() const
Definition: hps.h:18934
HPS::Type ObjectType() const
Definition: hps.h:40463
HPS::Type ObjectType() const
Definition: hps.h:39393
HPS::Type ObjectType() const
Definition: hps.h:14385
HPS::Type ObjectType() const
Definition: hps.h:33571
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41841
HPS::Type ObjectType() const
Definition: hps.h:26846
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41400
HPS::Type ObjectType() const
Definition: hps.h:12655
HPS::Type ObjectType() const
Definition: hps.h:25103
HPS::Type ObjectType() const
Definition: hps.h:36395
Channel
Definition: hps.h:904
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40855
AreaUnits
Definition: hps.h:1457
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3828
HPS::Type ObjectType() const
Definition: hps.h:12007
HPS::Type ObjectType() const
Definition: hps.h:34708
Action
Definition: hps.h:40937
HPS::Type ObjectType() const
Definition: hps.h:14223
HPS::Type ObjectType() const
Definition: hps.h:42565
HPS::Type ObjectType() const
Definition: hps.h:27553
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6434
HPS::Type ObjectType() const
Definition: hps.h:37894
HPS::Type ObjectType() const
Definition: hps.h:34225
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41333
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3937
Border
Definition: hps.h:264
UpdateControl
Definition: hps.h:175
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41160
HPS::Type ObjectType() const
Definition: hps.h:23124
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41810
HPS::Type ObjectType() const
Definition: hps.h:21390
WarningEvent(Event const &in_event)
Definition: hps.h:40806
HPS::Type ObjectType() const
Definition: hps.h:11510
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1931
static ModifierKeys KeyShift()
Definition: hps.h:41217
HPS::Type ObjectType() const
Definition: hps.h:28686
Shape
Definition: hps.h:1073
bool IsValid() const
Definition: hps.h:6818
Cuboid_3D()
Definition: hps.h:3729
ErrorEvent(Event const &in_event)
Definition: hps.h:40877
size_t GetWStrLength() const
Definition: hps.h:6847
Event * Clone() const
Definition: hps.h:40706
HPS::Type ObjectType() const
Definition: hps.h:11101
AppendMode
Definition: hps.h:332
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3922
void Meta(bool in_state)
Definition: hps.h:41182
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6069
HPS::Type ObjectType() const
Definition: hps.h:14663
UpdateStatus
Definition: hps.h:164
HPS_INLINE bool IsValid() const
Definition: hps.h:3779
HPS::Type ObjectType() const
Definition: hps.h:38477
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:41002
Quality
Definition: hps.h:1057
ResolutionUnits
Definition: hps.h:42908
TimerTickEvent(Event const &in_event)
Definition: hps.h:40631
Component
Definition: hps.h:352
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6020
HPS::Type ObjectType() const
Definition: hps.h:12271
Default
Definition: hps.h:1885
HPS::Type ObjectType() const
Definition: hps.h:10731
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5065
bool Shift() const
Definition: hps.h:41142
SizeToleranceUnits
Definition: hps.h:1617
HPS::Type ObjectType() const
Definition: hps.h:38601
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4008
Cap
Definition: hps.h:1836
Point_3D< F > max
Definition: hps.h:3723
HPS::Type ObjectType() const
Definition: hps.h:7418
HPS::Type ObjectType() const
Definition: hps.h:43224
HPS::Type ObjectType() const
Definition: hps.h:43332
MouseEvent()
Definition: hps.h:41627
HPS::Type ObjectType() const
Definition: hps.h:12112
HPS::Type ObjectType() const
Definition: hps.h:16688
HPS::Type ObjectType() const
Definition: hps.h:35167
Material Texture Channel.
static const float Infinity
Definition: hps.h:2187
InsetBehavior
Definition: hps.h:1817
HPS::Type ObjectType() const
Definition: hps.h:25029
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2200
HPS::Type ObjectType() const
Definition: hps.h:13677
HPS::Type ObjectType() const
Definition: hps.h:27146
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6433
HPS::Type ObjectType() const
Definition: hps.h:35357
HPS::Type ObjectType() const
Definition: hps.h:37621
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3901
Algorithm
Definition: hps.h:1445
Decimation
Definition: hps.h:1014
Granularity
Definition: hps.h:1366
Search the current segment only.
KeyboardEvent(Event const &in_event)
Definition: hps.h:41782
ClipOperation
Definition: hps.h:1305
HPS::Type ObjectType() const
Definition: hps.h:8948
Method
Definition: hps.h:1435
HPS::Type ObjectType() const
Definition: hps.h:26566
Parameterization
Definition: hps.h:959
FocusLostEvent()
Definition: hps.h:41010
CuttingLevel
Definition: hps.h:1736
Channel
Definition: hps.h:925
HandleResult
Definition: hps.h:40602
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5077
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40925
Value
Definition: hps.h:1416
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2208
Code
Definition: hps.h:105
HPS::Type ObjectType() const
Definition: hps.h:26062
Event * Clone() const
Definition: hps.h:41018
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41681
ErrorEvent()
Definition: hps.h:40864
Justification
Definition: hps.h:1551
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:14047
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5551
ErrorEvent(char const *in_message)
Definition: hps.h:40868
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41038
FrameSize
Definition: hps.h:205
Justification
Definition: hps.h:1853
HPS::Type ObjectType() const
Definition: hps.h:11832
HPS::Type ObjectType() const
Definition: hps.h:19791
HPS::Type ObjectType() const
Definition: hps.h:22198
HPS::Type ObjectType() const
Definition: hps.h:8731
HPS::Type ObjectType() const
Definition: hps.h:36885
HPS::Type ObjectType() const
Definition: hps.h:35071
GreekingMode
Definition: hps.h:1642
HPS::Type ObjectType() const
Definition: hps.h:20301
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41846
Operation
Definition: hps.h:455
HPS::Type ObjectType() const
Definition: hps.h:37466
Type
Definition: hps.h:1999
WorldPoint(Point const &in_point)
Definition: hps.h:5726
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41440
HPS::Type ObjectType() const
Definition: hps.h:9930
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2479
HPS::Type ObjectType() const
Definition: hps.h:6665
TouchEvent(Event const &in_event)
Definition: hps.h:41348
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41434
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6950
Relation
Definition: hps.h:378
Action
Definition: hps.h:41741
ChannelMapping
Definition: hps.h:1028
HPS::Type ObjectType() const
Definition: hps.h:22716
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5568
HPS::Type ObjectType() const
Definition: hps.h:38943
HPS::Type ObjectType() const
Definition: hps.h:39582
bool Alt() const
Definition: hps.h:41150
ToleranceUnits
Definition: hps.h:361
HPS::Type ObjectType() const
Definition: hps.h:12582
SizeUnits
Definition: hps.h:1804
Type
Definition: hps.h:2016
The vertex colors applied to faces.
RelationTest
Definition: hps.h:388
Type
Definition: hps.h:323
HPS::Type ObjectType() const
Definition: hps.h:14807
Behavior
Definition: hps.h:570
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6740
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41847
HPS::Type ObjectType() const
Definition: hps.h:18700
ImageFormat
Definition: hps.h:220
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5542
float blue
Definition: hps.h:4289
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:21129
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6968
PixelPoint(Point const &in_point)
Definition: hps.h:6072
HPS::Type ObjectType() const
Definition: hps.h:6194
HPS::Type ObjectType() const
Definition: hps.h:7057
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41707
HPS::Type ObjectType() const
Definition: hps.h:21726
HPS::Type ObjectType() const
Definition: hps.h:21606
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
HPS::Type ObjectType() const
Definition: hps.h:35310
HPS::Type ObjectType() const
Definition: hps.h:28829
HPS::Type ObjectType() const
Definition: hps.h:24192
HPS::Type ObjectType() const
Definition: hps.h:39222
HPS::Type ObjectType() const
Definition: hps.h:20991
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41727
Event * Clone() const
Definition: hps.h:41096
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5071
HPS::Type ObjectType() const
Definition: hps.h:34622
HPS::Type ObjectType() const
Definition: hps.h:40571
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS::Type ObjectType() const
Definition: hps.h:15838
Infinite line which extends infinitely in both directions along a vector.
intptr_t GetChannel() const
Definition: hps.h:6148
HPS::Type ObjectType() const
Definition: hps.h:9301
Algorithm
Definition: hps.h:1358
HPS::Type ObjectType() const
Definition: hps.h:31301
HPS::Type ObjectType() const
Definition: hps.h:37937
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3846
Driver
Definition: hps.h:43058
SizeUnits
Definition: hps.h:1672
StandAloneWindowEvent()
Definition: hps.h:40946
HPS::Type ObjectType() const
Definition: hps.h:36464
HPS::Type ObjectType() const
Definition: hps.h:34460
HPS::Type ObjectType() const
Definition: hps.h:12420
HPS::Type ObjectType() const
Definition: hps.h:11251
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40833
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41635
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5514
HPS::Type ObjectType() const
Definition: hps.h:17497
Level
Definition: hps.h:1349
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41115
void Control(bool in_state)
Definition: hps.h:41174
HPS::Type ObjectType() const
Definition: hps.h:42792
HPS::Type ObjectType() const
Definition: hps.h:18208
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3993
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:40854
The base class of all HPS exceptions.
Definition: hps.h:5506
RegionAlignment
Definition: hps.h:1651
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41342
Event * Clone() const
Definition: hps.h:41672
HPS::Type ObjectType() const
Definition: hps.h:21278
void Invalidate()
Definition: hps.h:3791
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4785
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5565
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41034
HPS::Type ObjectType() const
Definition: hps.h:33948
HPS::Type ObjectType() const
Definition: hps.h:39819
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6141
char const * GetBytes() const
Definition: hps.h:6854
virtual intptr_t Freshen() const
Definition: hps.h:41719
HPS::Type ObjectType() const
Definition: hps.h:35419
float green
Definition: hps.h:4288
Action
Definition: hps.h:41616
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1696
HPS::Type ObjectType() const
Definition: hps.h:10335
HPS::Type ObjectType() const
Definition: hps.h:27218
HPS::Type ObjectType() const
Definition: hps.h:24710
HPS::Type ObjectType() const
Definition: hps.h:24466
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:37989
HPS::Type ObjectType() const
Definition: hps.h:24831
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5973
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41081
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5823
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6413
static const float NegativeInfinity
Definition: hps.h:2189
HighlightEvent(Event const &in_event)
Definition: hps.h:40689
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6959
SizeUnits
Definition: hps.h:1477
HPS::Type ObjectType() const
Definition: hps.h:12858
HPS::Type ObjectType() const
Definition: hps.h:20687
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41729
HPS::Type ObjectType() const
Definition: hps.h:10556
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5924
GatheringLevel
Definition: hps.h:1752
HPS::Type ObjectType() const
Definition: hps.h:29039
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3758
FrameOptions
Definition: hps.h:214
HPS::Type ObjectType() const
Definition: hps.h:35260
Space
Definition: hps.h:8569
void Alt(bool in_state)
Definition: hps.h:41178
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41754
HPS::Type ObjectType() const
Definition: hps.h:37193
Type
Definition: hps.h:258
bool operator!=(Touch const &in_that) const
Definition: hps.h:6427
Type
Definition: hps.h:446
HPS::Type ObjectType() const
Definition: hps.h:42289
HPS::Type ObjectType() const
Definition: hps.h:43634
HPS::Type ObjectType() const
Definition: hps.h:43523
HPS::Type ObjectType() const
Definition: hps.h:33679
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5723
HPS::Type ObjectType() const
Definition: hps.h:9491
HPS::Type ObjectType() const
Definition: hps.h:43720
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6941
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41427
Event * Clone() const
Definition: hps.h:41367
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40904
Event * Clone() const
Definition: hps.h:40972
size_t GetLength() const
Definition: hps.h:6839
HPS::Type ObjectType() const
Definition: hps.h:21078
HPS::Type ObjectType() const
Definition: hps.h:26776
Type
Definition: hps.h:1134
HPS::Type ObjectType() const
Definition: hps.h:9409
bool None() const
Definition: hps.h:41138
size_t ClickCount
The number of clicks received.
Definition: hps.h:41731
virtual intptr_t Freshen() const
Definition: hps.h:6145
void Reset()
Definition: hps.h:6834
HPS::Type ObjectType() const
Definition: hps.h:37723
HPS::Type ObjectType() const
Definition: hps.h:23847
HPS::Type ObjectType() const
Definition: hps.h:39923
SizeUnits
Definition: hps.h:1605
Event * Clone() const
Definition: hps.h:40895
MouseEvent(Event const &in_event)
Definition: hps.h:41650
virtual bool Empty() const
Definition: hps.h:5606
Join
Definition: hps.h:1827
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3915
Modifier
Definition: hps.h:1864
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41325
HighlightEvent()
Definition: hps.h:40673
virtual HPS::Type ObjectType() const
Definition: hps.h:5602
HPS::Type ObjectType() const
Definition: hps.h:13870
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41439
Type
Definition: hps.h:581
virtual intptr_t Freshen() const
Definition: hps.h:40656
Background
Definition: hps.h:239
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3835
static ModifierKeys KeyControl()
Definition: hps.h:41221
HPS::Type ObjectType() const
Definition: hps.h:18420
HPS::Type ObjectType() const
Definition: hps.h:35674
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5871
HPS::Type ObjectType() const
Definition: hps.h:39715
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40951
Mode
Definition: hps.h:1717
Event * Clone() const
Definition: hps.h:41055
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4052
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3870
Type
Definition: hps.h:884
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3823
HPS::Type ObjectType() const
Definition: hps.h:12329
HPS::Type ObjectType() const
Definition: hps.h:32378
HPS::Type ObjectType() const
Definition: hps.h:37821
HPS::Type ObjectType() const
Definition: hps.h:42409
HPS::Type ObjectType() const
Definition: hps.h:42087
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3809
HPS::Type ObjectType() const
Definition: hps.h:36976
HPS::Type ObjectType() const
Definition: hps.h:12478
HPS::Type ObjectType() const
Definition: hps.h:17963
Mode
Definition: hps.h:1770
Event * Clone() const
Definition: hps.h:41801
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3881
Tiling
Definition: hps.h:987
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4037
WindowPoint(Point const &in_point)
Definition: hps.h:6023
Transform
Definition: hps.h:1560
HPS::Type ObjectType() const
Definition: hps.h:37291
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:38648
ModifierKeys()
Definition: hps.h:41110
Preference
Definition: hps.h:1585
HPS::Type ObjectType() const
Definition: hps.h:25383
Capping
Definition: hps.h:526
HPS::Type ObjectType() const
Definition: hps.h:35492
TouchEvent()
Definition: hps.h:41319
Interpolation
Definition: hps.h:1003
HPS::Type ObjectType() const
Definition: hps.h:20062
WarningEvent(char const *in_message)
Definition: hps.h:40797
HPS::Type ObjectType() const
Definition: hps.h:20855
Modifiers
Definition: hps.h:41235
Component
Definition: hps.h:518
HPS::Type ObjectType() const
Definition: hps.h:35982
HPS::Type ObjectType() const
Definition: hps.h:6530
HPS::Type ObjectType() const
Definition: hps.h:22629
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4022
HPS::Type ObjectType() const
Definition: hps.h:42944
HPS::Type ObjectType() const
Definition: hps.h:22419
Format
Definition: hps.h:37154
WarningEvent()
Definition: hps.h:40793
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40650
Touch()
Definition: hps.h:6407
Component
Definition: hps.h:408
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4287
ClipSpace
Definition: hps.h:1313
Control & operator=(Control &&in_that)
Definition: hps.h:5659
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40802
HPS::Type ObjectType() const
Definition: hps.h:13975
SizeUnits
Definition: hps.h:42901
virtual void Reset()
Definition: hps.h:40594
HPS::Type ObjectType() const
Definition: hps.h:11366
bool Meta() const
Definition: hps.h:41154
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4064
TimerTickEvent()
Definition: hps.h:40622
HPS::Type ObjectType() const
Definition: hps.h:22082
RenderingAlgorithm
Definition: hps.h:275
EmergencyHandler()
Definition: hps.h:40138
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5773
TouchID ID
TouchID for this Touch.
Definition: hps.h:6432
HPS::Type ObjectType() const
Definition: hps.h:10932
HPS::Type ObjectType() const
Definition: hps.h:33340
HPS::Type ObjectType() const
Definition: hps.h:8432
HandednessOptimization
Definition: hps.h:369
Projection
Definition: hps.h:1395
Control(Control &&in_that)
Definition: hps.h:5654
bool Control() const
Definition: hps.h:41146
HPS::Type ObjectType() const
Definition: hps.h:34859
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8681
Overlay
Definition: hps.h:1285
Status
Definition: hps.h:6121
HPS::Type ObjectType() const
Definition: hps.h:34989
HPS::Type ObjectType() const
Definition: hps.h:6612
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:41730
HPS::Type ObjectType() const
Definition: hps.h:42197