65535 vertices limit

You seem to miss the point. High poly count does not automatically mean to have a bad artist. When that would be the case then you would label all current top game artists as bad artists since the current games generation uses a very high poly count for its characters, compared to the usual 5k to 10k characters that you can buy at turbosquid or similar places.

When you need closeups then your geometry better does not look too blocky. And a terrain mesh (not a heightmap terrain) is such a case where you quickly run into the blocky look with just 65k tris.

Sure, i can create a level or a character also with 1000 triangles. But the best artist cannot make it as good looking as a 50k level or character. Detail can be done with techniques like normalmapping to some extend. But the best detail at a mesh comes from geometry. Guess what stuff like micro tesselation is good for.

What makes a good artist is to use as much polygons as needed, and as few as possible, given the limits of the current project. This could mean to have the almighty 1000 tris character, but this could also mean to have a character with 100 k tris or even more.

Graphics area evolves still heavily. Not long ago we had just 256 colours for the whole image stuff in a game. 8 Bit. Then we had 65k colours. 16 Bit. Then 16 million colours. 24 bit. Nowadays we are at 32 bit per colour channel. And 64 bit per channel is at the horizon. Nowadays PBR is the new holy grail, and so on.

Same goes for mesh size. Not long ago 1k tris was high poly for games. Then it was 5k, then 10k. Now we are at 50k … . Same goes for texture size. There were times when you have put all graphics of a game at a single 1024x256 chipset. Nowadays you use a 4096 texture for just a face of a character …

Would you use a game engine that uses 8 bit, means 256 colours, nowadays? Would you play a game like Assassins creeds or Witcher 3 with a character made of 1000 tris? I highly doubt so :slight_smile:

We have the same limit dilemma for the meshes with the lightmaps in Unity too. The size is capped at 2048 since years. But using a 4096 lightmap runs just fine, there’s a extension for that around. And the bigger size makes simply more sense in some situations, like for the shadows of the trees at a landscape. The heightmap size is also capped when i remember correct.

Unity should deliver freedom, not limitations. It’s the artists decision where to set the limits. Better said, the target platform and your current project decides that for you. A game with a dozen 50k characters onscreen will most likely lag a bit when you try to play that game at a mobile phone. But might just work fine at a PC. It’s all about the target platform and how many polygons just works. And as told before, polycount isn’t the bottle neck anymore.

You can find an interesting read about poly count here. It’s a bit aged nowadays. But nevertheless interesting: http://www.rsart.co.uk/2007/08/27/yes-but-how-many-polygons/

For example, 8 years ago, Lost Planet. :

Bad artists? :slight_smile:

Indeed. And what do you do with a level mesh (notice that i do not mean a heightmap based terrain here) that has over 65k vertices, and where i simply don’t need chunks for performance reasons? It gets split, and that means to have gaps. There is just no way around the floating point errors when you have several independant meshparts. And this results into visible gaps where the light shines through and the antialias fails.

Of course there are workarounds. The usual workaround is to extend the areas around the gaps, to extrude faces out of the involved edges, and bend them a bit backwards so that you have a X kind overlapping at the cutting edge. But that shouldn’t be necessary at all. It’s extra work. And it’s a workaround, not the solution.

2 Likes

You can make seamless chunks. It’s not always simple, but it’s just about always possible.

http://scrawkblog.com/2013/06/04/massive-terrain-in-unity/
http://scrawkblog.com/2013/03/21/creating-seamless-terrian-tiles-in-unity/

Just to prevent further misunderstandings, and the third time, i talk about mesh terrains, mesh level geometry. Handshaped levels. Not heightmap based ones, not the inbuilt Unity terrain :slight_smile:

Of course, everything is possible. I already named the workaround for the gaps problem. It’s just the question if there are better/easier solutions around for the problem. The best fix for the 16 bit limit dilemma would be a 32 bit mesh component.

The question is of course how hard or easy it is to implement such a 32 bit mesh component in Unity. And how many years it may take.

