Added layer view options

cura/Layer.py

@@ -49,12 +49,12 @@ class Layer:
 
         return result
 
-    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, indices):
+    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, line_types, indices):
         result_vertex_offset = vertex_offset
         result_index_offset = index_offset
         self._element_count = 0
         for polygon in self._polygons:
-            polygon.build(result_vertex_offset, result_index_offset, vertices, colors, line_dimensions, extruders, indices)
+            polygon.build(result_vertex_offset, result_index_offset, vertices, colors, line_dimensions, extruders, line_types, indices)
             result_vertex_offset += polygon.lineMeshVertexCount()
             result_index_offset += polygon.lineMeshElementCount()
             self._element_count += polygon.elementCount

cura/LayerDataBuilder.py

@@ -60,12 +60,13 @@ class LayerDataBuilder(MeshBuilder):
         line_dimensions = numpy.empty((vertex_count, 2), numpy.float32)
         colors = numpy.empty((vertex_count, 4), numpy.float32)
         indices = numpy.empty((index_count, 2), numpy.int32)
-        extruders = numpy.empty((vertex_count), numpy.float32)
+        extruders = numpy.empty((vertex_count), numpy.int32)
+        line_types = numpy.empty((vertex_count), numpy.int32)
 
         vertex_offset = 0
         index_offset = 0
         for layer, data in self._layers.items():
-            ( vertex_offset, index_offset ) = data.build( vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, indices)
+            ( vertex_offset, index_offset ) = data.build( vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, line_types, indices)
             self._element_counts[layer] = data.elementCount
 
         self.addVertices(vertices)
@@ -75,6 +76,8 @@ class LayerDataBuilder(MeshBuilder):
         material_colors = numpy.zeros((line_dimensions.shape[0], 4), dtype=numpy.float32)
         for extruder_nr in range(material_color_map.shape[0]):
             material_colors[extruders == extruder_nr] = material_color_map[extruder_nr]
+        material_colors[line_types == LayerPolygon.MoveCombingType] = [0.0, 0.0, 0.8, 1.0]
+        material_colors[line_types == LayerPolygon.MoveRetractionType] = [0.0, 0.0, 0.8, 1.0]
 
         attributes = {
             "line_dimensions": {
@@ -92,6 +95,11 @@ class LayerDataBuilder(MeshBuilder):
                 "opengl_name": "a_material_color",
                 "opengl_type": "vector4f"
                 },
+            "line_types": {
+                "value": line_types,
+                "opengl_name": "a_line_type",
+                "opengl_type": "float"
+                }
             }
 
         return LayerData(vertices=self.getVertices(), normals=self.getNormals(), indices=self.getIndices(),

cura/LayerPolygon.py

@@ -51,7 +51,7 @@ class LayerPolygon:
     def buildCache(self):
         # For the line mesh we do not draw Infill or Jumps. Therefore those lines are filtered out.
         # self._build_cache_line_mesh_mask = numpy.logical_not(numpy.logical_or(self._jump_mask, self._types == LayerPolygon.InfillType ))
-        self._build_cache_line_mesh_mask = numpy.logical_not(self._jump_mask)
+        self._build_cache_line_mesh_mask = numpy.ones(self._jump_mask.shape, dtype=bool)  # numpy.logical_not(self._jump_mask)
         mesh_line_count = numpy.sum(self._build_cache_line_mesh_mask)
         self._index_begin = 0
         self._index_end = mesh_line_count
@@ -60,14 +60,14 @@ class LayerPolygon:
         # Only if the type of line segment changes do we need to add an extra vertex to change colors
         self._build_cache_needed_points[1:, 0][:, numpy.newaxis] = self._types[1:] != self._types[:-1]
         # Mark points as unneeded if they are of types we don't want in the line mesh according to the calculated mask
-        numpy.logical_and(self._build_cache_needed_points, self._build_cache_line_mesh_mask, self._build_cache_needed_points )
+        numpy.logical_and(self._build_cache_needed_points, self._build_cache_line_mesh_mask )
 
         self._vertex_begin = 0
         self._vertex_end = numpy.sum( self._build_cache_needed_points )
         
     ##  build
     #   line_thicknesses: array with type as index and thickness as value
-    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, indices):
+    def build(self, vertex_offset, index_offset, vertices, colors, line_dimensions, extruders, line_types, indices):
         if (self._build_cache_line_mesh_mask is None) or (self._build_cache_needed_points is None ):
             self.buildCache()
             
