W.I.P.: Add paint-shader/layer so it can be used for the UV-painting feature.

Currently replacing the 'disabled' batch until we can get it to switch out on command (when we have the painting stage/tool/... pluging up and running.

part of CURA-12543

plugins/SolidView/SolidView.py

@@ -1,13 +1,12 @@
 # Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-import os.path
 from UM.View.View import View
 from UM.Scene.Iterator.DepthFirstIterator import DepthFirstIterator
 from UM.Scene.Selection import Selection
 from UM.Resources import Resources
-from PyQt6.QtGui import QOpenGLContext, QDesktopServices, QImage
+from PyQt6.QtGui import QDesktopServices, QImage
-from PyQt6.QtCore import QSize, QUrl
+from PyQt6.QtCore import QUrl
 
 import numpy as np
 import time
@@ -36,16 +35,20 @@ class SolidView(View):
     """Standard view for mesh models."""
 
     _show_xray_warning_preference = "view/show_xray_warning"
+    _show_overhang_preference = "view/show_overhang"
+    _paint_active_preference = "view/paint_active"
 
     def __init__(self):
         super().__init__()
         application = Application.getInstance()
-        application.getPreferences().addPreference("view/show_overhang", True)
+        application.getPreferences().addPreference(self._show_overhang_preference, True)
+        application.getPreferences().addPreference(self._paint_active_preference, False)
         application.globalContainerStackChanged.connect(self._onGlobalContainerChanged)
         self._enabled_shader = None
         self._disabled_shader = None
         self._non_printing_shader = None
         self._support_mesh_shader = None
+        self._paint_shader = None
 
         self._xray_shader = None
         self._xray_pass = None
@@ -139,6 +142,11 @@ class SolidView(View):
             min_height = max(min_height, init_layer_height)
         return min_height
 
+    def _setPaintTexture(self):
+        self._paint_texture = OpenGL.getInstance().createTexture(256, 256)
+        if self._paint_shader:
+            self._paint_shader.setTexture(0, self._paint_texture)
+
     def _checkSetup(self):
         if not self._extruders_model:
             self._extruders_model = Application.getInstance().getExtrudersModel()
@@ -167,6 +175,10 @@ class SolidView(View):
             self._support_mesh_shader.setUniformValue("u_vertical_stripes", True)
             self._support_mesh_shader.setUniformValue("u_width", 5.0)
 
+        if not self._paint_shader:
+            self._paint_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "paint.shader"))
+            self._setPaintTexture()
+
         if not Application.getInstance().getPreferences().getValue(self._show_xray_warning_preference):
             self._xray_shader = None
             self._xray_composite_shader = None
@@ -204,6 +216,9 @@ class SolidView(View):
                 self._old_composite_shader = self._composite_pass.getCompositeShader()
                 self._composite_pass.setCompositeShader(self._xray_composite_shader)
 
+    def setUvPixel(self, x, y, color):
+        self._paint_texture.setPixel(x, y, color)
+
     def beginRendering(self):
         scene = self.getController().getScene()
         renderer = self.getRenderer()
@@ -212,7 +227,7 @@ class SolidView(View):
 
         global_container_stack = Application.getInstance().getGlobalContainerStack()
         if global_container_stack:
-            if Application.getInstance().getPreferences().getValue("view/show_overhang"):
+            if Application.getInstance().getPreferences().getValue(self._show_overhang_preference):
                 # Make sure the overhang angle is valid before passing it to the shader
                 if self._support_angle >= 0 and self._support_angle <= 90:
                     self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(90 - self._support_angle)))
@@ -221,7 +236,7 @@ class SolidView(View):
             else:
                 self._enabled_shader.setUniformValue("u_overhangAngle", math.cos(math.radians(0)))
         self._enabled_shader.setUniformValue("u_lowestPrintableHeight", self._lowest_printable_height)
-        disabled_batch = renderer.createRenderBatch(shader = self._disabled_shader)
+        disabled_batch = renderer.createRenderBatch(shader = self._paint_shader)   #### TODO: put back to 'self._disabled_shader'
         normal_object_batch = renderer.createRenderBatch(shader = self._enabled_shader)
         renderer.addRenderBatch(disabled_batch)
         renderer.addRenderBatch(normal_object_batch)

resources/shaders/paint.shader

