def bottomFaceSelection(self) -> None:
selected_face = Selection.getSelectedFace()
if not selected_face:
Logger.log(
"e",
"Bottom face operation shouldn't have been called without a selected face."
)
return
original_node, face_id = selected_face
meshdata = original_node.getMeshDataTransformed()
if not meshdata or face_id < 0 or face_id > Selection.getMaxFaceSelectionId(
):
return
rotation_point, face_normal = meshdata.getFacePlane(face_id)
rotation_point_vector = Vector(rotation_point[0], rotation_point[1],
rotation_point[2])
face_normal_vector = Vector(face_normal[0], face_normal[1],
face_normal[2])
rotation_quaternion = Quaternion.rotationTo(
face_normal_vector.normalized(), Vector(0.0, -1.0, 0.0))
operation = GroupedOperation()
current_node = None # type: Optional[SceneNode]
for node in Selection.getAllSelectedObjects():
current_node = node
parent_node = current_node.getParent()
while parent_node and parent_node.callDecoration("isGroup"):
current_node = parent_node
parent_node = current_node.getParent()
if current_node is None:
return
rotate_operation = RotateOperation(current_node, rotation_quaternion,
rotation_point_vector)
operation.addOperation(rotate_operation)
operation.push()
def beginRendering(self):
scene = self.getController().getScene()
renderer = self.getRenderer()
if not self._extruders_model:
self._extruders_model = Application.getInstance(
).getExtrudersModel()
if not self._theme:
self._theme = Application.getInstance().getTheme()
if not self._enabled_shader:
self._enabled_shader = OpenGL.getInstance().createShaderProgram(
Resources.getPath(Resources.Shaders, "overhang.shader"))
self._enabled_shader.setUniformValue(
"u_overhangColor",
Color(*self._theme.getColor("model_overhang").getRgb()))
if not self._disabled_shader:
self._disabled_shader = OpenGL.getInstance().createShaderProgram(
Resources.getPath(Resources.Shaders, "striped.shader"))
self._disabled_shader.setUniformValue(
"u_diffuseColor1",
Color(*self._theme.getColor("model_unslicable").getRgb()))
self._disabled_shader.setUniformValue(
"u_diffuseColor2",
Color(*self._theme.getColor("model_unslicable_alt").getRgb()))
self._disabled_shader.setUniformValue("u_width", 50.0)
if not self._non_printing_shader:
self._non_printing_shader = OpenGL.getInstance(
).createShaderProgram(
Resources.getPath(Resources.Shaders,
"transparent_object.shader"))
self._non_printing_shader.setUniformValue(
"u_diffuseColor",
Color(*self._theme.getColor("model_non_printing").getRgb()))
self._non_printing_shader.setUniformValue("u_opacity", 0.6)
if not self._support_mesh_shader:
self._support_mesh_shader = OpenGL.getInstance(
).createShaderProgram(
Resources.getPath(Resources.Shaders, "striped.shader"))
self._support_mesh_shader.setUniformValue("u_vertical_stripes",
True)
self._support_mesh_shader.setUniformValue("u_width", 5.0)
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
if global_container_stack:
if Application.getInstance().getPreferences().getValue(
"view/show_overhang"):
# Make sure the overhang angle is valid before passing it to the shader
if self._support_angle is not None and self._support_angle >= 0 and self._support_angle <= 90:
self._enabled_shader.setUniformValue(
"u_overhangAngle",
math.cos(math.radians(90 - self._support_angle)))
else:
self._enabled_shader.setUniformValue(
"u_overhangAngle", math.cos(math.radians(0))
) #Overhang angle of 0 causes no area at all to be marked as overhang.
else:
self._enabled_shader.setUniformValue("u_overhangAngle",
math.cos(math.radians(0)))
for node in DepthFirstIterator(scene.getRoot()):
if not node.render(renderer):
if node.getMeshData() and node.isVisible(
) and not node.callDecoration("getLayerData"):
uniforms = {}
shade_factor = 1.0
per_mesh_stack = node.callDecoration("getStack")
extruder_index = node.callDecoration(
"getActiveExtruderPosition")
if extruder_index is None:
extruder_index = "0"
extruder_index = int(extruder_index)
# Use the support extruder instead of the active extruder if this is a support_mesh
if per_mesh_stack:
if per_mesh_stack.getProperty("support_mesh", "value"):
extruder_index = int(
global_container_stack.
getExtruderPositionValueWithDefault(
"support_extruder_nr"))
try:
material_color = self._extruders_model.getItem(
extruder_index)["color"]
except KeyError:
material_color = self._extruders_model.defaultColors[0]
if extruder_index != ExtruderManager.getInstance(
).activeExtruderIndex:
# Shade objects that are printed with the non-active extruder 25% darker
shade_factor = 0.6
try:
# Colors are passed as rgb hex strings (eg "#ffffff"), and the shader needs
# an rgba list of floats (eg [1.0, 1.0, 1.0, 1.0])
uniforms["diffuse_color"] = [
shade_factor * int(material_color[1:3], 16) / 255,
shade_factor * int(material_color[3:5], 16) / 255,
shade_factor * int(material_color[5:7], 16) / 255,
1.0
]
# Color the currently selected face-id.
face = Selection.getSelectedFace()
uniforms["selected_face"] = (
Selection.getMaxFaceSelectionId() +
1) if not face or node != face[0] else face[1]
except ValueError:
pass
if node.callDecoration("isNonPrintingMesh"):
if per_mesh_stack and (per_mesh_stack.getProperty(
"infill_mesh", "value")
or per_mesh_stack.getProperty(
"cutting_mesh", "value")):
renderer.queueNode(
node,
shader=self._non_printing_shader,
uniforms=uniforms,
transparent=True)
else:
renderer.queueNode(
node,
shader=self._non_printing_shader,
transparent=True)
elif getattr(node, "_outside_buildarea", False):
renderer.queueNode(node, shader=self._disabled_shader)
elif per_mesh_stack and per_mesh_stack.getProperty(
"support_mesh", "value"):
# Render support meshes with a vertical stripe that is darker
shade_factor = 0.6
uniforms["diffuse_color_2"] = [
uniforms["diffuse_color"][0] * shade_factor,
uniforms["diffuse_color"][1] * shade_factor,
uniforms["diffuse_color"][2] * shade_factor, 1.0
]
renderer.queueNode(node,
shader=self._support_mesh_shader,
uniforms=uniforms)
else:
renderer.queueNode(node,
shader=self._enabled_shader,
uniforms=uniforms)
if node.callDecoration("isGroup") and Selection.isSelected(
node):
renderer.queueNode(scene.getRoot(),
mesh=node.getBoundingBoxMesh(),
mode=RenderBatch.RenderMode.LineLoop)
