Merge branch 'feature_layerview_ghosts' of github.com:Ultimaker/Cura

plugins/LayerView/LayerPass.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2016 Ultimaker B.V.
+# Cura is released under the terms of the AGPLv3 or higher.
+
+from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
+from UM.Resources import Resources
+from UM.Scene.SceneNode import SceneNode
+from UM.Scene.ToolHandle import ToolHandle
+from UM.Application import Application
+
+from UM.View.RenderPass import RenderPass
+from UM.View.RenderBatch import RenderBatch
+from UM.View.GL.OpenGL import OpenGL
+
+## RenderPass used to display g-code paths.
+class LayerPass(RenderPass):
+    def __init__(self, width, height):
+        super().__init__("layerview", width, height)
+
+        self._shader = None
+        self._tool_handle_shader = None
+        self._gl = OpenGL.getInstance().getBindingsObject()
+        self._scene = Application.getInstance().getController().getScene()
+
+        self._layer_view = None
+
+    def setLayerView(self, layerview):
+        self._layerview = layerview
+
+    def render(self):
+        if not self._shader:
+            self._shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader"))
+        if not self._tool_handle_shader:
+            self._tool_handle_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "toolhandle.shader"))
+
+        self.bind()
+
+        tool_handle_batch = RenderBatch(self._tool_handle_shader, type = RenderBatch.RenderType.Overlay)
+
+        for node in DepthFirstIterator(self._scene.getRoot()):
+            if isinstance(node, ToolHandle):
+                tool_handle_batch.addItem(node.getWorldTransformation(), mesh = node.getSolidMesh())
+
+            elif isinstance(node, SceneNode) and node.getMeshData() and node.isVisible():
+                layer_data = node.callDecoration("getLayerData")
+                if not layer_data:
+                    continue
+
+                # Render all layers below a certain number as line mesh instead of vertices.
+                if self._layerview._current_layer_num - self._layerview._solid_layers > -1 and not self._layerview._only_show_top_layers:
+                    start = 0
+                    end = 0
+                    element_counts = layer_data.getElementCounts()
+                    for layer, counts in element_counts.items():
+                        if layer + self._layerview._solid_layers > self._layerview._current_layer_num:
+                            break
+                        end += counts
+
+                    # This uses glDrawRangeElements internally to only draw a certain range of lines.
+                    batch = RenderBatch(self._shader, type = RenderBatch.RenderType.Solid, mode = RenderBatch.RenderMode.Lines, range = (start, end))
+                    batch.addItem(node.getWorldTransformation(), layer_data)
+                    batch.render(self._scene.getActiveCamera())
+
+                # Create a new batch that is not range-limited
+                batch = RenderBatch(self._shader, type = RenderBatch.RenderType.Solid)
+
+                if self._layerview._current_layer_mesh:
+                    batch.addItem(node.getWorldTransformation(), self._layerview._current_layer_mesh)
+
+                if self._layerview._current_layer_jumps:
+                    batch.addItem(node.getWorldTransformation(), self._layerview._current_layer_jumps)
+
+                if len(batch.items) > 0:
+                    batch.render(self._scene.getActiveCamera())
+
+        # Render toolhandles on top of the layerview
+        if len(tool_handle_batch.items) > 0:
+            tool_handle_batch.render(self._scene.getActiveCamera())
+
+        self.release()

plugins/LayerView/LayerView.py

@@ -1,6 +1,7 @@
 # Copyright (c) 2015 Ultimaker B.V.
 # Cura is released under the terms of the AGPLv3 or higher.
 
+from UM.PluginRegistry import PluginRegistry
 from UM.View.View import View
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Resources import Resources
@@ -28,18 +29,16 @@ from . import LayerViewProxy
 from UM.i18n import i18nCatalog
 catalog = i18nCatalog("cura")
 
+from . import LayerPass
+
 import numpy
+import os.path
 
 ## View used to display g-code paths.
 class LayerView(View):
     def __init__(self):
         super().__init__()
-        self._shader = None
+
-        self._ghost_shader = None
-        self._num_layers = 0
-        self._layer_percentage = 0  # what percentage of layers need to be shown (Slider gives value between 0 - 100)
-        self._proxy = LayerViewProxy.LayerViewProxy()
-        self._controller.getScene().getRoot().childrenChanged.connect(self._onSceneChanged)
         self._max_layers = 0
         self._current_layer_num = 0
         self._current_layer_mesh = None
@@ -47,7 +46,19 @@ class LayerView(View):
         self._top_layers_job = None
         self._activity = False
         self._old_max_layers = 0
