How to do multiple Graphics.DrawMesh calls in a C# script attached to one GO to draw procedural meshes

I tried to get closer to the problem. It seems to depend which "Dispatch()" call I do first to precalculate a computebuffer in one computeshader before it is sent to the vertex buffer. It seems the first ComputeBuffer.Dispatch() call overrules all following ones, as only the results from the first call are drawn. Although from my point of unserstanding I am using different buffers. Edit: To be more precise: Both meshes ares drawn but they seem to share the same locations and probably so the buffer. I noticed that as the rendered triangles doubled with each Graphics.DrawMesh added.

Each "QuadtreeTerrain" class has two compute buffer references.

 class QuadtreeTerrain {
      public ComputeBuffer generationConstantsBuffer;
      public ComputeBuffer patchGeneratedDataBuffer;
 }

In SpaceObjectProceduralPlanet I initialize the buffers (call CreateBuffer(QuadtreeTerrain) in Start(), where in the called functions the buffers of each object are initialized ("new ComputeBuffer()"). Afterwards I dispatch each buffer by calling (in Start() ) the function Dispatch(QuadtreeTerrain). Then, in "OnRenderObject()" I sent the buffers to the renderer. For the ease of read I reduced the number of different buffers to 2. Any hint why the first Dispatch() call overrules all others is very much appreciated.

 using UnityEngine;
 using System.Collections;
 using System.Threading;
 using System.Collections.Generic;
 
 [RequireComponent(typeof(GameObject))]
 public class SpaceObjectProceduralPlanet : MonoBehaviour {
 public int seed;
 public Position position;
 public string name;
 public float radius;
 public float diameter;
 public Transform m_Transform;
 private int LOD;
 // Primitive
 private AbstractPrimitive primitive;
 private enum PrimitiveState { IN_PRECALCULATION, PRECALCULATED, DONE };
 private PrimitiveState primitiveState;
 // QuadtreeTerrain
 private QuadtreeTerrain quadtreeTerrain1;
 private QuadtreeTerrain quadtreeTerrain2;
 // Plane Template
 public Mesh prototypeMesh;
 public Mesh prototypeMesh2;
 public Plane plane;
 public Texture2D texture;
 // ComputeShader
 public Shader shader;
 public ComputeShader computeShader;
 private ComputeBuffer generationConstantsBuffer;
 private ComputeBuffer patchGeneratedDataBuffer;
 private int _kernel;
 // Constants
 public static int nVertsPerEdge { get { return 224; } }     //Should be multiple of 32
 public static int nVerts { get { return nVertsPerEdge * nVertsPerEdge; } }
 public int THREADS_PER_GROUP_X { get { return 32; } }
 public int THREADS_PER_GROUP_Y { get { return 32; } }
 public int THREADGROUP_SIZE_X { get { return nVertsPerEdge / THREADS_PER_GROUP_X; } }
 public int THREADGROUP_SIZE_Y { get { return nVertsPerEdge / THREADS_PER_GROUP_Y; } }
 public int THREADGROUP_SIZE_Z { get { return 1; } }

 struct PatchGenerationConstantsStruct
 {
     public int nVertsPerEdge;
     public float scale;
     public float spacing;
     public Vector3 patchCubeCenter;
     public Vector3 cubeFaceEastDirection;
     public Vector3 cubeFaceNorthDirection;
     public float planetRadius;
     public float terrainMaxHeight;
     public float noiseSeaLevel;
     public float noiseSnowLevel;
 }

 struct patchGeneratedDataStruct
 {
     public Vector4 position;
     public Vector3 normal;
     public float noise;
     public Vector3 patchCenter;
 }

 // Initial call. We setup the shaders and prototype meshes here.
 void Awake () {
     // Transform
     m_Transform = transform;

     // Mesh prottype
     this.prototypeMesh = MeshServiceProvider.setupNavyFishDummyMesh(nVertsPerEdge);
     this.prototypeMesh2 = MeshServiceProvider.setupNavyFishDummyMesh(nVertsPerEdge);
     // Plane Template (not used right now as we have the prototype mesh)
     this.plane = new Plane(nVertsPerEdge, Vector3.back);
     // Shader
     this.shader = Shader.Find("Custom/ProceduralPatch3");
     // ComputeShader
     this.computeShader = (ComputeShader)Resources.Load("Shaders/Space/Planet/Custom/ProceduralPatchCompute3");
     // Texture
     this.texture = (Texture2D)Resources.Load("Textures/space/planets/seamless/QuadtreeTerrainTexture.MugDry_1024") as Texture2D;
 }

 // We initialize the buffers and the material used to draw.
 void Start()
 {
     // Edge coordinates for initialization
     Vector3 edgeVector1 = new Vector3(-1, +1, -1);
     Vector3 edgeVector2 = new Vector3(+1, +1, -1);
     Vector3 edgeVector3 = new Vector3(-1, -1, -1);
     Vector3 edgeVector4 = new Vector3(+1, -1, -1);
     Vector3 edgeVector5 = new Vector3(+1, +1, +1);
     Vector3 edgeVector6 = new Vector3(-1, +1, +1);
     Vector3 edgeVector7 = new Vector3(+1, -1, +1);
     Vector3 edgeVector8 = new Vector3(-1, -1, +1);
     // Parameters
     QuadtreeTerrainParameter parameter = new QuadtreeTerrainParameter();
     parameter.nVertsPerEdge = nVertsPerEdge;
     parameter.scale = 2.0f / nVertsPerEdge;
     parameter.spacing = 2.0f / nVertsPerEdge;
     parameter.planetRadius = 6371.0f; // 6371000.0f; = earth
     parameter.terrainMaxHeight = 15.0f;
     parameter.noiseSeaLevel = 0.0f;
     parameter.noiseSnowLevel = 0.8f;
     QuadtreeTerrainParameter quadtreeTerrainParameter1 = parameter.clone();
     quadtreeTerrainParameter1.cubeFaceEastDirection = new Vector3(1, 0, 0);
     quadtreeTerrainParameter1.cubeFaceNorthDirection = new Vector3(0, 1, 0);
     QuadtreeTerrainParameter quadtreeTerrainParameter2 = parameter.clone();
     quadtreeTerrainParameter2.cubeFaceEastDirection = new Vector3(0, 0, 1);
     quadtreeTerrainParameter2.cubeFaceNorthDirection = new Vector3(0, 1, 0);
     // QuadtreeTerrain
     this.quadtreeTerrain1 = new QuadtreeTerrain(0, edgeVector1, edgeVector2, edgeVector3, edgeVector4, quadtreeTerrainParameter1);
     this.quadtreeTerrain2 = new QuadtreeTerrain(0, edgeVector2, edgeVector5, edgeVector4, edgeVector7, quadtreeTerrainParameter2);
     CreateBuffers(this.quadtreeTerrain1);
     CreateBuffers(this.quadtreeTerrain2);
     CreateMaterial(this.quadtreeTerrain1);
     CreateMaterial(this.quadtreeTerrain2);

 // Only the mesh is drawn where there has been the first Dispatch(..) call. E.g. if the first call is commented out, the second mesh (QuadtreeTerrain2) is drawn.
     //Dispatch(this.quadtreeTerrain1);
     Dispatch(this.quadtreeTerrain2);
 }

 void Update()
 {

 }

 // We compute the buffers.
 void CreateBuffers(QuadtreeTerrain quadtreeTerrain)
 {
     // Buffer Patch Generation Constants
     quadtreeTerrain.generationConstantsBuffer = new ComputeBuffer(4, // 1x int (4 bytes) for one index, index = 0
         4 +     // nVertsPerEdge (int = 4 bytes),
         4 +     // scale (float = 4 bytes),
         4 +     // spacing (float = 4 bytes),
         12 +    // patchCubeCenter (float3 = 12 bytes),
         12 +    // cubeFaceEastDirection (float3 = 12 bytes),
         12 +    // cubeFaceNorthDirection (float3 = 12 bytes),
         4 +     // planetRadius (float = 4 bytes),
         4 +     // terrainMaxHeight (float = 4 bytes),
         4 +     // noiseSeaLevel (float = 4 bytes),
         4);     // noiseSnowLevel (float = 4 bytes),
     PatchGenerationConstantsStruct[] generationConstants = new PatchGenerationConstantsStruct[1];
     generationConstants[0].nVertsPerEdge = quadtreeTerrain.parameters.nVertsPerEdge;
     generationConstants[0].scale = quadtreeTerrain.parameters.scale;
     generationConstants[0].spacing = quadtreeTerrain.parameters.spacing;
     generationConstants[0].patchCubeCenter = quadtreeTerrain.centerVector;
     generationConstants[0].cubeFaceEastDirection = quadtreeTerrain.parameters.cubeFaceEastDirection;
     generationConstants[0].cubeFaceNorthDirection = quadtreeTerrain.parameters.cubeFaceNorthDirection;
     generationConstants[0].planetRadius = quadtreeTerrain.parameters.planetRadius;
     generationConstants[0].terrainMaxHeight = quadtreeTerrain.parameters.terrainMaxHeight;
     generationConstants[0].noiseSeaLevel = quadtreeTerrain.parameters.noiseSeaLevel;
     generationConstants[0].noiseSnowLevel = quadtreeTerrain.parameters.noiseSnowLevel;
     quadtreeTerrain.generationConstantsBuffer.SetData(generationConstants);
     // Buffer Output
     quadtreeTerrain.patchGeneratedDataBuffer = new ComputeBuffer(nVerts, 16 + 12 + 4 + 12); // Output buffer contains vertice position (float4 = 16 bytes),
                                                                                             // normals (float3 = 12 bytes),
                                                                                             // noise (float = 4 bytes)
                                                                                             // patchCenter (float3 = 12 bytes)
 }

 //We create the material
 void CreateMaterial(QuadtreeTerrain quadtreeTerrain)
 {
     quadtreeTerrain.material = new Material(shader);
     quadtreeTerrain.material.SetTexture("_MainTex", this.texture);
     quadtreeTerrain.material.SetFloat("_Metallic", 0);
     quadtreeTerrain.material.SetFloat("_Glossiness", 0);
 }

 //The meat of this script, it sets the buffers for the compute shader.
 // We then dispatch threads of our CSMain1 and 2 kernels.
 void Dispatch(QuadtreeTerrain quadtreeTerrain)
 {
     // Set Buffers
     computeShader.SetBuffer(_kernel, "generationConstantsBuffer", quadtreeTerrain.generationConstantsBuffer);
     computeShader.SetBuffer(_kernel, "patchGeneratedDataBuffer", quadtreeTerrain.patchGeneratedDataBuffer);
     // Dispatch first kernel
     _kernel = computeShader.FindKernel("CSMain1");
     computeShader.Dispatch(_kernel, THREADGROUP_SIZE_X, THREADGROUP_SIZE_Y, THREADGROUP_SIZE_Z);
     // Dispatch second kernel
     _kernel = computeShader.FindKernel("CSMain2");
     computeShader.Dispatch(_kernel, THREADGROUP_SIZE_X, THREADGROUP_SIZE_Y, THREADGROUP_SIZE_Z);
 }

 //After all rendering is complete we dispatch the compute shader and then set the material before drawing.
 void OnRenderObject()
 {
     this.quadtreeTerrain1.material.SetBuffer("patchGeneratedDataBuffer", this.quadtreeTerrain1.patchGeneratedDataBuffer);
     Graphics.DrawMesh(this.prototypeMesh, transform.localToWorldMatrix, this.quadtreeTerrain1.material, LayerMask.NameToLayer(GlobalVariablesManager.Instance.layerLocalSpaceName), null, 0, null, true, true);
     this.quadtreeTerrain2.material.SetBuffer("patchGeneratedDataBuffer", this.quadtreeTerrain2.patchGeneratedDataBuffer);
     Graphics.DrawMesh(this.prototypeMesh, transform.localToWorldMatrix, this.quadtreeTerrain2.material, LayerMask.NameToLayer(GlobalVariablesManager.Instance.layerLocalSpaceName), null, 0, null, true, true);
 }


 //When this GameObject is disabled we must release the buffers.
 private void OnDisable()
 {
     ReleaseBuffer();
 }

 //Release buffers and destroy the material when play has been stopped.
 void ReleaseBuffer()
 {
     // Destroy everything recursive in the quadtrees.
     this.quadtreeTerrain1.generationConstantsBuffer.Release();
     this.quadtreeTerrain1.patchGeneratedDataBuffer.Release();
     this.quadtreeTerrain2.generationConstantsBuffer.Release();
     this.quadtreeTerrain2.patchGeneratedDataBuffer.Release();
     DestroyImmediate(this.quadtreeTerrain1.material);
     DestroyImmediate(this.quadtreeTerrain2.material);
 }
 }