Is Storing Rigidbody In a Variable And Using It To Access Rigidbody Good Practise

Hi,

I've heard from somewhere that if you access transform often in a script, then it is better to store it in a variable and access the transform via the variable. Though I've also heard that this is not the case for accessing the gameObject.

I wonder if accessing rigidbody via a variable is faster than accessing it directly. I mean, is there a difference between these two lines of code in terms of performance:

1- rigidbody.AddForce( Vector3.forward );

2- rigidbodyVariable.AddForce( Vector3.forward );

Thanks in advance.

 

It's the same thing as far as I know. If the script is attached to the gameObject you are trying to access, then it is not needed to store the rigidbody. However, if you are accessing the rigidbody from a script attached to something else, it helps to store it to prevent having to find the gameObject with the respective rigidbody everytime you want to alter it.

 

It's a get component lookup and you will see a difference. Lets not spread incorrect data. You should be caching all components.

Storing the variable is faster.

 

How much faster is it then? I never store the variable, since it seems redundant to do so in most cases and it uses memory as well I would guess.

 

There is a little comparison: http://x-team.com/2014/03/unity-3d-optimisation-and-best-practices-part-1/

 

I didn't know that. The docs only mention using a Type for performance. Thanks!

 

I'm reading up on cache this and cache that can't find any reference to exactly how cache'ing is done. How do I cache an object or component?

 

Components are classes, so caching one only stores a new reference. The memory footprint is absolutely negligible .

 

Code (csharp):

1.  
2. public class MyAwesomeScript : MonoBehaviour {
3. private Rigidbody cachedRigidbody;
4.  
5. void Awake() {
6. cachedRigidbody = rigidbody;
7. }
8.  
9. void Update() {
10. cachedRigidbody.AddForce(whatever);
11. }
12. }
13.  

 

This is how I cache. It's very simple and requires no extra modification to your code.

Code (CSharp):

1. public class Test : MonoBehaviour
2. {
3.     new private Rigidbody rigidbody;
4.  
5.     void Awake()
6.     {
7.         rigidbody = base.rigidbody;
8.     }
9. }

This will hide the original rigidbody property behind your cached variable. In order to access the old inefficient property, you will need to use base.rigidbody instead. When you want to access your cached version, simply access it like you'd normally access the non-cached version.

Hope this helps.

 

Ooh. Clever.

 

Although, if you're using that strategy, you should be doubly sure to backup your scripts when you update to 5.0. The convenience accessor properties are going away, and along with that there will be a script updater utility that will replace all "rigidbody" with "GetComponent<Rigidbody>()" in your project's scripts. I wouldn't count on this updater utility being smart enough to know the different between your 'new' accessor and the builtin ones, so it may replace all your now-efficient "rigidbody" references with inefficient "GetComponent<Rigidbody>()" references.

 

Didn't read any of the above, but Mod Robert, and he's correct. You should be cacheing all component types. Unity 4.x doesn't cache them properly, although I hear that in Unity 5, they will be fixing this issue.