As told, i have abandoned a project because it was ways too much effort in Unity because of the 65k limit. And you better don’t hold your breath for promised features. That’s why i’m looking for other solutions at the moment where i could realize my project. Unreal 4 for example doesn’t have such a 65k limit anymore afaik.

The question is, does Unity 5 still have this limit. That’s unanswered. Maybe somebody with Unity 5 Beta can answer this?

Every engine has limitations, so long as you don’t have full source access. Unfortunately, sometimes an engine with limitations most meets your needs in other respects, and you wind up spending more time on workarounds than development. Still beats writing an engine from the ground up.

How many vertices do you think are in this mesh? How many seams do you see? It’s not unity terrain.

https://www.youtube.com/watch?v=4ATkcRCGu3E

But it is also not a closed levelmesh like inside a castle neither. Nothing where the sun could shine through the seams. What you show here was based at a heightmap at one point. And a closed levelmesh like a castle has lots of such seams, while you stumble across the seams at your shown terrain just every now and then. Last but not least, for this kind of terrain it makes more than sense to chunk the parts for performance reasons. But not for a castle level.

And again, i know it is possible, but to make the seams bulletproof is pain in the ass and lots of work. Work that would not be necessary when there would be a 32 bit mesh filter. And for special things besides such levelgeometry it is too much work, not worth the effort. Unity is behind here.

Or you simply migrate engines. A little searching seems to indicate that Unreal 4 does not have this limitation. I don’t want to turn this into a comparison thread, but at some point Unity will have to step up and provide support for more vertices.

1 Like

Maybe an optional 32-bit int index could be a future Pro-only feature.

Maybe this is better then:

https://www.youtube.com/watch?v=51JNyjBcDMo

Or maybe take it one step further and build something like this:

https://www.youtube.com/watch?v=POb4MpIuymQ

Infitie worlds must be impossible with 16 bit limitations :smile:

Not really better, sorry. Still no closed levelmesh where the sun could shine through the gaps in the level geometry as it usually does then without a workaround. It’s not about infinite levels. It’s about the 16 bit limitation of the mesh component, which is in the way here and there.

This thread starts to make me heavily scratch my head why the 16 bit limitation of the mesh component gets defended so hard here. It’s a limit. And a limit is limiting as the name says.

And to repeat me again, it is not the point what is possible with 16 Bit when you use the right workarounds. But the point that several tasks would be much easier or even possible at all with 32 Bit. Have fun with mesh operations that goes across several chunks for example …

And as told before, and just to repeat me again and again (i don’t give up hope that it gets read at one point) , Unity should offer freedom, not limitations. Unreal 4 has 32 bit, Cry engine has 32 bit, Unity has 16 bit. Unity is behind.

@Tiles - Doesn’t matter if it is 16, 32, 64 or 128 bit limitations… sure, Unity can increase the limitation but I honestly think they got much more important things to work on as a 16 bit limitation isn’t even worth shrugging at…

Instead of trying to force a technical change to solve your problem… I would ask myself why so many others aren’t even bothered by it? The best part of the whole discussion is that you will end up at square one the next time you try to top yourself with an even bigger, majestic chunk of mesh and need even more bits…

Just to be fair, mesh operations that span chunks is an everyday thing with voxel engines and that doesn’t scare me one bit… sure… I might scratch my head if I do a poor implementation but that is completely my own fault, not the game engines or computers :wink: Heck, even regular games got their own version of “chunks” that you have to deal with, one famous type you might know about is called octree’s…

Every engine offers both freedom and limitations in their own ways :wink:

1 Like

I don’t know how much more work it would be for Unity to maintain 2 different systems or even possible with their current implementations. It does not sound a good idea to just switch to 32b if the current problem affects only minority of user base and even then it is probably possible to overcome by different visual or technical design solutions in most cases.

Unreal 4 and Cry Engine are not exactly lightweight engines.

That’s true. The biggest difference between AAA games is how badly the customer gets screwed over by the integration of in house DRM of the publisher :stuck_out_tongue:

