////////////////////////////////////////////////////////////////////////////// // // Copyright 2016 Autodesk, Inc. All rights reserved. // // Use of this software is subject to the terms of the Autodesk license // agreement provided at the time of installation or download, or which // otherwise accompanies this software. // ////////////////////////////////////////////////////////////////////////////// #pragma once #include "../../Core/Base.h" #include "../FusionTypeDefs.h" #include // THIS CLASS WILL BE VISIBLE TO AN API CLIENT. // THIS HEADER FILE WILL BE GENERATED FROM NIDL. #include "../../Core/OSMacros.h" #ifdef FUSIONXINTERFACE_EXPORTS # ifdef __COMPILING_ADSK_FUSION_EXTRUDEFEATUREINPUT_CPP__ # define ADSK_FUSION_EXTRUDEFEATUREINPUT_API XI_EXPORT # else # define ADSK_FUSION_EXTRUDEFEATUREINPUT_API # endif #else # define ADSK_FUSION_EXTRUDEFEATUREINPUT_API XI_IMPORT #endif namespace adsk { namespace fusion { class BaseFeature; class BRepBody; class ExtentDefinition; class Occurrence; }} namespace adsk { namespace core { class ValueInput; class Vector3D; }} namespace adsk { namespace fusion { /// This class defines the methods and properties that pertain to the definition of an extrude /// feature. This class also provides properties for setting/getting the Profile and Operation /// of the extrude. The Profile and Operation are defined when the ExtrudeFeatures.createInput /// method is called so they do not exist as properties on this class. class ExtrudeFeatureInput : public core::Base { public: /// Gets and sets the profiles or planar faces used to define the shape of the extrude. /// This property can return or be set with a single profile, a single planar face, or /// an ObjectCollection consisting of multiple profiles and planar faces. When an /// ObjectCollection is used all of the profiles and faces must be co-planar. /// To create a surface (non-solid) extrusion, you can use the createOpenProfile and createBRepEdgeProfile /// methods of the Component object to create an open profile. The isSolid property of the /// ExtrudeFeatureInput property must also be False. core::Ptr profile() const; bool profile(const core::Ptr& value); /// Gets and sets the type of operation performed by the extrusion. FeatureOperations operation() const; bool operation(FeatureOperations value); /// Gets and sets the taper angle of the extrusion. This is used to define the /// taper angle for a single sided and symmetric and defines the angle for side one /// of a two sided extrusion. This property is initialized with a taper angle of zero. /// A negative angle will taper the extrusion inward while a positive value will taper /// the extrusion outward. This property is valid for both parametric and non-parametric extrusions. core::Ptr taperAngle() const; bool taperAngle(const core::Ptr& value); /// Sets the extrusion extents option to 'Distance'. /// isSymmetric : Set to 'true' for an extrusion symmetrical about the profile plane /// distance : ValueInput object that defines the extrude distance. /// If the isSymmetric argument is 'false', a positive or negative distance can be used to control the direction. /// Returns true if successful bool setDistanceExtent(bool isSymmetric, const core::Ptr& distance); /// Sets the extrusion extents option to 'Two Side'. /// This method will fail in the case of a non-parametric extrusion. /// distanceOne : ValueInput object that defines the extrude distance for the first side. /// distanceTwo : ValueInput object that defines the extrude distance for the second side. /// Returns true if successful bool setTwoSidesDistanceExtent(const core::Ptr& distanceOne, const core::Ptr& distanceTwo); /// Sets the extrusion extents option to 'All' (i.e. the extrusion is through-all, in both directions.) /// This method will fail in the case of a non-parametric extrusion. /// direction : The direction can be either positive, negative, or symmetric. /// Returns true if successful bool setAllExtent(ExtentDirections direction); /// Sets the extrusion Direction option to 'One Side' and the Extents option to 'To' (a specified face) /// toEntity : The entity that defines the "to" extent. The valid types of entities can vary depending on /// the type of feature this is being used with. For an extrude it can be a BRepBody, BRepFace, /// BRepVertex, ConstructionPlane, or ConstructionPoint. /// matchShape : If the matchShape argument is 'true', the toEntity is extended to fully intersect the extrusion. /// directionHint : Specifies the direction of the extrusion. This is only used in the case where there are two possible solutions and the extrusion can /// hit the toEntity in either direction. An example is if the profile of the extrusion is within a hole. /// The extrusion will intersect the cylinder of the hole in either direction. /// Typically there is only a single solution and the direction is determined automatically. /// Returns true if successful. bool setOneSideToExtent(const core::Ptr& toEntity, bool matchShape, const core::Ptr& directionHint = NULL); /// Set the extrusion Direction option to 'Two Side' /// This method will fail in the case of a non-parametric extrusion. /// toEntityOne : The first entity that defines the "to" extent. The valid types of entities can vary depending on /// the type of feature this is being used with. For an extrude it can be a BRepBody, BRepFace, /// BRepVertex, ConstructionPlane, or ConstructionPoint. /// toEntityTwo : The second entity that defines the "to" extent. The valid types of entities can vary depending on /// the type of feature this is being used with. For an extrude it can be a BRepBody, BRepFace, /// BRepVertex, ConstructionPlane, or ConstructionPoint. /// matchShape : If the matchShape argument is 'true', the toEntity is extended to fully intersect the extrusion. /// Returns true if successful. bool setTwoSidesToExtent(const core::Ptr& toEntityOne, const core::Ptr& toEntityTwo, bool matchShape); /// In order for geometry to be transformed correctly, an Occurrence for creation needs to be /// specified when the Extrusion is created based on geometry (e.g. a profile and/or face(s)) /// in another component AND (the Extrusion) is not in the root component. /// The CreationOccurrence is analogous to the active occurrence in the UI core::Ptr creationOccurrence() const; bool creationOccurrence(const core::Ptr& value); /// Specifies if the extrusion should be created as a solid or surface. If /// it's a surface then there aren't any end caps and it's open. When a ExtrudeFeature /// input is created, this is initialized to true so a solid will be created if it's not changed. bool isSolid() const; bool isSolid(bool value); /// When creating a feature that is owned by a base feature, set this property to the /// base feature you want to associate the new feature with. By default, this is null, /// meaning it will not be associated with a base feature. /// Because of a current limitation, if you want to create a feature associated with a base /// feature, you must set this property AND call the startEdit method of the base feature, /// create the feature, and then call the finishEdit method of the base feature. The base /// feature must be in an "edit" state to be able to add any additional items to it. core::Ptr targetBaseFeature() const; bool targetBaseFeature(const core::Ptr& value); /// Gets and sets the extent used to define the start of the extrusion. When a new ExtrudeFeatureInput /// object is created the start extent is initialized to be the profile plane but you can change it /// to a profile plane with offset or from an object by setting this property with either a /// ProfilePlaneWithOffsetStartDefinition or a EntityStartDefinition object. You can get either one /// of those objects by using the static create method on the class. core::Ptr startExtent() const; bool startExtent(const core::Ptr& value); /// Defines the extrusion to go in one direction from the profile. The extent of the extrusion is /// defined by the extent argument. /// extent : An ExtentDefinition object that defines how the extent of the extrusion is defined. This can be /// a specified distance (DistanceExtentDefinition), to an entity (ToEntityExtent), or through-all (AllExtentDefinition). /// These objects can be obtained by using the static create method on the appropriate class. /// direction : Specifies the direction of the extrusion. PositiveExtentDirection and NegativeExtentDirection /// are valid values. PositiveExtentDirection is in the same direction as the normal of the profile's /// parent sketch plane. /// taperAngle : Optional argument that specifies the taper angle. If omitted a taper angle of 0 is used. /// Returns true is setting the input to a one sided extent was successful. bool setOneSideExtent(const core::Ptr& extent, ExtentDirections direction, const core::Ptr& taperAngle = NULL); /// Defines the extrusion to go in both directions from the profile. The extent is defined independently /// for each direction using the input arguments. /// sideOneExtent : An ExtentDefinition object that defines how the extent of the extrusion towards side one is defined. This can be /// a specified distance (DistanceExtentDefinition), to an entity (ToEntityExtent), or through-all (AllExtentDefinition). /// These objects can be obtained by using the static create method on the appropriate class. /// sideTwoExtent : An ExtentDefinition object that defines how the extent of the extrusion towards side two is defined. This can be /// a specified distance (DistanceExtentDefinition), to an entity (ToEntityExtent), or through-all (AllExtentDefinition). /// These objects can be obtained by using the static create method on the appropriate class. /// sideOneTaperAngle : Optional argument that specifies the taper angle for side one. If omitted a taper angle of 0 is used. /// sideTwoTaperAngle : Optional argument that specifies the taper angle for side two. If omitted a taper angle of 0 is used. /// Returns true is setting the extent was successful. bool setTwoSidesExtent(const core::Ptr& sideOneExtent, const core::Ptr& sideTwoExtent, const core::Ptr& sideOneTaperAngle = NULL, const core::Ptr& sideTwoTaperAngle = NULL); /// Defines the extrusion to go symmetrically in both directions from the profile. /// distance : The distance of the extrusions. This is either the full length of half of the length of the final extrusion /// depending on the value of the isFullLength property. /// isFullLength : Defines if the value defines the full length of the extrusion or half of the length. A value of true indicates /// it defines the full length. /// taperAngle : Optional argument that specifies the taper angle. The same taper angle is used for both sides for a symmetric /// extrusion. If omitted a taper angle of 0 is used. /// Returns true is setting the extent was successful. bool setSymmetricExtent(const core::Ptr& distance, bool isFullLength, const core::Ptr& taperAngle = NULL); /// Gets the extent assigned for a single sided extrude or side one of a two-sided extrusion. To set the extent, use /// one of the set methods on the ExtrudeFeatureInput object. core::Ptr extentOne() const; /// Gets the extent assigned for side two of the extrusion. If the extrude is single sided extrude this /// property will return null. The hasTwoExtents property can be used to determine if there /// are two sides or not. To set the extent, use one of the set methods on the ExtrudeFeatureInput object. core::Ptr extentTwo() const; /// Gets the value that will be used as the taper angle for a single sided extrusion or side one of a two-sided /// extrusion. To set the taper angle, use one of the set methods on the ExtrudeFeatureInput object. core::Ptr taperAngleOne() const; /// Gets the value that will be used as the taper angle for side two of a two-sided extrusion. If the extrusion is /// single-sided, this property will return null. The hasTwoExtents property can be used to determine if there /// are two sides or not. To set the taper angle, use one of the set methods on the ExtrudeFeatureInput object. core::Ptr taperAngleTwo() const; /// Property that indicates if the extrusion is a single or two-sided extrusion. If false, the extentTwo /// and taperAngleTwo properties should not be used. bool hasTwoExtents() const; /// Gets and sets the list of bodies that will participate in the feature when the operation is a cut or intersection. /// If this property has not been set, the default behavior is that all bodies that are intersected by the /// feature will participate. /// This property can return null in the case where the feature has not been fully defined so that /// possible intersecting bodies can be computed. std::vector> participantBodies() const; bool participantBodies(const std::vector>& value); /// Sets or returns whether the extrude is a thin extrude. /// Setting it as false will make it a regular extrude. bool isThinExtrude() const; bool isThinExtrude(bool value); /// Changes the extrude feature to be a thin extrude. This is only valid if the isThinExtrude property /// is False. If the extrusion is already a thin extrude, you can use the properties on the ExtrudeFeature /// to modify the thin extrude specific values. /// thinExtrudeWallLocationOne : Specifies the position of the thin wall extrude with respect to the profile being extruded. This defines /// the direction for a single sided thin extrude or side one of a two-sided extrusion. /// thinExtrudeWallThicknessOne : A ValueInput object that defines the thickness for a single sided thin extrude or side one of a two-sided /// extrusion . /// thinExtrudeWallLocationTwo : Optional argument that specifies the position of side two of a two-sided extrusion. This argument is ignored /// for a single sided thin extrude. /// thinExtrudeWallThicknessTwo : Optional argument that is a ValueInput object that defines the thickness for side two of a /// two-sided extrusion. This argument is ignored for a single sided thin extrude. /// Returns true if successful. bool setThinExtrude(ThinExtrudeWallLocation thinExtrudeWallLocationOne, const core::Ptr& thinExtrudeWallThicknessOne, ThinExtrudeWallLocation thinExtrudeWallLocationTwo = adsk::fusion::Side1, const core::Ptr& thinExtrudeWallThicknessTwo = NULL); /// Gets and sets the wall location for a one sided thin extrude or side one of a two sided thin extrude ThinExtrudeWallLocation thinExtrudeWallLocationOne() const; bool thinExtrudeWallLocationOne(ThinExtrudeWallLocation value); /// Gets and sets the wall location for side two of a two sided thin extrude ThinExtrudeWallLocation thinExtrudeWallLocationTwo() const; bool thinExtrudeWallLocationTwo(ThinExtrudeWallLocation value); /// Gets and sets the wall thickness for a one sided thin extrude or side one of a two sided thin extrude core::Ptr thinExtrudeWallThicknessOne() const; bool thinExtrudeWallThicknessOne(const core::Ptr& value); /// Gets and sets the wall thickness for side two of a two sided thin extrude core::Ptr thinExtrudeWallThicknessTwo() const; bool thinExtrudeWallThicknessTwo(const core::Ptr& value); ADSK_FUSION_EXTRUDEFEATUREINPUT_API static const char* classType(); ADSK_FUSION_EXTRUDEFEATUREINPUT_API const char* objectType() const override; ADSK_FUSION_EXTRUDEFEATUREINPUT_API void* queryInterface(const char* id) const override; ADSK_FUSION_EXTRUDEFEATUREINPUT_API static const char* interfaceId() { return classType(); } private: // Raw interface virtual core::Base* profile_raw() const = 0; virtual bool profile_raw(core::Base* value) = 0; virtual FeatureOperations operation_raw() const = 0; virtual bool operation_raw(FeatureOperations value) = 0; virtual core::ValueInput* taperAngle_raw() const = 0; virtual bool taperAngle_raw(core::ValueInput* value) = 0; virtual bool setDistanceExtent_raw(bool isSymmetric, core::ValueInput* distance) = 0; virtual bool setTwoSidesDistanceExtent_raw(core::ValueInput* distanceOne, core::ValueInput* distanceTwo) = 0; virtual bool setAllExtent_raw(ExtentDirections direction) = 0; virtual bool setOneSideToExtent_raw(core::Base* toEntity, bool matchShape, core::Vector3D* directionHint) = 0; virtual bool setTwoSidesToExtent_raw(core::Base* toEntityOne, core::Base* toEntityTwo, bool matchShape) = 0; virtual Occurrence* creationOccurrence_raw() const = 0; virtual bool creationOccurrence_raw(Occurrence* value) = 0; virtual bool isSolid_raw() const = 0; virtual bool isSolid_raw(bool value) = 0; virtual BaseFeature* targetBaseFeature_raw() const = 0; virtual bool targetBaseFeature_raw(BaseFeature* value) = 0; virtual ExtentDefinition* startExtent_raw() const = 0; virtual bool startExtent_raw(ExtentDefinition* value) = 0; virtual bool setOneSideExtent_raw(ExtentDefinition* extent, ExtentDirections direction, core::ValueInput* taperAngle) = 0; virtual bool setTwoSidesExtent_raw(ExtentDefinition* sideOneExtent, ExtentDefinition* sideTwoExtent, core::ValueInput* sideOneTaperAngle, core::ValueInput* sideTwoTaperAngle) = 0; virtual bool setSymmetricExtent_raw(core::ValueInput* distance, bool isFullLength, core::ValueInput* taperAngle) = 0; virtual ExtentDefinition* extentOne_raw() const = 0; virtual ExtentDefinition* extentTwo_raw() const = 0; virtual core::ValueInput* taperAngleOne_raw() const = 0; virtual core::ValueInput* taperAngleTwo_raw() const = 0; virtual bool hasTwoExtents_raw() const = 0; virtual BRepBody** participantBodies_raw(size_t& return_size) const = 0; virtual bool participantBodies_raw(BRepBody** value, size_t value_size) = 0; virtual bool isThinExtrude_raw() const = 0; virtual bool isThinExtrude_raw(bool value) = 0; virtual bool setThinExtrude_raw(ThinExtrudeWallLocation thinExtrudeWallLocationOne, core::ValueInput* thinExtrudeWallThicknessOne, ThinExtrudeWallLocation thinExtrudeWallLocationTwo, core::ValueInput* thinExtrudeWallThicknessTwo) = 0; virtual ThinExtrudeWallLocation thinExtrudeWallLocationOne_raw() const = 0; virtual bool thinExtrudeWallLocationOne_raw(ThinExtrudeWallLocation value) = 0; virtual ThinExtrudeWallLocation thinExtrudeWallLocationTwo_raw() const = 0; virtual bool thinExtrudeWallLocationTwo_raw(ThinExtrudeWallLocation value) = 0; virtual core::ValueInput* thinExtrudeWallThicknessOne_raw() const = 0; virtual bool thinExtrudeWallThicknessOne_raw(core::ValueInput* value) = 0; virtual core::ValueInput* thinExtrudeWallThicknessTwo_raw() const = 0; virtual bool thinExtrudeWallThicknessTwo_raw(core::ValueInput* value) = 0; }; // Inline wrappers inline core::Ptr ExtrudeFeatureInput::profile() const { core::Ptr res = profile_raw(); return res; } inline bool ExtrudeFeatureInput::profile(const core::Ptr& value) { return profile_raw(value.get()); } inline FeatureOperations ExtrudeFeatureInput::operation() const { FeatureOperations res = operation_raw(); return res; } inline bool ExtrudeFeatureInput::operation(FeatureOperations value) { return operation_raw(value); } inline core::Ptr ExtrudeFeatureInput::taperAngle() const { core::Ptr res = taperAngle_raw(); return res; } inline bool ExtrudeFeatureInput::taperAngle(const core::Ptr& value) { return taperAngle_raw(value.get()); } inline bool ExtrudeFeatureInput::setDistanceExtent(bool isSymmetric, const core::Ptr& distance) { bool res = setDistanceExtent_raw(isSymmetric, distance.get()); return res; } inline bool ExtrudeFeatureInput::setTwoSidesDistanceExtent(const core::Ptr& distanceOne, const core::Ptr& distanceTwo) { bool res = setTwoSidesDistanceExtent_raw(distanceOne.get(), distanceTwo.get()); return res; } inline bool ExtrudeFeatureInput::setAllExtent(ExtentDirections direction) { bool res = setAllExtent_raw(direction); return res; } inline bool ExtrudeFeatureInput::setOneSideToExtent(const core::Ptr& toEntity, bool matchShape, const core::Ptr& directionHint) { bool res = setOneSideToExtent_raw(toEntity.get(), matchShape, directionHint.get()); return res; } inline bool ExtrudeFeatureInput::setTwoSidesToExtent(const core::Ptr& toEntityOne, const core::Ptr& toEntityTwo, bool matchShape) { bool res = setTwoSidesToExtent_raw(toEntityOne.get(), toEntityTwo.get(), matchShape); return res; } inline core::Ptr ExtrudeFeatureInput::creationOccurrence() const { core::Ptr res = creationOccurrence_raw(); return res; } inline bool ExtrudeFeatureInput::creationOccurrence(const core::Ptr& value) { return creationOccurrence_raw(value.get()); } inline bool ExtrudeFeatureInput::isSolid() const { bool res = isSolid_raw(); return res; } inline bool ExtrudeFeatureInput::isSolid(bool value) { return isSolid_raw(value); } inline core::Ptr ExtrudeFeatureInput::targetBaseFeature() const { core::Ptr res = targetBaseFeature_raw(); return res; } inline bool ExtrudeFeatureInput::targetBaseFeature(const core::Ptr& value) { return targetBaseFeature_raw(value.get()); } inline core::Ptr ExtrudeFeatureInput::startExtent() const { core::Ptr res = startExtent_raw(); return res; } inline bool ExtrudeFeatureInput::startExtent(const core::Ptr& value) { return startExtent_raw(value.get()); } inline bool ExtrudeFeatureInput::setOneSideExtent(const core::Ptr& extent, ExtentDirections direction, const core::Ptr& taperAngle) { bool res = setOneSideExtent_raw(extent.get(), direction, taperAngle.get()); return res; } inline bool ExtrudeFeatureInput::setTwoSidesExtent(const core::Ptr& sideOneExtent, const core::Ptr& sideTwoExtent, const core::Ptr& sideOneTaperAngle, const core::Ptr& sideTwoTaperAngle) { bool res = setTwoSidesExtent_raw(sideOneExtent.get(), sideTwoExtent.get(), sideOneTaperAngle.get(), sideTwoTaperAngle.get()); return res; } inline bool ExtrudeFeatureInput::setSymmetricExtent(const core::Ptr& distance, bool isFullLength, const core::Ptr& taperAngle) { bool res = setSymmetricExtent_raw(distance.get(), isFullLength, taperAngle.get()); return res; } inline core::Ptr ExtrudeFeatureInput::extentOne() const { core::Ptr res = extentOne_raw(); return res; } inline core::Ptr ExtrudeFeatureInput::extentTwo() const { core::Ptr res = extentTwo_raw(); return res; } inline core::Ptr ExtrudeFeatureInput::taperAngleOne() const { core::Ptr res = taperAngleOne_raw(); return res; } inline core::Ptr ExtrudeFeatureInput::taperAngleTwo() const { core::Ptr res = taperAngleTwo_raw(); return res; } inline bool ExtrudeFeatureInput::hasTwoExtents() const { bool res = hasTwoExtents_raw(); return res; } inline std::vector> ExtrudeFeatureInput::participantBodies() const { std::vector> res; size_t s; BRepBody** p= participantBodies_raw(s); if(p) { res.assign(p, p+s); core::DeallocateArray(p); } return res; } inline bool ExtrudeFeatureInput::participantBodies(const std::vector>& value) { BRepBody** value_ = new BRepBody*[value.size()]; for(size_t i=0; i& thinExtrudeWallThicknessOne, ThinExtrudeWallLocation thinExtrudeWallLocationTwo, const core::Ptr& thinExtrudeWallThicknessTwo) { bool res = setThinExtrude_raw(thinExtrudeWallLocationOne, thinExtrudeWallThicknessOne.get(), thinExtrudeWallLocationTwo, thinExtrudeWallThicknessTwo.get()); return res; } inline ThinExtrudeWallLocation ExtrudeFeatureInput::thinExtrudeWallLocationOne() const { ThinExtrudeWallLocation res = thinExtrudeWallLocationOne_raw(); return res; } inline bool ExtrudeFeatureInput::thinExtrudeWallLocationOne(ThinExtrudeWallLocation value) { return thinExtrudeWallLocationOne_raw(value); } inline ThinExtrudeWallLocation ExtrudeFeatureInput::thinExtrudeWallLocationTwo() const { ThinExtrudeWallLocation res = thinExtrudeWallLocationTwo_raw(); return res; } inline bool ExtrudeFeatureInput::thinExtrudeWallLocationTwo(ThinExtrudeWallLocation value) { return thinExtrudeWallLocationTwo_raw(value); } inline core::Ptr ExtrudeFeatureInput::thinExtrudeWallThicknessOne() const { core::Ptr res = thinExtrudeWallThicknessOne_raw(); return res; } inline bool ExtrudeFeatureInput::thinExtrudeWallThicknessOne(const core::Ptr& value) { return thinExtrudeWallThicknessOne_raw(value.get()); } inline core::Ptr ExtrudeFeatureInput::thinExtrudeWallThicknessTwo() const { core::Ptr res = thinExtrudeWallThicknessTwo_raw(); return res; } inline bool ExtrudeFeatureInput::thinExtrudeWallThicknessTwo(const core::Ptr& value) { return thinExtrudeWallThicknessTwo_raw(value.get()); } }// namespace fusion }// namespace adsk #undef ADSK_FUSION_EXTRUDEFEATUREINPUT_API