diff --git a/cura/PreviewPass.py b/cura/PreviewPass.py
index de21a5dc86..2a3080b0cc 100644
--- a/cura/PreviewPass.py
+++ b/cura/PreviewPass.py
@@ -42,6 +42,8 @@ class PreviewPass(RenderPass):
         self._renderer = Application.getInstance().getRenderer()
 
         self._shader = None
+        self._non_printing_shader = None
+        self._support_mesh_shader = None
         self._scene = Application.getInstance().getController().getScene()
 
     #   Set the camera to be used by this render pass
@@ -57,23 +59,60 @@ class PreviewPass(RenderPass):
             self._shader.setUniformValue("u_specularColor", [0.6, 0.6, 0.6, 1.0])
             self._shader.setUniformValue("u_shininess", 20.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", [0.5, 0.5, 0.5, 0.5])
+            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)
+
         self._gl.glClearColor(0.0, 0.0, 0.0, 0.0)
         self._gl.glClear(self._gl.GL_COLOR_BUFFER_BIT | self._gl.GL_DEPTH_BUFFER_BIT)
 
-        # Create a new batch to be rendered
+        # Create batches to be rendered
         batch = RenderBatch(self._shader)
+        batch_non_printing = RenderBatch(self._non_printing_shader, type = RenderBatch.RenderType.Transparent)
+        batch_support_mesh = RenderBatch(self._support_mesh_shader)
 
         # Fill up the batch with objects that can be sliced. `
         for node in DepthFirstIterator(self._scene.getRoot()):
             if node.callDecoration("isSliceable") and node.getMeshData() and node.isVisible():
-                uniforms = {}
-                uniforms["diffuse_color"] = prettier_color(node.getDiffuseColor())
-                batch.addItem(node.getWorldTransformation(), node.getMeshData(), uniforms = uniforms)
+                per_mesh_stack = node.callDecoration("getStack")
+                if node.callDecoration("isNonPrintingMesh"):
+                    # Non printing mesh
+                    batch_non_printing.addItem(node.getWorldTransformation(), node.getMeshData(), uniforms = {})
+                elif per_mesh_stack is not None and per_mesh_stack.getProperty("support_mesh", "value") == True:
+                    # Support mesh
+                    uniforms = {}
+                    shade_factor = 0.6
+                    diffuse_color = node.getDiffuseColor()
+                    diffuse_color2 = [
+                        diffuse_color[0] * shade_factor,
+                        diffuse_color[1] * shade_factor,
+                        diffuse_color[2] * shade_factor,
+                        1.0]
+                    uniforms["diffuse_color"] = prettier_color(diffuse_color)
+                    uniforms["diffuse_color_2"] = prettier_color(diffuse_color2)
+                    batch_support_mesh.addItem(node.getWorldTransformation(), node.getMeshData(), uniforms = uniforms)
+                else:
+                    # Normal scene node
+                    uniforms = {}
+                    uniforms["diffuse_color"] = prettier_color(node.getDiffuseColor())
+                    batch.addItem(node.getWorldTransformation(), node.getMeshData(), uniforms = uniforms)
 
         self.bind()
+
         if self._camera is None:
-            batch.render(Application.getInstance().getController().getScene().getActiveCamera())
+            render_camera = Application.getInstance().getController().getScene().getActiveCamera()
         else:
-            batch.render(self._camera)
+            render_camera = self._camera
+
+        batch.render(render_camera)
+        batch_support_mesh.render(render_camera)
+        batch_non_printing.render(render_camera)
+
         self.release()