DrawMeshInstanced does not update the depth+normal texture

diff -r 0f089e052393 Assets/Materials/InternalDepthNormals.shader
--- /dev/null   Thu Jan 01 00:00:00 1970 +0000
+++ b/Assets/Materials/InternalDepthNormals.shader  Sun Aug 11 09:10:27 2019 +0200
@@ -0,0 +1,54 @@
+// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
+// modified by Armin Rigo
+
+Shader "Custom/InternalDepthNormals" {
+    Properties {
+    }
+
+    SubShader {
+        Pass {
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma multi_compile_instancing
+
+            #include "UnityCG.cginc"
+
+            UNITY_INSTANCING_BUFFER_START(Props)
+            UNITY_INSTANCING_BUFFER_END(Props)
+
+            struct appdata
+            {
+                float4 vertex : POSITION;
+                float3 normal : NORMAL;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f
+            {
+                float4 pos : SV_POSITION;
+                float4 nz : TEXCOORD0;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            v2f vert(appdata v)
+            {
+                v2f o;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_OUTPUT(v2f, o);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+                o.pos = UnityObjectToClipPos(v.vertex);
+                o.nz.xyz = COMPUTE_VIEW_NORMAL;
+                o.nz.w = COMPUTE_DEPTH_01;
+                return o;
+            }
+
+            float4 frag(v2f i) : SV_Target
+            {
+                return EncodeDepthNormal(i.nz.w, i.nz.xyz);
+            }
+            ENDCG
+        }
+    }
+}
diff -r 0f089e052393 Assets/Scripts/World.cs
--- a/Assets/Scripts/World.cs   Sat Aug 10 19:56:39 2019 +0200
+++ b/Assets/Scripts/World.cs   Sun Aug 11 09:10:27 2019 +0200
@@ -112,33 +112,39 @@
             static readonly Matrix4x4[] ROTATE = _MakeRotationMatrices();
             static Vector3[] deltaTime = new Vector3[8];

             internal static void SetShiftTime(float shift_time)
             {
                 /* shift_time is between -1 and 0 */
                 foreach (var step in UnitVector3Int.steps)
                     deltaTime[step.ToByte()] = ((Vector3)step) * shift_time;
             }

-            int _Flush(Camera camera, int i)
+            int _Flush(Camera camera, CommandBuffer cmdbuf, int i)
             {
+                var prefabs = SceneLoader.game_prefabs;
                 foreach (var draw_call in draw_calls)
                 {
                     Graphics.DrawMeshInstanced(draw_mesh,
                                                draw_call.submesh_index, draw_call.mat, matrices, i,
                                                null, draw_call.cast_shadows, draw_call.receive_shadows,
                                                0, camera);
+                    if (draw_call.cast_shadows != ShadowCastingMode.Off && draw_call.receive_shadows)
+                        cmdbuf.DrawMeshInstanced(draw_mesh,
+                                                 draw_call.submesh_index,
+                                                 prefabs.internalDepthNormalsMaterial,
+                                                 0, matrices, i);
                 }
                 return 0;
             }

-            internal void DrawMeshInstanced(Camera camera, Matrix4x4 world_matrix)
+            internal void DrawMeshInstanced(Camera camera, CommandBuffer cmdbuf, Matrix4x4 world_matrix)
             {
                 int i = 0;
                 int count = entries.Count;
                 for (int j = 0; j < count; j++)
                 {
                     var entry = entries[j];
                     var mat = ROTATE[entry.rotation];
                     if (entry.movement != 0xff)
                     {
                         Vector3 v = entry.position + deltaTime[entry.movement];
@@ -148,24 +154,24 @@
                     {
                         Vector3 v = entry.position;
                         mat.SetColumn(3, new Vector4(v.x, v.y, v.z, 1));

                         var rot_info = rotation_infos[j];
                         mat = rot_info.rendering_matrix * mat;
                     }

                     matrices[i++] = world_matrix * mat;
                     if (i == NUM_MATRICES)
-                        i = _Flush(camera, i);
+                        i = _Flush(camera, cmdbuf, i);
                 }
                 if (i > 0)
-                    _Flush(camera, i);
+                    _Flush(camera, cmdbuf, i);
             }

             static Matrix4x4[] _MakeRotationMatrices()
             {
                 var result = new Matrix4x4[64];
                 Matrix4x4 invalid = Matrix4x4.Rotate(Quaternion.Euler(45, 45, 45));  /* don't use */
                 for (int i = 0; i < 64; i++)
                 {
                     Quaternion? q = RotationInt._quaternion[i];
                     if (q != null)
@@ -202,20 +208,22 @@
             }
             else
             {
                 RenderSettings.ambientMode = AmbientMode.Skybox;
             }
         }

         private void OnDisable()
         {
             Camera.onPreCull -= DrawMeshInstanced;
+            UninstallCommandBuffer();
+
             if (objects_to_destroy != null)
             {
                 foreach (var obj in objects_to_destroy)
                     Destroy(obj);
                 objects_to_destroy = null;
             }
         }

         private void Start()
         {
@@ -537,40 +545,70 @@
                     var emitParams = new ParticleSystem.EmitParams
                     {
                         position = center,
                         applyShapeToPosition = true,
                     };
                     ps.Emit(emitParams, count);
                 }
             }
         }

+        CommandBuffer command_buffer;
+        HashSet<Camera> command_buffer_installed;
+
+        void UninstallCommandBuffer()
+        {
+            if (command_buffer_installed != null)
+            {
+                foreach (var camera in command_buffer_installed)
+                    if (camera)
+                        camera.RemoveCommandBuffer(CameraEvent.AfterDepthNormalsTexture, command_buffer);
+                command_buffer_installed = null;
+                command_buffer.Release();
+                command_buffer = null;
+            }
+        }
+
         void DrawMeshInstanced(Camera camera)
         {
             if (!camera)
                 return;

             var sel_coll = GetSelectionCell();
             sel_coll.Reset();
             if (selection_mat != null)
             {
                 sel_coll.ChangeMaterial(selection_mat);
                 foreach (var position in selection)
                     sel_coll.Add(position, RotationInt.identity, UnitVector3Int.zero);
                 selection_mat = null;  /* must be set again to keep displaying the selection */
             }

+            if (command_buffer_installed == null)
+            {
+                command_buffer = new CommandBuffer();
+                command_buffer.name = "hack to render Depth+Normals";
+                command_buffer_installed = new HashSet<Camera>();
+            }
+            if (!command_buffer_installed.Contains(camera))
+            {
+                camera.AddCommandBuffer(CameraEvent.AfterDepthNormalsTexture, command_buffer);
+                command_buffer_installed.Add(camera);
+                Debug.Log("Command buffer installed on " + command_buffer_installed.Count + " camera(s)");
+            }
+            command_buffer.Clear();
+
             var world_matrix = transform.localToWorldMatrix;

             UnityEngine.Profiling.Profiler.BeginSample("Draw World Instanced");
             foreach (var coll in all_cells)
-                coll.DrawMeshInstanced(camera, world_matrix);
+                coll.DrawMeshInstanced(camera, command_buffer, world_matrix);
             UnityEngine.Profiling.Profiler.EndSample();
         }

         public void SetShiftTime(float delta, IEnumerable<Geometry.GroupRotationInfo> group_rotations)
         {
             Coll.SetShiftTime(delta);

             /* delta is between -1 and 0.
              * xxx this could be further optimized, unclear if it's useful
              */