Home

Awesome

What is changing the tranform (position / rotation / scale)?

When working with Unity you've probably asked that question when a transform position/rotation/scale is changing and you have no idea why.

Generally you'd set a breakpoint and debug it this way but for transform you cannot easily do that. The best way seem to be replacing all calls that modify it directly, eg transform.postion = newPosition to some interceptor code that you can control, like Interceptor.SetPosition(transfrom, newPosition)

Unfortunately this is not always possible or easy.

There's now a simpler to use tool that'll allow you to add events to Unity dlls. With that it's possible to write event driven code, eg transform.SetPositionExecuting += (sender, e) => <your handler code> https://github.com/handzlikchris/Unity.MissingUnityEvents

This tool will help you do exactly that but automatically and without modifying any of your source code. Transform Setter Interceptor Workflow

Making This Tool Better - Visual Transform Changes Debugger

I've went further with this concept and created a tool that focuses on tracking ANY changes made to ANY transforms which is then neatly laid out in friendly GUI. Check it out at: https://immersiveVRTools.com/projects/transform-changes-debugger

Visual Transform Changes Debugger features showcase video

Approach

The tool will use IL Weaving and will redirect all the set calls to transform.position, transform.rotation and transform.scale to TransformSetterCallInterceptor where you could add any actions needed.

eg. Method signature and default implementation:

public static void InterceptSetPosition(Transform originalTransform, Vector3 setTo, Object callingObject, string callingMethodName)
    {
        //do whatever you want to do
        originalTransform.position = setTo;
    }

Method will give you access to

Setup

You can clone this repository and run it in Unity as an example.

To import into your project:

  1. In Unity add a package dependency to Malimbe which will hook up to Unity build process so the weaver code can work on your assemblies after Unity is done compiling them.

You can do that via manifest.json file located in /Packages folder. You'll have to add following entries (as per Malimbe page)

  
  "scopedRegistries": [
    {
      "name": "npmjs",
      "url": "https://registry.npmjs.org/",
      "scopes": [
        "io.extendreality"
      ]
    }
  ],
  "dependencies": {
    "io.extendreality.malimbe": "9.6.5",
    ...
  }
}
  1. Download and import TransformSetterInterceptor
  2. Recompile
  1. Now changes to your scripts will trigger recompile which will in turn trigger IL Weaving to intercept your calls

Filtering to specific transform

There's a simple script TransformSetterInterceptorFilter that'll allow you to further narrow down to exact transform that you're interested in via simple drag and drop. From there it'll be very easy to trace what's happening via logging, stack-trace or whatever custom approach you adopt.

Runtime Performance

At build time calls to transform setters will be intercepted and directed to static interceptor class, that should not have significant impact on performance as it's simply adding static method call.

For fallback weaving IL instructions are added at every place that is redirected and Debug.Log will be called for all of them, this call actually gets StackTrace which is rather quite costly. You can stop fallback weaving by removing FallbackSampleNameFormat from configuration.

At later stage I'll look into weaving additional 'if' statements so it can check if change should be printed.

Configuring Interception

In the package, you'll find TransformSetterCallInterceptor.cs with intercept methods. You can adjust that as needed. There's also an assembly attribute specified TransformSetterCallRedirector where you can configure some more options.

Using asmdef / Fallback Interception

Separate assemblies will not have access to that TransformSetterCallInterceptor when that happens interception will still be performed but using IL as defined in ModuleWeaver - it'll use Debug.Log with

Then you can further narrow it down from log console window and find exactly what you're after.

This is helpful if you like to weave external packages that you don't control (and don't wish to embed) - if you have control over assembly you can copy TransformSetterCallInterceptor.cs class with assembly attribute there.

Configuring fallback interception

You can control few parameters of fallback IL weaving, it's done via XML attributes in FodyWeavers.xml

Configuring Malimbe

You can further configure Malimbe via FodyWeavers.xml file, you'll find the details in their repository.

Known issues