diff options
Diffstat (limited to 'docs/scene')
16 files changed, 403 insertions, 14 deletions
diff --git a/docs/scene/images/components_interacting_with_scene.jpg b/docs/scene/images/components_interacting_with_scene.jpg Binary files differnew file mode 100644 index 0000000000..34e34e25af --- /dev/null +++ b/docs/scene/images/components_interacting_with_scene.jpg diff --git a/docs/scene/images/components_interacting_with_scene.png b/docs/scene/images/components_interacting_with_scene.png Binary files differnew file mode 100644 index 0000000000..a01a138811 --- /dev/null +++ b/docs/scene/images/components_interacting_with_scene.png diff --git a/docs/scene/images/layer_data_scene_node.jpg b/docs/scene/images/layer_data_scene_node.jpg Binary files differnew file mode 100644 index 0000000000..313b409ddf --- /dev/null +++ b/docs/scene/images/layer_data_scene_node.jpg diff --git a/docs/scene/images/mirror_tool.jpg b/docs/scene/images/mirror_tool.jpg Binary files differnew file mode 100644 index 0000000000..e3d485008e --- /dev/null +++ b/docs/scene/images/mirror_tool.jpg diff --git a/docs/scene/images/per_objectsettings_tool.jpg b/docs/scene/images/per_objectsettings_tool.jpg Binary files differnew file mode 100644 index 0000000000..0634177d4b --- /dev/null +++ b/docs/scene/images/per_objectsettings_tool.jpg diff --git a/docs/scene/images/rotate_tool.jpg b/docs/scene/images/rotate_tool.jpg Binary files differnew file mode 100644 index 0000000000..4e10569678 --- /dev/null +++ b/docs/scene/images/rotate_tool.jpg diff --git a/docs/scene/images/scale_tool.jpg b/docs/scene/images/scale_tool.jpg Binary files differnew file mode 100644 index 0000000000..c413aa0caf --- /dev/null +++ b/docs/scene/images/scale_tool.jpg diff --git a/docs/scene/images/scene_example.jpg b/docs/scene/images/scene_example.jpg Binary files differnew file mode 100644 index 0000000000..5e787c4420 --- /dev/null +++ b/docs/scene/images/scene_example.jpg diff --git a/docs/scene/images/scene_example_scene_graph.jpg b/docs/scene/images/scene_example_scene_graph.jpg Binary files differnew file mode 100644 index 0000000000..da8c10169d --- /dev/null +++ b/docs/scene/images/scene_example_scene_graph.jpg diff --git a/docs/scene/images/selection_tool.jpg b/docs/scene/images/selection_tool.jpg Binary files differnew file mode 100644 index 0000000000..c9058de526 --- /dev/null +++ b/docs/scene/images/selection_tool.jpg diff --git a/docs/scene/images/support_blocker_tool.jpg b/docs/scene/images/support_blocker_tool.jpg Binary files differnew file mode 100644 index 0000000000..bdc4b118c2 --- /dev/null +++ b/docs/scene/images/support_blocker_tool.jpg diff --git a/docs/scene/images/tools_tool-handles_class_diagram.jpg b/docs/scene/images/tools_tool-handles_class_diagram.jpg Binary files differnew file mode 100644 index 0000000000..cd58fad066 --- /dev/null +++ b/docs/scene/images/tools_tool-handles_class_diagram.jpg diff --git a/docs/scene/images/translate_tool.jpg b/docs/scene/images/translate_tool.jpg Binary files differnew file mode 100644 index 0000000000..80886a7f17 --- /dev/null +++ b/docs/scene/images/translate_tool.jpg diff --git a/docs/scene/operations.md b/docs/scene/operations.md new file mode 100644 index 0000000000..fe625514be --- /dev/null +++ b/docs/scene/operations.md @@ -0,0 +1,113 @@ +# Operations and the OperationStack + +Cura supports an operation stack. The `OperationStack` class maintains a history of the operations performed in Cura, which allows for undo and redo actions. Every operation registers itself in the stack. The OperationStuck supports the following functions: + + * `push(operation)`: Pushes an operation in the stack and applies the operation. This function is called when an operation pushes itself in the stack. + * `undo()`: Reverses the actions performed by the last operation and reduces the current index of the stack. + * `redo()`: Applies the actions performed by the next operation in the stack and increments the current index of the stack. + * `getOperations()`: Returns a list of all the operations that are currently inside the OperationStack + * `canUndo()`: Indicates whether the index of the operation stack has reached the bottom of the stack, which means that there are no more operations to be undone. + * `canRedo()`: Indicates whether the index of the operation stack has reached the top of the stack, which means that there are no more operations to be redone. + +**Note 1:** When consecutive operations are performed very quickly after each other, they are merged together at the top of the stack. This action ensures that these minor operation will be undone with one Undo keystroke (e.g. when moving the object around and you press and release the left mouse button really fast, it is considered as one move operation). + +**Note 2:** When an operation is pushed in the middle of the stack, all operations above it are removed from the stack. This ensures that there won't be any "history branches" created. + +### Operations + +Every action that happens in the scene and affects one or multiple models is associated with a subclass of the `Operation` class and is it added to the `OperationStack`. The subclassed operations that can be found in Cura (excluding the ones from downloadable plugins) are the following: + + * [GroupedOperation](#groupedoperation) + * [AddSceneNodeOperation](#addscenenodeoperation) + * [RemoveSceneNodeOperation](#removescenenodeoperation) + * [SetParentOperation](#setparentoperation) + * [SetTransformOperation](#settransformoperation) + * [SetObjectExtruderOperation](#setobjectextruderoperation) + * [GravityOperation](#gravityoperation) + * [PlatformPhysicsOperation](#platformphysicsoperation) + * [TranslateOperation](#translateoperation) + * [ScaleOperation](#scaleoperation) + * [RotateOperation](#rotateoperation) + * [MirrorOperation](#mirroroperation) + * [LayFlatOperation](#layflatoperation) + * [SetBuildPlateNumberOperation]() + +### GroupedOperation + +The `GroupedOperation` is an operation that groups several other operations together. The intent of this operation is to hide an underlying chain of operations from the user if they correspond to only one interaction with the user, such as an operation applied to multiple scene nodes or a re-arrangement of multiple items in the scene. + +Once a `GroupedOperation` is pushed into the stack, it applies all of its children operations in one go. Similarly, when it is undone, it reverses all its children operations at once. + + +### AddSceneNodeOperation + +The `AddSceneNodeOperation` is added to the stack whenever a mesh is loaded inside the `Scene`, either by a `FileReader` or by inserting a [Support Blocker](tools.md#supporteraser-tool) in an object. + +### RemoveSceneNodeOperation + +The `RemoveSceneNodeOperation` is added to the stack whenever a mesh is removed from the Scene by the user or when the user requests to clear the build plate (_Ctrl+D_). + +### SetParentOperation + +The `SetParentOperation` changes the parent of a node. It is primarily used when grouping (the group node is set as the nodes' parent) and ungrouping (the group's children's parent is set to the group's parent before the group node is deleted), or when a SupportEraser node is added to the scene (to set the selected object as the Eraser's parent). + +### SetTransformOperation + +The `SetTransformOperation` translates, rotates, and scales a node all at once. This operation accepts a transformation matrix, an orientation matrix, and a scale matrix, and it is used by the _"Reset All Model Positions"_ and _"Reset All Model Transformations"_ options in the right-click (context) menu. + +### SetObjectExtruderOperation + +This operation is used to set the extruder with which a certain object should be printed with. It adds a [SettingOverrideDecorator](scene.md#settingoverridedecorator) to the object (if it doesn't have any) and then sets the extruder number via the decoration function `node.callDecoration("setActiveExtruder", extruder_id)`. + +### GravityOperation + +The `GravityOperation` moves a scene node down to 0 on the y-axis. It is currently used by the _"Lay flat"_ and _"Select face to align to the build plate"_ actions of the `RotationTool` to ensure that the object will end up touching the build plate after the corresponding rotation operations have be done. + +### PlatformPhysicsOperation + +The `PlatformPhysicsOperation` is generated by the `PlatformPhysics` class and it is associated with the preferences _"Ensure models are kept apart"_ and _"Automatically drop models to the build plate"_. If any of these preferences is set to true, the `PlatformPhysics` class periodically checks to make sure that the two conditions are met and if not, it calculates the move vector for each of the nodes that will satisfy the conditions. + +Once the move vectors have been computed, they are applied to the nodes through consecutive `PlatformPhysicsOperations`, whose job is to use the `translate` function on the nodes. + +**Note:** When there are multiple nodes, multiple `PlatformPhysicsOperations` may be generated (all models may be moved to ensure they are kept apart). These operations eventually get merged together by the `OperationStack` due to the fact that the individual operations are applied very fast one after the other. + +### TranslateOperation + +The `TranslateOperation` applies a linear transformation on a node, moving the node in the scene. This operation is primarily linked to the [TranslateTool](tools.md#translatetool) but it is also used in other places around Cura, such as arranging objects on the build plate (Ctrl+R) and centering an object to the build plate (via the right-click context menu's _"Center Selected Model"_ option). + +When an object is moved using the move tool handles, multiple translate operations are generated to make sure that the object is rendered properly while it is moved. These translate operations are merged together once the user releases the tool handle. + +**Note:** Some functionalities may move (translate) nodes without generating a TranslateOperation (such as when a model with is imported from a 3mf into a certain position). This ensures that the moving of the object cannot be accidentally undone by the user. + +### ScaleOperation + +The `ScaleOperation` scales the selected scene node uniformly or non-uniformly. This operation is primarily generated by the [ScaleTool](tools.md#scaletool). + +When an object is scaled using the scale tool handles, multiple scale operations are generated to make sure that the object is rendered properly while it is being resized. These scale operations are merged together once the user releases the tool handle. + +**Note:** When the _"Scale extremely small models"_ or the _"Scale large models"_ preferences are enabled the model is scaled when it is inserted into the build plate but it **DOES NOT** generate a `ScaleOperation`. This ensures that Cura doesn't register the scaling as an action that can be undone and the user doesn't accidentally end up with a very big or very small model. + + +### RotateOperation + +The `RotateOperation` rotates the selected scene node(s) according to a given rotation quaternion and, optionally, around a given point. This operation is primarily generated by the [RotationTool](tools.md#rotatetool). It is also used by the arrange algorithm, which may rotate some models to fit them in the build plate. + +When an object is rotated using the rotate tool handles, multiple rotate operations are generated to make sure that the object is rendered properly while it is being rotated. These operations are merged together once the user releases the tool handle. + +### MirrorOperation + +The `MirrorOperation` mirrors the selected object. It is primarily associated with the [MirrorTool](tools.md#mirrortool) and allows for mirroring the object in a certain direction, using the `MirrorToolHandles`. + +The `MirrorOperation` accepts a transformation matrix that should only define values on the diagonal of the matrix, and only the values 1 or -1. It allows for mirroring around the center of the object or around the axis origin. The latter isn't used that often. + +### LayFlatOperation + +The `LayFlatOperation` computes some orientation to hopefully lay the object flat on the build plate. It is generated by the `layFlat()` function of the [RotateTool](tools.md#rotatetool). Contrary to the other operations, the `LayFlatOperation` is computed in a separate thread through the `LayFlatJob` since it can be quite computationally expensive. + + +### SetBuildPlateNumberOperation + +The `SetBuildPlateNumberOperation` is linked to a legacy feature which allowed the user to have multiple build plates open in Cura at the same time. With this operation it was possible to transfer a node to another build plate through the node's [BuildPlateDecorator](scene.md#buildplatedecorator) by calling the decoration `node.callDecoration("setBuildPlateNumber", new_build_plate_nr)`. + +**Note:** Changing the active build plate is a disabled feature in Cura and it is intended to be completely removed (internal ticket: CURA-4975), along with the `SetBuildPlateNumberOperation`. + diff --git a/docs/scene/scene.md b/docs/scene/scene.md index 5539df4a67..265554264c 100644 --- a/docs/scene/scene.md +++ b/docs/scene/scene.md @@ -8,19 +8,209 @@ Cura's scene graph is a mere tree data structure. This tree contains all scene n The main idea behind the scene tree is that each scene node has a transformation applied to it. The scene nodes can be nested beneath other scene nodes. The transformation of the parents is then also applied to the children. This way you can have scene nodes grouped together and transform the group as a whole. Since the transformations are all linear, this ensures that the elements of this group stay in the same relative position and orientation. It will look as if the whole group is a single object. This idea is very common for games where objects are often composed of multiple 3D models but need to move together as a whole. For Cura it is used to group objects together and to transform the collision area correctly. +Class Diagram +---- + +The following class diagram depicts the classes that interact with the Scene + + + +The scene lives in the Controller of the Application, and it is primarily interacting with SceneNode objects, which are the components of the Scene Graph. + + A Typical Scene ---- -Cura's scene has a few nodes that are always present, and a few nodes that are repeated for every object that the user loads onto their build plate. To give an idea of how a scene normally looks, this is an overview of a typical scene tree for Cura. - -* Root - * Camera - * [Build volume](build_volume.md) - * Platform - * Object 1 - * Group 1 - * Object 2 - * Object 3 - * Object 1 convex hull node - * Object 2 convex hull node - * Object 3 convex hull node - * Group 1 convex hull node
\ No newline at end of file +Cura's scene has a few nodes that are always present, and a few nodes that are repeated for every object that the user loads onto their build plate. The root of the scene graph is a SceneNode that lives inside the Scene and contains all the other children SceneNodes of the scene. Typically, inside the root you can find the SceneNodes that are always loaded (the Cameras, the [BuildVolume](build_volume.md), and the Platform), the objects that are loaded on the platform, and finally a ConvexHullNode for each object and each group of objects in the Scene. + +Let's take the following example Scene: + + + +The scene graph in this case is the following: + + + + +**Note 1:** The Platform is actually a child of the BuildVolume. + +**Note 2:** The ConvexHullNodes are not actually named after the object they decorate. Their names are used in the image to convey how the ConvexHullNodes are related to the objects in the scene. + +**Note 3:** The CuraSceneNode that holds the layer data (inside the BuildVolume) is created and destroyed according to the availability of sliced layer data provided by the CuraEngine. See the [LayerDataDecorator](#layerdatadecorator) for more information. + +Accessing SceneNodes in the Scene +---- + +SceneNodes can be accessed using a `BreadthFirstIterator` or a `DepthFirstIterator`. Each iterator traverses the scene graph and returns a Python iterator, which yields all the SceneNodes and their children. + +``` python +for node in BreadthFirstIterator(scene.getRoot()): + # do stuff with the node +``` + +Example result when iterating the above scene graph: + +```python +[i for i in BreadthFirstIterator(CuraApplication.getInstance().getController().getScene().getRoot()] +``` + * 00 = {SceneNode} <SceneNode object: 'Root'> + * 01 = {BuildVolume} <BuildVolume object '0x2e35dbce108'> + * 02 = {Camera} <Camera object: '3d'> + * 03 = {CuraSceneNode} <CuraSceneNode object: 'Torus.stl'> + * 04 = {CuraSceneNode} <CuraSceneNode object: 'Group #1'> + * 05 = {Camera} <Camera object: 'snapshot'> + * 06 = {CuraSceneNode} <CuraSceneNode object: 'Star.stl'> + * 07 = {ConvexHullNode} <ConvexHullNode object: '0x2e3000def08'> + * 08 = {ConvexHullNode} <ConvexHullNode object: '0x2e36861bd88'> + * 09 = {ConvexHullNode} <ConvexHullNode object: '0x2e3000bd4c8'> + * 10 = {ConvexHullNode} <ConvexHullNode object: '0x2e35fbb62c8'> + * 11 = {ConvexHullNode} <ConvexHullNode object: '0x2e3000a0648'> + * 12 = {ConvexHullNode} <ConvexHullNode object: '0x2e30019d0c8'> + * 13 = {ConvexHullNode} <ConvexHullNode object: '0x2e3001a2dc8'> + * 14 = {Platform} <Platform object '0x2e35a001948'> + * 15 = {CuraSceneNode} <CuraSceneNode object: 'Group #2'> + * 16 = {CuraSceneNode} <CuraSceneNode object: 'Sphere.stl'> + * 17 = {CuraSceneNode} <CuraSceneNode object: 'Cylinder.stl'> + * 18 = {CuraSceneNode} <CuraSceneNode object: 'Cube.stl'> + +SceneNodeDecorators +---- + +SceneNodeDecorators are decorators that can be added to the nodes of the scene to provide them with additional functions. + +Cura provides the following classes derived from the SceneNodeDecorator class: + 1. [GroupDecorator](#groupdecorator) + 2. [ConvexHullDecorator](#convexhulldecorator) + 3. [SettingOverrideDecorator](#settingoverridedecorator) + 4. [SliceableObjectDecorator](#sliceableobjectdecorator) + 5. [LayerDataDecorator](#layerdatadecorator) + 6. [ZOffsetDecorator](#zoffsetdecorator) + 7. [BlockSlicingDecorator](#blockslicingdecorator) + 8. [GCodeListDecorator](#gcodelistdecorator) + 9. [BuildPlateDecorator](#buildplatedecorator) + +GroupDecorator +---- + +Whenever objects on the build plate are grouped together, a new node is added in the scene as the parent of the grouped objects. Group nodes can be identified when traversing the SceneGraph by running the following: + +```python +node.callDecoration("isGroup") == True +``` + +Group nodes decorated by GroupDecorators are added in the scene either by reading project files which contain grouped objects, or when the user selects multiple objects and groups them together (Ctrl + G). + +Group nodes that are left with only one child are removed from the scene, making their only child a child of the group's parent. In addition, group nodes without any remaining children are removed from the scene. + +ConvexHullDecorator +---- + +As seen in the scene graph of the scene example, each CuraSceneNode that represents an object on the build plate is linked to a ConvexHullNode which is rendered as the object's shadow on the build plate. The ConvexHullDecorator is the link between these two nodes. + +In essence, the CuraSceneNode has a ConvexHullDecorator which points to the ConvexHullNode of the object. The data of the object's convex hull can be accessed via + +```python +convex_hull_polygon = object_node.callDecoration("getConvexHull") +``` + +The ConvexHullDecorator also provides convex hulls that include the head, the fans, and the adhesion of the object. These are primarily used and rendered when One-at-a-time mode is activated. + +For more information on the functions added to the node by this decorator, visit the [ConvexHullDecorator.py](https://github.com/Ultimaker/Cura/blob/master/cura/Scene/ConvexHullDecorator.py). + +SettingOverrideDecorator +---- + +SettingOverrideDecorators are primarily used for modifier meshes such as support meshes, cutting meshes, infill meshes, and anti-overhang meshes. When a user converts an object to a modifier mesh, the object's node is decorated by a SettingOverrideDecorator. This decorator adds a PerObjectContainerStack to the CuraSceneNode, which allows the user to modify the settings of the specific model. + +For more information on the functions added to the node by this decorator, visit the [SettingOverrideDecorator.py](https://github.com/Ultimaker/Cura/blob/master/cura/Settings/SettingOverrideDecorator.py). + + +SliceableObjectDecorator +---- + +This is a convenience decorator that allows us to easily identify the nodes which can be sliced. All **individual** objects (meshes) added to the build plate receive this decorator, apart from the nodes loaded from GCode files (.gcode, .g, .gz, .ufp). + +The SceneNodes that do not receive this decorator are: + + - Cameras + - BuildVolume + - Platform + - ConvexHullNodes + - CuraSceneNodes that serve as group nodes (these have a GroupDecorator instead) + - The CuraSceneNode that serves as the layer data node + - ToolHandles + - NozzleNode + - Nodes that contain GCode data. See the [BlockSlicingDecorator](#blockslicingdecorator) for more information on that. + +This decorator provides the following function to the node: + +```python +node.callDecoration("isSliceable") +``` + +LayerDataDecorator +---- + +Once the Slicing has completed and the CuraEngine has returned the slicing data, Cura creates a CuraSceneNode inside the BuildVolume which is decorated by a LayerDataDecorator. This decorator holds the layer data of the scene. + + + +The layer data can be accessed through the function given to the aforementioned CuraSceneNode by the LayerDataDecorator: + +```python +node.callDecoration("getLayerData") +``` + +This CuraSceneNode is created once Cura has completed processing the Layer data (after the user clicks on the Preview tab after slicing). The CuraSceneNode then is destroyed once any action that changes the Scene occurs (e.g. if the user moves/rotates/scales an object or changes a setting value), indicating that the layer data is no longer available. When that happens, the "Slice" button becomes available again. + +ZOffsetDecorator +---- + +The ZOffsetDecorator is added to an object in the scene when that object is moved below the build plate. It is primarily used when the "Automatically drop models to the build plate" preference is enabled, in order to make sure that the GravityOperation, which drops the mode on the build plate, is not applied when the object is moved under the build plate. + +The amount the object is moved under the build plate can be retrieved by calling the "getZOffset" decoration on the node: + +```python +z_offset = node.callDecoration("getZOffset") +``` + +The ZOffsetDecorator is removed from the node when the node is move above the build plate. + +BlockSlicingDecorator +---- + +The BlockSlicingDecorator is the opposite of the SliceableObjectDecorator. It is added on objects loaded on the scene which should not be sliced. This decorator is primarily added on objects loaded from ".gcode", ".ufp", ".g", and ".gz" files. Such an object already contains all the slice information and therefore should not allow Cura to slice it. + +If an object with a BlockSlicingDecorator appears in the scene, the backend (CuraEngine) and the print setup (changing print settings) become disabled, considering that G-code files cannot be modified. + +The BlockSlicingDecorator adds the following decoration function to the node: + +```python +node.callDecoration("isBlockSlicing") +``` + +GCodeListDecorator +---- + +The GCodeListDecorator is also added only when a file containing GCode is loaded in the scene. It's purpose is to hold a list of all the GCode data of the loaded object. +The GCode list data is stored in the scene's gcode_dict attribute which then is used in other places in the Cura code, e.g. to provide the GCode to the GCodeWriter or to the PostProcessingPlugin. + +The GCode data becomes available by calling the "getGCodeList" decoration of the node: + +```python +gcode_list = node.callDecoration("getGCodeList") +``` + +The CuraSceneNode with the GCodeListDecorator is destroyed when another object or project file is loaded in the Scene. + +BuildPlateDecorator +---- + +The BuildPlateDecorator is added to all the CuraSceneNodes. This decorator is linked to a legacy feature which allowed the user to have multiple build plates open in Cura at the same time. With this decorator it was possible to determine which nodes are present on each build plate, and therefore, which objects should be visible in the currently active build plate. It indicates the number of the build plate this scene node belongs to, which currently is always the build plate -1. + +This decorator provides a function to the node that returns the number of the build plate it belongs to: + +```python +node.callDecoration("getBuildPlateNumber") +``` + +**Note:** Changing the active build plate is a disabled feature in Cura and it is intended to be completely removed (internal ticket: CURA-4975). diff --git a/docs/scene/tools.md b/docs/scene/tools.md new file mode 100644 index 0000000000..0418bf4a97 --- /dev/null +++ b/docs/scene/tools.md @@ -0,0 +1,86 @@ +# Tools + +Tools are plugin objects which are used to manipulate or interact with the scene and the objects (node) in the scene. + + + +Tools live inside the Controller of the Application and may be associated with ToolHandles. Some of them interact with the scene as a whole (such as the Camera), while others interact with the objects (nodes) in the Scene (selection tool, rotate tool, scale tool etc.). The tools that are available in Cura (excluding the ones provided by downloadable plugins) are the following: + + * [CameraTool](#cameratool) + * [SelectionTool](#selectiontool) + * [TranslateTool](#translatetool) + * [ScaleTool](#scaletool) + * [RotateTool](#rotatetool) + * [MirrorTool](#mirrortool) + * [PerObjectSettingsTool](#perobjectsettingstool) + * [SupportEraserTool](#supporteraser) + +***** + +### CameraTool + +The CameraTool is the tool that allows the user to manipulate the Camera. It provides the functions of moving, zooming, and rotating the Camera. This tool does not contain a handle. + +### SelectionTool +This tool allows the user to select objects and groups of objects in the scene. The selected objects gain a blue outline and become available in the code through the Selection class. + + + +This tool does not contain a handle. + +### TranslateTool + +This tool allows the user to move the object around the build plate. The TranslateTool is activated once the user presses the Move icon in the tool sidebar or hits the shortcut (T) while an object is selected. + + + +The TranslateTool contains the TranslateToolHandle, which draws the arrow handles on the selected object(s). The TranslateTool generates TranslateOperations whenever the object is moved around the build plate. + + +### ScaleTool + +This tool allows the user to scale the selected object(s). The ScaleTool is activated once the user presses the Scale icon in the tool sidebar or hits the shortcut (S) while an object is selected. + + + +The ScaleTool contains the ScaleToolHandle, which draws the box handles on the selected object(s). The ScaleTool generates ScaleOperations whenever the object is scaled. + +### RotateTool + +This tool allows the user to rotate the selected object(s). The RotateTool is activated once the user presses the Rotate icon in the tool sidebar or hits the shortcut (R) while an object is selected. + + + +The RotateTool contains the RotateToolHandle, which draws the donuts (tori) and arrow handles on the selected object(s). The RotateTool generates RotateOperations whenever the object is rotated or if a face is selected to be laid flat on the build plate. It also contains the `layFlat()` action, which generates the [LayFlatOperation](operations.md#layflatoperation). + + +### MirrorTool + +This tool allows the user to mirror the selected object(s) in the required direction. The MirrorTool is activated once the user presses the Mirror icon in the tool sidebar or hits the shortcut (M) while an object is selected. + + + +The MirrorTool contains the MirrorToolHandle, which draws pyramid handles on the selected object(s). The MirrorTool generates MirrorOperations whenever the object is mirrored against an axis. + +### PerObjectSettingsTool + +This tool allows the user to change the mesh type of the object into one of the following: + + * Normal Model + * Print as support + * Modify settings for overlaps + - Infill mesh only + - Cutting mesh + * Don't support overlaps + + + +Contrary to other tools, this tool doesn't have any handles and it does not generate any operations. This means that once an object's type is changed it cannot be undone/redone using the OperationStack. This tool adds a [SettingOverrideDecorator](scene.md#settingoverridedecorator) on the object's node instead, which allows the user to change certain settings only for this mesh. + +### SupportEraser tool + +This tool allows the user to add support blockers on the selected model. The SupportEraserTool is activated once the user pressed the Support Blocker icon in the tool sidebar or hits the shortcut (E) while an object is selected. With this tool active, the user can add support blockers (cubes) on the object by clicking on various places on the selected mesh. + + + +The SupportEraser uses a GroupOperation to add a new CuraSceneNode (the eraser) in the scene and set the selected model as the parent of the eraser. This means that the addition of Erasers in the scene can be undone/redone. The SupportEraser does not have any tool handles.
\ No newline at end of file |