@@ -94,7 +94,10 @@ class LayerPolygon:
         line_dimensions[self._vertex_begin:self._vertex_end, 0] = numpy.tile(self._line_widths, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
         line_dimensions[self._vertex_begin:self._vertex_end, 1] = numpy.tile(self._line_thicknesses, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
 
-        extruders[self._vertex_begin:self._vertex_end] = float(self._extruder)
+        extruders[self._vertex_begin:self._vertex_end] = self._extruder
+
+        # Convert type per vertex to type per line
+        line_types[self._vertex_begin:self._vertex_end] = numpy.tile(self._types, (1, 2)).reshape((-1, 1))[needed_points_list.ravel()][:, 0]
 
         # The relative values of begin and end indices have already been set in buildCache, so we only need to offset them to the parents offset.
         self._index_begin += index_offset

plugins/LayerView/LayerPass.py

@@ -30,16 +30,24 @@ class LayerPass(RenderPass):
         self._layer_view = None
 
     def setLayerView(self, layerview):
-        self._layerview = layerview
+        self._layer_view = layerview
 
     def render(self):
         if not self._layer_shader:
             self._layer_shader = OpenGL.getInstance().createShaderProgram(os.path.join(PluginRegistry.getInstance().getPluginPath("LayerView"), "layers.shader"))
         # Use extruder 0 if the extruder manager reports extruder index -1 (for single extrusion printers)
         self._layer_shader.setUniformValue("u_active_extruder", float(max(0, self._extruder_manager.activeExtruderIndex)))
-        self._layer_shader.setUniformValue("u_layer_view_type", 0)
+        if self._layer_view:
+            self._layer_shader.setUniformValue("u_layer_view_type", self._layer_view.getLayerViewType())
+            self._layer_shader.setUniformValue("u_only_color_active_extruder", (1 if self._layer_view.getOnlyColorActiveExtruder() else 0))
+            self._layer_shader.setUniformValue("u_extruder_opacity", self._layer_view.getExtruderOpacities())
+            self._layer_shader.setUniformValue("u_show_travel_moves", self._layer_view.getShowTravelMoves())
+        else:
+            #defaults
+            self._layer_shader.setUniformValue("u_layer_view_type", 1)
             self._layer_shader.setUniformValue("u_only_color_active_extruder", 1)
             self._layer_shader.setUniformValue("u_extruder_opacity", [1, 1, 1, 1])
+            self._layer_shader.setUniformValue("u_show_travel_moves", 0)
 
         if not self._tool_handle_shader:
             self._tool_handle_shader = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "toolhandle.shader"))
@@ -58,12 +66,12 @@ class LayerPass(RenderPass):
                     continue
 
                 # Render all layers below a certain number as line mesh instead of vertices.
-                if self._layerview._current_layer_num > -1 and not self._layerview._only_show_top_layers:
+                if self._layer_view._current_layer_num > -1 and not self._layer_view._only_show_top_layers:
                     start = 0
                     end = 0
                     element_counts = layer_data.getElementCounts()
                     for layer, counts in element_counts.items():
-                        if layer > self._layerview._current_layer_num:
+                        if layer > self._layer_view._current_layer_num:
                             break
                         end += counts
 
@@ -75,11 +83,11 @@ class LayerPass(RenderPass):
                 # Create a new batch that is not range-limited
                 batch = RenderBatch(self._layer_shader, type = RenderBatch.RenderType.Solid)
 
-                if self._layerview._current_layer_mesh:
-                    batch.addItem(node.getWorldTransformation(), self._layerview._current_layer_mesh)
+                if self._layer_view._current_layer_mesh:
+                    batch.addItem(node.getWorldTransformation(), self._layer_view._current_layer_mesh)
 
