3D-printing/Cura
1
0
Fork 0
mirror of https://github.com/Ultimaker/Cura.git synced 2025-07-06 14:37:29 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Add the last line (when time-sim active) as a separate batch instead.

Browse source 
part of CURA-11521
This commit is contained in:
Remco Burema 2024-03-13 08:43:41 +01:00
parent 6e75eb34af
commit d6295171dd
3 changed files with 28 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

31
plugins/SimulationView/SimulationPass.py
View file

@ -121,6 +121,7 @@ class SimulationPass(RenderPass):
disabled_batch = RenderBatch(self._disabled_shader)
head_position = None # Indicates the current position of the print head
nozzle_node = None
not_a_vector = Vector(math.nan, math.nan, math.nan)
for node in DepthFirstIterator(self._scene.getRoot()):
@ -143,6 +144,9 @@ class SimulationPass(RenderPass):
if self._layer_view.getCurrentLayer() > -1 and ((not self._layer_view._only_show_top_layers) or (not self._layer_view.getCompatibilityMode())):
start = 0
end = 0
vertex_before_head = not_a_vector
vertex_after_head = not_a_vector
last_to_next_ratio = 0.0
towards_next_vertex = 0
element_counts = layer_data.getElementCounts()
for layer in sorted(element_counts.keys()):
@ -160,22 +164,19 @@ class SimulationPass(RenderPass):
ratio = self._layer_view.getCurrentPath() - math.floor(self._layer_view.getCurrentPath())
pos_a = Vector(polygon.data[index][0], polygon.data[index][1],
polygon.data[index][2])
vertex_before_head = pos_a
last_to_next_ratio = ratio
if ratio <= 0.0001 or index + 1 == len(polygon.data):
# in case there multiple polygons and polygon changes, the first point has the same value as the last point in the previous polygon
head_position = pos_a + node.getWorldPosition()
self._layer_shader.setUniformValue("u_last_vertex", pos_a)
self._layer_shader.setUniformValue("u_next_vertex", pos_a)
self._layer_shader.setUniformValue("u_last_line_ratio", 1.0)
else:
pos_b = Vector(polygon.data[index + 1][0],
polygon.data[index + 1][1],
polygon.data[index + 1][2])
vec = pos_a * (1.0 - ratio) + pos_b * ratio
head_position = vec + node.getWorldPosition()
vertex_after_head = pos_b
towards_next_vertex = 2
self._layer_shader.setUniformValue("u_last_vertex", pos_a)
self._layer_shader.setUniformValue("u_next_vertex", pos_b)
self._layer_shader.setUniformValue("u_last_line_ratio", ratio)
break
break
if self._layer_view.getMinimumLayer() > layer:
@ -184,7 +185,7 @@ class SimulationPass(RenderPass):
# Calculate the range of paths in the last layer
current_layer_start = end
current_layer_end = end + towards_next_vertex + int( self._layer_view.getCurrentPath()) * 2 # Because each point is used twice
current_layer_end = end + int( self._layer_view.getCurrentPath()) * 2 # Because each point is used twice
# This uses glDrawRangeElements internally to only draw a certain range of lines.
# All the layers but the current selected layer are rendered first
@ -195,6 +196,11 @@ class SimulationPass(RenderPass):
self._current_shader = self._layer_shader
self._switching_layers = True
# reset 'last vertex'
self._layer_shader.setUniformValue("u_last_vertex", not_a_vector)
self._layer_shader.setUniformValue("u_next_vertex", not_a_vector)
self._layer_shader.setUniformValue("u_last_line_ratio", 1.0)
# The first line does not have a previous line: add a MoveCombingType in front for start detection
# this way the first start of the layer can also be drawn
prev_line_types = numpy.concatenate([numpy.asarray([LayerPolygon.MoveCombingType], dtype = numpy.float32), layer_data._attributes["line_types"]["value"]])
@ -211,6 +217,17 @@ class SimulationPass(RenderPass):
current_layer_batch.addItem(node.getWorldTransformation(), layer_data)
current_layer_batch.render(self._scene.getActiveCamera())
# Last line may be partial
if vertex_after_head != not_a_vector and vertex_after_head != not_a_vector:
self._layer_shader.setUniformValue("u_last_vertex", vertex_before_head)
self._layer_shader.setUniformValue("u_next_vertex", vertex_after_head)
self._layer_shader.setUniformValue("u_last_line_ratio", last_to_next_ratio)
last_line_start = current_layer_end
last_line_end = current_layer_end + towards_next_vertex
last_line_batch = RenderBatch(self._layer_shader, type = RenderBatch.RenderType.Solid, mode=RenderBatch.RenderMode.Lines, range = (last_line_start, last_line_end))
last_line_batch.addItem(node.getWorldTransformation(), layer_data)
last_line_batch.render(self._scene.getActiveCamera())
self._old_current_layer = self._layer_view.getCurrentLayer()
self._old_current_path = self._layer_view.getCurrentPath()

4
plugins/SimulationView/layers3d.shader
View file

@ -435,6 +435,10 @@ u_max_feedrate = 1
u_min_thickness = 0
u_max_thickness = 1
u_last_vertex = [0.0, 0.0, 0.0]
u_next_vertex = [0.0, 0.0, 0.0]
u_last_line_ratio = 1.0
[bindings]
u_modelMatrix = model_matrix
u_viewMatrix = view_matrix

10
plugins/SimulationView/layers3d_shadow.shader
View file

@ -10,10 +10,6 @@ vertex41core =
uniform highp mat4 u_normalMatrix;
uniform vec3 u_last_vertex;
uniform vec3 u_next_vertex;
uniform float u_last_line_ratio;
in highp vec4 a_vertex;
in lowp vec4 a_color;
in lowp vec4 a_grayColor;
@ -39,10 +35,6 @@ vertex41core =
void main()
{
vec4 v1_vertex = a_vertex;
if (v1_vertex.xyz == u_next_vertex)
{
v1_vertex.xyz = mix(u_last_vertex, u_next_vertex, u_last_line_ratio);
}
v1_vertex.y -= a_line_dim.y / 2; // half layer down
vec4 world_space_vert = u_modelMatrix * v1_vertex;
@ -282,8 +274,6 @@ u_viewMatrix = view_matrix
u_projectionMatrix = projection_matrix
u_normalMatrix = normal_matrix
u_lightPosition = light_0_position
u_lastVertex = last_vertex
u_nextVertex = next_vertex
[attributes]
a_vertex = vertex