+
+        self._busy = False
+
+        self._ghost_shader = None
+        self._layer_pass = None
+        self._composite_pass = None
+        self._old_layer_bindings = None
+        self._layerview_composite_shader = None
+        self._old_composite_shader = None
+
         self._global_container_stack = None
+        self._proxy = LayerViewProxy.LayerViewProxy()
+        self._controller.getScene().getRoot().childrenChanged.connect(self._onSceneChanged)
 
         Preferences.getInstance().addPreference("view/top_layer_count", 5)
         Preferences.getInstance().addPreference("view/only_show_top_layers", False)
@@ -55,13 +66,21 @@ class LayerView(View):
 
         self._solid_layers = int(Preferences.getInstance().getValue("view/top_layer_count"))
         self._only_show_top_layers = bool(Preferences.getInstance().getValue("view/only_show_top_layers"))
-        self._busy = False
 
         self._wireprint_warning_message = Message(catalog.i18nc("@info:status", "Cura does not accurately display layers when Wire Printing is enabled"))
 
     def getActivity(self):
         return self._activity
 
+    def getLayerPass(self):
+        if not self._layer_pass:
+            # Currently the RenderPass constructor requires a size > 0
+            # This should be fixed in RenderPass's constructor.
+            self._layer_pass = LayerPass.LayerPass(1, 1)
+            self._layer_pass.setLayerView(self)
+            self.getRenderer().addRenderPass(self._layer_pass)
+        return self._layer_pass
+
     def getCurrentLayer(self):
         return self._current_layer_num
 
@@ -91,7 +110,7 @@ class LayerView(View):
 
         if not self._ghost_shader:
             self._ghost_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "color.shader"))
-            self._ghost_shader.setUniformValue("u_color", Color(0, 0, 0, 64))
+            self._ghost_shader.setUniformValue("u_color", Color(32, 32, 32, 96))
 
         for node in DepthFirstIterator(scene.getRoot()):
             # We do not want to render ConvexHullNode as it conflicts with the bottom layers.
@@ -101,35 +120,7 @@ class LayerView(View):
 
             if not node.render(renderer):
                 if node.getMeshData() and node.isVisible():
-                    renderer.queueNode(node,
+                    renderer.queueNode(node, transparent = True, shader = self._ghost_shader)
-                                       shader = self._ghost_shader,
-                                       type = RenderBatch.RenderType.Transparent                    )
-
-        for node in DepthFirstIterator(scene.getRoot()):
-            if type(node) is SceneNode:
-                if node.getMeshData() and node.isVisible():
-                    layer_data = node.callDecoration("getLayerData")
-                    if not layer_data:
-                        continue
-
-                    # Render all layers below a certain number as line mesh instead of vertices.
-                    if self._current_layer_num - self._solid_layers > -1 and not self._only_show_top_layers:
-                        start = 0
-                        end = 0
-                        element_counts = layer_data.getElementCounts()
-                        for layer, counts in element_counts.items():
-                            if layer + self._solid_layers > self._current_layer_num:
-                                break
-                            end += counts
-
-                        # This uses glDrawRangeElements internally to only draw a certain range of lines.
-                        renderer.queueNode(node, mesh = layer_data, mode = RenderBatch.RenderMode.Lines, range = (start, end))
-
-                    if self._current_layer_mesh:
-                        renderer.queueNode(node, mesh = self._current_layer_mesh)
-
-                    if self._current_layer_jumps:
-                        renderer.queueNode(node, mesh = self._current_layer_jumps)
 
     def setLayer(self, value):
         if self._current_layer_num != value:
@@ -195,15 +186,32 @@ class LayerView(View):
                 return True
 
         if event.type == Event.ViewActivateEvent:
+            # Make sure the LayerPass is created
+            self.getLayerPass()
+
             Application.getInstance().globalContainerStackChanged.connect(self._onGlobalStackChanged)
             self._onGlobalStackChanged()
 
+            if not self._layerview_composite_shader:
+                self._layerview_composite_shader = OpenGL.getInstance().createShaderProgram(os.path.join(PluginRegistry.getInstance().getPluginPath("LayerView"), "layerview_composite.shader"))
+
+            if not self._composite_pass:
+                self._composite_pass = self.getRenderer().getRenderPass("composite")
+
+            self._old_layer_bindings = self._composite_pass.getLayerBindings()[:] # make a copy so we can restore to it later
+            self._composite_pass.getLayerBindings().append("layerview")
+            self._old_composite_shader = self._composite_pass.getCompositeShader()
+            self._composite_pass.setCompositeShader(self._layerview_composite_shader)
+
         elif event.type == Event.ViewDeactivateEvent:
             self._wireprint_warning_message.hide()
             Application.getInstance().globalContainerStackChanged.disconnect(self._onGlobalStackChanged)
             if self._global_container_stack:
                 self._global_container_stack.propertyChanged.disconnect(self._onPropertyChanged)
 