Ah, I just got back from my little 2 month journey of UE4. It would seem Unity is the better environment for me. Never got my free source access from github (applied in November btw, damn they are backed up!) and as nice as it looks, I’m not one of those graphics > gameplay weirdos. I can get started faster and accomplish more in less time with Unity, and it’s got a head start on my VR tool of choice, the stem! Unity may cost more but it’s just too good to leave.

Also, why is this an issue, people? It’s not like the model breaks and unity crashes, the model gets split into pieces. Why can’t you just model and rig the model in parts? If they move together, people won’t even notice!

Well, @Tiles says his terrain ends up with cracks. The vertices across the sub meshes are meant to be identical, so I suspect it’s when the terrains end up with different levels of detail, so one side has a straight edge between verts, and the other has an additional vert put where the terrain engine thinks the terrain would be based on the sloping of the terrain.

Also re: limitations: why does it all have to be one mesh? Why not just import two? do your characters need to be 65535 up close? If so it’d probably be a game industry first. As for a building, or terrain, that can be split up nicely too. I’m pretty sure it’s possible to go full movie quality with this limitation, and if it gives us more speed, then so be it.

Just to be clear, I was never defending the limitation, just stating that all engines have limitations. It’s just something to consider when deciding to use a particular engine for a particular job. UE4 has limitations. Not this same particular limitation, but the limitations are there.

It does matter for what i wanted to do. Unity is technically behind here, and made my life too comlicated. So i stopped the project, and look for alternatives now.

That’s one posibility. In my case it was clearly a floating point problem not a lod problem. The vertices didn’t match in all cases after import. Which ended in visible seams where the light came through.

And just to explain it once more: it is not a terrain thing. We talk about the 16 bit limitations. A levelmesh is just one case where this could disturb. It doesn’t necessarily have to be a terrain.

Fair point. But there is clearly a resistance against an improvement here. And i wonder where this comes from :slight_smile:

Unreal 4 and Cry Engine uses 32 bit nowadays. That’s the direct competitors. Now why didn’t they stick with 16 bit when all is fine with it? :wink:

Of course, every engine has limitations. And the art is to get your things done, even with the limitations. It’s usually not a problem as long as you can work around in a way that doesn’t bother you this much that it is wiser to switch the engine. The right tool for the right job. Unfortunately i have reached this point here.

Dunno how often i have repeated it now. But just for the sake to repeat it one more time ^^

Because it CAN produce gaps with several submeshes. Not necessarily, but it can happen. Happened to me.
Because it CAN cause shading and AA problems where you need to work around. Happened to me.
And because it’s more complicated to work with chunks when you could work with a single mesh. Not impossible, but more complicated. Under special circumstances not worth the hassle because it becomes too complicated then. Happened to me.

And to repeat this point also: there are situations where you even need chunks for performance reasons. But that should be the decision of the artist or programmer. Not a hardwired limit of the engine.

1 Like

This pretty much sums up the argument I thought was taking place. Hardware will always have limitations, and chunks are the best way to handle those limitations. Whether that’s now with chunks of terrain with 65,535 vertices or in the future with chunks of terrain with 9,223,372,036,854,775,807 vertices. The only decision the artist / programmer is making is whether or not they’re going to be unreasonable.

It’s the same thing with unity using floats for transforms. Using doubles instead to fix spatial jittering only puts a band-aid on the underlying problem of reality - no system is ever going to overcome the problem of dealing with infinity. The answer is always going to be chunks and a bit of woo :wink:

Fair points all. But you wouldn’t work with 256 colours anymore, would you? Hardware evolves. And so should the limits of the software :slight_smile:

Too lazy too read everything, but Unity cannot handle more than 65k vertices per mesh automatically? Really?

Even Ogre3D does that automatically for you. Let’s not even speak of other engines.

Also Assassins Creed models are low poly because there are many on screen at the same time, sometimes 30 or more. Look at fighting games with just 2 models on screen at once, very different numbers.