def invertNormals(self) -> None:
if self._normals is not None:
mirror = Matrix()
mirror.setToIdentity()
mirror.scaleByFactor(-1.0)
self._normals = transformNormals(self._normals, mirror)
if self._indices is not None:
new_indices = []
for face in self._indices:
new_indices.append([face[1], face[0], face[2]])
self._indices = NumPyUtil.immutableNDArray(new_indices)
else:
new_vertices = []
num_vertices = len(self._vertices)
for i in range(0, num_vertices, 3):
new_vertices.append(self._vertices[i + 1])
new_vertices.append(self._vertices[i])
new_vertices.append(self._vertices[i + 2])
self._vertices = NumPyUtil.immutableNDArray(new_vertices)
def render(self) -> None:
if not self._shader:
self._shader = OpenGL.getInstance().createShaderProgram(
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"resources",
"shaders",
"coordinates.shader",
)
)
self._shader.setUniformValue("u_axisId", self._axis)
# Create a new batch to be rendered
batch = RenderBatch(self._shader)
# Fill up the batch with objects that can be sliced. `
for node in DepthFirstIterator(self._scene.getRoot()): # type: ignore #Ignore type error because iter() should get called automatically by Python syntax.
if (
node.callDecoration("isSliceable")
and node.getMeshData()
and node.isVisible()
):
batch.addItem(node.getWorldTransformation(), node.getMeshData())
z_fight_distance = 0.2 # Distance between buildplate and disallowed area meshes to prevent z-fighting
buildplate_transform = Matrix()
buildplate_transform.setToIdentity()
buildplate_transform.translate(Vector(0, z_fight_distance, 0))
buildplate_mesh = CuraApplication.getInstance().getBuildVolume()._grid_mesh
batch.addItem(buildplate_transform, buildplate_mesh)
width, height = self.getSize()
self.bind()
self._gl.glViewport(0, 0, width, height)
self._gl.glClearColor(1.0, 1.0, 1.0, 0.0)
self._gl.glClear(self._gl.GL_COLOR_BUFFER_BIT | self._gl.GL_DEPTH_BUFFER_BIT)
batch.render(self._scene.getActiveCamera())
self.release()
def _createSupportMesh(self, parent: CuraSceneNode, position: Vector , position2: Vector):
node = CuraSceneNode()
if self._SType == 'cylinder':
node.setName("CustomSupportCylinder")
elif self._SType == 'tube':
node.setName("CustomSupportTube")
elif self._SType == 'cube':
node.setName("CustomSupportCube")
elif self._SType == 'abutment':
node.setName("CustomSupportAbutment")
elif self._SType == 'freeform':
node.setName("CustomSupportFreeForm")
else:
node.setName("CustomSupportCustom")
node.setSelectable(True)
# long=Support Height
long=position.y
if self._SType == 'cylinder':
# Cylinder creation Diameter , Increment angle 2°, length
mesh = self._createCylinder(self._UseSize,self._MaxSize,2,long,self._UseAngle)
elif self._SType == 'tube':
# Tube creation Diameter , Diameter Int, Increment angle 2°, length
mesh = self._createTube(self._UseSize,self._MaxSize,self._UseISize,2,long,self._UseAngle)
elif self._SType == 'cube':
# Cube creation Size , length
mesh = self._createCube(self._UseSize,self._MaxSize,long,self._UseAngle)
elif self._SType == 'freeform':
# Cube creation Size , length
mesh = MeshBuilder()
MName = self._SubType + ".stl"
model_definition_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models", MName)
# Logger.log('d', 'Model_definition_path : ' + str(model_definition_path))
load_mesh = trimesh.load(model_definition_path)
origin = [0, 0, 0]
DirX = [1, 0, 0]
DirY = [0, 1, 0]
DirZ = [0, 0, 1]
load_mesh.apply_transform(trimesh.transformations.scale_matrix(self._UseSize, origin, DirX))
load_mesh.apply_transform(trimesh.transformations.scale_matrix(self._UseSize, origin, DirY))
load_mesh.apply_transform(trimesh.transformations.scale_matrix(long, origin, DirZ))
if self._MirrorSupport == True :
load_mesh.apply_transform(trimesh.transformations.rotation_matrix(math.radians(180), [0, 0, 1]))
if self._UseYDirection == True :
load_mesh.apply_transform(trimesh.transformations.rotation_matrix(math.radians(90), [0, 0, 1]))
mesh = self._toMeshData(load_mesh)
elif self._SType == 'abutment':
# Abutement creation Size , length , top
if self._EqualizeHeights == True :
Logger.log('d', 'SHeights : ' + str(self._SHeights))
if self._SHeights==0 :
self._SHeights=position.y
top=self._UseSize+(self._SHeights-position.y)
else:
top=self._UseSize
self._SHeights=0
# Logger.log('d', 'top : ' + str(top))
mesh = self._createAbutment(self._UseSize,self._MaxSize,long,top,self._UseAngle,self._UseYDirection)
else:
# Custom creation Size , P1 as vector P2 as vector
# Get support_interface_height as extra distance
extruder_stack = self._application.getExtruderManager().getActiveExtruderStacks()[0]
extra_top=extruder_stack.getProperty("support_interface_height", "value")
mesh = self._createCustom(self._UseSize,self._MaxSize,position,position2,self._UseAngle,extra_top)
# Mesh Freeform are loaded via trimesh doesn't aheve the Build method
if self._SType != 'freeform':
node.setMeshData(mesh.build())
else:
node.setMeshData(mesh)
# test for init position
node_transform = Matrix()
node_transform.setToIdentity()
node.setTransformation(node_transform)
active_build_plate = CuraApplication.getInstance().getMultiBuildPlateModel().activeBuildPlate
node.addDecorator(BuildPlateDecorator(active_build_plate))
node.addDecorator(SliceableObjectDecorator())
stack = node.callDecoration("getStack") # created by SettingOverrideDecorator that is automatically added to CuraSceneNode
settings = stack.getTop()
# Define the new mesh as "support_mesh" or "support_mesh_drop_down"
# Must be set for this 2 types
# for key in ["support_mesh", "support_mesh_drop_down"]:
# Don't fix
definition = stack.getSettingDefinition("support_mesh")
new_instance = SettingInstance(definition, settings)
new_instance.setProperty("value", True)
new_instance.resetState() # Ensure that the state is not seen as a user state.
settings.addInstance(new_instance)
definition = stack.getSettingDefinition("support_mesh_drop_down")
new_instance = SettingInstance(definition, settings)
new_instance.setProperty("value", False)
new_instance.resetState() # Ensure that the state is not seen as a user state.
settings.addInstance(new_instance)
global_container_stack = CuraApplication.getInstance().getGlobalContainerStack()
s_p = global_container_stack.getProperty("support_type", "value")
if s_p == 'buildplate' :
Message(text = "Info modification support_type new value : everywhere", title = catalog.i18nc("@info:title", "Custom Supports Cylinder")).show()
Logger.log('d', 'support_type different : ' + str(s_p))
# Define support_type=everywhere
global_container_stack.setProperty("support_type", "value", 'everywhere')
op = GroupedOperation()
# First add node to the scene at the correct position/scale, before parenting, so the support mesh does not get scaled with the parent
op.addOperation(AddSceneNodeOperation(node, self._controller.getScene().getRoot()))
op.addOperation(SetParentOperation(node, parent))
op.push()
node.setPosition(position, CuraSceneNode.TransformSpace.World)
CuraApplication.getInstance().getController().getScene().sceneChanged.emit(node)