-                if self._layerview._current_layer_jumps:
-                    batch.addItem(node.getWorldTransformation(), self._layerview._current_layer_jumps)
+                if self._layer_view._current_layer_jumps:
+                    batch.addItem(node.getWorldTransformation(), self._layer_view._current_layer_jumps)
 
                 if len(batch.items) > 0:
                     batch.render(self._scene.getActiveCamera())

plugins/LayerView/LayerView.py

@@ -60,8 +60,14 @@ class LayerView(View):
         self._proxy = LayerViewProxy.LayerViewProxy()
         self._controller.getScene().getRoot().childrenChanged.connect(self._onSceneChanged)
 
+        self._layer_view_type = 0  # 0 is material color, 1 is color by linetype, 2 is speed
+        self._only_color_active_extruder = True
+        self._extruder_opacity = [1.0, 1.0, 1.0, 1.0]
+        self._show_travel_moves = 0
+
         Preferences.getInstance().addPreference("view/top_layer_count", 5)
         Preferences.getInstance().addPreference("view/only_show_top_layers", False)
+
         Preferences.getInstance().preferenceChanged.connect(self._onPreferencesChanged)
 
         self._solid_layers = int(Preferences.getInstance().getValue("view/top_layer_count"))
@@ -134,6 +140,34 @@ class LayerView(View):
 
             self.currentLayerNumChanged.emit()
 
+    def setLayerViewType(self, layer_view_type):
+        self._layer_view_type = layer_view_type
+        self.currentLayerNumChanged.emit()
+
+    def getLayerViewType(self):
+        return self._layer_view_type
+
+    def setOnlyColorActiveExtruder(self, only_color_active_extruder):
+        self._only_color_active_extruder = only_color_active_extruder
+        self.currentLayerNumChanged.emit()
+
+    def getOnlyColorActiveExtruder(self):
+        return self._only_color_active_extruder
+
+    def setExtruderOpacity(self, extruder_nr, opacity):
+        self._extruder_opacity[extruder_nr] = opacity
+        self.currentLayerNumChanged.emit()
+
+    def getExtruderOpacities(self):
+        return self._extruder_opacity
+
+    def setShowTravelMoves(self, show):
+        self._show_travel_moves = show
+        self.currentLayerNumChanged.emit()
+
+    def getShowTravelMoves(self):
+        return self._show_travel_moves
+
     def calculateMaxLayers(self):
         scene = self.getController().getScene()
         self._activity = True

plugins/LayerView/LayerView.qml

