Random Points to mesh?

Questions
22

I found in this moment crawling my own examples
dynamic polyeder - delaunay triangulation
(move one sphere to run the animation)

this one from an other coder in the playground which uses the delaunator.js library:
Babylon.js Playground (babylonjs.com)

23

I hope i am not too annoying here… but i have another question:
right now i am making the terrain using the delaunator library, wich generates a quite complex huge mesh.
In an optimal world i would need this with some kind of LOD. But LODs are dependent on camera Distance to the object. so it does not quite make any sense for a terrain (where the camera is close, but only on a certain area).
After a bit of searching around i found two solutions:

  • Dynamic Terrain, wich seems to load higher quality Terrain close to the camera,
    or
  • Tiles with different resolutions (does babylonjs have some kind of support for 3d Tiles?)

What would be the most performant way to display huge (800x800m * 1m resolution) terrains in babylon?

Thanks a lot for hints and ideas!

24

I was curious, too, about the best method of making huge terrains and asked my virtual assistant.

GPT:
When it comes to displaying large terrains with LOD (Level of Detail) in Babylon.js, both dynamic terrain and tiles with different resolutions are viable options. Let’s discuss each approach to help you decide which one would be more performant for your case.

  1. Dynamic Terrain: Dynamic terrain involves dynamically adjusting the level of detail based on the camera’s proximity to the terrain. It allows for rendering higher quality terrain close to the camera and lower quality terrain in the distance.

To implement dynamic terrain in Babylon.js, you can consider using a combination of techniques such as:

  • Level of Detail (LOD): Generate multiple versions of your terrain mesh at different resolutions. As the camera moves closer to the terrain, switch to a higher resolution mesh for more details.
  • Frustum Culling: Only render the portions of the terrain that are within the camera’s view frustum, optimizing the rendering process.
  • Occlusion Culling: If parts of the terrain are obstructed from view, you can skip rendering those portions to further improve performance.

Implementing dynamic terrain in Babylon.js requires managing LOD levels, updating the mesh based on the camera’s position, and implementing the culling techniques mentioned above. It can be a complex solution but can provide the desired level of detail for your terrain.

  1. Tiles with Different Resolutions: Another approach is to divide your terrain into tiles and assign different resolutions to each tile. This approach is commonly used in 3D tile-based rendering systems.

In Babylon.js, you can achieve this by:

  • Dividing your terrain into smaller tiles, each representing a portion of the terrain.
  • Assigning different levels of detail (resolutions) to each tile based on their distance from the camera.
  • Implementing a tile management system that loads and unloads tiles dynamically based on the camera’s position and visibility.

Babylon.js does not have built-in support for 3D tiles specifically, but you can implement a tile-based system using the framework’s powerful mesh and scene management capabilities.

Comparing the Two Approaches: Both dynamic terrain and tiles with different resolutions can achieve LOD for large terrains, but they have different trade-offs:

  • Dynamic terrain provides more fine-grained control over the level of detail, allowing for smoother transitions between resolutions. However, it requires managing LOD levels and implementing culling techniques, which can be more complex to implement.
  • Tiles with different resolutions are easier to manage conceptually, as you divide your terrain into discrete chunks. However, managing the loading and unloading of tiles based on the camera’s position requires careful implementation.

Ultimately, the most performant approach depends on your specific requirements, available resources, and the trade-offs you are willing to make. If you prefer a simpler implementation and can manage the terrain division into tiles, the tile-based approach may be more suitable. On the other hand, if you require more control over the level of detail and smooth transitions, dynamic terrain can be a better choice despite the additional complexity.

Consider evaluating the specific needs of your project and weighing the pros and cons of each approach to make an informed decision.

Some additional tutorials:

happy coding! :slight_smile:

25

@pcace Hello, may I ask if your function has been completed? I am going to do something similar recently. Can you provide any good suggestions

26

Hi there, i am sorry for that late response, but i fear that i cannot really help you. the data i am working with is no longer random. in a pre-process i change the datastructure to a rastered grid ( in my case using GDAL — GDAL documentation
and with this i am generating a mesh in advance, not in realtime.

Cheers and sorry for disappointment :wink:

27

I created a PTS parser to handle large point clouds on the front end. Specifically, in my case, it was ones with around 30 million points that I needed to reconstruct in the end. PTS is a format used for storing these kinds of data.
I use the voxelization technique, where you can set your voxel size. Check out the tool here: @dp-software/point-cloud - npm. It will not solve your problem straight away, but you can use the voxelization part from there.

Also, take a look at my presentation, where I used this library with BabylonJS for a better idea of how you can get a simplified point cloud with preserved shapes: https://youtu.be/iXHKkVY0yOY?t=2504.

Hope this helps a little (-;