@@ -0,0 +1,142 @@
+[shaders]
+vertex =
+    uniform highp mat4 u_modelMatrix;
+    uniform highp mat4 u_viewMatrix;
+    uniform highp mat4 u_projectionMatrix;
+
+    uniform highp mat4 u_normalMatrix;
+
+    attribute highp vec4 a_vertex;
+    attribute highp vec4 a_normal;
+    attribute highp vec2 a_uvs;
+
+    varying highp vec3 v_vertex;
+    varying highp vec3 v_normal;
+    varying highp vec2 v_uvs;
+
+    void main()
+    {
+        vec4 world_space_vert = u_modelMatrix * a_vertex;
+        gl_Position = u_projectionMatrix * u_viewMatrix * world_space_vert;
+
+        v_vertex = world_space_vert.xyz;
+        v_normal = (u_normalMatrix * normalize(a_normal)).xyz;
+
+        v_uvs = a_uvs;
+    }
+
+fragment =
+    uniform mediump vec4 u_ambientColor;
+    uniform mediump vec4 u_diffuseColor;
+    uniform highp vec3 u_lightPosition;
+    uniform highp vec3 u_viewPosition;
+    uniform mediump float u_opacity;
+    uniform sampler2D u_texture;
+
+    varying highp vec3 v_vertex;
+    varying highp vec3 v_normal;
+    varying highp vec2 v_uvs;
+
+    void main()
+    {
+        mediump vec4 final_color = vec4(0.0);
+
+        /* Ambient Component */
+        final_color += u_ambientColor;
+
+        highp vec3 normal = normalize(v_normal);
+        highp vec3 light_dir = normalize(u_lightPosition - v_vertex);
+
+        /* Diffuse Component */
+        highp float n_dot_l = clamp(dot(normal, light_dir), 0.0, 1.0);
+        final_color += (n_dot_l * u_diffuseColor);
+
+        final_color.a = u_opacity;
+
+        lowp vec4 texture = texture2D(u_texture, v_uvs);
+        final_color = mix(final_color, texture, texture.a);
+
+        gl_FragColor = final_color;
+    }
+
+vertex41core =
+    #version 410
+    uniform highp mat4 u_modelMatrix;
+    uniform highp mat4 u_viewMatrix;
+    uniform highp mat4 u_projectionMatrix;
+
+    uniform highp mat4 u_normalMatrix;
+
+    in highp vec4 a_vertex;
+    in highp vec4 a_normal;
+    in highp vec2 a_uvs;
+
+    out highp vec3 v_vertex;
+    out highp vec3 v_normal;
+    out highp vec2 v_uvs;
+
+    void main()
+    {
+        vec4 world_space_vert = u_modelMatrix * a_vertex;
+        gl_Position = u_projectionMatrix * u_viewMatrix * world_space_vert;
+
+        v_vertex = world_space_vert.xyz;
+        v_normal = (u_normalMatrix * normalize(a_normal)).xyz;
+
+        v_uvs = a_uvs;
+    }
+
+fragment41core =
+    #version 410
+    uniform mediump vec4 u_ambientColor;
+    uniform mediump vec4 u_diffuseColor;
+    uniform highp vec3 u_lightPosition;
+    uniform highp vec3 u_viewPosition;
+    uniform mediump float u_opacity;
+    uniform sampler2D u_texture;
+
+    in highp vec3 v_vertex;
+    in highp vec3 v_normal;
+    in highp vec2 v_uvs;
+    out vec4 frag_color;
+
+    void main()
+    {
+        mediump vec4 final_color = vec4(0.0);
+
+        /* Ambient Component */
+        final_color += u_ambientColor;
+
+        highp vec3 normal = normalize(v_normal);
+        highp vec3 light_dir = normalize(u_lightPosition - v_vertex);
+
+        /* Diffuse Component */
+        highp float n_dot_l = clamp(dot(normal, light_dir), 0.0, 1.0);
+        final_color += (n_dot_l * u_diffuseColor);
+
+        final_color.a = u_opacity;
+
+        lowp vec4 texture = texture(u_texture, v_uvs);
+        final_color = mix(final_color, texture, texture.a);
+
+        frag_color = final_color;
+    }
+
+[defaults]
+u_ambientColor = [0.3, 0.3, 0.3, 1.0]
+u_diffuseColor = [1.0, 1.0, 1.0, 1.0]
+u_opacity = 0.5
+u_texture = 0
+
+[bindings]
+u_modelMatrix = model_matrix
+u_viewMatrix = view_matrix
+u_projectionMatrix = projection_matrix
+u_normalMatrix = normal_matrix
+u_lightPosition = light_0_position
+u_viewPosition = camera_position
+
+[attributes]
+a_vertex = vertex
+a_normal = normal
+a_uvs = uv0