Maximizing performance of 3D user-generated assets in Unity The document discusses optimizing 3D assets in Unity. It begins with an introduction and agenda, then covers optimization principles through examples from a trail renderer asset. The examples demonstrate reducing garbage collection by using queues instead of arrays, reusing components instead of creating new game objects, and comparing distances through dot products instead of taking square roots. Hands-on demonstrations are provided. Key takeaways are to profile for garbage collection, eliminate it by reusing objects when possible, and optimize comparisons.

1. Maximizing performance of
3D user-generated
assets in Unity
Max Pixel
Freeform Labs

2. DBA since May 2015
Incorporated March 2016
Your Speaker
2003
Games & Websites as a hobby
2008
Freelance
web development
2011 - 2014 - 2015
USC Film Production
→
Interactive Entertainment
Freeform Labs
Inception Feb 2014
Funded March 2016

5. Q: Why is it
freezing?

6. A: GARBAGE
COLLECTIO
N

7. The Agenda
Optimization principles
Real examples
???
PROFIT

8. Hands-on Demonstration!
Starting Point:
http://wiki.unity3d.com/index.php/OptimizedTrailRenderer
https://github.com/M-Pixel/unity-procedural-mesh-optimization-presentation

9. Encapsulation grumble grumble
public float maxAngle → [SerializeField] private float _maxAngle
Hold down alt for magic Buy ReSharper for more magic
Full disclosure: I have no affiliation with ReSharper. They don’t give me money. I just really like it.

10. Start
private void Start()
{
_trailObj = new GameObject("Trail"); // Why have a game object that just controls another one?
_trailObj.transform.parent = null;
_trailObj.transform.position = Vector3.zero;
_trailObj.transform.rotation = Quaternion.identity;
_trailObj.transform.localScale = Vector3.one;
var meshFilter = (MeshFilter)_trailObj.AddComponent(typeof(MeshFilter));
_mesh = meshFilter.mesh;
_trailObj.AddComponent(typeof(MeshRenderer));
_instanceMaterial = new Material(_material);
_fadeOutRatio = 1f / _instanceMaterial.GetColor("_TintColor").a;
_trailObj.GetComponent<Renderer>().material = _instanceMaterial;
}
Prefer Observation
[SerializeField] private Transform _source;
RequireComponent
[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
public class Trail : MonoBehaviour {
Destroy(_trailObj);
Destroy(this); // ???
New Start
private void Start()
{
_mesh = GetComponent<MeshFilter>().mesh;
_instanceMaterial = new Material(_material);
_fadeOutRatio = 1f /
_instanceMaterial.GetColor("_TintColor").a;
_renderer = GetComponent<MeshRenderer>();
_renderer.material = _instanceMaterial;
}
(because the mesh origin needs to
be stationary, that’s why)

11. Avoid Reflection
if (_pointCnt < 2)
{
_trailObj.GetComponent<Renderer>().enabled = false;
return;
}
_trailObj.GetComponent<Renderer>().enabled = true;
Revised
if (_pointCnt < 2)
{
_renderer.enabled = false;
return;
}
_renderer.enabled = true;
Add to Class
private MeshRenderer _renderer;
In Start
_renderer = GetComponent<MeshRenderer>();

12. Optimize by actually optimizing, not reducing quality
// Optimization
if (_pointCnt > _optimizeCount)
{
_maxAngle += _optimizeAngleInterval;
_maxVertexDistance += _optimizeDistanceInterval;
_optimizeCount += 1;
}

13. Heap vs Stack
Long-term, Garbage Collected
● Class instances
● Arrays
○ Even tiny ones (ﾉಥ益ಥ)ﾉ
Very short-term
● POD
● Structs
○ … sometimes

14. Points are being deleted and reallocated at runtime
for (var i = _pointCnt - 1; i >= 0; i--) {
var point = _points[i];
if (point == null || point.TimeAlive > _segmentLifetime) {
_points[i] = null;
_pointCnt--;
} else break;
}
if (_emit) {
if (_pointCnt == 0) {
_points[_pointCnt++] = new Point(_source.transform);
_points[_pointCnt++] = new Point(_source.transform);
}
...

15. indices > _pointCnt are ignored anyways
for (var i = _pointCnt - 1; i >= 0; i--) {
var point = _points[i];
if (point == null || point.TimeAlive > _segmentLifetime) {
_points[i] = null;
_pointCnt--;
} else break;
}
if (_emit) {
// Make sure there are always at least 2 points when emitting
if (_pointCnt < 2) {
if (_pointCnt < 1) InsertPoint();
InsertPoint();
}
...

16. RAM & Speed
Putting things away and taking
them out again takes a lot of time

17. Shifting is unnecessarily expensive
Removing old points
for (var i = _pointCnt - 1; i >= 0; i--){
var point = _points[i];
if (point.TimeAlive >
_segmentLifetime) {
_pointCnt--;
} else break;
}
Adding new points
for(int i = pointCnt; i > 0; i--)
points[i] = points[i-1];
points[0] = new Point(transform);
pointCnt++;
What about adding new points on top of the
array?
Just reverses problem
What about a Queue?
Yes!

18. using (var e = _ints.GetEnumerator()) {
while (e.MoveNext()) {
_current += e.Current;
}
}
for (var i = 0; i < _ints.Count; i++) {
var item = _ints.Dequeue();
_current += item;
_ints.Enqueue(item);
}
Unity’s Enumerator Problem

19. Temporary Arrays
// Rebuild it
var vertices = new Vector3[pointCount * 2];
var uvs = new Vector2[pointCount * 2];
var triangles = new int[(pointCount - 1) * 6];
var meshColors = new Color[pointCount * 2];
5.3 MB/s

20. Comparing Distance
var sqrDistance = (
_points[1].Position -
_source.transform.position
).sqrMagnitude;
if (sqrDistance > _minVertexDistance * _minVertexDistance)
{
…
}
if (Vector3.Dot(a, b) > _preSquaredBasis) …

21. Comparing Distance
a2 + b2 = c2
a2 + b2 + c2 = d2
d = sqrt ( a2 + b2 + c2 )
Square root is a relatively expensive operation
Dot == a2 + b2 + c2
Vector3.Distance == Sqrt ( Dot ( A , B ) )
Comparing dots is faster than comparing distances
Double trouble: Unity’s Vector3.Dot uses doubles

22. Other Optimizations
Use arrays for vertex, color, uv buffers (triangle buffer must be a List)
Make Point a struct (Pre-allocate)
Eliminate (inline) pool
Eliminate Points altogether, work directly with vertices?

23. What about extra vertices?
It turns out, any number of extra
verts/colors/etc. have negligible impact
Only triangles matter!
mesh.SetTriangles takes a List

24. The final result...

25. 34 to 60KB garbage + .41ms
vs
0B garbage + .24ms
(per frame)

26. Takeaways
Use the Unity Profiler’s gcalloc column to find out where heap allocation occurs
First use utilities like Queue, List to eliminate GC, then once your pattern is confirmed
to work and the design is locked down, you can refactor to naked arrays
Reuse Arrays, Delegates, G.O.s whenever possible
Start/end indexes
Pool unused instances
Don’t use IEnumerators, find a workaround
When comparing distances, use Dot instead of Distance

27. Thank you!
max@freeformlabs.xyz