+            self._composite_pass.setLayerBindings(self._old_layer_bindings)
+            self._composite_pass.setCompositeShader(self._old_composite_shader)
+
     def _onGlobalStackChanged(self):
         if self._global_container_stack:
             self._global_container_stack.propertyChanged.disconnect(self._onPropertyChanged)
@@ -315,3 +323,4 @@ class _CreateTopLayersJob(Job):
     def cancel(self):
         self._cancel = True
         super().cancel()
+

plugins/LayerView/layerview_composite.shader

@@ -0,0 +1,78 @@
+[shaders]
+vertex =
+    uniform highp mat4 u_modelViewProjectionMatrix;
+    attribute highp vec4 a_vertex;
+    attribute highp vec2 a_uvs;
+
+    varying highp vec2 v_uvs;
+
+    void main()
+    {
+        gl_Position = u_modelViewProjectionMatrix * a_vertex;
+        v_uvs = a_uvs;
+    }
+
+fragment =
+    uniform sampler2D u_layer0;
+    uniform sampler2D u_layer1;
+    uniform sampler2D u_layer2;
+
+    uniform vec2 u_offset[9];
+
+    uniform vec4 u_background_color;
+    uniform float u_outline_strength;
+    uniform vec4 u_outline_color;
+
+    varying vec2 v_uvs;
+
+    float kernel[9];
+
+    const vec3 x_axis = vec3(1.0, 0.0, 0.0);
+    const vec3 y_axis = vec3(0.0, 1.0, 0.0);
+    const vec3 z_axis = vec3(0.0, 0.0, 1.0);
+
+    void main()
+    {
+        kernel[0] = 0.0; kernel[1] = 1.0; kernel[2] = 0.0;
+        kernel[3] = 1.0; kernel[4] = -4.0; kernel[5] = 1.0;
+        kernel[6] = 0.0; kernel[7] = 1.0; kernel[8] = 0.0;
+
+        vec4 result = u_background_color;
+
+        vec4 main_layer = texture2D(u_layer0, v_uvs);
+        vec4 selection_layer = texture2D(u_layer1, v_uvs);
+        vec4 layerview_layer = texture2D(u_layer2, v_uvs);
+
+        result = main_layer * main_layer.a + result * (1.0 - main_layer.a);
+        result = layerview_layer * layerview_layer.a + result * (1.0 - layerview_layer.a);
+
+        vec4 sum = vec4(0.0);
+        for (int i = 0; i < 9; i++)
+        {
+            vec4 color = vec4(texture2D(u_layer1, v_uvs.xy + u_offset[i]).a);
+            sum += color * (kernel[i] / u_outline_strength);
+        }
+
+        if((selection_layer.rgb == x_axis || selection_layer.rgb == y_axis || selection_layer.rgb == z_axis))
+        {
+            gl_FragColor = result;
+        }
+        else
+        {
+            gl_FragColor = mix(result, u_outline_color, abs(sum.a));
+        }
+    }
+
+[defaults]
+u_layer0 = 0
+u_layer1 = 1
+u_layer2 = 2
+u_background_color = [0.965, 0.965, 0.965, 1.0]
+u_outline_strength = 1.0
+u_outline_color = [0.05, 0.66, 0.89, 1.0]
+
+[bindings]
+
+[attributes]
+a_vertex = vertex
+a_uvs = uv

plugins/XRayView/xray_composite.shader

@@ -16,10 +16,6 @@ fragment =
     uniform sampler2D u_layer0;
     uniform sampler2D u_layer1;
     uniform sampler2D u_layer2;
-    uniform sampler2D u_layer3;
-
-    uniform float u_imageWidth;
-    uniform float u_imageHeight;
 
     uniform vec2 u_offset[9];
 
@@ -62,7 +58,6 @@ fragment =
 u_layer0 = 0
 u_layer1 = 1
 u_layer2 = 2
-u_layer3 = 3
 u_outline_strength = 1.0
 u_outline_color = [0.05, 0.66, 0.89, 1.0]
 u_error_color = [1.0, 0.0, 0.0, 1.0]