16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
23 # define HPS_TEMPLATE_API __declspec (dllexport)
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
44 # define EXPIMP_TEMPLATE extern
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
60 # define ENUM_CLASS enum class
82 class EventDispatcherImpl;
237 GradientTopLeftToBottomRight,
238 GradientTopRightToBottomLeft,
239 GradientBottomLeftToTopRight,
240 GradientBottomRightToTopLeft,
349 FeatureSizePercentage
550 SubsegmentsAndIncludes
591 Everything = 0x00ffffff,
594 Include = 0x00000042,
595 Segment = 0x00000043,
597 Includer = 0x00000100,
600 Geometry = 0x10000000,
607 NURBSSurface = 0x1000002b,
610 Polygon = 0x1000002f,
613 CircularWedge = 0x10000032,
614 Ellipse = 0x10000033,
616 NURBSCurve = 0x10000037,
617 CircularArc = 0x10000038,
618 EllipticalArc = 0x10000039,
623 Reference = 0x10000040,
626 DistantLight = 0x10000100,
628 InfiniteRay = 0x10000102,
631 Attribute = 0x20000000,
633 Priority = 0x20000001,
638 ModellingMatrix = 0x20000010,
639 UserData = 0x20000021,
640 TextureMatrix = 0x20000023,
643 Culling = 0x20001000,
644 CullingBackFace = 0x20001001,
645 CullingExtent = 0x20001002,
646 CullingVector = 0x20001003,
647 CullingVectorTolerance = 0x20001004,
648 CullingFrustum = 0x20001005,
649 CullingDeferralExtent = 0x20001006,
651 CurveAttribute = 0x20002000,
652 CurveAttributeBudget = 0x20002001,
653 CurveAttributeContinuedBudget = 0x20002002,
654 CurveAttributeViewDependent = 0x20002003,
655 CurveAttributeMaximumDeviation = 0x20002004,
656 CurveAttributeMaximumAngle = 0x20002005,
657 CurveAttributeMaximumLength = 0x20002006,
659 CylinderAttribute = 0x20003000,
660 CylinderAttributeTessellation = 0x20003001,
661 CylinderAttributeOrientation = 0x20003002,
664 EdgeAttribute = 0x20004000,
665 EdgeAttributePattern = 0x20004015,
666 EdgeAttributeWeight = 0x20004016,
668 LightingAttribute = 0x20005000,
669 LightingAttributeInterpolation = 0x20005001,
672 LineAttribute = 0x20006000,
673 LineAttributePattern = 0x20006019,
674 LineAttributeWeight = 0x2000601a,
677 MarkerAttribute = 0x20007000,
678 MarkerAttributeSize = 0x2000701b,
679 MarkerAttributeSymbol = 0x2000701c,
681 SurfaceAttribute = 0x20008000,
682 SurfaceAttributeBudget = 0x20008001,
683 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
684 SurfaceAttributeMaximumFacetAngle = 0x20008003,
685 SurfaceAttributeMaximumFacetWidth = 0x20008004,
686 SurfaceAttributeTrimCurveBudget = 0x20008005,
687 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
690 SelectabilityWindows = 0x20009001,
691 SelectabilityEdges = 0x20009002,
692 SelectabilityFaces = 0x20009003,
693 SelectabilityLights = 0x20009004,
694 SelectabilityLines = 0x20009005,
695 SelectabilityMarkers = 0x20009006,
696 SelectabilityVertices = 0x20009007,
697 SelectabilityText = 0x20009008,
699 SphereAttribute = 0x2000a000,
700 SphereAttributeTessellation = 0x2000a001,
703 SubwindowEitherType = 0x2000b001,
704 SubwindowStandard = 0x2000b00d,
705 SubwindowLightweight = 0x2000b002,
706 SubwindowBackground = 0x2000b003,
707 SubwindowBorder = 0x2000b004,
708 SubwindowRenderingAlgorithm = 0x2000b005,
711 TextAttribute = 0x2000c000,
712 TextAttributeAlignment = 0x2000c01d,
713 TextAttributeBold = 0x2000c002,
714 TextAttributeItalic = 0x2000c003,
715 TextAttributeOverline = 0x2000c004,
716 TextAttributeStrikethrough = 0x2000c005,
717 TextAttributeUnderline = 0x2000c006,
718 TextAttributeSlant = 0x2000c007,
719 TextAttributeLineSpacing = 0x2000c008,
720 TextAttributeRotation = 0x2000c00a,
721 TextAttributeExtraSpace = 0x2000c00b,
722 TextAttributeGreeking = 0x2000c00c,
723 TextAttributeSizeTolerance = 0x2000c00d,
724 TextAttributeSize = 0x2000c00e,
725 TextAttributeFont = 0x2000c00f,
726 TextAttributeTransform = 0x2000c010,
727 TextAttributeRenderer = 0x2000c011,
728 TextAttributePreference = 0x2000c012,
729 TextAttributePath = 0x2000c01f,
730 TextAttributeSpacing = 0x2000c020,
733 TransparencyMethod = 0x2000d001,
734 TransparencyAlgorithm = 0x2000d002,
735 TransparencyDepthPeelingLayers = 0x2000d004,
736 TransparencyDepthPeelingMinimumArea = 0x2000d005,
737 TransparencyDepthWriting = 0x2000d006,
739 Visibility = 0x2000e000,
740 VisibilityCuttingSections = 0x2000e001,
741 VisibilityCutEdges = 0x2000e002,
742 VisibilityCutFaces = 0x2000e003,
743 VisibilityWindows = 0x2000e004,
744 VisibilityText = 0x2000e005,
745 VisibilityLines = 0x2000e006,
746 VisibilityEdgeLights = 0x2000e007,
747 VisibilityMarkerLights = 0x2000e008,
748 VisibilityFaceLights = 0x2000e009,
749 VisibilityGenericEdges = 0x2000e00a,
750 VisibilityHardEdges = 0x2000e00b,
751 VisibilityAdjacentEdges = 0x2000e00c,
752 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
753 VisibilityShadowEmitting = 0x2000e00e,
754 VisibilityShadowReceiving = 0x2000e00f,
755 VisibilityShadowCasting = 0x2000e010,
756 VisibilityMarkers = 0x2000e011,
757 VisibilityVertices = 0x2000e012,
758 VisibilityFaces = 0x2000e013,
759 VisibilityPerimeterEdges = 0x2000e014,
760 VisibilityNonCulledEdges = 0x2000e015,
761 VisibilityMeshQuadEdges = 0x2000e016,
763 VisualEffects = 0x2000f000,
764 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
765 VisualEffectsAntiAliasing = 0x2000f002,
766 VisualEffectsShadowMaps = 0x2000f003,
767 VisualEffectsSimpleShadow = 0x2000f004,
768 VisualEffectsSimpleShadowPlane = 0x2000f005,
769 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
770 VisualEffectsSimpleShadowColor = 0x2000f007,
771 VisualEffectsSimpleReflection = 0x2000f008,
772 VisualEffectsSimpleReflectionPlane = 0x2000f009,
773 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
776 PerformanceDisplayLists = 0x20010001,
777 PerformanceStaticModel = 0x20010002,
778 StaticModelSegment = 0x40000043,
781 DrawingAttribute = 0x20011000,
782 DrawingAttributePolygonHandedness = 0x20011001,
783 DrawingAttributeDepthRange = 0x20011002,
784 DrawingAttributeFaceDisplacement = 0x20011003,
785 DrawingAttributeGeneralDisplacement = 0x20011004,
786 DrawingAttributeVertexDisplacement = 0x20011005,
787 DrawingAttributeOverlay = 0x20011006,
788 DrawingAttributeDeferral = 0x20011007,
789 DrawingAttributeWorldHandedness = 0x20011018,
790 DrawingAttributeClipRegion = 0x20011019,
792 HiddenLineAttribute = 0x20012000,
793 HiddenLineAttributeColor = 0x20012001,
794 HiddenLineAttributeDimFactor = 0x20012002,
795 HiddenLineAttributeFaceDisplacement = 0x20012003,
796 HiddenLineAttributeLinePattern = 0x20012005,
797 HiddenLineAttributeRenderFaces = 0x20012006,
798 HiddenLineAttributeRenderText = 0x20012007,
799 HiddenLineAttributeAlgorithm = 0x20012008,
800 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
801 HiddenLineAttributeVisibility = 0x2001200a,
802 HiddenLineAttributeWeight = 0x2001200b,
803 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
805 SegmentStyle = 0x20013001,
806 NamedStyle = 0x20013002,
807 MaterialPalette = 0x20013003,
808 Portfolio = 0x20013004,
811 ContourLineVisibility = 0x20014001,
812 ContourLinePosition = 0x20014002,
813 ContourLineColor = 0x20014003,
814 ContourLinePattern = 0x20014004,
815 ContourLineWeight = 0x20014005,
816 ContourLineLighting = 0x20014006,
821 BoundingVolume = 0x20016001,
822 BoundingExclusion = 0x20016002,
825 AttributeLockSetting = 0x20017001,
826 AttributeLockSubsegmentOverride = 0x20017002,
828 TransformMask = 0x20018000,
829 TransformMaskCamera = 0x20018001,
830 TransformMaskCameraTranslation = 0x20018002,
831 TransformMaskCameraScale = 0x20018003,
832 TransformMaskCameraOffset = 0x20018004,
833 TransformMaskCameraRotation = 0x20018005,
834 TransformMaskCameraPerspectiveScale = 0x20018006,
835 TransformMaskCameraProjection = 0x20018007,
836 TransformMaskModellingMatrix = 0x20018008,
837 TransformMaskModellingMatrixTranslation = 0x20018009,
838 TransformMaskModellingMatrixScale = 0x20018010,
839 TransformMaskModellingMatrixOffset = 0x20018011,
840 TransformMaskModellingMatrixRotation = 0x20018012,
842 ColorInterpolation = 0x20019000,
843 ColorInterpolationFaceColor = 0x20019001,
844 ColorInterpolationEdgeColor = 0x20019002,
845 ColorInterpolationMarkerColor = 0x20019003,
846 ColorInterpolationFaceIndex = 0x20019004,
847 ColorInterpolationEdgeIndex = 0x20019005,
848 ColorInterpolationMarkerIndex = 0x20019006,
850 CuttingSectionAttribute = 0x2001a000,
851 CuttingSectionAttributeCuttingLevel = 0x2001a001,
852 CuttingSectionAttributeCappingLevel = 0x2001a002,
853 CuttingSectionAttributeMaterialPreference = 0x2001a003,
871 InvalidMaterialIndex = -1,
898 EnvironmentTexture = 8,
899 EnvironmentCubeMap = 9,
938 EnvironmentTexture = 8,
939 EnvironmentCubeMap = 9
1085 GeometryDisplayLists,
1104 AttributeStaticModel,
1105 AttributeSpatialStaticModel
1121 Everything = 0x01000000,
1123 Visibility = 0x02000000,
1125 VisibilityCuttingSections,
1131 VisibilityEdgeLights,
1132 VisibilityMarkerLights,
1133 VisibilityFaceLights,
1134 VisibilityGenericEdges,
1135 VisibilityHardEdges,
1136 VisibilityAdjacentEdges,
1137 VisibilityInteriorSilhouetteEdges,
1138 VisibilityShadowEmitting,
1139 VisibilityShadowReceiving,
1140 VisibilityShadowCasting,
1144 VisibilityPerimeterEdges,
1145 VisibilityNonCulledEdges,
1146 VisibilityMeshQuadEdges,
1147 VisibilityCutGeometry,
1156 MaterialCutGeometry,
1158 MaterialAmbientLightUpColor,
1159 MaterialAmbientLightDownColor,
1160 MaterialAmbientLightColor,
1162 MaterialWindowColor,
1163 MaterialWindowContrastColor,
1167 MaterialMarkerColor,
1169 MaterialCutEdgeColor,
1172 MaterialVertexDiffuse,
1173 MaterialVertexDiffuseColor,
1174 MaterialVertexDiffuseAlpha,
1175 MaterialVertexDiffuseTexture,
1176 MaterialVertexSpecular,
1177 MaterialVertexMirror,
1178 MaterialVertexTransmission,
1179 MaterialVertexEmission,
1180 MaterialVertexEnvironment,
1182 MaterialVertexGloss,
1185 MaterialEdgeDiffuse,
1186 MaterialEdgeDiffuseColor,
1187 MaterialEdgeDiffuseAlpha,
1188 MaterialEdgeDiffuseTexture,
1189 MaterialEdgeSpecular,
1191 MaterialEdgeTransmission,
1192 MaterialEdgeEmission,
1193 MaterialEdgeEnvironment,
1198 MaterialFaceDiffuse,
1199 MaterialFaceDiffuseColor,
1200 MaterialFaceDiffuseAlpha,
1201 MaterialFaceDiffuseTexture,
1202 MaterialFaceSpecular,
1204 MaterialFaceTransmission,
1205 MaterialFaceEmission,
1206 MaterialFaceEnvironment,
1211 MaterialBackFaceDiffuse,
1212 MaterialBackFaceDiffuseColor,
1213 MaterialBackFaceDiffuseAlpha,
1214 MaterialBackFaceDiffuseTexture,
1215 MaterialBackFaceSpecular,
1216 MaterialBackFaceMirror,
1217 MaterialBackFaceTransmission,
1218 MaterialBackFaceEmission,
1219 MaterialBackFaceEnvironment,
1220 MaterialBackFaceBump,
1221 MaterialBackFaceGloss,
1224 MaterialFrontFaceDiffuse,
1225 MaterialFrontFaceDiffuseColor,
1226 MaterialFrontFaceDiffuseAlpha,
1227 MaterialFrontFaceDiffuseTexture,
1228 MaterialFrontFaceSpecular,
1229 MaterialFrontFaceMirror,
1230 MaterialFrontFaceTransmission,
1231 MaterialFrontFaceEmission,
1232 MaterialFrontFaceEnvironment,
1233 MaterialFrontFaceBump,
1234 MaterialFrontFaceGloss,
1237 MaterialCutFaceDiffuse,
1238 MaterialCutFaceDiffuseColor,
1239 MaterialCutFaceDiffuseAlpha,
1240 MaterialCutFaceDiffuseTexture,
1241 MaterialCutFaceSpecular,
1242 MaterialCutFaceMirror,
1243 MaterialCutFaceTransmission,
1244 MaterialCutFaceEmission,
1245 MaterialCutFaceEnvironment,
1246 MaterialCutFaceBump,
1247 MaterialCutFaceGloss,
1553 CharacterPositionOnly,
1556 CharacterPositionAdjusted
1777 UnableToLoadLibraries,
1778 VersionIncompatibility,
1779 InitializationFailed,
1940 TriangleDownWithDot,
1943 TriangleRightWithDot,
1946 TriangleLeftWithDot,
1953 SolidTriangleRightV,
2015 # define HPS_INLINE __forceinline
2018 # define HPS_INLINE inline
2021 #ifndef HPS_UNREFERENCED
2022 #define HPS_UNREFERENCED(param) ((void)(param))
2026 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2028 template<
typename T>
2029 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2031 return degrees * (T)(PI / 180.0);
2034 template<
typename T>
2035 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2037 return radians * (T)(180.0 / PI);
2040 template<
typename T>
2041 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2042 T a = Degrees_To_Radians(angle);
2047 template<
typename T>
2048 HPS_INLINE T Cos(T
const & angle) {
2049 return cos (Degrees_To_Radians(angle));
2052 template<
typename T>
2053 HPS_INLINE T Sin(T
const & angle) {
2054 return sin (Degrees_To_Radians(angle));
2057 template<
typename T>
2058 HPS_INLINE T ACos(T
const & x) {
2063 return Radians_To_Degrees(acos(x));
2066 template<
typename T>
2067 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2068 if (x == 0 && y == 0)
2070 return Radians_To_Degrees(atan2(y, x));
2076 typedef double Alternative;
2077 static const int Type = 1;
2078 static float Epsilon () {
return 1.0e-30f; }
2081 typedef float Alternative;
2082 static const int Type = 2;
2083 static double Epsilon () {
return 1.0e-300; }
2092 # if HOOPS_BIGENDIAN
2100 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2101 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2102 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2103 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2105 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2106 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2107 return exp == 0x7F800000 && mantissa != 0;
2109 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2110 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2111 return exp == 0x7F800000 && mantissa != 0;
2113 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2114 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2115 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2117 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2118 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2119 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2122 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2123 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2124 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2125 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2134 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2135 static HPS_INLINE
bool IsInfinite(
double const & a) {
2137 memcpy (v, &a,
sizeof(
double));
2138 return is_infinite (v);
2142 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2143 static HPS_INLINE
bool IsNAN(
double const & a) {
2145 memcpy (v, &a,
sizeof(
double));
2150 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2151 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2153 memcpy (v, &a,
sizeof(
double));
2154 return is_special (v);
2159 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2160 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2162 #ifndef HOOPS_DEFINED
2163 template <
typename Alloc>
2164 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2166 if (a.size() != b.size())
2169 auto it1 = a.begin();
2170 auto it2 = b.begin();
2171 auto const end = a.end();
2172 for ( ; it1 != end; ++it1, ++it2)
2174 if (!Equals(*it1, *it2, tolerance))
2181 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2182 return extract_uint32_t(a) & 0x80000000;
2184 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2186 memcpy (v, &a,
sizeof(
double));
2187 return v[High] & 0x80000000;
2190 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2191 uint32_t v = extract_uint32_t(a);
2194 inject_uint32_t(a, v);
2196 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2198 memcpy (v, &a,
sizeof(
double));
2199 v[High] &= 0x7FFFFFFF;
2200 v[High] |= sign_bit;
2201 memcpy (&a, v,
sizeof(
double));
2205 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2206 uint32_t v = extract_uint32_t(a);
2214 uint32_t exp = v >> 23;
2215 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2217 return (
unsigned char) (man >> (16 + 126 - exp));
2220 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2221 uint32_t v = extract_uint32_t(a);
2229 uint32_t exp = v >> 23;
2230 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2232 uint32_t x = (man >> (16 + 126 - exp));
2234 return (
unsigned char) ((x * (mix+1)) >> 8);
2238 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2239 uint32_t va = extract_uint32_t(a);
2240 uint32_t vb = extract_uint32_t(b);
2242 if (((va | vb) & 0x7FFFFFFF) == 0)
2247 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2252 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2253 uint32_t va = extract_uint32_t(a);
2254 uint32_t vb = extract_uint32_t(b);
2256 uint32_t a_sign = va & 0x80000000;
2257 uint32_t b_sign = vb & 0x80000000;
2259 (int32_t&)a_sign >>= 31;
2260 (int32_t&)b_sign >>= 31;
2262 uint32_t mash = (a_sign&b_sign);
2267 if ((int32_t&)vb < (int32_t&)va)
2268 memcpy(&a, &b,
sizeof(
float));
2270 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2275 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2276 uint32_t va = extract_uint32_t(a);
2277 uint32_t vb = extract_uint32_t(b);
2279 uint32_t a_sign = va & 0x80000000;
2280 uint32_t b_sign = vb & 0x80000000;
2282 (int32_t&)a_sign >>= 31;
2283 (int32_t&)b_sign >>= 31;
2285 uint32_t mash = (a_sign&b_sign);
2290 if ((int32_t&)vb > (int32_t&)va)
2291 memcpy(&a, &b,
sizeof(
float));
2293 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2299 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2301 memcpy(&i, &a,
sizeof(
float));
2305 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2306 memcpy(&a, &i,
sizeof(
float));
2309 static HPS_INLINE
float C2F(
unsigned char x) {
2311 return char_to_float[x];
2316 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2317 memcpy(&m[0], &f,
sizeof(
float));
2318 memcpy(&m[1], &f,
sizeof(
float));
2319 memcpy(&m[2], &f,
sizeof(
float));
2320 memcpy(&m[3], &f,
sizeof(
float));
2323 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2324 memcpy(&m[0], &f0,
sizeof(
float));
2325 memcpy(&m[1], &f1,
sizeof(
float));
2326 memcpy(&m[2], &f2,
sizeof(
float));
2327 memcpy(&m[3], &f3,
sizeof(
float));
2330 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2331 memcpy(f0, m,
sizeof(
float)*4);
2334 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2335 memcpy(&f0, &m[0],
sizeof(
float));
2336 memcpy(&f1, &m[1],
sizeof(
float));
2337 memcpy(&f2, &m[2],
sizeof(
float));
2338 memcpy(&f3, &m[3],
sizeof(
float));
2342 static const float char_to_float[256];
2351 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2352 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2354 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2355 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2356 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2357 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2358 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2359 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2361 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2362 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2363 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d) {
return Min(Min(a, b, c),d); }
2364 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Min(Min(a,b,c,d),e); }
2365 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Min(Min(a,b,c,d,e),f); }
2367 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2368 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2369 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d) {
return Max(Max(a, b, c),d); }
2370 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e) {
return Max(Max(a,b,c,d),e); }
2371 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c, T
const & d, T
const & e, T
const & f) {
return Max(Max(a,b,c,d,e),f); }
2373 template <
typename T> HPS_INLINE T
const & Clamp(T
const & x, T
const & min, T
const & max) {
return x < min ? min : x > max ? max : x; }
2376 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2377 uint32_t v = Float::extract_uint32_t(a);
2380 Float::inject_uint32_t(f,v);
2384 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2385 uint32_t v = Float::extract_uint32_t(a);
2387 if ((v & 0x7FFFFFFF) == 0)
2390 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2393 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2394 int a_sign = Sign(a);
2395 int b_sign = Sign(b);
2397 if (a_sign != b_sign)
2398 return Compare(a_sign, b_sign);
2400 uint32_t v = Float::extract_uint32_t(a);
2401 uint32_t u = Float::extract_uint32_t(b);
2403 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2406 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2412 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2421 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2422 int32_t va = Float::extract_uint32_t(a);
2423 int32_t vb = Float::extract_uint32_t(b);
2425 if (is_special(va) || is_special(vb)) {
2426 if (is_infinite(va) || is_infinite(vb))
2428 if (is_nan(va) || is_nan(vb))
2432 int const close_to_zero = 0x36A00000;
2433 if ((va & 0x7FFFFFFF) == 0)
2434 return (vb & 0x7FFFFFFF) < close_to_zero;
2435 else if ((vb & 0x7FFFFFFF) == 0)
2436 return (va & 0x7FFFFFFF) < close_to_zero;
2438 uint32_t sign_mask = va ^ vb;
2439 (int32_t &)sign_mask >>= 31;
2441 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2442 int32_t v1 = tolerance + diff;
2443 int32_t v2 = tolerance - diff;
2444 return (v1|v2) >= 0;
2447 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2448 int32_t va[2], vb[2];
2449 memcpy (va, &a,
sizeof(
double));
2450 memcpy (vb, &b,
sizeof(
double));
2452 if (is_special(va) || is_special(vb)) {
2453 if (is_infinite(va) || is_infinite(vb))
2454 return va[High] == vb[High] && va[Low] == vb[Low];
2455 if (is_nan(va) || is_nan(vb))
2459 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2460 return Abs(a - b) < 0.000000000000005;
2462 if (extract_sign_bit(a) != extract_sign_bit(b))
2465 if (va[High] != vb[High])
2468 return Abs(va[Low] - vb[Low]) <= tolerance;
2475 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2477 template <
typename T>
2478 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2480 if (Is_Abnormal (*t++))
2485 template <
typename T>
2486 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2487 return count >= 0 && Is_Abnormal((
size_t)count, t);
2494 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2495 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2496 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2497 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2500 template <
typename F>
2508 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2510 template <
typename D>
2511 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2519 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2520 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2522 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2529 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2530 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2531 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2532 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2534 F & operator[] (
size_t i) {
return (&x)[i]; }
2535 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2568 template <
typename F,
typename S>
2571 template <
typename F>
2572 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2573 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2576 template <
typename F>
2577 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2578 return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2581 template <
typename F>
2582 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2583 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2587 template <
typename F>
2594 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2596 template <
typename D>
2604 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2605 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2607 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2612 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2613 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2615 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2617 F & operator[] (
size_t i) {
return (&x)[i]; }
2618 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2639 template <
typename F>
2642 template <
typename F,
typename S>
2643 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F>
const & a) {
return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2645 template <
typename F>
2646 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2647 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2650 template <
typename F>
2651 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2652 return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2655 template <
typename F>
2656 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2657 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2661 template <
typename F>
2669 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2670 template <
typename D>
2679 bool operator== (
Vector_3D const & v)
const {
2680 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2682 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2684 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2690 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2691 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2695 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2696 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2698 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2700 F & operator[] (
size_t i) {
return (&x)[i]; }
2701 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2703 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2705 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2707 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2709 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2713 F range = Max (Abs (x), Abs (y), Abs (z));
2714 if (range > F(1.0e10))
2718 F len = (F)Length();
2725 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2727 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2728 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2730 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2733 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2738 return Vector_3D (x * v.x, y * v.y, z * v.z);
2752 template <
typename F,
typename S>
2755 template <
typename F>
2756 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2757 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2761 template <
typename F>
2762 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2764 template <
typename F>
2765 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F>
const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2766 template <
typename F>
2767 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F>
const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2769 template <
typename F>
2770 HPS_INLINE Vector_3D<F>
const Point_3D<F>::operator- (Point_3D<F>
const & p)
const {
return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2772 template <
typename F>
2773 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2774 template <
typename F>
2775 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2777 template <
typename F>
2778 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F>
const & v) { x *= v.x; y *= v.y; z *= v.z;
return *
this; }
2779 template <
typename F>
2780 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F>
const & v) { x /= v.x; y /= v.y; z /= v.z;
return *
this; }
2781 template <
typename F>
2782 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2783 template <
typename F>
2784 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_3D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2788 template <
typename F>
2789 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2790 return a + (b - a) * t;
2793 template <
typename F>
2794 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2795 return Vector_3D<F>(a + (b - a) * t).Normalize();
2800 template <
typename F>
2801 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2802 return (p2 - p1).Length();
2805 template <
typename F>
2806 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2807 return (p2 - p1).LengthSquared();
2810 template <
typename F>
2811 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2812 F p =
static_cast<F
>((c - b).LengthSquared());
2813 F q =
static_cast<F
>((c - a).LengthSquared());
2814 F r =
static_cast<F
>((b - a).LengthSquared());
2817 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2818 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2823 template <
typename F>
2824 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2825 bool success =
true;
2826 for (
size_t i = 0; i < count; ++i) {
2827 if (vectors->Normalize() == Vector_3D<F>::Zero())
2835 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2837 template <
typename F>
2844 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2845 template <
typename D>
2854 bool operator== (
Vector_2D const & v)
const {
2855 return Float::match(x, v.x) && Float::match(y, v.y);
2857 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2859 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2868 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2869 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2871 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2873 F & operator[] (
size_t i) {
return (&x)[i]; }
2874 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2876 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2878 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2882 F range = Max (Abs (x), Abs (y));
2883 if (range > F(1.0e10))
2887 F len = (F)Length();
2894 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2896 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2897 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2899 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2902 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2903 return x * v.y - y * v.x;
2920 template <
typename F,
typename S>
2923 template <
typename F>
2924 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
2925 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2929 template <
typename F>
2930 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
2932 template <
typename F>
2933 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
2935 template <
typename F>
2936 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2937 template <
typename F>
2938 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
2940 template <
typename F>
2941 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x + v.x, y + v.y, z); }
2942 template <
typename F>
2943 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x - v.x, y - v.y, z); }
2945 template <
typename F>
2946 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
2947 template <
typename F>
2948 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
2950 template <
typename F>
2951 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x * v.x, y * v.y, z); }
2952 template <
typename F>
2953 HPS_INLINE Point_3D<F>
const Point_3D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_3D<F> (x / v.x, y / v.y, z); }
2956 template <
typename F>
2957 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2958 template <
typename F>
2959 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
2961 template <
typename F>
2962 HPS_INLINE Vector_2D<F>
const Point_2D<F>::operator- (Point_2D<F>
const & p)
const {
return Vector_2D<F> (x - p.x, y - p.y); }
2964 template <
typename F>
2965 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator+ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x + v.x, y + v.y); }
2966 template <
typename F>
2967 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator- (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x - v.x, y - v.y); }
2969 template <
typename F>
2970 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
2971 template <
typename F>
2972 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
2973 template <
typename F>
2974 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator* (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x * v.x, y * v.y); }
2975 template <
typename F>
2976 HPS_INLINE Point_2D<F>
const Point_2D<F>::operator/ (Vector_2D<F>
const & v)
const {
return Point_2D<F> (x / v.x, y / v.y); }
2982 template <
typename F>
2991 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
2995 template <
typename D>
2996 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3012 for (
size_t i=0; i<count; ++i) {
3015 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3016 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3017 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3027 double inv_count = 1.0 / (double)count;
3035 *
this = Plane_3D::Zero();
3041 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3042 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3044 F & operator[] (
size_t i) {
return (&a)[i]; }
3045 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3047 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3062 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3063 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3066 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3067 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3068 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3075 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3076 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3078 return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3081 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3085 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3086 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3087 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3088 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3095 template <
typename F>
3096 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3097 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3101 template <
typename F>
3102 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3103 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3105 template <
typename F>
3106 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3107 return plane * point;
3110 template <
typename F>
3111 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3112 return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3115 template <
typename F>
3116 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3123 template <
typename F>
3131 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3135 template <
typename D>
3136 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3140 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3141 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3143 F & operator[] (
size_t i) {
return (&a)[i]; }
3144 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3146 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3163 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3164 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3165 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3166 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3173 template <
typename F>
3174 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3175 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3179 template <
typename F>
3180 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3181 return plane.a * point.x + plane.b * point.y + plane.c;
3183 template <
typename F>
3184 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3185 return plane * point;
3188 template <
typename F>
3189 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3190 return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3193 template <
typename F>
3194 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3208 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3209 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3211 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3212 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3215 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3220 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3224 return !(*
this == rect);
3227 HPS_INLINE
int PixelWidth()
const {
3228 return right - left + 1;
3231 HPS_INLINE
int PixelHeight()
const {
3232 return top - bottom + 1;
3235 HPS_INLINE
int Width()
const {
3236 return right - left;
3239 HPS_INLINE
int Height()
const {
3240 return top - bottom;
3243 HPS_INLINE
int Area()
const {
3244 return Width() * Height();
3247 HPS_INLINE
Point2D Center()
const {
3248 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3251 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3252 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3255 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3256 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3269 right += rect.right;
3270 bottom -= rect.bottom;
3285 right -= rect.right;
3286 bottom += rect.bottom;
3292 left = Max(left, rect.left);
3293 right = Min(right, rect.right);
3294 bottom = Max(bottom, rect.bottom);
3295 top = Min(top, rect.top);
3300 left = Min(left, rect.left);
3301 right = Max(right, rect.right);
3302 bottom = Min(bottom, rect.bottom);
3303 top = Max(top, rect.top);
3320 return temp.Expand(border);
3323 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3324 IntRectangle temp = a;
3325 return temp.Expand(border);
3328 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3329 IntRectangle temp = a;
3330 return temp.Contract(border);
3333 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3334 IntRectangle temp = a;
3335 return temp.Contract(border);
3338 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3339 IntRectangle temp = a;
3340 return temp.Intersect(b);
3343 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3344 IntRectangle temp = a;
3345 return temp.Union(b);
3355 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3356 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3358 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3359 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3362 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3365 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3375 Merge(count, points);
3387 Merge(count, points);
3391 HPS_INLINE
float Width()
const {
3392 return right - left;
3395 HPS_INLINE
float Height()
const {
3396 return top - bottom;
3399 HPS_INLINE
float Area()
const {
3400 return Width() * Height();
3403 HPS_INLINE
Point2D Center()
const {
3404 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3407 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3410 if (Compare(points[0].x, points[1].x)>0) {
3411 Float::replace_if_smaller(left, points[1].x);
3412 Float::replace_if_larger(right, points[0].x);
3415 Float::replace_if_smaller(left, points[0].x);
3416 Float::replace_if_larger(right, points[1].x);
3419 if (Compare(points[0].y, points[1].y)>0) {
3420 Float::replace_if_smaller(bottom, points[1].y);
3421 Float::replace_if_larger(top, points[0].y);
3424 Float::replace_if_smaller(bottom, points[0].y);
3425 Float::replace_if_larger(top, points[1].y);
3436 HPS_INLINE
void Merge(
Point const & point) {
3437 Float::replace_if_smaller(left, point.x);
3438 Float::replace_if_smaller(bottom, point.y);
3439 Float::replace_if_larger(right, point.x);
3440 Float::replace_if_larger(top, point.y);
3443 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3446 if (Compare(points[0].x, points[1].x)>0) {
3447 Float::replace_if_smaller(left, points[1].x);
3448 Float::replace_if_larger(right, points[0].x);
3451 Float::replace_if_smaller(left, points[0].x);
3452 Float::replace_if_larger(right, points[1].x);
3455 if (Compare(points[0].y, points[1].y)>0) {
3456 Float::replace_if_smaller(bottom, points[1].y);
3457 Float::replace_if_larger(top, points[0].y);
3460 Float::replace_if_smaller(bottom, points[0].y);
3461 Float::replace_if_larger(top, points[1].y);
3472 HPS_INLINE
void Merge(
Point2D const & point) {
3473 Float::replace_if_smaller(left, point.x);
3474 Float::replace_if_smaller(bottom, point.y);
3475 Float::replace_if_larger(right, point.x);
3476 Float::replace_if_larger(top, point.y);
3479 bool operator==(
Rectangle const & rect)
const {
3480 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3483 bool operator!=(
Rectangle const & rect)
const {
3484 return !(*
this == rect);
3487 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3488 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3491 HPS_INLINE
bool Contains(
Point const & contained)
const {
3492 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3495 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3496 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3499 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3500 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3503 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3504 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3505 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3508 HPS_INLINE
Rectangle & Expand(
float border) {
3516 HPS_INLINE
Rectangle & Expand(
int border) {
3517 Expand((
float)border);
3523 right += rect.right;
3524 bottom -= rect.bottom;
3529 HPS_INLINE
Rectangle & Contract(
int border) {
3539 right -= rect.right;
3540 bottom += rect.bottom;
3546 left = Max(left, rect.left);
3547 right = Min(right, rect.right);
3548 bottom = Max(bottom, rect.bottom);
3549 top = Min(top, rect.top);
3554 left = Min(left, rect.left);
3555 right = Max(right, rect.right);
3556 bottom = Min(bottom, rect.bottom);
3557 top = Max(top, rect.top);
3562 float scale = (scope.right - scope.left) * 0.5f;
3563 float trans = (scope.right + scope.left) * 0.5f;
3565 left = left * scale + trans;
3566 right = right * scale + trans;
3568 scale = (scope.top - scope.bottom) * 0.5f;
3569 trans = (scope.top + scope.bottom) * 0.5f;
3571 bottom = bottom * scale + trans;
3572 top = top * scale + trans;
3577 float tmp = 2.0f/(scope.right - scope.left);
3578 right = (right - scope.left) * tmp - 1.0f;
3579 left = (left - scope.left) * tmp - 1.0f;
3581 tmp = 2.0f/(scope.top - scope.bottom);
3582 top = (top - scope.bottom) * tmp - 1.0f;
3583 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3587 static HPS_INLINE
Rectangle FullScope() {
3588 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3591 static HPS_INLINE
Rectangle InvalidScope() {
3592 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3604 temp.left = Floor (a.left);
3605 temp.right = Floor (a.right);
3606 temp.bottom = Floor (a.bottom);
3607 temp.top = Floor (a.top);
3611 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3613 return temp.Expand(border);
3616 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3618 return temp.Expand(border);
3621 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3623 return temp.Contract(border);
3626 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3628 return temp.Contract(border);
3631 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3633 return temp.Intersect(b);
3636 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3638 return temp.Union(b);
3641 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3643 return temp.Inscribe_Scope(scope);
3646 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3648 return temp.Circumscribe_Scope(scope);
3651 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3652 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3657 template <
typename F>
3660 template <
typename F>
3673 template <
typename D>
3702 min = Limit_Point();
3703 max = -Limit_Point();
3706 min = max = *points++;
3709 Merge(count, points);
3722 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3739 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3745 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3770 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3778 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3779 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3780 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3789 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3790 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3791 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3802 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3814 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3831 Float::replace_if_smaller(min.x, cuboid.
min.x);
3832 Float::replace_if_smaller(min.y, cuboid.
min.y);
3833 Float::replace_if_smaller(min.z, cuboid.
min.z);
3834 Float::replace_if_larger(max.x, cuboid.
max.x);
3835 Float::replace_if_larger(max.y, cuboid.
max.y);
3836 Float::replace_if_larger(max.z, cuboid.
max.z);
3852 Float::replace_if_smaller(min.x, point.x);
3853 Float::replace_if_smaller(min.y, point.y);
3854 Float::replace_if_smaller(min.z, point.z);
3855 Float::replace_if_larger(max.x, point.x);
3856 Float::replace_if_larger(max.y, point.y);
3857 Float::replace_if_larger(max.z, point.z);
3868 if (Compare(points[0].x, points[1].x)>0) {
3869 Float::replace_if_smaller(min.x, points[1].x);
3870 Float::replace_if_larger(max.x, points[0].x);
3873 Float::replace_if_smaller(min.x, points[0].x);
3874 Float::replace_if_larger(max.x, points[1].x);
3877 if (Compare(points[0].y, points[1].y)>0) {
3878 Float::replace_if_smaller(min.y, points[1].y);
3879 Float::replace_if_larger(max.y, points[0].y);
3882 Float::replace_if_smaller(min.y, points[0].y);
3883 Float::replace_if_larger(max.y, points[1].y);
3886 if (Compare(points[0].z, points[1].z)>0) {
3887 Float::replace_if_smaller(min.z, points[1].z);
3888 Float::replace_if_larger(max.z, points[0].z);
3891 Float::replace_if_smaller(min.z, points[0].z);
3892 Float::replace_if_larger(max.z, points[1].z);
3909 return (contained.
min.x >= min.x &&
3910 contained.
min.y >= min.y &&
3911 contained.
min.z >= min.z &&
3912 contained.
max.x <= max.x &&
3913 contained.
max.y <= max.y &&
3914 contained.
max.z <= max.z);
3923 return (contained.x >= min.x &&
3924 contained.y >= min.y &&
3925 contained.z >= min.z &&
3926 contained.x <= max.x &&
3927 contained.y <= max.y &&
3928 contained.z <= max.z);
3938 return (contained.x >= min.x - epsilon &&
3939 contained.y >= min.y - epsilon &&
3940 contained.z >= min.z - epsilon &&
3941 contained.x <= max.x + epsilon &&
3942 contained.y <= max.y + epsilon &&
3943 contained.z <= max.z + epsilon);
3952 Float::replace_if_larger(min.x, cuboid.
min.x);
3953 Float::replace_if_larger(min.y, cuboid.
min.y);
3954 Float::replace_if_larger(min.z, cuboid.
min.z);
3955 Float::replace_if_smaller(max.x, cuboid.
max.x);
3956 Float::replace_if_smaller(max.y, cuboid.
max.y);
3957 Float::replace_if_smaller(max.z, cuboid.
max.z);
3967 Float::replace_if_smaller(min.x, cuboid.
min.x);
3968 Float::replace_if_smaller(min.y, cuboid.
min.y);
3969 Float::replace_if_smaller(min.z, cuboid.
min.z);
3970 Float::replace_if_larger(max.x, cuboid.
max.x);
3971 Float::replace_if_larger(max.y, cuboid.
max.y);
3972 Float::replace_if_larger(max.z, cuboid.
max.z);
4002 F
const limit = std::numeric_limits<F>::max();
4007 typedef Cuboid_3D<float> SimpleCuboid;
4008 typedef Cuboid_3D<double> DSimpleCuboid;
4011 template <
typename F>
4012 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4013 Cuboid_3D<F> temp = a;
4014 return temp.Intersect(b);
4017 template <
typename F>
4018 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4019 Cuboid_3D<F> temp = a;
4020 return temp.Union(b);
4023 template <
typename F>
4024 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4025 Cuboid_3D<F> temp = a;
4026 return temp.Expand(border);
4029 template <
typename F>
4030 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4031 Cuboid_3D<F> temp = a;
4032 return temp.Contract(border);
4037 template <
typename F>
4038 struct HPS_TEMPLATE_API Sphere_3D {
4042 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4044 template <
typename D>
4045 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4047 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4048 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4050 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4052 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4053 Cuboid_3D<F> cuboid(count, points);
4054 center = Midpoint(cuboid.min, cuboid.max);
4055 Engulf (count, points);
4058 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4059 Engulf (count, points);
4062 HPS_INLINE
bool IsValid()
const {
4066 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4068 void Invalidate() {radius = -1;}
4070 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4071 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4073 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4075 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4076 Vector_3D<F> dir = point - center;
4077 F distance = (F)dir.Length();
4079 if (distance > radius) {
4080 F t = F(0.5) * (distance - radius);
4081 center += t * dir.Normalize();
4086 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4088 for (
size_t i = 0; i < count; ++i) {
4089 Vector_3D<F> dir = *points - center;
4090 F distance = (F)dir.Length();
4092 if (distance > radius) {
4093 F t = F(0.5) * (distance - radius);
4094 center += t * dir.Normalize();
4102 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4103 Vector_3D<F> dir = sphere.center - center;
4104 F distance = (F)dir.Length();
4106 if (distance + sphere.radius > radius) {
4107 if (distance + radius > sphere.radius) {
4108 F t = F(0.5 * (sphere.radius + distance - radius));
4109 center += t * dir.Normalize();
4113 center = sphere.center;
4114 radius = sphere.radius;
4119 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4123 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4124 for (
size_t i = 0; i < count; ++i) {
4125 double dsq = (*points++ - center).LengthSquared();
4126 if ((F)dsq > radius * radius)
4127 radius = (F)sqrt(dsq);
4132 typedef Sphere_3D<float> SimpleSphere;
4133 typedef Sphere_3D<double> DSimpleSphere;
4136 template <
typename F>
4138 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4139 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4157 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4158 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4159 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4160 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4161 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4162 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4164 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4165 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4166 float Distance(RGBColor
const & other_color)
const;
4167 HPS_INLINE
bool IsValid()
const {
4168 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4171 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4172 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4174 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4177 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4178 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4179 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4180 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4181 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4182 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4184 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4185 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4186 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4187 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4188 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4189 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4190 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4191 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4193 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4194 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4195 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4197 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4198 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4199 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4201 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4202 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4203 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4206 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4207 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4208 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4220 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4221 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4223 HPS_INLINE RGBAColor (RGBColor
const & c) {
4224 memcpy(
this, &c,
sizeof(RGBColor));
4226 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4228 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4229 memcpy(
this, &c,
sizeof(RGBColor));
4230 memcpy(&alpha, &a,
sizeof(
float));
4231 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4233 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4234 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4236 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4237 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4238 HPS_INLINE
bool IsValid()
const {
4239 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4256 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4258 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4263 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4264 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4265 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4266 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4267 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4268 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4270 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4271 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4272 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4273 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4274 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4275 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4276 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4277 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4279 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4280 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4281 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4282 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4283 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4284 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4286 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4287 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4288 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4289 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4303 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4304 unsigned char b, g, r, a;
4308 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4309 unsigned char r, g, b, a;
4313 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4314 unsigned char r, g, b, a;
4324 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4330 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4338 explicit HPS_INLINE RGBAS32Color (
RGBColor const & c)
4340 r = Float::unit_to_byte(c.red);
4341 g = Float::unit_to_byte(c.green);
4342 b = Float::unit_to_byte(c.blue);
4346 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4350 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4352 r = Float::unit_to_byte(c.red);
4353 g = Float::unit_to_byte(c.green);
4354 b = Float::unit_to_byte(c.blue);
4355 a = Float::unit_to_byte(alpha);
4357 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4359 r = Float::unit_to_byte(c.red);
4360 g = Float::unit_to_byte(c.green);
4361 b = Float::unit_to_byte(c.blue);
4364 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
4366 r = Float::unit_to_byte(c.
red);
4367 g = Float::unit_to_byte(c.
green);
4368 b = Float::unit_to_byte(c.
blue);
4369 a = Float::unit_to_byte(c.
alpha);
4371 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4373 r = Float::unit_to_byte(c.
red);
4374 g = Float::unit_to_byte(c.
green);
4375 b = Float::unit_to_byte(c.
blue);
4376 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4379 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4380 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4381 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4383 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4384 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4386 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4387 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4388 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4390 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4401 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4402 : r (gray), g (gray), b (gray), a (aa) {}
4403 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4404 : r (rr), g (gg), b (bb), a (aa) {}
4406 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4407 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4408 r = Float::unit_to_byte(c.red);
4409 g = Float::unit_to_byte(c.green);
4410 b = Float::unit_to_byte(c.blue);
4413 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4414 r = Float::unit_to_byte(c.red);
4415 g = Float::unit_to_byte(c.green);
4416 b = Float::unit_to_byte(c.blue);
4417 a = Float::unit_to_byte(alpha);
4419 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4420 r = Float::unit_to_byte(c.red);
4421 g = Float::unit_to_byte(c.green);
4422 b = Float::unit_to_byte(c.blue);
4425 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4426 r = Float::unit_to_byte(c.
red);
4427 g = Float::unit_to_byte(c.
green);
4428 b = Float::unit_to_byte(c.
blue);
4429 a = Float::unit_to_byte(c.
alpha);
4431 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4432 r = Float::unit_to_byte(c.
red);
4433 g = Float::unit_to_byte(c.
green);
4434 b = Float::unit_to_byte(c.
blue);
4435 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4438 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4439 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4441 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4442 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4444 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4445 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4447 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4459 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4460 : r (gray), g (gray), b (gray) {}
4461 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4462 : r (rr), g (gg), b (bb) {}
4463 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4464 r = Float::unit_to_byte(c.red);
4465 g = Float::unit_to_byte(c.green);
4466 b = Float::unit_to_byte(c.blue);
4469 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4470 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4472 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4473 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4476 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4477 red = Float::C2F(c32.r);
4478 green = Float::C2F(c32.g);
4479 blue = Float::C2F(c32.b);
4482 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4483 red = Float::C2F(c32.r);
4484 green = Float::C2F(c32.g);
4485 blue = Float::C2F(c32.b);
4488 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4494 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4495 red = Float::C2F(c24.r);
4496 green = Float::C2F(c24.g);
4497 blue = Float::C2F(c24.b);
4500 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4508 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4516 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
const & c32) {
4517 red = Float::C2F(c32.r);
4518 green = Float::C2F(c32.g);
4519 blue = Float::C2F(c32.b);
4520 alpha = Float::C2F(c32.a);
4523 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4524 red = Float::C2F(c32.r);
4525 green = Float::C2F(c32.g);
4526 blue = Float::C2F(c32.b);
4527 alpha = Float::C2F(c32.a);
4530 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4531 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4536 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4537 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4540 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4541 return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4544 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4545 return RGBAS32Color(
4546 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4547 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4548 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4549 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4552 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4554 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4555 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4556 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4557 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4560 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4562 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4563 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4564 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4576 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4578 Quaternion(
float in_w,
float in_x,
float in_y,
float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4596 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4597 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4598 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4599 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4602 Quaternion operator* (
float in_right)
const {
4603 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4607 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4610 Quaternion operator/ (
float in_right)
const {
4611 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4615 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4619 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4622 inline float Norm()
const {
4623 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4629 float mag_q = Norm();
4630 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4632 ret.w =
static_cast<float>(log(mag_q));
4635 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4642 ret.x = ret.y = ret.z = 0;
4649 float ea =
static_cast<float>(exp(w));
4650 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4651 float scale = ea * sin(mag_V) / mag_V;
4653 ret.w = ea * cos(mag_V);
4662 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4663 return ret.Normalize();
4667 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4669 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4671 if (in_shortest_path_only && dot < 0) {
4678 if (dot > -0.95f && dot < 0.95f) {
4679 float angle =
static_cast<float>(acos(dot));
4680 float sina =
static_cast<float>(sin(angle));
4681 float sinat =
static_cast<float>(sin(angle*in_fraction));
4682 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4684 return (*
this * sinaomt + q3 * sinat) / sina;
4687 return Lerp(q3, in_fraction);
4700 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4701 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4703 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4715 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4720 typedef unsigned char byte;
4721 typedef signed char sbyte;
4722 typedef intptr_t WindowHandle;
4723 typedef double Time;
4724 typedef int64_t TouchID;
4725 typedef intptr_t PlatformData;
4758 class AttributesControl;
4764 class VisibilityControl;
4765 class CameraControl;
4766 class SelectabilityControl;
4767 class TransparencyKit;
4768 class TransparencyControl;
4770 class CullingControl;
4772 class MarkerAttributeControl;
4773 class GlyphDefinition;
4774 class GeometryInsertControl;
4776 class TextAttributeControl;
4777 class TextAttributeKit;
4778 class LineAttributeKit;
4779 class LineAttributeControl;
4780 class EdgeAttributeKit;
4781 class EdgeAttributeControl;
4782 class CurveAttributeKit;
4783 class CurveAttributeControl;
4786 class ModellingMatrixControl;
4787 class TextureMatrixControl;
4788 class TextureDefinition;
4789 class MaterialMappingKit;
4790 class MaterialMappingControl;
4794 class DistantLightKit;
4795 class DistantLightKey;
4796 class CuttingSectionKit;
4797 class CuttingSectionKey;
4798 class CuttingSectionAttributeKit;
4799 class CuttingSectionAttributeControl;
4800 class CylinderAttributeKit;
4801 class CylinderAttributeControl;
4807 class SphereAttributeKit;
4808 class SphereAttributeControl;
4813 class CircularArcKey;
4814 class CircularArcKit;
4815 class CircularWedgeKey;
4816 class CircularWedgeKit;
4818 class InfiniteLineKey;
4819 class InfiniteLineKit;
4822 class NURBSCurveKey;
4823 class NURBSCurveKit;
4824 class NURBSSurfaceKey;
4825 class NURBSSurfaceKit;
4830 class EllipticalArcKey;
4831 class EllipticalArcKit;
4839 class NURBSSurfaceAttributeKit;
4840 class NURBSSurfaceAttributeControl;
4843 class PerformanceKit;
4844 class PerformanceControl;
4845 class HiddenLineAttributeKit;
4846 class HiddenLineAttributeControl;
4847 class DrawingAttributeKit;
4848 class DrawingAttributeControl;
4851 class SelectionOptionsKit;
4852 class SelectionResults;
4853 class SelectionItem;
4854 class SelectionControl;
4855 class HighlightControl;
4856 class HighlightOptionsKit;
4857 class ImageDefinition;
4859 class TextureDefinition;
4860 class TextureOptionsKit;
4861 class NamedStyleDefinition;
4862 class MaterialPaletteDefinition;
4863 class GlyphDefinition;
4864 class LinePatternOptionsKit;
4865 class LinePatternDefinition;
4866 class LinePatternKit;
4867 class LinePatternElement;
4868 class LinePatternParallelKit;
4869 class CubeMapDefinition;
4871 class ShaderDefinition;
4872 class EmergencyHandler;
4873 class EventDispatcher;
4876 class StandAloneWindowKey;
4877 class StandAloneWindowOptionsKit;
4878 class ApplicationWindowKey;
4879 class ApplicationWindowOptionsKit;
4880 class OffScreenWindowKey;
4881 class OffScreenWindowOptionsKit;
4882 class LightingAttributeControl;
4883 class VisualEffectsControl;
4884 class PostProcessEffectsControl;
4885 class SelectionOptionsControl;
4889 class NormalizedPoint;
4890 class ScreenRangePoint;
4891 class InnerWindowPoint;
4892 class InnerPixelPoint;
4895 class VisibilityKit;
4897 class SelectabilityKit;
4898 class MarkerAttributeKit;
4899 class LightingAttributeKit;
4900 class VisualEffectsKit;
4901 class PostProcessEffectsKit;
4903 class SubwindowControl;
4906 class DebuggingControl;
4909 class ContourLineKit;
4910 class ContourLineControl;
4913 class PortfolioControl;
4915 class ConditionControl;
4916 class WindowInfoKit;
4917 class WindowInfoControl;
4918 class FontInfoState;
4919 class FontInfoControl;
4920 class SearchOptionsKit;
4921 class AttributeLockControl;
4922 class AttributeLockKit;
4926 class BoundingControl;
4927 class TransformMaskKit;
4928 class TransformMaskControl;
4929 class ColorInterpolationKit;
4930 class ColorInterpolationControl;
4931 class UpdateOptionsKit;
4932 class UpdateOptionsControl;
4935 class ShellRelationOptionsKit;
4936 class ShellRelationResultsKit;
4939 class CutGeometryGatheringOptionsKit;
4985 enum class Type : uint32_t
4988 GenericMask = 0xffffff00,
4992 EventDispatcher = 0x00000003,
4993 EventHandler = 0x00000004,
4994 EventNotifier = 0x00000005,
4995 UpdateNotifier = 0x00000006,
4996 SearchResults = 0x00000008,
4997 FontSearchResults = 0x00000009,
4998 SearchResultsIterator = 0x0100000a,
4999 FontSearchResultsIterator = 0x0100000b,
5000 SelectionResults = 0x0000000c,
5001 SelectionResultsIterator = 0x0100000d,
5002 SelectionItem = 0x0000000e,
5003 TreeContext = 0x0000000f,
5005 IONotifier = 0x04000100,
5006 StreamImportNotifier = 0x04000101,
5007 STLImportNotifier = 0x04000102,
5008 OBJImportNotifier = 0x04000103,
5009 ExchangeImportNotifier = 0x04000104,
5010 SketchupImportNotifier = 0x04000105,
5011 ParasolidImportNotifier = 0x04000106,
5012 ExchangeTranslationNotifier = 0x04000107,
5015 MarkerKit = 0x01000010,
5016 SphereAttributeKit = 0x01000011,
5017 TextAttributeKit = 0x01000012,
5018 TransparencyKit = 0x01000013,
5019 VisibilityKit = 0x01000014,
5020 VisualEffectsKit = 0x01000015,
5021 CuttingSectionAttributeKit = 0x01000016,
5022 CircleKit = 0x01000017,
5023 CircularArcKit = 0x01000018,
5024 CircularWedgeKit = 0x01000019,
5025 CuttingSectionKit = 0x0100001a,
5026 CylinderKit = 0x0100001b,
5027 DistantLightKit = 0x0100001c,
5028 EllipseKit = 0x0100001d,
5029 EllipticalArcKit = 0x0100001e,
5030 InfiniteLineKit = 0x0100001f,
5031 LineKit = 0x01000020,
5032 NURBSCurveKit = 0x01000021,
5033 MeshKit = 0x01000022,
5034 NURBSSurfaceKit = 0x01000023,
5035 PolygonKit = 0x01000024,
5036 SphereKit = 0x01000025,
5037 SpotlightKit = 0x01000026,
5038 ShellKit = 0x01000027,
5039 TextKit = 0x01000028,
5040 MaterialKit = 0x01000029,
5041 TrimKit = 0x0100002a,
5042 TextureOptionsKit = 0x0100002c,
5043 LinePatternKit = 0x0100002d,
5044 GlyphKit = 0x0100002e,
5045 ImageKit = 0x0100002f,
5046 LinePatternOptionsKit = 0x01000030,
5047 CameraKit = 0x01000031,
5048 BoundingKit = 0x01000032,
5049 CullingKit = 0x01000033,
5050 CurveAttributeKit = 0x01000034,
5051 CylinderAttributeKit = 0x01000035,
5052 EdgeAttributeKit = 0x01000036,
5053 LightingAttributeKit = 0x01000037,
5054 LineAttributeKit = 0x01000038,
5055 MarkerAttributeKit = 0x01000039,
5056 MaterialMappingKit = 0x0100003a,
5057 MatrixKit = 0x0100003b,
5058 NURBSSurfaceAttributeKit = 0x0100003c,
5059 PostProcessEffectsKit = 0x0100003d,
5060 SelectabilityKit = 0x0100003e,
5061 SelectionOptionsKit = 0x0100003f,
5062 StandAloneWindowOptionsKit = 0x01000040,
5063 OffScreenWindowOptionsKit = 0x01000041,
5064 ApplicationWindowOptionsKit = 0x01000042,
5065 HighlightOptionsKit = 0x01000043,
5066 LinePatternParallelKit = 0x01000044,
5067 SubwindowKit = 0x01000045,
5068 PerformanceKit = 0x01000046,
5069 HiddenLineAttributeKit = 0x01000047,
5070 DrawingAttributeKit = 0x01000048,
5071 ShaderKit = 0x01000049,
5072 DebuggingKit = 0x0100004a,
5073 ContourLineKit = 0x0100004b,
5074 StreamImportOptionsKit = 0x0100004c,
5075 StreamImportResultsKit = 0x0100004d,
5076 StreamExportOptionsKit = 0x0100004e,
5077 StreamExportResultsKit = 0x0100004f,
5078 WindowInfoKit = 0x01000050,
5079 ImageImportOptionsKit = 0x01000051,
5080 SearchOptionsKit = 0x01000052,
5081 ShaderImportOptionsKit = 0x01000053,
5082 HardcopyExportOptionsKit = 0x01000055,
5083 AttributeLockKit = 0x01000056,
5084 TransformMaskKit = 0x01000057,
5085 ColorInterpolationKit = 0x01000058,
5086 UpdateOptionsKit = 0x01000059,
5087 ImageExportOptionsKit = 0x0100005a,
5088 OBJImportOptionsKit = 0x0100005b,
5089 OBJImportResultsKit = 0x0100005c,
5090 STLImportOptionsKit = 0x0100005d,
5091 STLImportResultsKit = 0x0100005e,
5092 ShellOptimizationOptionsKit = 0x0100005f,
5093 ShellRelationOptionsKit = 0x01000060,
5094 ShellRelationResultsKit = 0x01000061,
5095 GridKit = 0x01000062,
5096 CutGeometryGatheringOptionsKit = 0x01000063,
5099 LinePatternElement = 0x03000000,
5100 SolidLinePatternElement = 0x03000001,
5101 BlankLinePatternElement = 0x03000002,
5102 GlyphLinePatternElement = 0x03000003,
5104 GlyphElement = 0x05000000,
5105 DotGlyphElement = 0x05000001,
5106 LineGlyphElement = 0x05000002,
5107 EllipseGlyphElement = 0x05000003,
5108 CircularArcGlyphElement = 0x05000004,
5109 InfiniteLineGlyphElement = 0x05000005,
5111 TrimElement = 0x07000000,
5113 Condition = 0x09000000,
5114 NOTCondition = 0x09000001,
5115 ANDCondition = 0x09000002,
5116 ORCondition = 0x09000003,
5117 XORCondition = 0x09000004,
5119 MouseState = 0x01001001,
5120 TouchState = 0x01001002,
5121 KeyboardState = 0x01001003,
5122 FontInfoState = 0x01001004,
5124 KeyPath = 0x01000F01,
5127 IncludeKey = 0x10000001,
5128 PortfolioKey = 0x10000002,
5129 StyleKey = 0x10000003,
5131 SegmentKey = 0x10200000,
5132 WindowKey = 0x10600000,
5133 StandAloneWindowKey = 0x10600001,
5134 OffScreenWindowKey = 0x10600002,
5135 ApplicationWindowKey = 0x10600003,
5137 GeometryKey = 0x10100000,
5138 ReferenceKey = 0x10100001,
5139 CircleKey = 0x10100002,
5140 CircularArcKey = 0x10100003,
5141 CircularWedgeKey = 0x10100004,
5142 CuttingSectionKey = 0x10100005,
5143 CylinderKey = 0x10100006,
5144 EllipseKey = 0x10100007,
5145 EllipticalArcKey = 0x10100008,
5146 InfiniteLineKey = 0x10100009,
5147 LineKey = 0x1010000a,
5148 DistantLightKey = 0x1010000b,
5149 SpotlightKey = 0x1010000c,
5150 MarkerKey = 0x1010000d,
5151 MeshKey = 0x1010000e,
5152 NURBSCurveKey = 0x1010000f,
5153 NURBSSurfaceKey = 0x10100010,
5154 PolygonKey = 0x10100011,
5155 ShellKey = 0x10100012,
5156 SphereKey = 0x10100013,
5157 TextKey = 0x10100014,
5158 GridKey = 0x10100015,
5160 Definition = 0x20000000,
5161 NamedStyleDefinition = 0x20000001,
5162 TextureDefinition = 0x20000002,
5163 LinePatternDefinition = 0x20000003,
5164 GlyphDefinition = 0x20000004,
5165 CubeMapDefinition = 0x20000005,
5166 ImageDefinition = 0x20000006,
5167 MaterialPaletteDefinition = 0x20000007,
5168 ShaderDefinition = 0x20000008,
5170 Control = 0x50000000,
5171 CameraControl = 0x50000001,
5172 SelectabilityControl = 0x50000002,
5173 MarkerAttributeControl = 0x50000003,
5174 SphereAttributeControl = 0x50000004,
5175 LightingAttributeControl = 0x50000005,
5176 CylinderAttributeControl = 0x50000006,
5177 TextAttributeControl = 0x50000007,
5178 LineAttributeControl = 0x50000008,
5179 EdgeAttributeControl = 0x50000009,
5180 CurveAttributeControl = 0x5000000a,
5181 ModellingMatrixControl = 0x5000000b,
5182 TextureMatrixControl = 0x5000000c,
5183 CullingControl = 0x5000000d,
5184 TransparencyControl = 0x5000000e,
5185 MaterialMappingControl = 0x5000000f,
5186 NURBSSurfaceAttributeControl = 0x50000010,
5187 PostProcessEffectsControl = 0x50000011,
5188 BoundingControl = 0x50000012,
5189 VisualEffectsControl = 0x50000013,
5190 SelectionOptionsControl = 0x50000014,
5191 HighlightOptionsControl = 0x50000015,
5192 DefinitionControl = 0x50000016,
5193 SelectionControl = 0x50000017,
5194 HighlightControl = 0x50000018,
5195 StandAloneWindowOptionsControl = 0x50000019,
5196 OffScreenWindowOptionsControl = 0x5000001a,
5197 ApplicationWindowOptionsControl = 0x5000001b,
5198 VisibilityControl = 0x5000001c,
5199 SubwindowControl = 0x5000001d,
5200 PerformanceControl = 0x5000001e,
5201 HiddenLineAttributeControl = 0x5000001f,
5202 DrawingAttributeControl = 0x50000020,
5203 DebuggingControl = 0x50000021,
5204 ContourLineControl = 0x50000022,
5205 StyleControl = 0x50000023,
5206 ConditionControl = 0x50000024,
5207 PortfolioControl = 0x50000025,
5208 WindowInfoControl = 0x50000026,
5209 AttributeLockControl = 0x50000027,
5210 TransformMaskControl = 0x50000028,
5211 ColorInterpolationControl = 0x50000029,
5212 UpdateOptionsControl = 0x50000030,
5213 CuttingSectionAttributeControl = 0x50000031,
5215 LibraryMask = 0x80FF0000,
5217 Sprocket = 0x80000000,
5218 Canvas = 0x80000001,
5219 Layout = 0x80000002,
5222 Operator = 0x80000005,
5223 SprocketPath = 0x80000007,
5225 SprocketControl = 0xD0000000,
5226 OperatorControl = 0xD0000008,
5227 NavigationCubeControl = 0xD0000009,
5228 AxisTriadControl = 0xD000000A,
5230 Metadata = 0x80001000,
5231 IntegerMetadata = 0x80001001,
5232 UnsignedIntegerMetadata = 0x80001002,
5233 DoubleMetadata = 0x80001003,
5234 StringMetadata = 0x80001004,
5235 TimeMetadata = 0x80001005,
5236 BooleanMetadata = 0x80001006,
5238 Component = 0x80000200,
5239 Filter = 0x80000600,
5240 Capture = 0x80000a00,
5241 CADModel = 0x80000300,
5242 ComponentPath = 0x81001000,
5244 ExchangeMask = 0x80020000,
5245 ExchangeComponent = 0x80021200,
5246 ExchangeFilter = 0x80020601,
5247 ExchangeCapture = 0x80020a01,
5248 ExchangeCADModel = 0x80020301,
5249 ExchangeConfiguration = 0x81020001,
5250 ExchangeImportOptionsKit = 0x81020002,
5251 ExchangeExportACISOptionsKit = 0x81020003,
5252 ExchangeExportIGESOptionsKit = 0x81020004,
5253 ExchangeExportJTOptionsKit = 0x81020005,
5254 ExchangeExportParasolidOptionsKit = 0x81020006,
5255 ExchangeExportPRCOptionsKit = 0x81020007,
5256 ExchangeExportSTEPOptionsKit = 0x81020008,
5257 ExchangeExportSTLOptionsKit = 0x81020009,
5258 ExchangeExportU3DOptionsKit = 0x8102000a,
5259 ExchangeExportXMLOptionsKit = 0x8102000b,
5260 ExchangeTessellationOptionsKit = 0x8102000c,
5261 ExchangeSheet = 0x8002120d,
5263 PublishMask = 0x80040000,
5264 PublishDocumentKit = 0x81040001,
5265 PublishPageKit = 0x81040002,
5266 PublishTemplateKit = 0x81040003,
5267 PublishAnnotationKit = 0x81040004,
5268 PublishArtworkKit = 0x81040005,
5269 PublishViewKit = 0x81040006,
5270 PublishTextKit = 0x81040007,
5271 PublishImageKit = 0x81040008,
5272 PublishTableKit = 0x81040009,
5273 PublishExportOptionsKit = 0x8104000a,
5274 PublishLinkKit = 0x8104000b,
5275 PublishButtonKit = 0x8104000c,
5276 PublishTextFieldKit = 0x8104000d,
5277 PublishSlideTableKit = 0x8104000e,
5278 PublishCheckBoxKit = 0x8104000f,
5279 PublishRadioButtonKit = 0x81040010,
5280 PublishListBoxKit = 0x81040011,
5281 PublishDropDownListKit = 0x81040012,
5282 PublishSignatureFieldKit = 0x81040013,
5284 PublishDocumentKey = 0x80040001,
5285 PublishPageControl = 0x80040002,
5287 SceneTree = 0x80008001,
5288 SceneTreeItem = 0x80008002,
5290 ComponentTree = 0x80008003,
5291 ComponentTreeItem = 0x80008004,
5293 SketchupMask = 0x80100000,
5294 SketchupImportOptionsKit = 0x81100001,
5295 SketchupImportResultsKit = 0x81100002,
5297 ParasolidMask = 0x80200000,
5298 ParasolidComponent = 0x80201201,
5299 ParasolidCADModel = 0x80200302,
5300 ParasolidImportOptionsKit = 0x81200003,
5301 ParasolidFacetTessellationKit = 0x81200004,
5302 ParasolidLineTessellationKit = 0x81200005,
5303 ParasolidExportOptionsKit = 0x81200006,
5305 IONotifierData = 0x84000200,
5306 StreamImportNotifierData = 0x84000201,
5307 STLImportNotifierData = 0x84000202,
5308 OBJImportNotifierData = 0x84000203,
5309 ExchangeImportNotifierData = 0x84020204,
5310 SketchupImportNotifierData = 0x84100205,
5311 ParasolidImportNotifierData = 0x84200206,
5312 ExchangeTranslationNotifierData = 0x84020207,
5324 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5331 static void Free(
void * in_pointer);
5340 template <
typename T>
5341 class NO_HPS_API Allocator
5344 typedef T value_type;
5345 typedef value_type * pointer;
5346 typedef value_type
const * const_pointer;
5347 typedef value_type & reference;
5348 typedef value_type
const & const_reference;
5349 typedef size_t size_type;
5350 typedef ptrdiff_t difference_type;
5354 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5357 template <
typename U> Allocator(Allocator<U>
const &) {}
5359 template <
typename U>
5362 typedef Allocator<U> other;
5366 pointer address(reference x)
const {
return &x; }
5367 const_pointer address(const_reference x)
const {
return &x; }
5369 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5370 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5372 #if defined(_MSC_VER) || defined (__APPLE__)
5373 void construct(pointer p, const_reference x) {
new(p) T(x); }
5375 template<
typename U,
typename... Args>
5376 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5378 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5380 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5383 template <
typename T,
typename U>
5384 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5386 template <
typename T,
typename U>
5387 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5393 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5401 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5411 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5490 virtual bool Empty()
const {
return (impl_ == 0);};
5493 virtual void Reset();
5498 bool HasType(Type in_mask)
const;
5502 intptr_t GetClassID()
const;
5507 intptr_t GetInstanceID()
const;
5509 template <
typename T>
5510 static intptr_t ClassID()
5512 static const intptr_t ret = T().GetClassID();
5517 friend class HPSI::Impl;
5518 friend class HPSI::KeyImpl;
5519 friend class HPSI::TicketImpl;
5528 Type ObjectType()
const {
return Type::Control;}
5545 this->Object::operator=(std::move(in_that));
6013 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6018 intptr_t GetClassID()
const;
6022 virtual Event * Clone()
const=0;
6025 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6040 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6041 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6048 friend class HPSI::EventDispatcherImpl;
6098 enum class KeyboardCode
6298 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6305 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6313 return !(*
this == in_that);
6322 typedef std::vector<Point, Allocator<Point> > PointArray;
6323 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6324 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6325 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6326 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6327 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6328 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6329 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6330 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6331 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6332 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6333 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6334 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6335 typedef std::vector<int, Allocator<int> > IntArray;
6336 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6337 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6338 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6339 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6340 typedef std::vector<float, Allocator<float> > FloatArray;
6341 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6342 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6343 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6344 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6345 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6346 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6347 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6348 typedef std::vector<bool, Allocator<bool> > BoolArray;
6349 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6350 typedef std::vector<Key, Allocator<Key> > KeyArray;
6351 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6352 typedef std::vector<char, Allocator<char> > CharArray;
6353 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6354 typedef std::vector<byte, Allocator<byte> > ByteArray;
6355 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6356 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6357 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6358 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6359 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6360 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6361 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6362 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6363 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6364 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6365 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6366 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6367 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6368 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6369 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6370 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6371 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6372 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6373 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6374 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6375 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6376 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6377 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6378 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6379 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6380 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6381 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6382 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6383 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6384 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6385 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6386 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6450 bool IsValid()
const;
6458 Key GetItem()
const;
6462 Key operator*()
const;
6466 SearchTypeArray GetResultTypes()
const;
6491 virtual void Reset();
6510 size_t GetCount()
const;
6549 Type
ObjectType()
const {
return Type::FontSearchResultsIterator;}
6580 bool IsValid()
const;
6619 virtual void Reset();
6639 size_t GetCount()
const;
6663 UTF8(
char const * in_string,
char const * in_locale = 0);
6667 UTF8(
wchar_t const * in_string);
6686 return Assign(std::move(in_utf8));
6693 size_t ToWStr(
wchar_t * out_wide_string)
const;
6698 size_t ToWStr(WCharArray & out_wide_string)
const;
6704 return (_length > 0);
6711 return (_length == 0);
6745 inline operator char const * ()
const
6752 char At(
size_t in_index)
const
6756 else if(in_index >= _length)
6759 return _text[in_index];
6765 UTF8 & Assign(
UTF8 const & in_utf8);
6772 return Assign(in_utf8);
6778 UTF8 & operator+= (
UTF8 const & in_utf8);
6783 UTF8 & operator+= (
char const * in_utf8);
6788 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6793 UTF8 operator+ (
char const * in_utf8)
const;
6798 bool operator== (
UTF8 const & in_utf8)
const;
6803 bool operator!= (
UTF8 const & in_utf8)
const
6805 return !(*
this == in_utf8);
6811 bool operator== (
char const * in_utf8)
const;
6816 bool operator!= (
char const * in_utf8)
const
6818 return !(*
this == in_utf8);
6827 return in_right == in_left;
6836 return in_right != in_left;
6845 return in_right ==
UTF8(in_left);
6854 return in_right !=
UTF8(in_left);
6861 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
6863 return UTF8(in_left) + in_right;
6870 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
6872 return UTF8(in_left) + in_right;
6878 size_t GetHash()
const;
6882 size_t internal_encode(
wchar_t const * in_wide_string);
6883 size_t internal_decode(
wchar_t * out_wide_string)
const;
6887 mutable size_t _hash_key;
6888 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
6889 char _buffer[_buffer_size];
6894 inline size_t operator()(
const UTF8 & in_utf8)
const
6933 bool ShowCondition(
UTF8 & out_condition)
const;
6939 bool ShowOperands(ConditionArray & out_operands)
const;
6949 bool Equals(
Condition const & in_that)
const;
6954 bool operator==(
Condition const & in_that)
const;
6959 bool operator!=(
Condition const & in_that)
const;
7031 HPS_API Condition NOT(Condition
const & in_operand);
7037 HPS_API Condition OR(Condition
const & in_operand1, Condition
const & in_operand2);
7043 HPS_API Condition XOR(Condition
const & in_operand1, Condition
const & in_operand2);
7049 HPS_API Condition AND(Condition
const & in_operand1, Condition
const & in_operand2);
7066 Key(
Key const & in_that);
7079 Key & operator=(
Key && in_that);
7087 bool HasOwner()
const;
7099 void MoveTo(
SegmentKey const & in_new_owner);
7106 Key & operator=(
Key const & in_that);
7109 virtual void Assign(
Key const & in_that);
7112 bool Equals(
Key const & in_that)
const;
7115 bool operator!= (
Key const & in_that)
const;
7118 bool operator== (
Key const & in_that)
const;
7122 size_t GetHash()
const;
7127 inline size_t operator()(
const Key & in_key)
const
7175 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7179 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7237 size_t ShowSubsegments()
const;
7240 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7245 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7250 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7255 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7260 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7265 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7270 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7289 SegmentKey & SetCondition(
char const * in_condition);
7292 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7295 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7301 bool ShowConditions(UTF8Array & out_conditions)
const;
7311 SegmentKey & SetMaterialPalette(
char const * in_name);
7317 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7335 bool ShowPriority(
int & out_priority)
const;
7343 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7349 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7354 SegmentKey & UnsetUserData(intptr_t in_index);
7360 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7365 SegmentKey & UnsetUserData(IntPtrTArray
const & in_indices);
7372 size_t ShowUserDataCount()
const;
7377 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7383 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7390 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7393 LineKey InsertLine(PointArray
const & in_pts);
7469 PolygonKey InsertPolygon(PointArray
const & in_pts);
7479 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7482 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7489 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7492 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7540 NURBSCurveKey InsertNURBSCurve(
size_t in_degree, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_knots,
float in_start_u,
float in_end_u);
7543 NURBSCurveKey InsertNURBSCurve(
size_t in_degree,
size_t in_pcount,
Point const in_points [],
float const in_weights[],
size_t in_knot_count,
float const in_knots[],
float in_start_u,
float in_end_u);
7550 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots);
7553 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[]);
7556 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount, PointArray
const & in_points, FloatArray
const & in_weights, FloatArray
const & in_uknots, FloatArray
const & in_vknots, TrimKitArray
const & in_trims);
7559 NURBSSurfaceKey InsertNURBSSurface(
size_t in_udegree,
size_t in_vdegree,
size_t in_ucount,
size_t in_vcount,
size_t in_point_count,
Point const in_points[],
float const in_weights[],
size_t in_uknot_count,
float const in_uknots[],
size_t in_vknot_count,
float const in_vknots[],
size_t in_trim_count,
TrimKit const in_trims[]);
7570 TextKey InsertText(
Point const & in_position,
char const * in_text);
7589 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7616 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7634 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
7716 bool ShowCamera(
CameraKit & out_kit)
const;
7765 bool ShowCulling(
CullingKit & out_kit)
const;
7794 SegmentKey & UnsetCuttingSectionAttributes();
7941 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8061 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8369 bool ShowSnapshot(
ImageKit & out_kit)
const;
8380 SegmentKey & UnsetCuttingSectionAttributes();
8403 void MoveTo(
SegmentKey const & in_new_owner);
8422 KeyPath(KeyArray
const & in_path);
8427 KeyPath(
size_t in_path_count,
Key const in_path []);
8460 KeyPath & operator+=(KeyArray
const & in_key_array);
8475 KeyPath & Append(KeyArray
const & in_key_array);
8485 KeyPath & operator=(KeyArray
const & in_path);
8489 void Set(
KeyPath const & in_that);
8494 bool Equals(
KeyPath const & in_that)
const;
8499 bool operator!= (
KeyPath const & in_that)
const;
8504 bool operator== (
KeyPath const & in_that)
const;
8510 KeyPath & SetKeys(KeyArray
const & in_keys);
8516 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
8526 bool ShowKeys(KeyArray & out_keys)
const;
8550 bool ComputeTextExtent(
const char* in_text,
float & out_xfrac,
float & out_yfrac)
const;
8567 bool ShowNetBounding(
BoundingKit & out_kit)
const;
8571 bool ShowNetCamera(
CameraKit & out_kit)
const;
8635 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
8639 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
8643 bool ShowNetCulling(
CullingKit & out_kit)
const;
8675 bool ShowNetConditions(UTF8Array & out_conditions)
const;
8691 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
8700 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
8709 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
8718 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
8727 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
8736 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
8745 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
8754 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
8763 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
8830 bool operator==(
BoundingKit const & in_kit)
const;
8835 bool operator!=(
BoundingKit const & in_kit)
const;
8876 bool ShowExclusion(
bool & out_exclusion)
const;
8955 bool ShowExclusion(
bool & out_exclusion)
const;
9287 bool ShowCuttingSections(
bool & out_state)
const;
9292 bool ShowCutEdges(
bool & out_state)
const;
9297 bool ShowCutFaces(
bool & out_state)
const;
9302 bool ShowWindows(
bool & out_state)
const;
9307 bool ShowText(
bool & out_state)
const;
9312 bool ShowLines(
bool & out_state)
const;
9317 bool ShowEdgeLights(
bool & out_state)
const;
9322 bool ShowMarkerLights(
bool & out_state)
const;
9327 bool ShowFaceLights(
bool & out_state)
const;
9332 bool ShowGenericEdges(
bool & out_state)
const;
9337 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9342 bool ShowAdjacentEdges(
bool & out_state)
const;
9347 bool ShowHardEdges(
bool & out_state)
const;
9352 bool ShowMeshQuadEdges(
bool & out_state)
const;
9357 bool ShowNonCulledEdges(
bool & out_state)
const;
9362 bool ShowPerimeterEdges(
bool & out_state)
const;
9367 bool ShowFaces(
bool & out_state)
const;
9372 bool ShowVertices(
bool & out_state)
const;
9377 bool ShowMarkers(
bool & out_state)
const;
9382 bool ShowShadowCasting(
bool & out_state)
const;
9387 bool ShowShadowReceiving(
bool & out_state)
const;
9392 bool ShowShadowEmitting(
bool & out_state)
const;
9689 bool ShowCuttingSections(
bool & out_state)
const;
9694 bool ShowCutEdges(
bool & out_state)
const;
9699 bool ShowCutFaces(
bool & out_state)
const;
9704 bool ShowWindows(
bool & out_state)
const;
9709 bool ShowText(
bool & out_state)
const;
9714 bool ShowLines(
bool & out_state)
const;
9719 bool ShowEdgeLights(
bool & out_state)
const;
9724 bool ShowMarkerLights(
bool & out_state)
const;
9729 bool ShowFaceLights(
bool & out_state)
const;
9734 bool ShowGenericEdges(
bool & out_state)
const;
9739 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9744 bool ShowAdjacentEdges(
bool & out_state)
const;
9749 bool ShowHardEdges(
bool & out_state)
const;
9754 bool ShowMeshQuadEdges(
bool & out_state)
const;
9759 bool ShowNonCulledEdges(
bool & out_state)
const;
9764 bool ShowPerimeterEdges(
bool & out_state)
const;
9769 bool ShowFaces(
bool & out_state)
const;
9774 bool ShowVertices(
bool & out_state)
const;
9779 bool ShowMarkers(
bool & out_state)
const;
9784 bool ShowShadowCasting(
bool & out_state)
const;
9789 bool ShowShadowReceiving(
bool & out_state)
const;
9794 bool ShowShadowEmitting(
bool & out_state)
const;
9856 bool Equals(
CameraKit const & in_kit)
const;
9861 bool operator==(
CameraKit const & in_kit)
const;
9866 bool operator!=(
CameraKit const & in_kit)
const;
9896 CameraKit & SetField(
float in_width,
float in_height);
9907 CameraKit & SetNearLimit(
float const in_limit);
9941 bool ShowUpVector(
Vector & out_up)
const;
9946 bool ShowPosition(
Point & out_position)
const;
9951 bool ShowTarget(
Point & out_target)
const;
9963 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
9968 bool ShowWidth(
float & out_width)
const;
9973 bool ShowHeight(
float & out_height)
const;
9979 bool ShowField(
float & out_width,
float & out_height)
const;
9984 bool ShowNearLimit(
float & out_near_limit)
const;
9992 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10000 CameraKit & Orbit(
float in_theta,
float in_phi);
10008 CameraKit & Pan(
float in_theta,
float in_phi);
10110 bool ShowUpVector(
Vector & out_up)
const;
10115 bool ShowPosition(
Point & out_position)
const;
10120 bool ShowTarget(
Point & out_target)
const;
10132 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10137 bool ShowWidth(
float & out_width)
const;
10142 bool ShowHeight(
float & out_height)
const;
10148 bool ShowField(
float & out_width,
float & out_height)
const;
10153 bool ShowNearLimit(
float & out_width)
const;
10161 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10247 bool Empty()
const;
10617 bool Empty()
const;
10703 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
10714 bool ShowDepthWriting(
bool & out_state)
const;
10818 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
10829 bool ShowDepthWriting(
bool & out_state)
const;
10874 bool Empty()
const;
10949 bool ShowFaceColor(
bool & out_state)
const;
10954 bool ShowEdgeColor(
bool & out_state)
const;
10959 bool ShowVertexColor(
bool & out_state)
const;
10964 bool ShowFaceIndex(
bool & out_state)
const;
10969 bool ShowEdgeIndex(
bool & out_state)
const;
10974 bool ShowVertexIndex(
bool & out_state)
const;
11070 bool ShowFaceColor(
bool & out_state)
const;
11075 bool ShowEdgeColor(
bool & out_state)
const;
11080 bool ShowVertexColor(
bool & out_state)
const;
11085 bool ShowFaceIndex(
bool & out_state)
const;
11090 bool ShowEdgeIndex(
bool & out_state)
const;
11095 bool ShowVertexIndex(
bool & out_state)
const;
11150 bool Empty()
const;
11155 bool Equals(
CullingKit const & in_kit)
const;
11160 bool operator==(
CullingKit const & in_kit)
const;
11165 bool operator!=(
CullingKit const & in_kit)
const;
11171 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11177 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11183 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11189 CullingKit & SetExtent(
unsigned int in_pixels);
11202 CullingKit & SetVector(
bool in_state,
Vector const & in_vector,
float in_tolerance_degrees);
11210 CullingKit & SetVector(
Vector const & in_vector,
float in_tolerance_degrees);
11230 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11269 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11275 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11280 bool ShowBackFace(
bool & out_state)
const;
11287 bool ShowVector(
bool & out_state,
Vector & out_vector)
const;
11292 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11297 bool ShowFrustum(
bool & out_state)
const;
11337 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11351 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
11371 CullingControl & SetVector(
bool in_state,
Vector const & in_vector,
float in_tolerance_degrees);
11399 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
11438 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11444 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11449 bool ShowBackFace(
bool & out_state)
const;
11456 bool ShowVector(
bool & out_state,
Vector & out_vector)
const;
11461 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11466 bool ShowFrustum(
bool & out_state)
const;
11523 bool Empty()
const;
11569 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
11639 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
11700 bool Empty()
const;
11736 bool ShowTessellation(
size_t & out_facets)
const;
11790 bool ShowTessellation(
size_t & out_facets)
const;
11845 bool Empty()
const;
11994 bool Empty()
const;
12040 bool ShowTessellation(
size_t & out_facets)
const;
12110 bool ShowTessellation(
size_t & out_facets)
const;
12171 bool Empty()
const;
12266 Type
ObjectType()
const {
return Type::CuttingSectionAttributeControl;};
12374 bool Empty()
const;
12648 bool ShowBold(
bool & out_state)
const;
12653 bool ShowItalic(
bool & out_state)
const;
12658 bool ShowOverline(
bool & out_state)
const;
12663 bool ShowStrikethrough(
bool & out_state)
const;
12668 bool ShowUnderline(
bool & out_state)
const;
12673 bool ShowSlant(
float & out_angle)
const;
12678 bool ShowLineSpacing(
float & out_multiplier)
const;
12684 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
12691 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
12717 bool ShowFont(
UTF8 & out_name)
const;
12740 bool ShowPath(
Vector & out_path)
const;
12745 bool ShowSpacing(
float & out_multiplier)
const;
13038 bool ShowBold(
bool & out_state)
const;
13043 bool ShowItalic(
bool & out_state)
const;
13048 bool ShowOverline(
bool & out_state)
const;
13053 bool ShowStrikethrough(
bool & out_state)
const;
13058 bool ShowUnderline(
bool & out_state)
const;
13063 bool ShowSlant(
float & out_angle)
const;
13068 bool ShowLineSpacing(
float & out_multiplier)
const;
13074 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13081 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13107 bool ShowFont(
UTF8 & out_name)
const;
13130 bool ShowPath(
Vector & out_path)
const;
13135 bool ShowSpacing(
float & out_multiplier)
const;
13193 bool Empty()
const;
13252 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13330 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13386 bool Empty()
const;
13432 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13438 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13502 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13508 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13563 bool Empty()
const;
13658 bool ShowBudget(
size_t & out_budget)
const;
13664 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
13669 bool ShowViewDependent(
bool & out_state)
const;
13675 bool ShowMaximumDeviation(
float & out_deviation)
const;
13681 bool ShowMaximumAngle(
float & out_degrees)
const;
13687 bool ShowMaximumLength(
float & out_length)
const;
13801 bool ShowBudget(
size_t & out_budget)
const;
13807 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
13812 bool ShowViewDependent(
bool & out_state)
const;
13818 bool ShowMaximumDeviation(
float & out_deviation)
const;
13824 bool ShowMaximumAngle(
float & out_degrees)
const;
13830 bool ShowMaximumLength(
float & out_length)
const;
13865 MatrixKit(FloatArray
const & in_matrix_source);
13870 MatrixKit(
float const in_matrix_source []);
13900 bool Empty()
const;
13905 bool Equals(
MatrixKit const & in_kit)
const;
13910 bool operator==(
MatrixKit const & in_kit)
const;
13915 bool operator!=(
MatrixKit const & in_kit)
const;
13922 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
13928 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
13933 MatrixKit & SetElements(FloatArray
const & in_matrix);
13939 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
13952 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
13958 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
13963 bool ShowElements(FloatArray & out_matrix)
const;
13968 bool ShowDeterminant(
float & out_determinant)
const;
13973 bool ShowInverse(
MatrixKit & out_matrix)
const;
13979 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
13987 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14000 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14007 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14041 MatrixKit Multiply(
float in_scalar)
const;
14046 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14061 MatrixKit operator*(
float in_scalar)
const;
14066 MatrixKit const & operator*=(
float in_scalar);
14072 Point Transform(
Point const & in_source)
const;
14077 PointArray Transform(PointArray
const & in_source)
const;
14083 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14093 VectorArray Transform(VectorArray
const & in_source)
const;
14099 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14104 Plane Transform(
Plane const & in_source)
const;
14109 PlaneArray Transform(PlaneArray
const & in_source)
const;
14115 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14187 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14193 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14198 bool ShowElements(FloatArray & out_matrix)
const;
14203 bool ShowDeterminant(
float & out_determinant)
const;
14208 bool ShowInverse(
MatrixKit & out_matrix)
const;
14214 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14332 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14338 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14343 bool ShowElements(FloatArray & out_matrix)
const;
14348 bool ShowDeterminant(
float & out_determinant)
const;
14353 bool ShowInverse(
MatrixKit & out_matrix)
const;
14359 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14460 bool Empty()
const;
15064 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15071 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15290 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15916 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15924 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16142 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16179 size_t GetCount()
const;
16232 bool Show(PortfolioKeyArray & out_portfolios)
const;
16270 size_t GetCount()
const;
16274 StyleKey PushNamed(
char const * in_style_name);
16277 StyleKey PushNamed(
char const * in_style_name,
Condition const & in_condition);
16313 void Flush(
SegmentKey const & in_style_source);
16326 void Flush(
char const * in_style_name);
16334 void Flush(
char const * in_style_name,
Condition const & in_condition);
16339 StyleKey SetNamed(
char const * in_style_name);
16362 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionArray
const & in_conditions);
16368 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
16384 void UnsetAllSegment();
16387 void UnsetAllNamed();
16390 void UnsetEverything();
16404 bool ShowTop(
StyleKey & out_style)
const;
16412 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions)
const;
16417 bool Show(StyleKeyArray & out_styles)
const;
16423 bool ShowAllSegment(SegmentKeyArray & out_segments, ConditionArray & out_conditions)
const;
16428 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
16434 bool ShowAllNamed(UTF8Array & out_names, ConditionArray & out_conditions)
const;
16439 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
16478 size_t GetCount()
const;
16516 bool ShowCondition(
char const * in_condition)
const;
16521 bool ShowConditions(UTF8Array & out_conditions)
const;
16572 bool Empty()
const;
16582 bool operator==(
MaterialKit const & in_kit)
const;
16587 bool operator!=(
MaterialKit const & in_kit)
const;
16624 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
16633 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
16639 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
16646 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
16654 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
16663 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
16669 MaterialKit & SetShader(
char const * in_shader_name);
16681 MaterialKit & SetSpecular(
char const * in_texture_name);
16687 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16699 MaterialKit & SetMirror(
char const * in_texture_name);
16712 MaterialKit & SetTransmission(
char const * in_texture_name);
16718 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16730 MaterialKit & SetEmission(
char const * in_texture_name);
16736 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16743 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
16749 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
16754 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
16760 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
16770 MaterialKit & SetBump(
char const * in_texture_name);
16801 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
16842 bool ShowDiffuse()
const;
16847 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
16852 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
16857 bool ShowDiffuseAlpha(
float & out_alpha)
const;
16882 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
16887 bool ShowShader(
UTF8 & out_shader_name)
const;
16947 bool ShowBump(
UTF8 & out_texture_name)
const;
16953 bool ShowGloss(
float & out_gloss)
const;
17004 bool Empty()
const;
17086 bool ShowBudget(
size_t & out_budget)
const;
17091 bool ShowMaximumDeviation(
float & out_deviation)
const;
17096 bool ShowMaximumAngle(
float & out_degrees)
const;
17101 bool ShowMaximumWidth(
float & out_width)
const;
17106 bool ShowTrimBudget(
size_t & out_budget)
const;
17111 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17142 Type
ObjectType()
const {
return Type::NURBSSurfaceAttributeControl;};
17212 bool ShowBudget(
size_t & out_budget)
const;
17217 bool ShowMaximumDeviation(
float & out_deviation)
const;
17222 bool ShowMaximumAngle(
float & out_degrees)
const;
17227 bool ShowMaximumWidth(
float & out_width)
const;
17232 bool ShowTrimBudget(
size_t & out_budget)
const;
17237 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17293 bool Empty()
const;
17470 bool Empty()
const;
17610 bool ShowColor(
RGBAColor & out_color)
const;
17615 bool ShowDimFactor(
float & out_zero_to_one)
const;
17620 bool ShowFaceDisplacement(
float & out_buckets)
const;
17625 bool ShowLinePattern(
UTF8 & out_pattern)
const;
17630 bool ShowRenderFaces(
bool & out_state)
const;
17635 bool ShowRenderText(
bool & out_state)
const;
17645 bool ShowSilhouetteCleanup(
bool & out_state)
const;
17650 bool ShowVisibility(
bool & out_state)
const;
17656 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
17661 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
17820 bool ShowColor(
RGBAColor & out_color)
const;
17825 bool ShowDimFactor(
float & out_zero_to_one)
const;
17830 bool ShowFaceDisplacement(
float & out_buckets)
const;
17835 bool ShowLinePattern(
UTF8 & out_pattern)
const;
17840 bool ShowRenderFaces(
bool & out_state)
const;
17845 bool ShowRenderText(
bool & out_state)
const;
17855 bool ShowSilhouetteCleanup(
bool & out_state)
const;
17860 bool ShowVisibility(
bool & out_state)
const;
17866 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
17871 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
17927 bool Empty()
const;
18111 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18117 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18123 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18129 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18139 bool ShowDeferral(
int & out_defer_batch)
const;
18351 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
18357 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18363 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18369 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18379 bool ShowDeferral(
int & out_defer_batch)
const;
18441 bool Empty()
const;
18504 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
18513 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
18530 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
18538 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
18587 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
18596 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
18605 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
18695 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
18711 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
18769 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
18778 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
18787 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
18832 bool Empty()
const;
18976 bool ShowCameraRotation(
bool & out_state)
const;
18981 bool ShowCameraScale(
bool & out_state)
const;
18986 bool ShowCameraTranslation(
bool & out_state)
const;
18991 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
18996 bool ShowCameraProjection(
bool & out_state)
const;
19001 bool ShowCameraOffset(
bool & out_state)
const;
19006 bool ShowCameraNearLimit(
bool & out_state)
const;
19011 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19016 bool ShowModellingMatrixScale(
bool & out_state)
const;
19021 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19026 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19192 bool ShowCameraRotation(
bool & out_state)
const;
19197 bool ShowCameraScale(
bool & out_state)
const;
19202 bool ShowCameraTranslation(
bool & out_state)
const;
19207 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19212 bool ShowCameraProjection(
bool & out_state)
const;
19217 bool ShowCameraOffset(
bool & out_state)
const;
19222 bool ShowCameraNearLimit(
bool & out_state)
const;
19227 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19232 bool ShowModellingMatrixScale(
bool & out_state)
const;
19237 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19242 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19298 bool Empty()
const;
19334 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19344 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19352 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19359 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19386 VisualEffectsKit & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
19397 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19457 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19462 bool ShowAntiAliasing(
bool & out_state)
const;
19471 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19479 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19484 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
19489 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
19494 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
19504 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
19510 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
19515 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
19571 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19581 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19589 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19596 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19623 VisualEffectsControl & SetSimpleReflection(
bool in_state,
float in_opacity = 0.5f,
unsigned int in_blurring = 1,
bool in_fading =
false,
float in_attenuation_near_distance = 0.0f,
float in_attenuation_far_distance =
Float::Infinity);
19634 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19695 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19700 bool ShowAntiAliasing(
bool & out_state)
const;
19709 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19717 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19722 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
19727 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
19732 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
19742 bool ShowSimpleReflection(
bool & out_state,
float & out_opacity,
unsigned int & out_blurring,
bool & out_fading,
float & out_attenuation_near_distance,
float & out_attenuation_far_distance)
const;
19747 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
19752 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
19808 bool Empty()
const;
19835 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
19846 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
19884 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
19937 bool ShowVisibility(
bool & out_state)
const;
19944 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
19949 bool ShowColors(RGBColorArray & out_colors)
const;
19954 bool ShowPatterns(UTF8Array & out_patterns)
const;
19960 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
19965 bool ShowLighting(
bool & out_state)
const;
20058 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20111 bool ShowVisibility(
bool & out_state)
const;
20118 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20123 bool ShowColors(RGBColorArray & out_colors)
const;
20128 bool ShowPatterns(UTF8Array & out_patterns)
const;
20134 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20139 bool ShowLighting(
bool & out_state)
const;
20194 bool Empty()
const;
20453 bool Empty()
const;
20489 bool ShowResourceMonitor(
bool & out_display)
const;
20533 bool ShowResourceMonitor(
bool & out_display)
const;
20582 bool Empty()
const;
20604 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
20610 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
20616 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
20622 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
20650 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20656 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
20662 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20668 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
20675 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
20680 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
20685 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
20724 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20730 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
20736 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
20742 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
20749 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
20754 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
20759 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
20811 bool Empty()
const;
20830 UTF8 GetName()
const;
20834 bool GetShellConvertibility()
const;
20887 bool Empty()
const;
20915 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
20929 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
20946 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
20963 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
20975 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21023 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21037 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21071 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21083 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21132 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
21137 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
21156 bool ShowPriority(
int & out_priority)
const;
21164 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21170 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21176 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21187 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21192 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
21199 size_t ShowUserDataCount()
const;
21204 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21210 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21216 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21252 void Consume(
LineKit & in_kit);
21256 void Set(
LineKit const & in_kit);
21260 void Show(
LineKit & out_kit)
const;
21269 bool Empty()
const;
21274 bool Equals(
LineKit const & in_kit)
const;
21279 bool operator==(
LineKit const & in_kit)
const;
21284 bool operator!=(
LineKit const & in_kit)
const;
21288 size_t GetPointCount()
const;
21296 LineKit & SetPriority(
int in_priority);
21305 bool ShowPriority(
int & out_priority)
const;
21311 LineKit & SetPoints(PointArray
const & in_points);
21317 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
21332 bool ShowPoints(PointArray & out_points)
const;
21340 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21346 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21352 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21359 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21366 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21373 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21379 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21385 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21390 LineKit & UnsetUserData(intptr_t in_index);
21396 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21401 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
21405 LineKit & UnsetAllUserData();
21408 size_t ShowUserDataCount()
const;
21413 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21419 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21425 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21466 void Consume(
LineKit & in_kit);
21470 void Set(
LineKit const & in_kit);
21474 void Show(
LineKit & out_kit)
const;
21478 size_t GetPointCount()
const;
21483 LineKey & SetPoints(PointArray
const & in_points);
21489 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
21495 bool ShowPoints(PointArray & out_points)
const;
21503 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21509 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21515 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21522 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21529 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21578 bool Empty()
const;
21583 bool Equals(
MarkerKit const & in_kit)
const;
21588 bool operator==(
MarkerKit const & in_kit)
const;
21593 bool operator!=(
MarkerKit const & in_kit)
const;
21602 MarkerKit & SetPriority(
int in_priority);
21611 bool ShowPriority(
int & out_priority)
const;
21631 bool ShowPoint(
Point & out_point)
const;
21638 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21644 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21650 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21655 MarkerKit & UnsetUserData(intptr_t in_index);
21661 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21666 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
21673 size_t ShowUserDataCount()
const;
21678 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21684 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21690 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21750 bool ShowPoint(
Point & out_point)
const;
21799 bool Empty()
const;
21874 bool ShowPriority(
int & out_priority)
const;
21879 bool ShowDirection(
Vector & out_vector)
const;
21891 bool ShowCameraRelative(
bool & out_state)
const;
21898 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21904 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21910 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21921 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21933 size_t ShowUserDataCount()
const;
21938 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21944 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21950 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22034 bool ShowDirection(
Vector & out_vector)
const;
22046 bool ShowCameraRelative(
bool & out_state)
const;
22096 bool Empty()
const;
22106 bool operator==(
CylinderKit const & in_kit)
const;
22111 bool operator!=(
CylinderKit const & in_kit)
const;
22115 size_t GetPointCount()
const;
22132 bool ShowPriority(
int & out_priority)
const;
22138 CylinderKit & SetPoints(PointArray
const & in_points);
22149 CylinderKit & SetRadii(FloatArray
const & in_radii);
22155 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
22183 bool ShowPoints(PointArray & out_points)
const;
22188 bool ShowRadii(FloatArray & out_radii)
const;
22314 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22319 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
22352 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22366 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22373 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22379 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22385 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22396 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22401 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
22408 size_t ShowUserDataCount()
const;
22413 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22419 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22425 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22479 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22485 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22491 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22498 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22505 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22513 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
22519 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
22525 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
22532 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
22539 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
22548 size_t GetPointCount()
const;
22553 bool ShowPoints(PointArray & out_points)
const;
22558 bool ShowRadii(FloatArray & out_radii)
const;
22624 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22650 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22664 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22714 bool Empty()
const;
22719 bool Equals(
SphereKit const & in_kit)
const;
22724 bool operator==(
SphereKit const & in_kit)
const;
22729 bool operator!=(
SphereKit const & in_kit)
const;
22737 SphereKit & SetPriority(
int in_priority);
22746 bool ShowPriority(
int & out_priority)
const;
22756 SphereKit & SetRadius(
float in_radius);
22785 bool ShowCenter(
Point & out_center)
const;
22790 bool ShowRadius(
float & out_radius)
const;
22796 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
22803 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22809 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22815 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22820 SphereKit & UnsetUserData(intptr_t in_index);
22826 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22831 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
22838 size_t ShowUserDataCount()
const;
22843 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22849 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22855 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22914 SphereKey & SetRadius(
float in_radius);
22926 bool ShowCenter(
Point & out_center)
const;
22931 bool ShowRadius(
float & out_radius)
const;
22937 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
22987 bool Empty()
const;
22992 bool Equals(
CircleKit const & in_kit)
const;
22997 bool operator==(
CircleKit const & in_kit)
const;
23002 bool operator!=(
CircleKit const & in_kit)
const;
23010 CircleKit & SetPriority(
int const in_priority);
23019 bool ShowPriority(
int & out_priority)
const;
23031 CircleKit & SetRadius(
float in_radius);
23059 bool ShowCenter(
Point & out_center)
const;
23064 bool ShowRadius(
float & out_radius)
const;
23069 bool ShowNormal(
Vector & out_normal)
const;
23076 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23082 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23088 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23093 CircleKit & UnsetUserData(intptr_t in_index);
23099 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23104 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
23111 size_t ShowUserDataCount()
const;
23116 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23122 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23128 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23190 CircleKey & SetRadius(
float in_radius);
23201 bool ShowCenter(
Point & out_center)
const;
23206 bool ShowRadius(
float & out_radius)
const;
23211 bool ShowNormal(
Vector & out_normal)
const;
23261 bool Empty()
const;
23293 bool ShowPriority(
int & out_priority)
const;
23332 bool ShowStart(
Point & out_start)
const;
23337 bool ShowMiddle(
Point & out_middle)
const;
23342 bool ShowEnd(
Point & out_end)
const;
23349 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23355 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23361 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23372 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23377 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
23384 size_t ShowUserDataCount()
const;
23389 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23395 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23401 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23473 bool ShowStart(
Point & out_start)
const;
23478 bool ShowMiddle(
Point & out_middle)
const;
23483 bool ShowEnd(
Point & out_end)
const;
23532 bool Empty()
const;
23565 bool ShowPriority(
int & out_priority)
const;
23604 bool ShowStart(
Point & out_start)
const;
23609 bool ShowMiddle(
Point & out_middle)
const;
23614 bool ShowEnd(
Point & out_end)
const;
23621 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23627 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23633 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23644 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23656 size_t ShowUserDataCount()
const;
23661 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23667 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23673 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23747 bool ShowStart(
Point & out_start)
const;
23752 bool ShowMiddle(
Point & out_middle)
const;
23757 bool ShowEnd(
Point & out_end)
const;
23806 bool Empty()
const;
23838 bool ShowPriority(
int & out_priority)
const;
23880 size_t GetPlaneCount()
const;
23885 bool ShowPlanes(PlaneArray & out_planes)
const;
23908 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
23924 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
23933 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
23940 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23952 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23963 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23975 size_t ShowUserDataCount()
const;
23980 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23986 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23992 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24071 size_t GetPlaneCount()
const;
24076 bool ShowPlanes(PlaneArray & out_planes)
const;
24099 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24115 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24124 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24173 bool Empty()
const;
24205 bool ShowPriority(
int & out_priority)
const;
24244 bool ShowFirst(
Point & out_first)
const;
24249 bool ShowSecond(
Point & out_second)
const;
24261 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24267 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24273 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24284 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24296 size_t ShowUserDataCount()
const;
24301 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24307 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24313 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24384 bool ShowFirst(
Point & out_first)
const;
24389 bool ShowSecond(
Point & out_second)
const;
24450 bool Empty()
const;
24519 SpotlightKit & SetConcentration(
float in_concentration);
24569 bool ShowPriority(
int & out_priority)
const;
24574 bool ShowPosition(
Point & out_position)
const;
24579 bool ShowTarget(
Point & out_target)
const;
24603 bool ShowConcentration(
float & out_concentration)
const;
24608 bool ShowCameraRelative(
bool & out_state)
const;
24615 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24621 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24627 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24638 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24643 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
24650 size_t ShowUserDataCount()
const;
24655 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24661 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24667 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24762 SpotlightKey & SetConcentration(
float in_concentration);
24780 bool ShowPosition(
Point & out_position)
const;
24785 bool ShowTarget(
Point & out_target)
const;
24809 bool ShowConcentration(
float & out_concentration)
const;
24814 bool ShowCameraRelative(
bool & out_state)
const;
24863 bool Empty()
const;
24882 size_t GetPointCount()
const;
24899 bool ShowPriority(
int & out_priority)
const;
24926 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
24937 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
24943 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
24974 bool ShowDegree(
size_t & out_degree)
const;
24979 bool ShowPoints(PointArray & out_points)
const;
24984 bool ShowWeights(FloatArray & out_weights)
const;
24989 bool ShowKnots(FloatArray & out_knots)
const;
24995 bool ShowParameters(
float & out_start,
float & out_end)
const;
25004 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25011 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25019 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25027 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25035 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25045 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25053 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25062 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25070 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25078 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25086 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25092 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25099 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
25107 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25115 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25122 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25128 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25134 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25145 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25150 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
25157 size_t ShowUserDataCount()
const;
25162 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25168 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25174 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25227 size_t GetPointCount()
const;
25233 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
25238 bool ShowDegree(
size_t & out_degree)
const;
25243 bool ShowPoints(PointArray & out_points)
const;
25248 bool ShowWeights(FloatArray & out_weights)
const;
25253 bool ShowKnots(FloatArray & out_knots)
const;
25259 bool ShowParameters(
float & out_start,
float & out_end)
const;
25269 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25277 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25288 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25297 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25307 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25315 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25364 bool Empty()
const;
25383 size_t GetPointCount()
const;
25400 bool ShowPriority(
int & out_priority)
const;
25444 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
25457 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
25470 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
25528 bool ShowUDegree(
size_t & out_degree)
const;
25533 bool ShowVDegree(
size_t & out_degree)
const;
25538 bool ShowUCount(
size_t & out_count)
const;
25543 bool ShowVCount(
size_t & out_count)
const;
25548 bool ShowPoints(PointArray & out_points)
const;
25553 bool ShowWeights(FloatArray & out_weights)
const;
25558 bool ShowUKnots(FloatArray & out_knots)
const;
25563 bool ShowVKnots(FloatArray & out_knots)
const;
25568 bool ShowTrims(TrimKitArray & out_trims)
const;
25577 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25584 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25592 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25600 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25608 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25618 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25626 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25635 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25643 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25651 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25660 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25667 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25675 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
25683 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25691 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25700 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25707 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25715 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
25723 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25731 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25738 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25744 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25750 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25761 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25773 size_t ShowUserDataCount()
const;
25778 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25784 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25790 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25843 size_t GetPointCount()
const;
25865 bool ShowUDegree(
size_t & out_degree)
const;
25870 bool ShowVDegree(
size_t & out_degree)
const;
25875 bool ShowUCount(
size_t & out_count)
const;
25880 bool ShowVCount(
size_t & out_count)
const;
25885 bool ShowPoints(PointArray & out_points)
const;
25890 bool ShowWeights(FloatArray & out_weights)
const;
25895 bool ShowUKnots(FloatArray & out_knots)
const;
25900 bool ShowVKnots(FloatArray & out_knots)
const;
25905 bool ShowTrims(TrimKitArray & out_trims)
const;
25915 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25923 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25934 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25943 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25953 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25961 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25971 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25979 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26036 bool operator==(
TrimElement const & in_that)
const;
26041 bool operator!=(
TrimElement const & in_that)
const;
26047 void SetCurve(
LineKit const & in_line);
26091 void Set(
TrimKit const & in_kit);
26095 void Show(
TrimKit & out_kit)
const;
26104 bool Empty()
const;
26109 bool Equals(
TrimKit const & in_kit)
const;
26114 bool operator==(
TrimKit const & in_kit)
const;
26119 bool operator!=(
TrimKit const & in_kit)
const;
26131 TrimKit & SetShape(TrimElementArray
const & in_shape);
26155 bool ShowShape(TrimElementArray & out_shape)
const;
26209 bool Empty()
const;
26214 bool Equals(
EllipseKit const & in_kit)
const;
26219 bool operator==(
EllipseKit const & in_kit)
const;
26224 bool operator!=(
EllipseKit const & in_kit)
const;
26241 bool ShowPriority(
int & out_priority)
const;
26280 bool ShowCenter(
Point & out_center)
const;
26285 bool ShowMajor(
Point & out_major)
const;
26290 bool ShowMinor(
Point & out_minor)
const;
26297 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26303 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26309 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26314 EllipseKit & UnsetUserData(intptr_t in_index);
26320 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26325 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
26332 size_t ShowUserDataCount()
const;
26337 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26343 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26349 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26421 bool ShowCenter(
Point & out_center)
const;
26426 bool ShowMajor(
Point & out_major)
const;
26431 bool ShowMinor(
Point & out_minor)
const;
26480 bool Empty()
const;
26512 bool ShowPriority(
int & out_priority)
const;
26577 bool ShowCenter(
Point & out_center)
const;
26582 bool ShowMajor(
Point & out_major)
const;
26587 bool ShowMinor(
Point & out_minor)
const;
26592 bool ShowStart(
float & out_start)
const;
26597 bool ShowEnd(
float & out_end)
const;
26604 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26610 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26616 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26627 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26639 size_t ShowUserDataCount()
const;
26644 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26650 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26656 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26746 bool ShowCenter(
Point & out_center)
const;
26751 bool ShowMajor(
Point & out_major)
const;
26756 bool ShowMinor(
Point & out_minor)
const;
26761 bool ShowStart(
float & out_start)
const;
26766 bool ShowEnd(
float & out_end)
const;
26798 void Consume(
TextKit & in_kit);
26802 void Set(
TextKit const & in_kit);
26806 void Show(
TextKit & out_kit)
const;
26815 bool Empty()
const;
26820 bool Equals(
TextKit const & in_kit)
const;
26825 bool operator==(
TextKit const & in_kit)
const;
26830 bool operator!=(
TextKit const & in_kit)
const;
26838 TextKit & SetPriority(
int in_priority);
26847 bool ShowPriority(
int & out_priority)
const;
26857 TextKit & SetText(
char const * in_string);
26867 TextKit & SetColorByIndex(
float in_index);
26884 TextKit & SetBold(
bool in_state);
26889 TextKit & SetItalic(
bool in_state);
26894 TextKit & SetOverline(
bool in_state);
26899 TextKit & SetStrikethrough(
bool in_state);
26904 TextKit & SetUnderline(
bool in_state);
26910 TextKit & SetSlant(
float in_angle);
26915 TextKit & SetLineSpacing(
float in_multiplier);
26927 TextKit & SetRotation(
float in_angle);
26987 TextKit & SetFont(
char const * in_name);
27022 TextKit & SetSpacing(
float in_multiplier);
27039 TextKit & UnsetModellingMatrix();
27059 TextKit & UnsetStrikethrough();
27071 TextKit & UnsetLineSpacing();
27087 TextKit & UnsetSizeTolerance();
27125 bool ShowPosition(
Point & out_position)
const;
27130 bool ShowText(
UTF8 & out_string)
const;
27142 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27154 bool ShowBold(
bool & out_state)
const;
27159 bool ShowItalic(
bool & out_state)
const;
27164 bool ShowOverline(
bool & out_state)
const;
27169 bool ShowStrikethrough(
bool & out_state)
const;
27174 bool ShowUnderline(
bool & out_state)
const;
27179 bool ShowSlant(
float & out_angle)
const;
27184 bool ShowLineSpacing(
float & out_multiplier)
const;
27190 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27197 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27223 bool ShowFont(
UTF8 & out_name)
const;
27246 bool ShowPath(
Vector & out_path)
const;
27251 bool ShowSpacing(
float & out_multiplier)
const;
27261 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27269 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
27277 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27287 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
27301 TextKit & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27316 TextKit & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27323 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27333 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27339 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27344 TextKit & UnsetUserData(intptr_t in_index);
27350 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27355 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
27359 TextKit & UnsetAllUserData();
27362 size_t ShowUserDataCount()
const;
27367 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27373 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27379 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27420 void Consume(
TextKit & in_kit);
27424 void Set(
TextKit const & in_kit);
27428 void Show(
TextKit & out_kit)
const;
27447 TextKey & SetText(
char const * in_string);
27457 TextKey & SetColorByIndex(
float in_index);
27474 TextKey & SetBold(
bool in_state);
27479 TextKey & SetItalic(
bool in_state);
27484 TextKey & SetOverline(
bool in_state);
27489 TextKey & SetStrikethrough(
bool in_state);
27494 TextKey & SetUnderline(
bool in_state);
27500 TextKey & SetSlant(
float in_angle);
27506 TextKey & SetLineSpacing(
float in_multiplier);
27518 TextKey & SetRotation(
float in_angle);
27578 TextKey & SetFont(
char const * in_name);
27615 TextKey & SetSpacing(
float in_multiplier);
27629 TextKey & SetRegion(PointArray & in_region,
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27644 TextKey & SetRegion(
size_t in_region_count,
Point const in_region [],
Text::RegionAlignment in_region_alignment,
bool in_region_fitting,
bool in_region_adjust_direction,
bool in_region_relative_coordinates,
bool in_region_window_space);
27653 TextKey & UnsetModellingMatrix();
27673 TextKey & UnsetStrikethrough();
27685 TextKey & UnsetLineSpacing();
27701 TextKey & UnsetSizeTolerance();
27743 bool ShowPosition(
Point & out_position)
const;
27748 bool ShowText(
UTF8 & out_string)
const;
27760 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27772 bool ShowBold(
bool & out_state)
const;
27777 bool ShowItalic(
bool & out_state)
const;
27782 bool ShowOverline(
bool & out_state)
const;
27787 bool ShowStrikethrough(
bool & out_state)
const;
27792 bool ShowUnderline(
bool & out_state)
const;
27797 bool ShowSlant(
float & out_angle)
const;
27802 bool ShowLineSpacing(
float & out_multiplier)
const;
27808 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27815 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27841 bool ShowFont(
UTF8 & out_name)
const;
27864 bool ShowPath(
Vector & out_path)
const;
27869 bool ShowSpacing(
float & out_multiplier)
const;
27879 bool ShowRegion(PointArray & out_region,
Text::RegionAlignment & out_region_alignment,
bool & out_region_fitting,
bool & out_region_adjust_direction,
bool & out_region_relative_coordinates,
bool & out_region_window_space)
const;
27889 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27897 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
27905 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27927 Type
ObjectType()
const {
return Type::ShellOptimizationOptionsKit; };
27953 bool Empty()
const;
28024 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
28035 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
28096 bool Empty()
const;
28160 bool ShowTolerance(
float & out_tolerance)
const;
28170 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
28175 bool ShowNearestFaceCalculation(
bool & out_state)
const;
28222 bool Empty()
const;
28243 bool ShowRelations(ShellRelationArray & out_results)
const;
28248 bool ShowNearestFaces(SizeTArray & out_faces)
const;
28253 bool ShowDistances(FloatArray & out_distances)
const;
28288 void Set(
ShellKit const & in_kit);
28292 void Show(
ShellKit & out_kit)
const;
28296 size_t GetPointCount()
const;
28300 size_t GetFaceCount()
const;
28309 bool Empty()
const;
28314 bool Equals(
ShellKit const & in_kit)
const;
28319 bool operator==(
ShellKit const & in_kit)
const;
28324 bool operator!=(
ShellKit const & in_kit)
const;
28332 ShellKit & SetPriority(
int in_priority);
28341 bool ShowPriority(
int & out_priority)
const;
28348 ShellKit & SetPoints(PointArray
const & in_points);
28354 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
28359 ShellKit & SetFacelist(IntArray
const & in_facelist);
28365 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
28382 bool ShowPoints(PointArray & out_points)
const;
28387 bool ShowFacelist(IntArray & out_facelist)
const;
28568 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
28574 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
28581 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
28588 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
28594 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
28601 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
28607 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
28616 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
28624 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
28634 ShellKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
28643 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
28651 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
28657 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
28664 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
28671 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
28677 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
28684 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
28690 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
28695 ShellKit & UnsetMaterialMapping();
28706 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
28711 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
28741 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
28746 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
28751 ShellKit & UnsetVertexParameters();
28757 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
28762 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
28767 ShellKit & UnsetVertexVisibilities();
28773 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
28778 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
28783 ShellKit & UnsetVertexEverything();
28805 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
28806 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
28822 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
28823 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
28834 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
28844 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
28856 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
28867 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
28878 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
28889 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
28900 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
28910 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
28919 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
28925 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
28932 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
28939 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
28945 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
28952 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
28958 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
28966 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
28972 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
28979 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
28986 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
28992 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
28999 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
29005 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
29013 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29019 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29026 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29033 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
29039 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
29046 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
29052 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
29060 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29066 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29073 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29080 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
29086 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
29093 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
29099 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
29110 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
29115 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
29126 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
29131 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
29136 ShellKit & UnsetFaceVisibilities();
29142 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
29147 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
29164 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29176 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29187 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29197 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
29208 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29218 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29227 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29234 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
29241 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
29248 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29255 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
29264 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
29271 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
29278 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
29288 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
29297 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
29326 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
29332 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
29338 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
29343 ShellKit & UnsetUserData(intptr_t in_index);
29349 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
29354 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
29361 size_t ShowUserDataCount()
const;
29366 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
29372 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
29378 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
29425 void Set(
ShellKit const & in_kit);
29429 void Show(
ShellKit & out_kit)
const;
29433 size_t GetPointCount()
const;
29437 size_t GetFaceCount()
const;
29443 ShellKey & SetPoints(PointArray
const & in_points);
29449 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
29454 ShellKey & SetFacelist(IntArray
const & in_facelist);
29460 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
29478 ShellKey & UnsetMaterialMapping();
29487 bool ShowPoints(PointArray & out_points)
const;
29492 bool ShowFacelist(IntArray & out_facelist)
const;
29673 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29680 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29687 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29694 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29700 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29707 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29713 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29723 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29731 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29741 ShellKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29750 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29758 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29765 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29772 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29779 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29785 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29792 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29798 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29809 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29814 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29844 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29849 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29854 ShellKey & UnsetVertexParameters();
29860 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29865 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29870 ShellKey & UnsetVertexVisibilities();
29876 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29881 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29886 ShellKey & UnsetVertexEverything();
29902 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29903 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29919 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29920 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29931 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29941 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29953 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
29964 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29975 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
29986 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29997 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30007 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30015 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
30022 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
30029 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
30036 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
30042 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
30049 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
30055 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
30063 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
30070 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
30077 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
30084 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
30090 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
30097 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
30103 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
30111 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30118 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30125 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30132 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
30138 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
30145 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
30151 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
30159 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30166 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30173 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30180 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
30186 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
30193 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
30199 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
30210 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
30215 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
30226 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
30231 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
30236 ShellKey & UnsetFaceVisibilities();
30242 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
30247 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
30264 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30276 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30287 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30297 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
30305 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
30313 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
30324 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30334 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30343 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30350 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
30357 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
30364 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30371 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
30380 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30387 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
30394 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
30404 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30413 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30467 void Consume(
MeshKit & in_kit);
30471 void Set(
MeshKit const & in_kit);
30475 void Show(
MeshKit & out_kit)
const;
30484 bool Empty()
const;
30489 bool Equals(
MeshKit const & in_kit)
const;
30494 bool operator==(
MeshKit const & in_kit)
const;
30499 bool operator!=(
MeshKit const & in_kit)
const;
30503 size_t GetPointCount()
const;
30511 MeshKit & SetPriority(
int in_priority);
30520 bool ShowPriority(
int & out_priority)
const;
30525 MeshKit & SetPoints(PointArray
const & in_points);
30531 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
30538 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
30546 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
30551 MeshKit & SetRows(
size_t in_rows);
30556 MeshKit & SetColumns(
size_t in_columns);
30577 bool ShowPoints(PointArray & out_points)
const;
30584 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
30589 bool ShowRows(
size_t & out_rows)
const;
30594 bool ShowColumns(
size_t & out_columns)
const;
30774 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30780 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30787 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30794 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30800 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30807 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30813 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30822 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30830 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30840 MeshKit & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30849 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30857 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30863 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30870 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30877 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
30883 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
30890 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
30896 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
30901 MeshKit & UnsetMaterialMapping();
30905 MeshKit & UnsetVertexColors();
30911 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
30916 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
30940 MeshKit & UnsetVertexNormals();
30946 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
30951 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
30956 MeshKit & UnsetVertexParameters();
30962 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
30967 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
30972 MeshKit & UnsetVertexVisibilities();
30978 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
30983 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
30988 MeshKit & UnsetVertexEverything();
31009 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31010 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31026 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31027 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31038 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31048 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
31060 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
31071 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31082 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
31093 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31104 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31114 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31122 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31128 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31135 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
31142 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
31148 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
31155 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
31161 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
31169 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
31175 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
31182 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
31189 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
31195 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
31202 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
31208 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
31216 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31222 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31229 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31236 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
31242 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
31249 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
31255 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
31263 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31269 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31276 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31283 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
31289 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
31296 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
31302 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
31313 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
31318 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
31323 MeshKit & UnsetFaceNormals();
31329 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
31334 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
31339 MeshKit & UnsetFaceVisibilities();
31345 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
31350 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
31355 MeshKit & UnsetFaceEverything();
31367 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31379 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31390 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31400 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31411 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31421 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31428 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
31434 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
31440 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
31445 MeshKit & UnsetUserData(intptr_t in_index);
31451 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
31456 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
31460 MeshKit & UnsetAllUserData();
31463 size_t ShowUserDataCount()
const;
31468 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
31474 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
31480 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
31524 void Consume(
MeshKit & in_kit);
31528 void Set(
MeshKit const & in_kit);
31532 void Show(
MeshKit & out_kit)
const;
31536 size_t GetPointCount()
const;
31543 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
31551 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31556 bool ShowPoints(PointArray & out_points)
const;
31563 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31568 bool ShowRows(
size_t & out_rows)
const;
31573 bool ShowColumns(
size_t & out_columns)
const;
31584 MeshKey & UnsetMaterialMapping();
31765 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31772 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31779 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31786 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
31792 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
31799 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
31805 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
31815 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31823 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
31833 MeshKey & SetVertexParametersByList(
size_t in_vertex_count,
size_t const in_vertices[],
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31842 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
31850 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31857 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31864 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31871 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31877 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31884 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31890 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31895 MeshKey & UnsetVertexColors();
31901 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31906 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31930 MeshKey & UnsetVertexNormals();
31936 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31941 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31946 MeshKey & UnsetVertexParameters();
31952 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31957 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31962 MeshKey & UnsetVertexVisibilities();
31968 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31973 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31978 MeshKey & UnsetVertexEverything();
31998 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31999 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32015 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32016 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32027 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32037 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32049 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32060 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32071 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32082 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32093 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32103 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32111 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32118 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
32125 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
32132 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32138 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32145 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32151 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32159 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32166 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32173 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32180 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32186 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32193 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32199 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32207 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32214 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32221 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32228 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
32234 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32241 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32247 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32255 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32262 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32269 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32276 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32282 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32289 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32295 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32306 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32311 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
32316 MeshKey & UnsetFaceNormals();
32322 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32327 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
32332 MeshKey & UnsetFaceVisibilities();
32338 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32343 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
32348 MeshKey & UnsetFaceEverything();
32360 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32372 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32383 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32393 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32404 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32414 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32424 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count,
size_t in_point_count,
Point const in_points[]);
32433 MeshKey & EditMeshByReplacement(
size_t in_row_offset,
size_t in_column_offset,
size_t in_row_count,
size_t in_column_count, PointArray
const & in_points);
32483 bool Empty()
const;
32488 bool Equals(
PolygonKit const & in_kit)
const;
32493 bool operator==(
PolygonKit const & in_kit)
const;
32498 bool operator!=(
PolygonKit const & in_kit)
const;
32502 size_t GetPointCount()
const;
32519 bool ShowPriority(
int & out_priority)
const;
32525 PolygonKit & SetPoints(PointArray
const & in_points);
32544 bool ShowPoints(PointArray & out_points)
const;
32551 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32557 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
32563 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
32570 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32576 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
32583 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32589 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32595 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32600 PolygonKit & UnsetUserData(intptr_t in_index);
32606 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32611 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
32618 size_t ShowUserDataCount()
const;
32623 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32629 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32635 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32690 size_t GetPointCount()
const;
32695 PolygonKey & SetPoints(PointArray
const & in_points);
32706 bool ShowPoints(PointArray & out_points)
const;
32713 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32719 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
32725 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
32732 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
32738 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
32765 void Consume(
GridKit & in_kit);
32769 void Set(
GridKit const & in_kit);
32773 void Show(
GridKit & out_kit)
const;
32787 bool Empty()
const;
32792 bool Equals(
GridKit const & in_kit)
const;
32797 bool operator==(
GridKit const & in_kit)
const;
32802 bool operator!=(
GridKit const & in_kit)
const;
32811 GridKit & SetPriority(
int in_priority);
32829 GridKit & SetFirstPoint(
Point const & in_first_point);
32838 GridKit & SetSecondPoint(
Point const & in_second_point);
32853 GridKit & SetFirstCount(
int in_first_count);
32865 GridKit & SetSecondCount(
int in_second_count);
32886 GridKit & UnsetSecondPoint();
32894 GridKit & UnsetSecondCount();
32904 bool ShowPriority(
int & out_priority)
const;
32914 bool ShowOrigin(
Point & out_origin)
const;
32919 bool ShowFirstPoint(
Point & out_first_point)
const;
32924 bool ShowSecondPoint(
Point & out_second_point)
const;
32929 bool ShowFirstCount(
int & out_first_count)
const;
32934 bool ShowSecondCount(
int & out_second_count)
const;
32941 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32947 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32953 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32958 GridKit & UnsetUserData(intptr_t in_index);
32964 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32969 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
32973 GridKit & UnsetAllUserData();
32976 size_t ShowUserDataCount()
const;
32981 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32987 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32993 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33034 void Consume(
GridKit & in_kit);
33038 void Set(
GridKit const & in_kit);
33042 void Show(
GridKit & out_kit)
const;
33061 GridKey & SetFirstPoint(
Point const & in_first_point);
33070 GridKey & SetSecondPoint(
Point const & in_second_point);
33085 GridKey & SetFirstCount(
int in_first_count);
33097 GridKey & SetSecondCount(
int in_second_count);
33109 bool ShowOrigin(
Point & out_origin)
const;
33114 bool ShowFirstPoint(
Point & out_first_point)
const;
33119 bool ShowSecondPoint(
Point & out_second_point)
const;
33124 bool ShowFirstCount(
int & out_first_count)
const;
33129 bool ShowSecondCount(
int & out_second_count)
const;
33205 bool ShowPriority(
int & out_priority)
const;
33210 bool ShowCondition(
Condition & out_condition)
const;
33232 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
33254 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
33261 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
33336 bool ShowCondition(
Condition & out_condition)
const;
33359 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
33381 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
33388 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
33439 Key GetTarget()
const;
33444 size_t ShowTargets(
bool masked=
true)
const;
33450 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
33455 size_t ShowGeometryMask()
const;
33461 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
33466 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
33474 void SetModellingMatrix(
MatrixKit const & in_kit);
33488 void UnsetModellingMatrix();
33498 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
33503 bool ShowCondition(
Condition & out_condition)
const;
33542 Type
ObjectType()
const {
return Type::StandAloneWindowOptionsKit; };
33564 bool Empty()
const;
33650 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
33655 bool ShowTitle(
UTF8 & out_window_name)
const;
33660 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
33670 bool ShowFullScreen(
bool & out_state)
const;
33704 Type
ObjectType()
const {
return Type::StandAloneWindowOptionsControl; };
33736 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
33741 bool ShowTitle(
UTF8 & out_window_name)
const;
33746 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
33756 bool ShowFullScreen(
bool & out_state)
const;
33812 bool Empty()
const;
33886 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
33891 bool ShowHardwareResident(
bool & out_state)
const;
33897 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
33925 Type
ObjectType()
const {
return Type::ApplicationWindowOptionsKit; };
33947 bool Empty()
const;
34014 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34019 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34024 bool ShowFramebufferRetention(
bool & out_retain)
const;
34055 Type
ObjectType()
const {
return Type::ApplicationWindowOptionsControl; };
34066 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34076 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
34081 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34086 bool ShowFramebufferRetention(
bool & out_retain)
const;
34265 void SetIndexedColor(byte in_index);
34268 void SetNormalColor();
34272 void SetExplicitColor(
RGBAColor const & in_color);
34330 void SetPoints(GlyphPointArray
const & in_points);
34335 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
34340 bool ShowPoints(GlyphPointArray & out_points)
const;
34385 bool ShowPoint(
GlyphPoint & out_point)
const;
34427 void SetLowerLeft(
GlyphPoint const & in_point);
34431 void SetUpperRight(
GlyphPoint const & in_point);
34441 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
34446 bool ShowUpperRight(
GlyphPoint & out_point)
const;
34489 void SetStartPoint(
GlyphPoint const & in_point);
34493 void SetIntermediatePoint(
GlyphPoint const & in_point);
34497 void SetEndPoint(
GlyphPoint const & in_point);
34508 bool ShowStartPoint(
GlyphPoint & out_point)
const;
34513 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
34518 bool ShowEndPoint(
GlyphPoint & out_point)
const;
34561 void SetFirstPoint(
GlyphPoint const & in_point);
34565 void SetSecondPoint(
GlyphPoint const & in_point);
34579 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
34584 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
34626 void Set(
GlyphKit const & in_kit);
34630 void Show(
GlyphKit & out_kit)
const;
34639 bool Empty()
const;
34644 bool Equals(
GlyphKit const & in_kit)
const;
34649 bool operator==(
GlyphKit const & in_kit)
const;
34654 bool operator!=(
GlyphKit const & in_kit)
const;
34659 GlyphKit & SetRadius(sbyte in_radius);
34670 GlyphKit & SetElements(GlyphElementArray
const & in_def);
34697 bool ShowRadius(sbyte & out_radius)
const;
34702 bool ShowOffset(
GlyphPoint & out_point)
const;
34707 bool ShowElements(GlyphElementArray & out_def)
const;
34756 bool Empty()
const;
34959 void SetColor(
RGBAColor const & in_color);
34964 void SetMaterialByIndex(
float in_material_index);
35051 void SetSource(
char const * in_source);
35064 void SetMirror(
bool in_state);
35068 void SetFixed(
bool in_state);
35072 void SetRotation(
float in_degrees);
35077 bool ShowSource(
UTF8 & out_source)
const;
35093 bool ShowMirror(
bool & out_state)
const;
35098 bool ShowFixed(
bool & out_state)
const;
35103 bool ShowRotation(
float & out_degrees)
const;
35146 bool Empty()
const;
35286 bool ShowBody(LinePatternElementArray & out_elements)
const;
35291 bool ShowAbsoluteLength(
bool & out_state)
const;
35296 bool ShowAbsoluteWeight(
bool & out_state)
const;
35320 bool ShowContinuous(
bool & out_state)
const;
35369 bool Empty()
const;
35389 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
35417 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
35475 virtual void Assign(
Definition const & in_that);
35480 bool Equals(
Definition const & in_that)
const;
35485 bool operator==(
Definition const & in_that)
const;
35490 bool operator!=(
Definition const & in_that)
const;
35659 PortfolioKey & UndefineNamedStyle(
char const * in_name);
35664 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
35674 PortfolioKey & UndefineLinePattern(
char const * in_name);
35792 size_t GetDefinitionCount()
const;
35795 size_t GetTextureDefinitionCount()
const;
35798 size_t GetCubeMapDefinitionCount()
const;
35801 size_t GetImageDefinitionCount()
const;
35804 size_t GetNamedStyleDefinitionCount()
const;
35807 size_t GetMaterialPaletteDefinitionCount()
const;
35810 size_t GetGlyphDefinitionCount()
const;
35813 size_t GetLinePatternDefinitionCount()
const;
35816 size_t GetShaderDefinitionCount()
const;
35822 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
35827 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
35833 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
35838 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
35844 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
35849 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
35860 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
35871 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
35877 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
35882 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
35893 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
35899 bool ShowShaderDefinition(
char const * in_name,
ShaderDefinition & out_found)
const;
35904 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
35908 void MoveTo(
SegmentKey const & in_new_owner);
35954 void Set(
GlyphKit const & in_kit);
35958 void Show(
GlyphKit & out_kit)
const;
36063 bool Empty()
const;
36169 bool ShowDecal(
bool & out_state)
const;
36174 bool ShowDownSampling(
bool & out_state)
const;
36179 bool ShowModulation(
bool & out_state)
const;
36184 bool ShowParameterOffset(
size_t & out_offset)
const;
36209 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
36279 bool Empty()
const;
36300 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
36324 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36372 bool Empty()
const;
36395 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
36438 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36448 bool ShowDownSampling(
bool & out_state)
const;
36453 bool ShowCompressionQuality(
float & out_quality)
const;
36482 static void Export(
char const * in_file_name,
WindowKey const & in_window,
unsigned int in_width,
unsigned int in_height,
Format in_format = Format::Png);
36488 static void Export(
char const * in_file_name,
ImageKit const & in_image_kit);
36534 void Set(
ImageKit const & in_kit);
36538 void Show(
ImageKit & out_kit)
const;
36547 bool Empty()
const;
36552 bool Equals(
ImageKit const & in_kit)
const;
36557 bool operator==(
ImageKit const & in_kit)
const;
36562 bool operator!=(
ImageKit const & in_kit)
const;
36577 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
36582 ImageKit & SetData(ByteArray
const & in_image_data);
36588 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
36598 ImageKit & SetDownSampling(
bool in_state);
36603 ImageKit & SetCompressionQuality(
float in_quality);
36623 ImageKit & UnsetCompressionQuality();
36633 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36638 bool ShowData(ByteArray & out_image_data)
const;
36648 bool ShowDownSampling(
bool & out_state)
const;
36653 bool ShowCompressionQuality(
float & out_quality)
const;
36685 Type
ObjectType()
const {
return Type::OffScreenWindowOptionsControl; };
36707 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
36713 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
36724 bool ShowHardwareResident(
bool & out_state)
const;
36730 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
36825 void Set(
ImageKit const & in_kit);
36829 void Show(
ImageKit & out_kit)
const;
36893 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
36986 void Set(MaterialKitArray
const & in_source);
36991 void Set(
size_t in_count,
MaterialKit const in_source []);
36995 void Show(MaterialKitArray & out_source)
const;
37058 PhysicalReflection,
37119 bool Empty()
const;
37176 bool ShowMultitexture(
bool & out_state)
const;
37186 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37251 bool Empty()
const;
37256 bool Equals(
ShaderKit const & in_kit)
const;
37261 bool operator==(
ShaderKit const & in_kit)
const;
37266 bool operator!=(
ShaderKit const & in_kit)
const;
37271 ShaderKit & SetSource(
char const * in_source);
37279 ShaderKit & SetMultitexture(
bool in_state);
37302 ShaderKit & UnsetParameterizationSource();
37315 bool ShowSource(
UTF8 & out_source)
const;
37322 bool ShowMultitexture(
bool & out_state)
const;
37332 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37410 Type
ObjectType()
const {
return Type::CutGeometryGatheringOptionsKit;};
37432 bool Empty()
const;
37491 bool ShowOffset(
size_t & out_offset)
const;
37544 bool Empty()
const;
37611 bool ShowCriteria(SearchTypeArray & out_types)
const;
37616 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
37661 bool operator==(
TreeContext const & in_that)
const;
37666 bool operator!=(
TreeContext const & in_that)
const;
37715 bool Empty()
const;
37897 bool ShowProximity(
float & out_proximity)
const;
37907 bool ShowInternalLimit(
size_t & out_limit)
const;
37912 bool ShowRelatedLimit(
size_t & out_limit)
const;
37917 bool ShowSorting(
bool & out_sorted)
const;
37932 bool ShowScope(
KeyPath & out_start_path)
const;
37937 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
37942 bool ShowExtentCullingRespected(
bool & out_state)
const;
37947 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
37952 bool ShowFrustumCullingRespected(
bool & out_state)
const;
37957 bool ShowVectorCullingRespected(
bool & out_state)
const;
38087 bool ShowProximity(
float & out_proximity)
const;
38097 bool ShowInternalLimit(
size_t & out_limit)
const;
38102 bool ShowRelatedLimit(
size_t & out_limit)
const;
38107 bool ShowSorting(
bool & out_sorted)
const;
38122 bool ShowExtentCullingRespected(
bool & out_state)
const;
38127 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
38132 bool ShowFrustumCullingRespected(
bool & out_state)
const;
38137 bool ShowVectorCullingRespected(
bool & out_state)
const;
38203 bool ShowSelectedItem(
Key & out_selection)
const;
38208 bool ShowPath(
KeyPath & out_path)
const;
38213 bool ShowFaces(SizeTArray & out_faces)
const;
38218 bool ShowVertices(SizeTArray & out_vertices)
const;
38224 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
38229 bool ShowCharacters(SizeTArray & out_characters)
const;
38234 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
38239 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
38300 bool IsValid()
const;
38368 virtual void Reset();
38376 size_t GetCount()
const;
38482 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
38497 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
38510 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
38525 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
38649 bool Empty()
const;
38717 bool ShowStyleName(
UTF8 & out_style_name)
const;
38722 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
38732 bool ShowNotification(
bool & out_state)
const;
38886 bool Empty()
const;
38934 bool ShowTimeLimit(Time & out_time_limit)
const;
39005 bool ShowTimeLimit(Time & out_time_limit)
const;
39020 World(
char const * in_license);
39031 World & SetMaterialLibraryDirectory(
char const * in_directory);
39037 World & SetFontDirectory(
char const * in_directory);
39044 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
39050 World & SetFontDirectories(UTF8Array
const & in_directories);
39057 World & SetDriverConfigFile(
char const * in_filename);
39064 World & SetExchangeLibraryDirectory(
char const * in_directory);
39071 World & SetPublishResourceDirectory(
char const * in_directory);
39077 World & SetParasolidSchemaDirectory(
char const * in_directory);
39081 World & UnsetMaterialLibraryDirectory();
39085 World & UnsetFontDirectories();
39089 World & UnsetDriverConfigFile();
39093 World & UnsetExchangeLibraryDirectory();
39097 World & UnsetPublishResourceDirectory();
39101 World & UnsetParasolidSchemaDirectory();
39106 bool ShowLicense(
UTF8 & out_license)
const;
39111 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
39116 bool ShowFontDirectories(UTF8Array & out_directories)
const;
39121 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
39126 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
39131 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
39136 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
39144 virtual void Reset() {}
39173 intptr_t GetClassID()
const;
39182 virtual void Handle(
const char * message,
Emergency::Code code)
const = 0;
39184 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
39185 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
39198 static void Execute(
bool in_once=
true);
39202 static Time GetTime();
39205 static void Sleep(Time milliseconds);
39231 static void RelinquishMemory();
39259 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
39268 static void Reset();
39271 static void Synchronize();
39275 static WindowKeyArray GetWindowKeys();
39279 static SegmentKeyArray GetRootSegments();
39283 static PortfolioKeyArray GetPortfolios();
39289 static PortfolioKey const GetMaterialLibraryPortfolio();
39364 static size_t SelectByShell(
ShellKit const & in_shell,
39373 static size_t SelectByShell(
ShellKey const & in_shell,
39383 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
39393 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
39405 static bool GetInformationEventFilter(
Info::Code in_code);
39410 static bool GetWarningEventFilter(
Info::Code in_code);
39415 static bool GetErrorEventFilter(
Info::Code in_code);
39421 static bool SetInformationEventFilter(
Info::Code in_code,
bool in_filtered);
39427 static bool SetWarningEventFilter(
Info::Code in_code,
bool in_filtered);
39433 static bool SetErrorEventFilter(
Info::Code in_code,
bool in_filtered);
39438 static void SetEmergencyHandler(
EmergencyHandler const & in_emergency_handler);
39441 static void UnsetEmergencyHandler();
39445 static size_t GetSoftMemoryLimit();
39450 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
39519 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
39525 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
39531 bool UnSubscribe(
EventHandler const & in_handler)
const;
39537 bool UnSubscribe(intptr_t in_type)
const;
39542 bool InjectEvent(
Event const & in_event)
const;
39552 void Shutdown()
const;
39556 bool IsShutdown()
const;
39561 void SetName(
char const * in_name)
const;
39565 void ShowName(
UTF8 & out_name)
const;
39569 virtual void Reset() {}
39608 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
39614 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
39622 void UnSubscribeEverything()
const;
39625 virtual void Reset() { UnSubscribeEverything(); }
39655 channel = GetClassID();
39656 consumable =
false;
39664 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
39683 HPS_UNREFERENCED(in_that_event);
39688 return GetClassID();
39706 channel = GetClassID();
39707 consumable =
false;
39708 action = Action::None;
39712 :
Event(), action(in_action), results(in_results), options(in_options)
39714 channel = GetClassID();
39715 consumable =
false;
39722 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
39725 action = that.action;
39726 results = that.results;
39727 options = that.options;
39768 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
39772 code =
event->code;
39795 return message == in_that.
message && code == in_that.
code;
39803 return Equals(in_that);
39811 return !Equals(in_that);
39839 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
39843 code =
event->code;
39866 return message == in_that.
message && code == in_that.
code;
39874 return Equals(in_that);
39882 return !Equals(in_that);
39899 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(
Info::Code::Unknown) { channel = GetClassID(); }
39910 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
39914 code =
event->code;
39937 return message == in_that.
message && code == in_that.
code;
39945 return Equals(in_that);
39953 return !Equals(in_that);
39988 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40014 return action == in_that.
action;
40022 return Equals(in_that);
40030 return !Equals(in_that);
40043 { channel = GetClassID(); }
40087 , import_status_message(
UTF8())
40088 { channel = GetClassID(); }
40092 , import_status_message(in_message)
40093 { channel = GetClassID(); }
40095 ~ImportStatusEvent() {};
40105 UTF8 import_status_message;
40120 return modifiers == in_that.modifiers;
40128 return Equals(in_that);
40136 return !Equals(in_that);
40141 bool None()
const {
return modifiers == _key_none; }
40145 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
40149 bool Control()
const {
return (modifiers & _key_control) != 0; }
40153 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
40157 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
40163 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
40173 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
40177 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
40181 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
40185 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
40193 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
40203 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
40240 _key_none = 0x0000,
40241 _key_shift = 0x0001,
40242 _key_control = 0x0002,
40244 _key_meta = 0x0008,
40287 return Equals(in_that);
40295 return !Equals(in_that);
40303 return ModifierKeyState;
40330 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
40338 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
40347 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
40354 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
40357 channel = GetClassID();
40358 CurrentAction =
event->CurrentAction;
40359 Touches =
event->Touches;
40360 ModifierKeyState =
event->ModifierKeyState;
40390 return Equals(in_that);
40398 return !Equals(in_that);
40408 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
40409 && Touches.size() == that_touch_event->
Touches.size() )
40411 TouchArray these_touches = Touches;
40412 TouchArray those_touches = that_touch_event->
Touches;
40414 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
40415 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
40417 for (
size_t i = 0 ; i < these_touches.size() ; i++)
40419 if (these_touches[i].ID != those_touches[i].ID)
40433 Touches.assign(in_touches, in_touches + in_touch_count);
40440 Touches = in_touches;
40452 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
40454 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
40471 return buttons == in_that.buttons;
40479 return Equals(in_that);
40487 return !Equals(in_that);
40492 bool None()
const {
return buttons == _button_none; }
40496 bool Left()
const {
return (buttons & _button_left) != 0; }
40500 bool Right()
const {
return (buttons & _button_right) != 0; }
40504 bool Middle()
const {
return (buttons & _button_middle) != 0; }
40508 bool X1()
const {
return (buttons & _button_x1) != 0; }
40512 bool X2()
const {
return (buttons & _button_x2) != 0; }
40518 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
40527 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
40531 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
40535 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
40539 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
40543 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
40551 ret.buttons = buttons | in_buttons_to_merge.buttons;
40561 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
40602 _button_none = 0x0000,
40603 _button_left = 0x0001,
40604 _button_right = 0x0002,
40605 _button_middle = 0x0004,
40606 _button_x1 = 0x0008,
40607 _button_x2 = 0x0010
40640 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
40650 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
40656 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
40659 channel = GetClassID();
40660 CurrentAction =
event->CurrentAction;
40661 Location =
event->Location;
40662 CurrentButton =
event->CurrentButton;
40663 WheelDelta =
event->WheelDelta;
40664 ClickCount =
event->ClickCount;
40697 return Equals(in_that);
40705 return !Equals(in_that);
40716 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
40725 if (CurrentAction == Action::Move)
40726 return GetClassID();
40759 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
40767 :
InputEvent(in_modifiers), CurrentAction(in_action)
40769 channel = GetClassID();
40770 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40778 :
InputEvent(in_modifiers), CurrentAction(in_action)
40780 channel = GetClassID();
40781 KeyboardCodes = in_keyboardcodes;
40788 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
40791 channel = GetClassID();
40792 KeyboardCodes =
event->KeyboardCodes;
40793 CurrentAction =
event->CurrentAction;
40824 return Equals(in_that);
40832 return !Equals(in_that);
40840 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40847 KeyboardCodes = in_keyboardcodes;
40892 bool Equals(
MouseState const & in_that)
const;
40897 bool operator== (
MouseState const & in_that)
const;
40902 bool operator!= (
MouseState const & in_that)
const;
40916 KeyArray GetEventPath()
const;
40970 bool Equals(
TouchState const & in_that)
const;
40975 bool operator== (
TouchState const & in_that)
const;
40980 bool operator!= (
TouchState const & in_that)
const;
40994 KeyArray GetEventPath()
const;
40998 size_t GetTouchCount()
const;
41002 TouchArray GetTouches()
const;
41072 KeyArray GetEventPath()
const;
41076 size_t GetKeyboardCodeCount()
const;
41080 KeyboardCodeArray GetKeyboardCodes()
const;
41085 bool GetKeyState(KeyboardCode in_key_code)
const;
41137 IOResult Status()
const;
41142 IOResult Status(
float & out_percent_complete)
const;
41195 bool Empty()
const;
41225 bool ShowSegment(
SegmentKey & out_segment)
const;
41240 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
41255 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
41302 bool Empty()
const;
41334 bool ShowSegment(
SegmentKey & out_segment)
const;
41352 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
41370 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
41386 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
41394 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
41405 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
41458 bool Empty()
const;
41482 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
41491 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
41498 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
41507 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
41516 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
41533 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
41571 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
41577 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
41583 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
41589 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
41595 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
41600 bool ShowConnectivityCompression(
bool & out_state)
const;
41606 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
41715 DotsPerCentimeter = DPCM,
41764 bool Empty()
const;
41789 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
41829 bool ShowWYSIWYG(
bool & out_onoff)
const;
41866 static IOResult Export(
char const * in_filename, Driver in_driver_type,
WindowKey const & in_window, ExportOptionsKit
const & in_options);
41916 bool Empty()
const;
41939 bool ShowResolution(
float & out_resolution)
const;
41955 bool ShowWYSIWYG(
bool & out_onoff)
const;
41978 static IOResult Export(intptr_t hdc, intptr_t attribdc,
WindowKey const & window, ExportOptionsKit
const & options);
42038 bool Empty()
const;
42068 bool ShowSegment(
SegmentKey & out_segment)
const;
42083 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42146 bool Empty()
const;
42178 bool ShowSegment(
SegmentKey & out_segment)
const;
42196 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42337 bool Empty()
const;
42399 bool ShowSegment(
SegmentKey & out_segment)
const;
42448 bool Empty()
const;
42480 bool ShowSegment(
SegmentKey & out_segment)
const;
42558 # pragma warning(pop)
Type ObjectType() const
Definition: hps.h:39025
Rotation
Definition: hps.h:1580
Type ObjectType() const
Definition: hps.h:26188
bool Empty() const
Definition: hps.h:6709
CameraPoint(Point const &in_point)
Definition: hps.h:5660
Alignment
Definition: hps.h:1513
Space
Definition: hps.h:546
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:40732
Channel
Definition: hps.h:930
Type ObjectType() const
Definition: hps.h:23438
Handedness
Definition: hps.h:1261
ColorSource
Definition: hps.h:1906
Type ObjectType() const
Definition: hps.h:16555
Type ObjectType() const
Definition: hps.h:35347
Event(intptr_t in_channel=0)
Definition: hps.h:6013
Type ObjectType() const
Definition: hps.h:42250
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3693
float alpha
Definition: hps.h:4217
Type ObjectType() const
Definition: hps.h:34954
bool operator==(Touch const &in_that) const
Definition: hps.h:6303
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:40173
Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:39957
Type ObjectType() const
Definition: hps.h:37370
Type ObjectType() const
Definition: hps.h:33434
Type ObjectType() const
Definition: hps.h:21248
Type ObjectType() const
Definition: hps.h:22966
Type ObjectType() const
Definition: hps.h:23712
Action
Definition: hps.h:40315
Orientation
Definition: hps.h:522
Code
Definition: hps.h:127
Definition: sprk_exchange.h:42
Algorithm
Definition: hps.h:1316
Multiline strings will be left justfied.
Type ObjectType() const
Definition: hps.h:14438
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40012
Type ObjectType() const
Definition: hps.h:8193
Type ObjectType() const
Definition: hps.h:27416
Event * Clone() const
Definition: hps.h:39855
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:40649
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:39643
ImportStatusEvent()
Definition: hps.h:40085
Type ObjectType() const
Definition: hps.h:20865
Type ObjectType() const
Definition: hps.h:35129
Type ObjectType() const
Definition: hps.h:25211
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:40380
Type ObjectType() const
Definition: hps.h:29417
Type ObjectType() const
Definition: hps.h:24842
Type ObjectType() const
Definition: hps.h:11128
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39904
void SetKeyboardCodes(size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[])
Definition: hps.h:40838
Type ObjectType() const
Definition: hps.h:36821
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5557
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5805
Driver
Definition: hps.h:147
Type ObjectType() const
Definition: hps.h:40878
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2134
Type ObjectType() const
Definition: hps.h:38169
CappingLevel
Definition: hps.h:1712
Type ObjectType() const
Definition: hps.h:22693
Type ObjectType() const
Definition: hps.h:34882
Object space units ignoring any scaling components in modelling matrices.
Type ObjectType() const
Definition: hps.h:12266
Type ObjectType() const
Definition: hps.h:40956
Type ObjectType() const
Definition: hps.h:19994
Type ObjectType() const
Definition: hps.h:13283
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5417
Type ObjectType() const
Definition: hps.h:28201
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3800
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40777
static ModifierKeys KeyMeta()
Definition: hps.h:40232
Type ObjectType() const
Definition: hps.h:34617
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Type ObjectType() const
Definition: hps.h:35996
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3679
Type ObjectType() const
Definition: hps.h:38341
Type ObjectType() const
Definition: hps.h:22891
Type ObjectType() const
Definition: hps.h:34188
Type ObjectType() const
Definition: hps.h:16264
Type ObjectType() const
Definition: hps.h:37410
Time GetTimeStamp() const
Definition: hps.h:6035
Type ObjectType() const
Definition: hps.h:21726
NormalizedPoint(Point const &in_point)
Definition: hps.h:5710
Type ObjectType() const
Definition: hps.h:23240
Event * Clone() const
Definition: hps.h:39672
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3728
Renderer
Definition: hps.h:1561
Type ObjectType() const
Definition: hps.h:33170
KeyboardEvent()
Definition: hps.h:40753
Type ObjectType() const
Definition: hps.h:7084
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3908
ObjectPoint(Point const &in_point)
Definition: hps.h:5560
Type ObjectType() const
Definition: hps.h:17142
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3663
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:39986
static ModifierKeys KeyAlt()
Definition: hps.h:40228
bool IsConsumable() const
Definition: hps.h:6038
MaterialPreference
Definition: hps.h:1729
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40766
Mobility
Definition: hps.h:188
Type ObjectType() const
Definition: hps.h:12776
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5758
InterpolationAlgorithm
Definition: hps.h:1496
Fill
Definition: hps.h:1897
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3716
Type ObjectType() const
Definition: hps.h:26693
Type ObjectType() const
Definition: hps.h:18635
char At(size_t in_index) const
Definition: hps.h:6752
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:40168
Type ObjectType() const
Definition: hps.h:35009
ReferenceFrame
Definition: hps.h:1528
Type ObjectType() const
Definition: hps.h:16471
GreekingUnits
Definition: hps.h:1615
Type ObjectType() const
Definition: hps.h:11678
InnerConeUnits
Definition: hps.h:471
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5854
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40062
OuterConeUnits
Definition: hps.h:457
Type ObjectType() const
Definition: hps.h:18419
Type ObjectType() const
Definition: hps.h:39493
Type ObjectType() const
Definition: hps.h:38438
Type ObjectType() const
Definition: hps.h:13879
Type ObjectType() const
Definition: hps.h:32673
void SetKeyboardCodes(KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:40845
Type ObjectType() const
Definition: hps.h:26087
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40404
Type ObjectType() const
Definition: hps.h:12149
Type ObjectType() const
Definition: hps.h:24424
Type ObjectType() const
Definition: hps.h:35460
Channel
Definition: hps.h:889
Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:39886
AreaUnits
Definition: hps.h:1442
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3770
Type ObjectType() const
Definition: hps.h:11501
Type ObjectType() const
Definition: hps.h:33790
Action
Definition: hps.h:39968
Type ObjectType() const
Definition: hps.h:13717
Type ObjectType() const
Definition: hps.h:41441
Type ObjectType() const
Definition: hps.h:26794
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6318
Type ObjectType() const
Definition: hps.h:36939
Type ObjectType() const
Definition: hps.h:33307
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40337
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3866
Border
Definition: hps.h:249
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:40163
Type ObjectType() const
Definition: hps.h:22463
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:40814
Type ObjectType() const
Definition: hps.h:20790
WarningEvent(Event const &in_event)
Definition: hps.h:39837
Type ObjectType() const
Definition: hps.h:11004
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1916
static ModifierKeys KeyShift()
Definition: hps.h:40220
Type ObjectType() const
Definition: hps.h:27927
Shape
Definition: hps.h:1058
bool IsValid() const
Definition: hps.h:6702
Cuboid_3D()
Definition: hps.h:3671
ErrorEvent(Event const &in_event)
Definition: hps.h:39908
size_t GetWStrLength() const
Definition: hps.h:6731
Event * Clone() const
Definition: hps.h:39737
Type ObjectType() const
Definition: hps.h:10595
AppendMode
Definition: hps.h:317
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3851
void Meta(bool in_state)
Definition: hps.h:40185
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5953
Type ObjectType() const
Definition: hps.h:14147
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3721
Type ObjectType() const
Definition: hps.h:37522
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40033
Quality
Definition: hps.h:1042
ResolutionUnits
Definition: hps.h:41711
TimerTickEvent(Event const &in_event)
Definition: hps.h:39662
Component
Definition: hps.h:337
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5904
Type ObjectType() const
Definition: hps.h:11765
Default
Definition: hps.h:1870
Type ObjectType() const
Definition: hps.h:10225
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:4965
bool Shift() const
Definition: hps.h:40145
SizeToleranceUnits
Definition: hps.h:1602
Type ObjectType() const
Definition: hps.h:37646
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:3937
Cap
Definition: hps.h:1821
Point_3D< F > max
Definition: hps.h:3665
Type ObjectType() const
Definition: hps.h:7164
Type ObjectType() const
Definition: hps.h:42021
Type ObjectType() const
Definition: hps.h:42129
MouseEvent()
Definition: hps.h:40631
Type ObjectType() const
Definition: hps.h:11606
Type ObjectType() const
Definition: hps.h:16173
Type ObjectType() const
Definition: hps.h:34233
Material Texture Channel.
static const float Infinity
Definition: hps.h:2129
InsetBehavior
Definition: hps.h:1802
Type ObjectType() const
Definition: hps.h:24350
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2142
Type ObjectType() const
Definition: hps.h:13171
Type ObjectType() const
Definition: hps.h:26387
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6317
Type ObjectType() const
Definition: hps.h:34423
Type ObjectType() const
Definition: hps.h:36685
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3830
Algorithm
Definition: hps.h:1430
Decimation
Definition: hps.h:999
Granularity
Definition: hps.h:1351
Parameterization
Definition: hps.h:37053
Search the current segment only.
KeyboardEvent(Event const &in_event)
Definition: hps.h:40786
ClipOperation
Definition: hps.h:1290
Type ObjectType() const
Definition: hps.h:8445
Method
Definition: hps.h:1420
Type ObjectType() const
Definition: hps.h:25827
Parameterization
Definition: hps.h:944
FocusLostEvent()
Definition: hps.h:40041
CuttingLevel
Definition: hps.h:1721
Channel
Definition: hps.h:910
HandleResult
Definition: hps.h:39633
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:4977
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:39956
Value
Definition: hps.h:1401
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2150
Type ObjectType() const
Definition: hps.h:25343
Event * Clone() const
Definition: hps.h:40049
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:40685
ErrorEvent()
Definition: hps.h:39895
Justification
Definition: hps.h:1536
The vertex colors applied to faces.
Type ObjectType() const
Definition: hps.h:13541
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5435
ErrorEvent(char const *in_message)
Definition: hps.h:39899
FrameSize
Definition: hps.h:199
Justification
Definition: hps.h:1838
Type ObjectType() const
Definition: hps.h:11326
Type ObjectType() const
Definition: hps.h:19276
Type ObjectType() const
Definition: hps.h:21557
Type ObjectType() const
Definition: hps.h:8240
Type ObjectType() const
Definition: hps.h:35950
Type ObjectType() const
Definition: hps.h:34137
GreekingMode
Definition: hps.h:1627
Type ObjectType() const
Definition: hps.h:19786
KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:40850
Operation
Definition: hps.h:440
Type ObjectType() const
Definition: hps.h:36530
Type
Definition: hps.h:1984
WorldPoint(Point const &in_point)
Definition: hps.h:5610
TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:40444
Type ObjectType() const
Definition: hps.h:9424
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2421
Type ObjectType() const
Definition: hps.h:6549
TouchEvent(Event const &in_event)
Definition: hps.h:40352
void SetTouches(TouchArray const &in_touches)
Definition: hps.h:40438
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6834
Relation
Definition: hps.h:363
Action
Definition: hps.h:40745
ChannelMapping
Definition: hps.h:1013
Type ObjectType() const
Definition: hps.h:22075
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5452
Type ObjectType() const
Definition: hps.h:37988
Type ObjectType() const
Definition: hps.h:38627
bool Alt() const
Definition: hps.h:40153
ToleranceUnits
Definition: hps.h:346
Type ObjectType() const
Definition: hps.h:12076
SizeUnits
Definition: hps.h:1789
Type
Definition: hps.h:2001
The vertex colors applied to faces.
RelationTest
Definition: hps.h:373
Type
Definition: hps.h:308
Type ObjectType() const
Definition: hps.h:14291
Behavior
Definition: hps.h:555
Ambient Occulsion Quality.
Type ObjectType() const
Definition: hps.h:6624
KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:40851
Type ObjectType() const
Definition: hps.h:18185
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5426
float blue
Definition: hps.h:4216
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:413
Type ObjectType() const
Definition: hps.h:20565
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6852
PixelPoint(Point const &in_point)
Definition: hps.h:5956
Type ObjectType() const
Definition: hps.h:6078
Type ObjectType() const
Definition: hps.h:6927
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40711
Type ObjectType() const
Definition: hps.h:21126
Type ObjectType() const
Definition: hps.h:21006
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
Type ObjectType() const
Definition: hps.h:34376
Type ObjectType() const
Definition: hps.h:28070
Type ObjectType() const
Definition: hps.h:23511
Type ObjectType() const
Definition: hps.h:38267
Type ObjectType() const
Definition: hps.h:20431
MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:40731
Event * Clone() const
Definition: hps.h:40099
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:4971
Type ObjectType() const
Definition: hps.h:33704
Type ObjectType() const
Definition: hps.h:39602
Alignment and justification will be defined relative to a screen-facing box around the text...
Type ObjectType() const
Definition: hps.h:15322
Infinite line which extends infinitely in both directions along a vector.
intptr_t GetChannel() const
Definition: hps.h:6032
Type ObjectType() const
Definition: hps.h:8798
Algorithm
Definition: hps.h:1343
Type ObjectType() const
Definition: hps.h:30463
Type ObjectType() const
Definition: hps.h:36982
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3788
Driver
Definition: hps.h:41855
SizeUnits
Definition: hps.h:1657
StandAloneWindowEvent()
Definition: hps.h:39977
Type ObjectType() const
Definition: hps.h:35529
Type ObjectType() const
Definition: hps.h:33542
Type ObjectType() const
Definition: hps.h:11914
Type ObjectType() const
Definition: hps.h:10745
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:39864
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:40639
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5398
Type ObjectType() const
Definition: hps.h:16982
Level
Definition: hps.h:1334
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:40118
void Control(bool in_state)
Definition: hps.h:40177
Type ObjectType() const
Definition: hps.h:41639
Type ObjectType() const
Definition: hps.h:17693
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3922
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:39885
The base class of all HPS exceptions.
Definition: hps.h:5390
RegionAlignment
Definition: hps.h:1636
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40346
Event * Clone() const
Definition: hps.h:40676
Type ObjectType() const
Definition: hps.h:20714
void Invalidate()
Definition: hps.h:3733
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4712
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5449
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40065
Type ObjectType() const
Definition: hps.h:33030
Type ObjectType() const
Definition: hps.h:38864
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6025
char const * GetBytes() const
Definition: hps.h:6738
virtual intptr_t Freshen() const
Definition: hps.h:40723
Type ObjectType() const
Definition: hps.h:34485
float green
Definition: hps.h:4215
Action
Definition: hps.h:40620
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1681
Type ObjectType() const
Definition: hps.h:9829
Type ObjectType() const
Definition: hps.h:26459
Type ObjectType() const
Definition: hps.h:24029
Type ObjectType() const
Definition: hps.h:23785
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Type ObjectType() const
Definition: hps.h:37034
Type ObjectType() const
Definition: hps.h:24152
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5857
Type ObjectType() const
Definition: hps.h:41899
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5707
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6297
static const float NegativeInfinity
Definition: hps.h:2131
HighlightEvent(Event const &in_event)
Definition: hps.h:39720
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6843
SizeUnits
Definition: hps.h:1462
Type ObjectType() const
Definition: hps.h:12352
Type ObjectType() const
Definition: hps.h:20172
MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:40733
Type ObjectType() const
Definition: hps.h:10050
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5808
GatheringLevel
Definition: hps.h:1737
Type ObjectType() const
Definition: hps.h:28280
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3700
FrameOptions
Definition: hps.h:208
Type ObjectType() const
Definition: hps.h:34326
Space
Definition: hps.h:8151
void Alt(bool in_state)
Definition: hps.h:40181
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40758
Type ObjectType() const
Definition: hps.h:36257
Type
Definition: hps.h:243
bool operator!=(Touch const &in_that) const
Definition: hps.h:6311
Type
Definition: hps.h:431
Type ObjectType() const
Definition: hps.h:41178
Type ObjectType() const
Definition: hps.h:42431
Type ObjectType() const
Definition: hps.h:37234
Type ObjectType() const
Definition: hps.h:42320
Type ObjectType() const
Definition: hps.h:32761
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5607
Type ObjectType() const
Definition: hps.h:8988
Type ObjectType() const
Definition: hps.h:42517
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6825
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:40431
Event * Clone() const
Definition: hps.h:40371
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:39935
Event * Clone() const
Definition: hps.h:40003
size_t GetLength() const
Definition: hps.h:6723
Type ObjectType() const
Definition: hps.h:20518
Type ObjectType() const
Definition: hps.h:26017
Type
Definition: hps.h:1119
Type ObjectType() const
Definition: hps.h:8906
bool None() const
Definition: hps.h:40141
size_t ClickCount
The number of clicks received.
Definition: hps.h:40735
virtual intptr_t Freshen() const
Definition: hps.h:6029
void Reset()
Definition: hps.h:6718
Type ObjectType() const
Definition: hps.h:36768
Type ObjectType() const
Definition: hps.h:23166
Type ObjectType() const
Definition: hps.h:38968
SizeUnits
Definition: hps.h:1590
Event * Clone() const
Definition: hps.h:39926
MouseEvent(Event const &in_event)
Definition: hps.h:40654
virtual bool Empty() const
Definition: hps.h:5490
Join
Definition: hps.h:1812
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3844
Modifier
Definition: hps.h:1849
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40329
HighlightEvent()
Definition: hps.h:39704
virtual Type ObjectType() const
Definition: hps.h:5486
Type ObjectType() const
Definition: hps.h:13364
TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:40443
Type
Definition: hps.h:566
virtual intptr_t Freshen() const
Definition: hps.h:39687
Background
Definition: hps.h:224
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3777
static ModifierKeys KeyControl()
Definition: hps.h:40224
Type ObjectType() const
Definition: hps.h:17905
Type ObjectType() const
Definition: hps.h:34739
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5755
Type ObjectType() const
Definition: hps.h:38760
StandAloneWindowEvent(Action in_action)
Definition: hps.h:39982
Mode
Definition: hps.h:1702
Event * Clone() const
Definition: hps.h:40071
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:3981
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3812
Type
Definition: hps.h:869
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3765
Type ObjectType() const
Definition: hps.h:11823
Type ObjectType() const
Definition: hps.h:31520
Type ObjectType() const
Definition: hps.h:36866
Type ObjectType() const
Definition: hps.h:41285
Type ObjectType() const
Definition: hps.h:41034
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3751
Type ObjectType() const
Definition: hps.h:36041
Type ObjectType() const
Definition: hps.h:11972
Type ObjectType() const
Definition: hps.h:17448
Mode
Definition: hps.h:1755
Event * Clone() const
Definition: hps.h:40805
Tiling
Definition: hps.h:972
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:3966
WindowPoint(Point const &in_point)
Definition: hps.h:5907
Transform
Definition: hps.h:1545
Type ObjectType() const
Definition: hps.h:36355
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Grid composed of quadrilaterals.
Type ObjectType() const
Definition: hps.h:37693
ModifierKeys()
Definition: hps.h:40113
Preference
Definition: hps.h:1570
Type ObjectType() const
Definition: hps.h:24704
Capping
Definition: hps.h:511
Type ObjectType() const
Definition: hps.h:34557
TouchEvent()
Definition: hps.h:40323
Interpolation
Definition: hps.h:988
Type ObjectType() const
Definition: hps.h:19547
WarningEvent(char const *in_message)
Definition: hps.h:39828
Type ObjectType() const
Definition: hps.h:20318
Modifiers
Definition: hps.h:40238
Component
Definition: hps.h:503
Type ObjectType() const
Definition: hps.h:35047
Type ObjectType() const
Definition: hps.h:6414
Type ObjectType() const
Definition: hps.h:21988
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:3951
Type ObjectType() const
Definition: hps.h:41747
Type ObjectType() const
Definition: hps.h:21778
Format
Definition: hps.h:36219
WarningEvent()
Definition: hps.h:39824
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:39681
Touch()
Definition: hps.h:6291
Component
Definition: hps.h:393
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4214
ClipSpace
Definition: hps.h:1298
Control & operator=(Control &&in_that)
Definition: hps.h:5543
WarningEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39833
Type ObjectType() const
Definition: hps.h:13469
SizeUnits
Definition: hps.h:41704
virtual void Reset()
Definition: hps.h:39625
Type ObjectType() const
Definition: hps.h:10860
bool Meta() const
Definition: hps.h:40157
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:3993
TimerTickEvent()
Definition: hps.h:39653
Type ObjectType() const
Definition: hps.h:21461
RenderingAlgorithm
Definition: hps.h:260
EmergencyHandler()
Definition: hps.h:39168
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5657
TouchID ID
TouchID for this Touch.
Definition: hps.h:6316
Type ObjectType() const
Definition: hps.h:10426
Type ObjectType() const
Definition: hps.h:32462
HandednessOptimization
Definition: hps.h:354
Projection
Definition: hps.h:1380
Control(Control &&in_that)
Definition: hps.h:5538
bool Control() const
Definition: hps.h:40149
Type ObjectType() const
Definition: hps.h:33925
Overlay
Definition: hps.h:1270
Type ObjectType() const
Definition: hps.h:37102
Status
Definition: hps.h:6005
Type ObjectType() const
Definition: hps.h:34055
Type ObjectType() const
Definition: hps.h:6496
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:40734
Type ObjectType() const
Definition: hps.h:41121