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

Fix convex hull and layer view rendering

Browse source
This commit is contained in:
Arjen Hiemstra 2015-12-08 13:49:49 +01:00
parent 63c80c42ce
commit 435186e6d1
2 changed files with 32 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

4
cura/ConvexHullNode.py
View file

@ -24,7 +24,7 @@ class ConvexHullNode(SceneNode):
self._inherit_orientation = False self._inherit_orientation = False
self._inherit_scale = False self._inherit_scale = False
self._color = Color(35, 35, 35, 0.5) self._color = Color(35, 35, 35, 128)
self._node = node self._node = node
self._node.transformationChanged.connect(self._onNodePositionChanged) self._node.transformationChanged.connect(self._onNodePositionChanged)
@ -66,9 +66,9 @@ class ConvexHullNode(SceneNode):
def render(self, renderer): def render(self, renderer):
if not self._shader: if not self._shader:
self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader")) self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader"))
self._shader.setUniformValue("u_color", self._color)
if self.getParent(): if self.getParent():
self._shader.setUniformValue("u_color", self._color)
renderer.queueNode(self, transparent = True, shader = self._shader) renderer.queueNode(self, transparent = True, shader = self._shader)
if self._convex_hull_head_mesh: if self._convex_hull_head_mesh:
renderer.queueNode(self, shader = self._shader, transparent = True, mesh = self._convex_hull_head_mesh) renderer.queueNode(self, shader = self._shader, transparent = True, mesh = self._convex_hull_head_mesh)

30
plugins/LayerView/LayerView.py
View file

@ -11,6 +11,9 @@ from UM.Scene.Selection import Selection
from UM.Math.Color import Color from UM.Math.Color import Color
from UM.Mesh.MeshData import MeshData from UM.Mesh.MeshData import MeshData
from UM.View.RenderBatch import RenderBatch
from UM.View.GL.OpenGL import OpenGL
from cura.ConvexHullNode import ConvexHullNode from cura.ConvexHullNode import ConvexHullNode
from PyQt5 import QtCore, QtWidgets from PyQt5 import QtCore, QtWidgets
@ -21,7 +24,8 @@ from . import LayerViewProxy
class LayerView(View): class LayerView(View):
def __init__(self): def __init__(self):
super().__init__() super().__init__()
self._material = None self._shader = None
self._selection_shader = None
self._num_layers = 0 self._num_layers = 0
self._layer_percentage = 0 # what percentage of layers need to be shown (SLider gives value between 0 - 100) self._layer_percentage = 0 # what percentage of layers need to be shown (SLider gives value between 0 - 100)
self._proxy = LayerViewProxy.LayerViewProxy() self._proxy = LayerViewProxy.LayerViewProxy()
@ -53,14 +57,10 @@ class LayerView(View):
def beginRendering(self): def beginRendering(self):
scene = self.getController().getScene() scene = self.getController().getScene()
renderer = self.getRenderer() renderer = self.getRenderer()
renderer.setRenderSelection(False)
if not self._material: if not self._selection_shader:
self._material = renderer.createMaterial(Resources.getPath(Resources.Shaders, "basic.vert"), Resources.getPath(Resources.Shaders, "vertexcolor.frag")) self._selection_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader"))
self._material.setUniformValue("u_color", [1.0, 0.0, 0.0, 1.0]) self._selection_shader.setUniformValue("u_color", Color(32, 32, 32, 128))
self._selection_material = renderer.createMaterial(Resources.getPath(Resources.Shaders, "basic.vert"), Resources.getPath(Resources.Shaders, "color.frag"))
self._selection_material.setUniformValue("u_color", Color(35, 35, 35, 128))
for node in DepthFirstIterator(scene.getRoot()): for node in DepthFirstIterator(scene.getRoot()):
# We do not want to render ConvexHullNode as it conflicts with the bottom layers. # We do not want to render ConvexHullNode as it conflicts with the bottom layers.
@ -71,7 +71,7 @@ class LayerView(View):
if not node.render(renderer): if not node.render(renderer):
if node.getMeshData() and node.isVisible(): if node.getMeshData() and node.isVisible():
if Selection.isSelected(node): if Selection.isSelected(node):
renderer.queueNode(node, material = self._selection_material, transparent = True) renderer.queueNode(node, transparent = True, shader = self._selection_shader)
layer_data = node.callDecoration("getLayerData") layer_data = node.callDecoration("getLayerData")
if not layer_data: if not layer_data:
continue continue
@ -87,7 +87,7 @@ class LayerView(View):
end += counts end += counts
# This uses glDrawRangeElements internally to only draw a certain range of lines. # This uses glDrawRangeElements internally to only draw a certain range of lines.
renderer.queueNode(node, mesh = layer_data, material = self._material, mode = Renderer.RenderLines, start = start, end = end) renderer.queueNode(node, mesh = layer_data, mode = RenderBatch.RenderMode.Lines, range = (start, end))
# We currently recreate the current "solid" layers every time a # We currently recreate the current "solid" layers every time a
if not self._current_layer_mesh: if not self._current_layer_mesh:
@ -111,7 +111,7 @@ class LayerView(View):
if self._current_layer_mesh: if self._current_layer_mesh:
self._current_layer_mesh.addColors(layer_mesh.getColors() * brightness) self._current_layer_mesh.addColors(layer_mesh.getColors() * brightness)
if self._current_layer_mesh: if self._current_layer_mesh:
renderer.queueNode(node, mesh = self._current_layer_mesh, material = self._material) renderer.queueNode(node, mesh = self._current_layer_mesh)
if not self._current_layer_jumps: if not self._current_layer_jumps:
self._current_layer_jumps = MeshData() self._current_layer_jumps = MeshData()
@ -133,7 +133,7 @@ class LayerView(View):
brightness = (2.0 - (i / self._solid_layers)) / 2.0 brightness = (2.0 - (i / self._solid_layers)) / 2.0
self._current_layer_jumps.addColors(layer_mesh.getColors() * brightness) self._current_layer_jumps.addColors(layer_mesh.getColors() * brightness)
renderer.queueNode(node, mesh = self._current_layer_jumps, material = self._material) renderer.queueNode(node, mesh = self._current_layer_jumps)
def setLayer(self, value): def setLayer(self, value):
if self._current_layer_num != value: if self._current_layer_num != value:
@ -152,16 +152,12 @@ class LayerView(View):
def calculateMaxLayers(self): def calculateMaxLayers(self):
scene = self.getController().getScene() scene = self.getController().getScene()
renderer = self.getRenderer() renderer = self.getRenderer()
if renderer and self._material:
self._activity = True self._activity = True
renderer.setRenderSelection(False)
self._old_max_layers = self._max_layers self._old_max_layers = self._max_layers
## Recalculate num max layers ## Recalculate num max layers
new_max_layers = 0 new_max_layers = 0
for node in DepthFirstIterator(scene.getRoot()): for node in DepthFirstIterator(scene.getRoot()):
if not node.render(renderer):
if node.getMeshData() and node.isVisible():
layer_data = node.callDecoration("getLayerData") layer_data = node.callDecoration("getLayerData")
if not layer_data: if not layer_data:
continue continue