Resolved How to replace Mesh with new BRG API?

I cannot figure out how to unregister a Mesh dynamically during runtime, replace it with another one, and set it. This is the (DOTS-based) test code I am using to fetch from a perfectly fine rendered entity the mesh.:

Code (CSharp):

1.  
2. var renderMeshArray = entityManager.GetSharedComponentManaged<RenderMeshArray>entity);
3. var meshInfo = entityManager.GetComponentData<MaterialMeshInfo>(entity);
4. var hybridRenderer = World.GetExistingSystemManaged<EntitiesGraphicsSystem>();
5. hybridRenderer.UnregisterMesh(meshInfo.MeshID);  <--error
6. hybridRenderer.RegisterMesh(newMesh);
7. GameObject.Destroy(renderMeshArray.Meshes[0]);
8. renderMeshArray.Meshes[0] = newMesh;
9. entityManager.SetSharedComponentManaged(entity, renderMeshArray);
10.  

Getting the error "Trying to unregister an invalid BRGMeshID". If I comment out this line and just destroy the mesh, the editor crashes. Any advice?

 

Many Thanks for your support. Did what you suggest, and in addition I changed how I register the mesh upon first generations (it's a procedurally generated mesh not amendable to baking): in both cases the error "Trying to unregister an invalid BRGMeshID" goes away, but on the flip side (1) the mesh stops rendering immediately upon destroying the old mesh and (2) the editor crashes when I hit stop play (crash log attached). Do I have to wait for a frame before destroying the old Mesh so that the EntitiesGraphicsSystem can do whatever it is doing upon mesh changes?

EDIT: solution to (1) was to set the new updated MaterialMeshInfo:

entityManager.SetComponentData(entity, updatedMaterialMeshInfo);

. The the editor crash bug is still there when I destroy the old Mesh after doing all those changes to the entity.

Here the change I did to the initial Mesh registration:

Code (CSharp):

1. //as per HybridURPSamples: does this even Register the Material and Mesh with the entitiesRenderer BRG?
2. RenderMeshUtility.AddComponents(spawned, _entityManager, renderMeshDescription, renderMeshArray, MaterialMeshInfo.FromRenderMeshArrayIndices(0, 0));
3.  
4. //alternative way to register:
5. var hybridRenderer = World.GetExistingSystemManaged<EntitiesGraphicsSystem>();
6. var meshID = hybridRenderer.RegisterMesh(earthMesh);
7. var materialID = hybridRenderer.RegisterMaterial(earthTextureMaterial);
8. var materialMeshInfo = new MaterialMeshInfo { MaterialID = materialID, MeshID = meshID };
9. RenderMeshUtility.AddComponents(spawned, _entityManager, renderMeshDescription, renderMeshArray, materialMeshInfo);

 

Awesome: thanks so much for your insights! My only BIG concern now are memory leaks when I am not permitted anymore to cleanup procedurally generated meshes that are not needed anymore: in my project I am generating thousands of them, and I only introduced this mesh destruction because the memory usage was skyrocketing into double digit GB with minutes and it looked to me like Unity is not cleaning those useless meshes up as long as there is still reference to them somewhere? So from that angle I would find it concerning that BRG maintains references to those zombie meshes.

EDIT: found a way to destroy the old mesh. The trick is to call renderMeshArray.ResetHash128() after replacing the mesh. Here the complete code I am using now to replace a mesh at (any) index of a given SharedRenderMeshComponent. A bit convoluted but works. Open to any suggestions how to improve this. (main goal is to prevent unused procedural generated meshes to clog up the memory)

Code (CSharp):

1. protected override void OnCreate()
2. {
3.     [...]
4.     hybridRenderer = World.GetExistingSystemManaged<EntitiesGraphicsSystem>();  
5.     [...]
6. }
7.  
8. protected override void OnUpdate()
9. {
10.     [...]
11.     Debug.Log($"Setting new Mesh");
12.     var newMesh = SpawnHelper.GetMesh(m_vertices, m_indices, m_bounds[0], MeshLayouts.TextureLayout);
13.  
14.     //update MaterialMeshInfo
15.     var materialMeshInfo = entityManager.GetComponentData<MaterialMeshInfo>(entity);
16.     hybridRenderer.UnregisterMesh(materialMeshInfo.MeshID);
17.     materialMeshInfo.MeshID = hybridRenderer.RegisterMesh(newMesh);
18.     entityManager.SetComponentData(entity, materialMeshInfo);
19.  
20.     //update RenderMeshArray
21.     var renderMeshArray = entityManager.GetSharedComponentManaged<RenderMeshArray>(entity);
22.     var oldMesh = renderMeshArray.Meshes[0];
23.     renderMeshArray.Meshes[0] = newMesh;
24.     renderMeshArray.ResetHash128();
25.     entityManager.SetSharedComponentManaged(entity, renderMeshArray);
26.     GameObject.Destroy(oldMesh);
27.     [...]
28. }

 

Got it now, Thanks you for sharing in detail how it works.

To this end, it would be nice if you could change GetMesh(BatchMeshID mesh) from "internal" to "public" (line 2332 in EntitiesGraphicsSystem.cs). Same with GetMaterial(BatchMaterialID material) in line 2333.

Using now an ICleanupComponentData to detect destroyed entities that had "MaterialMeshInfo". That ICleanupComponentData contains a copy of the MaterialMeshInfo, making it easy to implement a cleanup after Entity destruction (Unregister and Destroy the mesh). Would not like to implement my own tracking between BatchMeshID and associated Mesh/Material across systems, when BRG offers this already (as a public method), so would be great if EntitiesGraphicsSystem could just keep it public (and maybe not change the method name from GetRegisteredMaterial to GetMaterial?).

 

@JussiKnuuttila: in the recent 1.0.0-pre.15 update GetMesh() and GetMaterial() are still private: Are there any concerns making them public? I use this API in a cleanup system to destroy procedural meshes that are not needed anymore after Unregistering them from the EntityGraphicsSystem. Or can I rely on the UntityEngine to destroy those meshes eventually? They have no references to them anymore and should be destroyed, but in my experience they where not and memory usage was exploding.

Code (CSharp):

1.  
2. Entities
3.     .WithNone<MaterialMeshInfo>()
4.     .WithAll<AreaColorMeshState>()
5.     .WithoutBurst()
6.     .WithStructuralChanges()
7.     .ForEach((Entity e, in AreaColorMeshState state1) =>
8. {
9.     var oldMesh = hybridRenderer.GetMesh(state1.meshID);
10.     hybridRenderer.UnregisterMesh(state1.meshID);
11.     GameObject.Destroy(oldMesh);
12.     _entityManager.RemoveComponent<AreaColorMeshState>(e);
13. }).Run();
14.  

 

What should we do if we use Meshes and Materials that are not currently included in the MeshRenderArray when we newly enter a region?

Would it be better to create a new RenderMeshArray component? Or is it better to RegisterMesh on the RenderMeshArray and remember the starting index to use?

What is a better choice if using the existing DOTS entities subscene?

Is it better to loadasync a separate SubScene ?

Is it impossible to separate RenderMeshArray by Section?

 

If non destructive layer geometries are to be made into RenderMeshArray, is it better to prepare a few trival meshes and use them as patches? If so, how are textures managed? Is it okay to use a virtual texture as a displacement?