Yes, my approach was to hide the tiles from being apparent. My tiles were more like sophisticated geometrical seeds for things to be procedurally added in local space. And for this I needed tessellation to blend between two spaces (or scales) seamlessly.
So I had these two spaces, practically, one that was global, where every tile is known and populated with rough macro data, and the local space, which generated on the fly according to camera quat (technically a position on this sphere). One of the most important things was auto-culling, able to cull a sphere against camera frustum, so the camera was free to observe the sphere from any angle, while the tessellation would kick in based on distance. So the closer you get, the less of the global world you see, but the triangles get more dense, refining the topology, hence it would reach a frame polycount equilibrium, which was really nice to see in action. I also had two different renderers, rendering at different scales and married through overlaid renders, so that you could really fly through space and reach to the surface. It wasn’t a true planetary scale, though, it was around 6 times less than the Earth in equator, but still huge and very impressive.
Also, unlike the global one, the local camera was fixed, meaning the world would turn beneath you, so having the two views combined to form a seamless image was a mini-feat in itself. I made this so that I wouldn’t worry about the floating point imprecisions because of the scales involved. The global world was really small, I think 6000 times less, if I remember correctly, so that it wouldn’t become a problem if I wanted to implement an entire solar system at some later point.
The macro world had a dedicated map generator, that would consider tectonic forces and create tectonic plates with varying levels of composition density, orogenic and volcanic processes – of course, simplified to an extent – but all of this creates incredibly believable and consistent Earth-like geography. I wanted to implement mid-ocean ridges but never got to do it, but I got lost in this for weeks. Such a nice job, minus the fact that I had to make an inspector to experiment with it more. Perlin would kick in subsequent refining passes, and tessellation was based on blitz-fast face subdivision where you end up having only two possible geometrical patterns in order to maintain splitting without T junctions, and then recursively refining down to a certain limit. The end face would be around a meter or so compared to the player.
All of this was a massive learning experience for me, and I was astonished how fast it turned up in the end. I also had some really interesting solutions; for example, one of which I’ve named a toponym, practically a way to bundle and unique identify any point on the surface, not in terms of standard coordinates, spherical (2x 32 bits) or Cartesian (3x 32 bits) or god forbid quats (4x 32 bits), but in terms of tile triangular subdivision, which ended up being perfectly unambiguous, coherent with my setup, and only 24 bits in size. Which is pretty interesting when you think about it, to keep precision coordinates of a huge sphere in just one uint. Obviously the concept has a limited resolution and works in tiny triangular steps, but I haven’t even used the full 32 bits, so I could’ve refined it to sub-face barycentric space if I wanted, just by adding few more steps. It’s incredible how compressed and fractal-like this thing is at describing the spherical plane. This alone opened up new mathematical venues for me.
Anyway, the whole thing turned out glorious for a proof of concept, but I have shelved the project in pursuit of some other ideas. I had to do it because it started to resemble something that only a decent-sized studio would be able to pull off satisfactorily as a full game – and I have only scratched the surface of some tech, no game in sight – and so I’ve found myself in a situation where I had to come up with stepping stones in between that place and where I was initially. I made this on a potato and this made me realize I could implement and get away with much smaller and simpler technologies, if only I’d put more emphasize on key takeaways from this. As it turned out, I’ve figured out ways to stay noticeable without having to commit to a spherical geometry (let’s be honest here, it’s hard as hell, but at least I learned quats inside and out), but that let me focus more on the gameplay side of things.
Oh I’ve designed a dedicated mesh container with topological relationships, so that I could immediately tell the tile neighbors, tile triangles, that kind of thing, and I would optimally export Unity meshes from that. Had two of these, one global and one local, and the local would import ad hoc geometry from the other one, and split this geometry as needed. Regarding textures, the idea was to create a custom splat shader for the local terrain (never got to do it, but I had everything in place), and to dynamically unwrap the macro world for the stratospheric view, with the intent to make the local splat shader fade in based on macro render’s gbuffer depth. When I made the unwrapper (it’s on the forum) I’ve also discovered a bias in FromToRotation which I had to fix, there is a thread somewhere around here. And so on, pretty massive undertaking, I’m a bit crazy, and still learning to discipline myself when it comes to feature megalomania. Contrary to popular belief, being able to make almost anything on your own, also comes with its share of problems.
And maybe I’m an okay programmer, but I still need to think like an indie if I’m to achieve anything of commercial value. So it’s a learning process on so many levels. Anyways, I’m glad you’re pursuing this path as well, there is a lot to discover in this space, and it has a lot of potential. Obviously you’ve tuned your tech constraints and sanity checks in such a way to meet more realistic requirements.