@@ -129,12 +129,12 @@ Item
         {
             id: layerViewTypes
             ListElement {
-                text: "Line type"
-                type_id: 0  // these ids match the switching in the shader
+                text: "Material color"
+                type_id: 0
             }
             ListElement {
-                text: "Material color"
-                type_id: 1
+                text: "Line type"
+                type_id: 1  // these ids match the switching in the shader
             }
             ListElement {
                 text: "Printing speed"
@@ -150,6 +150,7 @@ Item
             onActivated: {
                 CuraApplication.log("Combobox" + String(index));
                 CuraApplication.log(layerViewTypes.get(index).type_id);
+                UM.LayerView.setLayerViewType(layerViewTypes.get(index).type_id);
             }
         }
 
@@ -158,27 +159,28 @@ Item
             CheckBox {
                 checked: true
                 onClicked: {
-                    CuraApplication.log("First");
+                    UM.LayerView.setExtruderOpacity(0, checked ? 1.0 : 0.0);
                 }
                 text: "Extruder 1"
             }
             CheckBox {
                 checked: true
                 onClicked: {
-                    CuraApplication.log("First");
+                    UM.LayerView.setExtruderOpacity(1, checked ? 1.0 : 0.0);
                 }
                 text: "Extruder 2"
             }
             CheckBox {
                 onClicked: {
-                    CuraApplication.log("First");
+                    UM.LayerView.setShowTravelMoves(checked ? 1 : 0);
                 }
                 text: "Travel moves"
             }
             CheckBox {
                 checked: true
                 onClicked: {
-                    CuraApplication.log("First");
+                    CuraApplication.log("First" + checked);
+                    UM.LayerView.setOnlyColorActiveExtruder(checked);
                 }
                 text: "Only color active extruder"
             }

plugins/LayerView/LayerViewProxy.py

@@ -50,6 +50,31 @@ class LayerViewProxy(QObject):
         if type(active_view) == LayerView.LayerView.LayerView:
             active_view.setLayer(layer_num)
 
+    @pyqtSlot(int)
+    def setLayerViewType(self, layer_view_type):
+        active_view = self._controller.getActiveView()
+        if type(active_view) == LayerView.LayerView.LayerView:
+            active_view.setLayerViewType(layer_view_type)
+
+    @pyqtSlot(bool)
+    def setOnlyColorActiveExtruder(self, only_color_active_extruder):
+        active_view = self._controller.getActiveView()
+        if type(active_view) == LayerView.LayerView.LayerView:
+            active_view.setOnlyColorActiveExtruder(only_color_active_extruder)
+
+    # Opacity 0..1
+    @pyqtSlot(int, float)
+    def setExtruderOpacity(self, extruder_nr, opacity):
+        active_view = self._controller.getActiveView()
+        if type(active_view) == LayerView.LayerView.LayerView:
+            active_view.setExtruderOpacity(extruder_nr, opacity)
+
+    @pyqtSlot(bool)
+    def setShowTravelMoves(self, show):
+        active_view = self._controller.getActiveView()
+        if type(active_view) == LayerView.LayerView.LayerView:
+            active_view.setShowTravelMoves(show)
+
     def _layerActivityChanged(self):
         self.activityChanged.emit()
             

plugins/LayerView/layers.shader

@@ -17,6 +17,7 @@ vertex =
     attribute highp vec4 a_normal;
     attribute highp vec2 a_line_dim;  // line width and thickness
     attribute highp int a_extruder;
+    attribute highp int a_line_type;
 
     varying lowp vec4 v_color;
     //varying lowp vec4 v_material_color;
@@ -26,6 +27,7 @@ vertex =
     //varying lowp vec2 v_uvs;
     varying lowp vec2 v_line_dim;
     varying highp int v_extruder;
+    varying int v_line_type;
 
     varying lowp vec4 f_color;
     varying highp vec3 f_vertex;
@@ -44,19 +46,19 @@ vertex =
 
         switch (u_layer_view_type) {
             case 0:  // "Line type"
-                v_color = a_color;
+                v_color = a_material_color;
                 break;
             case 1:  // "Material color"
-                v_color = a_material_color;
+                v_color = a_color;
                 break;
             case 2:  // "Speed"
                 v_color = a_color;
                 break;
         }
         if (u_only_color_active_extruder == 1) {
-            v_color = (a_extruder == u_active_extruder) ? v_color : vec4(0.4, 0.4, 0.4, 1.0);
+            v_color = (a_extruder == u_active_extruder) ? v_color : vec4(0.4, 0.4, 0.4, v_color.a);
         } else {
-            v_color = (a_extruder == u_active_extruder) ? v_color : v_color * u_shade_factor;
+            v_color = (a_extruder == u_active_extruder) ? v_color : vec4((v_color * u_shade_factor).rgb, v_color.a);
         }
         if (a_extruder < 4) {
             v_color.a *= u_extruder_opacity[a_extruder];  // make it (in)visible
@@ -66,19 +68,20 @@ vertex =
         v_normal = (u_normalMatrix * normalize(a_normal)).xyz;
         v_line_dim = a_line_dim;
         v_extruder = a_extruder;
-        //v_material_color = a_material_color;
+        v_line_type = a_line_type;
 
         // for testing without geometry shader
-        f_color = v_color;
+        /*f_color = v_color;
         f_vertex = v_vertex;
         f_normal = v_normal;
-        f_extruder = v_extruder;
+        f_extruder = v_extruder; */
     }
 
 geometry =
     #version 410
 
     uniform highp mat4 u_viewProjectionMatrix;
+    uniform int u_show_travel_moves;
 
     layout(lines) in;
     layout(triangle_strip, max_vertices = 26) out;
@@ -88,7 +91,7 @@ geometry =
     in vec3 v_normal[];
     in vec2 v_line_dim[];
     in int v_extruder[];
-    //in vec4 v_material_color[];
+    in int v_line_type[];
 
     out vec4 f_color;
     out vec3 f_normal;
@@ -106,13 +109,24 @@ geometry =
         vec3 g_vertex_normal_horz_head;
         vec4 g_vertex_offset_horz_head;
 
-        float size_x = v_line_dim[0].x / 2 + 0.01;  // radius, and make it nicely overlapping
-        float size_y = v_line_dim[0].y / 2 + 0.01;
+        float size_x;
+        float size_y;
+
+        // See LayerPolygon; 8 is MoveCombingType, 9 is RetractionType
+        if (((v_line_type[0] == 8) || (v_line_type[0] == 9)) && (u_show_travel_moves == 0)) {
+            return;
+        }
+        if ((v_line_type[0] == 8) || (v_line_type[0] == 9)) {
+            // fixed size for movements
+            size_x = 0.1;
+            size_y = 0.1;
+        } else {
+            size_x = v_line_dim[0].x / 2 + 0.01;  // radius, and make it nicely overlapping
+            size_y = v_line_dim[0].y / 2 + 0.01;
+        }
 
         f_extruder = v_extruder[0];
-        //f_material_color = v_material_color[0];
 
-        //g_vertex_normal_horz = normalize(v_normal[0]);  //vec3(g_vertex_delta.z, g_vertex_delta.y, -g_vertex_delta.x);
         g_vertex_delta = gl_in[1].gl_Position - gl_in[0].gl_Position;
         g_vertex_normal_horz_head = normalize(vec3(-g_vertex_delta.x, -g_vertex_delta.y, -g_vertex_delta.z));
         g_vertex_offset_horz_head = vec4(g_vertex_normal_horz_head * size_x, 0.0);
@@ -125,28 +139,24 @@ geometry =
 
         f_vertex = v_vertex[0];
         f_color = v_color[0];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = g_vertex_normal_horz;
         gl_Position = u_viewProjectionMatrix * (gl_in[0].gl_Position + g_vertex_offset_horz);
         EmitVertex();
 
         f_vertex = v_vertex[1];
         f_color = v_color[1];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = g_vertex_normal_horz;
         gl_Position = u_viewProjectionMatrix * (gl_in[1].gl_Position + g_vertex_offset_horz);
         EmitVertex();
 
         f_vertex = v_vertex[0];
         f_color = v_color[0];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = g_vertex_normal_vert;
         gl_Position = u_viewProjectionMatrix * (gl_in[0].gl_Position + g_vertex_offset_vert);
         EmitVertex();
 
         f_vertex = v_vertex[1];
         f_color = v_color[1];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = g_vertex_normal_vert;
         gl_Position = u_viewProjectionMatrix * (gl_in[1].gl_Position + g_vertex_offset_vert);
         EmitVertex();
@@ -154,27 +164,23 @@ geometry =
         f_vertex = v_vertex[0];
         f_normal = -g_vertex_normal_horz;
         f_color = v_color[0];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         gl_Position = u_viewProjectionMatrix * (gl_in[0].gl_Position - g_vertex_offset_horz);
         EmitVertex();
 
         f_vertex = v_vertex[1];
         f_color = v_color[1];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = -g_vertex_normal_horz;
         gl_Position = u_viewProjectionMatrix * (gl_in[1].gl_Position - g_vertex_offset_horz);
         EmitVertex();
 
         f_vertex = v_vertex[0];
         f_color = v_color[0];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = -g_vertex_normal_vert;
         gl_Position = u_viewProjectionMatrix * (gl_in[0].gl_Position - g_vertex_offset_vert);
         EmitVertex();
 
         f_vertex = v_vertex[1];
         f_color = v_color[1];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = -g_vertex_normal_vert;
         gl_Position = u_viewProjectionMatrix * (gl_in[1].gl_Position - g_vertex_offset_vert);
         EmitVertex();
@@ -182,13 +188,11 @@ geometry =
         f_vertex = v_vertex[0];
         f_normal = g_vertex_normal_horz;
         f_color = v_color[0];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         gl_Position = u_viewProjectionMatrix * (gl_in[0].gl_Position + g_vertex_offset_horz);
         EmitVertex();
 
         f_vertex = v_vertex[1];
         f_color = v_color[1];
-        //f_color = vec4(v_uvs[0], 0.0, 1.0);
         f_normal = g_vertex_normal_horz;
         gl_Position = u_viewProjectionMatrix * (gl_in[1].gl_Position + g_vertex_offset_horz);
         EmitVertex();
@@ -289,8 +293,9 @@ fragment =
     void main()
     {
         mediump vec4 finalColor = vec4(0.0);
+        float alpha = f_color.a;
 
-        finalColor += u_ambientColor;
+        finalColor.rgb += f_color.rgb * 0.3;
 
         highp vec3 normal = normalize(f_normal);
         highp vec3 lightDir = normalize(u_lightPosition - f_vertex);
@@ -298,8 +303,7 @@ fragment =
         // Diffuse Component
         highp float NdotL = clamp(dot(normal, lightDir), 0.0, 1.0);
         finalColor += (NdotL * f_color);
-        //finalColor += (NdotL * f_material_color);
-        //finalColor.a = 1.0;
+        finalColor.a = alpha;  // Do not change alpha in any way
 
         gl_FragColor = finalColor;
     }
@@ -313,10 +317,12 @@ u_extruder_opacity = [1.0, 1.0]
 
 u_shade_factor = 0.60
 u_specularColor = [0.4, 0.4, 0.4, 1.0]
-u_ambientColor = [0.3, 0.3, 0.3, 0.3]
+u_ambientColor = [0.3, 0.3, 0.3, 0.0]
 u_diffuseColor = [1.0, 0.79, 0.14, 1.0]
 u_shininess = 20.0
 
+u_show_travel_moves = 0
+
 [bindings]
 u_modelViewProjectionMatrix = model_view_projection_matrix
 u_modelMatrix = model_matrix
@@ -331,3 +337,4 @@ a_normal = normal
 a_line_dim = line_dim
 a_extruder = extruders
 a_material_color = material_color
+a_line_type = line_type

resources/shaders/overhang.shader

@@ -8,50 +8,16 @@ vertex =
     attribute highp vec4 a_normal;
     attribute highp vec2 a_uvs;
 
-    varying highp vec3 v_vertex;
-    varying highp vec3 v_normal;
+    varying highp vec3 f_vertex;
+    varying highp vec3 f_normal;
 
     void main()
     {
         vec4 world_space_vert = u_modelMatrix * a_vertex;
         gl_Position = u_viewProjectionMatrix * world_space_vert;
 
-        v_vertex = world_space_vert.xyz;
-        v_normal = (u_normalMatrix * normalize(a_normal)).xyz;
-    }
-
-geometry =
-    #version 410
-
-    layout(triangles) in;
-    layout(triangle_strip, max_vertices = 6) out;
-
-    in vec3 v_normal[];
-    in vec3 v_vertex[];
-
-    out vec3 f_normal;
-    out vec3 f_vertex;
-
-    void main()
-    {
-        int i;
-        for(i = 0; i < 3; i++)
-        {
-            f_normal = v_normal[i];
-            f_vertex = v_vertex[i];
-            gl_Position = gl_in[i].gl_Position + vec4(-50, 0.0, 0.0, 0.0);
-            EmitVertex();
-        }
-        EndPrimitive();
-
-        for(i = 0; i < 3; i++)
-        {
-            f_normal = v_normal[i];
-            f_vertex = v_vertex[i];
-            gl_Position = gl_in[i].gl_Position + vec4(50, 0.0, 0.0, 0.0);
-            EmitVertex();
-        }
-        EndPrimitive();
+        f_vertex = world_space_vert.xyz;
+        f_normal = (u_normalMatrix * normalize(a_normal)).xyz;
     }
 
 fragment =