Correct in assuming xBox, PlatStation PC’s etc etc & phone games & on line game like World of Warcraft have different rules ?
I’m curious about all the rules for every thing but mostly xBox, PlatStation PC’s etc etc.
What should the polycount be ?
What is to high of a polycount ?
What’s the standard maps and map size ?
etc etc
Would the rules change from Blender ,Unreal ,Unity ,etc etc ?
Thanks a lot
There aren’t really any rules. It depends on whether it’s for mobile/console/PC/VR and so on. For android you can have 65k vertices per mesh. For PC you can have anything from a few thousand to a million (which you probably don’t want). AAA stuff is probably 50-100k tris for FPS stuff, but it really depends on the genre. I used high poly count characters before but with many shape keys models took really long to import into the game engine so I replaced them with lower poly models. You can just tessellate characters anyway. Of course you can use LODs too and show a high poly character when you’re close and a lower res model when you’re far away.
The texture sizes change too. This is noticable in something like World of Warcraft, since it’s an MMORPG there can be tons of players/monsters/buildings on the same screen at once so texture sizes are pretty small. If you only see a few characters on the screen at a time you can use bigger textures. Big textures are usually 4-8k and smaller are 1k or so. But you can use whatever you want.
For VR you may want higher poly counts for meshes instead of normal maps since you can notice it looks fake. You can use parallax mapping though but then you have a higher shader cost anyway. Generally fancy shaders are more expensive than raw geometry (high poly counts) so I wouldn’t really worry too much about the poly count. You don’t want to throw in a sculpted model, you have to retopo it but you don’t have to be very concerned about poly counts.
I don’t know standard map sizes. That depends too much on the genre too. But you can have smaller maps like in Rocket League or something or lots of maps that are streamed like in Fallout 4 (with procedural levels). In UE4 there’s a 2km*2km limit for multiplayer right now which is pretty huge already. It may get fixed though, I saw a pull request on the Epic Games github.
And the rules do change depending on the game engine. You will probably get worse performance in the BGE (which is why I don’t recommend it). Personally I use UE4 because it’s easy to use and looks good, and everything you need is free (unlike Unity in most cases).
Whatever balances your performance and design needs on a given platform.
One that consumes resources inefficiently whether computational or electrical. No LOD, Tesselating coplanar geo for instance.
Check the sizes of maps in your target genre. Not that size correlates with uptake AFAIK.
Most likely. Profiling will tell you best though.
There are no general rules, it depends on a lot of factors. In general, any polygon that isn’t fulfilling a purpose is one too many, but you have to weigh that against the time you invest into modeling and the performance benefits you are (not) getting.
A few things to consider:
Animated meshes, especially those with skeletal animations, are generally more expensive per vertex. Depending on where the work is performed (GPU and/or CPU), performance may scale differently.
It’s common for game engines to have a 65k triangle limit per mesh, even on the PC. This is because 65k fits into a 16-bit index buffer, halving memory cost over a 32-bit index buffer. On some devices (especially mobile) this is also a hardware limit. Above that, meshes will have to be split up (which the engine might do automatically), increasing the amount of draw calls required.
Less triangles are usually good, but large (onscreen) triangles are bad. You may actually increase performance by having more triangles, in that case. Also, there’s a minimum amount of triangles (probably around 1000 on a desktop GPU) per draw call, below which there is no performance improvement for having less triangles.
I’ve mentioned draw calls, but I haven’t explained what they are. Basically, you need one draw call to draw one mesh, but you might need more if it has multiple different materials or for multipass rendering. Game engines will usually combine static meshes with the same material into a batch, so you may actually end up with significantly less draw calls if you follow the specifications. Optimizing for draw calls can be crucial (especially on mobile), but it will become less important with low-overhead APIs like D3D12 and Vulkan.
As far as textures are concerned, keep them power-of-two dimensioned (e.g. 256x256, 1024x512, 64x512…). It usually doesn’t hurt to keep them at high resolution, because most game engines can scale the textures automatically as a setting.
However is always better to aim as few as polygons as possible. Save whenever you can but keep an eye on the quality as well.