#include <Core/Application/Application.h>
#include <Core/Application/Documents.h>
#include <Core/Application/Document.h>
#include <Core/Application/Product.h>
#include <Core/Application/ObjectCollection.h>
#include <Core/Application/ValueInput.h>
#include <Core/Geometry/Point3D.h>
#include <Fusion/Components/Component.h>
#include <Fusion/Construction/ConstructionPlane.h>
#include <Fusion/BRep/BRepBodies.h>
#include <Fusion/BRep/BRepBody.h>
#include <Fusion/BRep/BRepEdges.h>
#include <Fusion/BRep/BRepEdge.h>
#include <Fusion/Features/Features.h>
#include <Fusion/Features/ExtrudeFeature.h>
#include <Fusion/Features/ExtrudeFeatures.h>
#include <Fusion/Features/ExtrudeFeatureInput.h>
#include <Fusion/Features/Path.h>
#include <Fusion/Features/RuledSurfaceFeatures.h>
#include <Fusion/Features/RuledSurfaceFeatureInput.h>
#include <Fusion/Features/RuledSurfaceFeature.h>
#include <Fusion/Fusion/Design.h>
#include <Fusion/Sketch/Sketch.h>
#include <Fusion/Sketch/Sketches.h>
#include <Fusion/Sketch/SketchCurves.h>
#include <Fusion/Sketch/SketchLines.h>
#include <Fusion/Sketch/SketchLine.h>
#include <Fusion/Sketch/Profile.h>
#include <Fusion/Sketch/Profiles.h>
using namespace adsk::core;
using namespace adsk::fusion;
Ptr<UserInterface> ui;
extern "C" XI_EXPORT bool run(const char* context)
{
Ptr<Application> app = Application::get();
if (!app)
return false;
ui = app->userInterface();
if (!ui)
return false;
Ptr<Documents> documents = app->documents();
if (!documents)
return false;
Ptr<Document> doc = documents->add(DocumentTypes::FusionDesignDocumentType);
if (!doc)
return false;
Ptr<Product> product = app->activeProduct();
if (!product)
return false;
Ptr<Design> design = product;
if (!design)
return false;
// Get the root component of the active design
Ptr<Component> rootComp = design->rootComponent();
if (!rootComp)
return false;
// Get ruled surfaces features
Ptr<Features> feats = rootComp->features();
if (!feats)
return false;
Ptr<RuledSurfaceFeatures> ruledSurfaces = feats->ruledSurfaceFeatures();
if (!ruledSurfaces)
return false;
// Create sketch line on the xz plane.
Ptr<Sketches> sketches = rootComp->sketches();
if (!sketches)
return false;
Ptr<Sketch> sketch = sketches->add(rootComp->xZConstructionPlane());
if (!sketch)
return false;
Ptr<SketchCurves> sketchCurves = sketch->sketchCurves();
if (!sketchCurves)
return false;
Ptr<SketchLines> sketchLines = sketchCurves->sketchLines();
if (!sketchLines)
return false;
Ptr<Point3D> startPoint = Point3D::create(0, 0, 0);
Ptr<Point3D> endPoint = Point3D::create(1.0, 0, 0);
Ptr<SketchLine> sketchLine = sketchLines->addByTwoPoints(startPoint, endPoint);
// Create a open profile.
Ptr<Profile> openProfile = rootComp->createOpenProfile(sketchLine);
// Create an extrusion input.
Ptr<Features> features = rootComp->features();
if (!features)
return false;
Ptr<ExtrudeFeatures> extrudes = features->extrudeFeatures();
if (!extrudes)
return false;
Ptr<ExtrudeFeatureInput> extrudeInput =
extrudes->createInput(openProfile, FeatureOperations::NewBodyFeatureOperation);
if (!extrudeInput)
return false;
extrudeInput->isSolid(false);
// Define the extent.
Ptr<ValueInput> distanceExtrusion = ValueInput::createByReal(1.0);
extrudeInput->setDistanceExtent(false, distanceExtrusion);
// Create the extrusion.
Ptr<ExtrudeFeature> extrude = extrudes->add(extrudeInput);
if (!extrude)
return false;
Ptr<BRepBodies> bodies = extrude->bodies();
if (!bodies)
return false;
Ptr<BRepBody> body = bodies->item(0);
// Get an edge from surface, and add it to object collection.
Ptr<BRepEdges> edges = body->edges();
if (!edges)
return false;
Ptr<BRepEdge> edge = edges->item(0);
Ptr<ObjectCollection> objCol = ObjectCollection::create();
objCol->add(edge);
Ptr<Path> profile = Path::create(objCol, ChainedCurveOptions::connectedChainedCurves);
// Create a ruled surface input.
Ptr<ValueInput> distance = ValueInput::createByReal(1.0);
Ptr<ValueInput> angle = ValueInput::createByReal(0.0);
extrudeInput->setDistanceExtent(false, distance);
Ptr<RuledSurfaceFeatureInput> ruledSurfaceInput =
ruledSurfaces->createInput(profile, distance, angle, NormalRuledSurfaceType);
if (!ruledSurfaceInput)
return false;
// Create the ruled surface
Ptr<RuledSurfaceFeature> ruledSurface = ruledSurfaces->add(ruledSurfaceInput);
if (!ruledSurface)
return false;
bodies = ruledSurface->bodies();
if (!bodies)
return false;
body = bodies->item(0);
if (!body)
return false;
body->name("RuledSurfaceFromEdge");
return true;
}
/**
* Ruled Surface Feature API Sample
* Demonstrates creating a new ruled surface feature.
*/
import { adsk } from '@adsk/fusion';
function run() {
// Get the Fusion API's application object
const app = adsk.core.Application.get();
if (!app) throw Error("No adsk.core.Application.");
// Get the user interface
const ui = app.userInterface;
if (!ui) throw Error("No adsk.core.UserInterface.");
const documents = app.documents;
if (!documents) throw Error("No documents.");
const doc = documents.add(adsk.core.DocumentTypes.FusionDesignDocumentType);
if (!doc) throw Error("No document.");
const product = app.activeProduct;
if (!product) throw Error("No active product.");
const design = product as adsk.fusion.Design;
if (!design) throw Error("No active design.");
// Get the root component of the active design
const rootComp = design.rootComponent;
if (!rootComp) throw Error("No root component.");
// Get ruled surfaces features
const feats = rootComp.features;
if (!feats) throw Error("No features.");
const ruledSurfaces = feats.ruledSurfaceFeatures;
if (!ruledSurfaces) throw Error("No ruled surfaces.");
// Create sketch line on the xz plane
const sketches = rootComp.sketches;
if (!sketches) throw Error("No sketches.");
const sketch = sketches.add(rootComp.xZConstructionPlane);
if (!sketch) throw Error("No sketch.");
const sketchCurves = sketch.sketchCurves;
if (!sketchCurves) throw Error("No sketch curves.");
const sketchLines = sketchCurves.sketchLines;
if (!sketchLines) throw Error("No sketch lines.");
const startPoint = adsk.core.Point3D.create(0, 0, 0);
const endPoint = adsk.core.Point3D.create(1.0, 0, 0);
const sketchLine = sketchLines.addByTwoPoints(startPoint, endPoint);
// Create an open profile
const openProfile = rootComp.createOpenProfile(sketchLine);
// Create an extrusion input
const features = rootComp.features;
if (!features) throw Error("No features.");
const extrudes = features.extrudeFeatures;
if (!extrudes) throw Error("No extrudes.");
const extrudeInput = extrudes.createInput(openProfile, adsk.fusion.FeatureOperations.NewBodyFeatureOperation);
if (!extrudeInput) throw Error("No extrude input.");
extrudeInput.isSolid = false;
const distance = adsk.core.ValueInput.createByReal(1.0)
const distanceExtentDef = adsk.fusion.DistanceExtentDefinition.create(distance)
extrudeInput.setOneSideExtent(distanceExtentDef, adsk.fusion.ExtentDirections.PositiveExtentDirection)
// Create the extrusion
const extrude = extrudes.add(extrudeInput);
if (!extrude) throw Error("No extrude.");
const bodies = extrude.bodies;
if (!bodies) throw Error("No bodies.");
const body = bodies.item(0);
// Get an edge from surface, and add it to object collection
const edges = body.edges;
if (!edges) throw Error("No edges.");
const edge = edges.item(0);
const objCol = adsk.core.ObjectCollection.create();
objCol.add(edge);
const profile = adsk.fusion.Path.create(objCol, adsk.fusion.ChainedCurveOptions.connectedChainedCurves);
// Create a ruled surface input
const angle = adsk.core.ValueInput.createByReal(0.0);
const ruledSurfaceInput = ruledSurfaces.createInput(profile, distance, angle, adsk.fusion.NormalRuledSurfaceType);
if (!ruledSurfaceInput) throw Error("No ruled surface input.");
// Create the ruled surface
const ruledSurface = ruledSurfaces.add(ruledSurfaceInput);
if (!ruledSurface) throw Error("No ruled surface.");
const ruledBodies = ruledSurface.bodies;
if (!ruledBodies) throw Error("No ruled bodies.");
const ruledBody = ruledBodies.item(0);
if (!ruledBody) throw Error("No ruled body.");
ruledBody.name = "RuledSurfaceFromEdge";
}
run();