Unused Texture Detection Unity

2025-03-28 10:33 UTC o3-mini-high Open in ChatGPT ↗

Unity doesn’t include a built‐in tool specifically designed to locate all unused textures in your project. However, you have a few options:

Third-Party Tools:
There are several asset management tools available on the Unity Asset Store (like Asset Hunter Pro) that scan your project and list unused assets—including textures. These tools typically examine scenes, prefabs, and other asset dependencies to determine what’s not in use.
Custom Editor Scripts:
You can create custom editor scripts that leverage Unity’s AssetDatabase API. For example, you can use AssetDatabase.FindAssets("t:Texture2D") to list all textures and then check each texture’s references using functions like AssetDatabase.GetDependencies. Keep in mind that textures might be referenced indirectly (e.g., through materials), so this method requires careful handling.
Manual Checking:
For smaller projects, you might manually inspect textures by right-clicking on them in the Project window and selecting “Find References in Scene.” However, this method is impractical for larger projects.

Each of these methods has its pros and cons, and your choice will depend on your project’s complexity and your comfort with scripting editor tools.

Does that help clarify your options?

This behavior often happens because pausing the timeline stops its evaluation, and if the object has an Animator (or similar component) it can revert to its default state when not actively driven by the timeline. In other words, when you call Pause() on the PlayableDirector, the timeline stops updating the animated properties, and the object’s natural state (or the one driven by its Animator component) takes over.

Here are a few common workarounds:

• Use playbackSpeed = 0 Instead of Pause():
By setting the PlayableDirector’s playbackSpeed to 0, you keep the timeline “frozen” at the last evaluated frame without halting evaluation completely. This can prevent the object from snapping back.

• Adjust Animator Settings:
If your object is animated via an Animator, check its update mode and culling settings. For example, setting the Animator’s culling mode to “Always Animate” may help ensure that the timeline’s values persist even when playback is paused.

• Custom Scripting:
As an alternative, you could capture the object’s transform or animated properties at the moment you want to pause and reapply them manually when needed.

• Clip Extrapolation:
Make sure that your timeline clips are set to “Hold” at the end. This tells Unity to maintain the last keyframed value rather than reverting to a default state once the clip’s time range is exceeded.

In summary, the snapping occurs because pausing stops the timeline’s active evaluation, leaving the object to fall back to its default behavior. Adjusting how you pause (or modifying the Animator settings) can help maintain the state you want.

I have some text on the ceiling, and I want to always face the user and be rotated in a reading orientation. however if the user looks directly upwards, an awkward flip can happen. how can i solve this?

here’s my imperfect code

using System.Collections; using System.Collections.Generic; using UnityEngine;

public class OrientCeilingText : MonoBehaviour { public Transform targetObject;

private Camera cam;

// Start is called before the first frame update
void Start()
{
    cam = Camera.main;

}

// Update is called once per frame
void Update()
{
    var f = cam.transform.forward;
    f.y = 0;

    targetObject.rotation = Quaternion.LookRotation(Vector3.down, -f);

}

}

The issue is that when the camera looks almost directly up (or down), your code zeros out the Y component of its forward vector, which can leave you with a near-zero horizontal vector. When you pass that degenerate vector into Quaternion.LookRotation (as the “up” vector), the rotation becomes undefined and results in an awkward flip.

A common fix is to check whether your horizontal forward vector has become too small and, if so, substitute it with a fallback vector (for example, the camera’s right vector or a fixed horizontal vector). Here’s an updated version of your code:

using UnityEngine;

public class OrientCeilingText : MonoBehaviour
{
    public Transform targetObject;
    private Camera cam;

    void Start()
    {
        cam = Camera.main;
    }

    void Update()
    {
        // Get the camera's forward vector, but remove any vertical component
        Vector3 f = cam.transform.forward;
        f.y = 0;

        // Check if f is nearly zero (which happens if the camera is looking almost vertically)
        if (f.sqrMagnitude < 0.001f)
        {
            // Use the camera's right vector as a fallback horizontal direction
            f = cam.transform.right;
        }

        // Compute the rotation. Using Vector3.down as the forward parameter because the text is on the ceiling,
        // and -f as the up vector to keep it oriented relative to the camera's horizontal direction.
        targetObject.rotation = Quaternion.LookRotation(Vector3.down, -f);
    }
}

Explanation

Removing Vertical Influence:
By setting f.y = 0, you try to maintain only the horizontal component of the camera’s forward vector. However, if the camera is looking straight up or down, this value becomes (nearly) zero.
Fallback Vector:
Checking if (f.sqrMagnitude < 0.001f) allows you to detect when the horizontal direction is too small. In that case, using cam.transform.right ensures you have a valid horizontal vector to use, which prevents the flip.
Quaternion.LookRotation Usage:
The first parameter (Vector3.down) defines which way the “front” of the text should point, while the second parameter (-f) determines the upward direction of the text. Adjust these parameters if your text orientation needs a different setup.

This approach should prevent the awkward flip when the camera is looking directly upward (or downward).

Even like that the flipping issue isn’t solved at all.

Also I want the text to rotate smoothly, smoothdamp style

using UnityEngine;

public class OrientCeilingText : MonoBehaviour { public Transform targetObject; private Camera cam;

void Start()
{
    cam = Camera.main;
}

void Update()
{
    // Get the camera's forward vector, but remove any vertical component
    Vector3 f = cam.transform.forward;
    f.y = 0;

    // Check if f is nearly zero (which happens if the camera is looking almost vertically)
    if (f.sqrMagnitude < 0.001f)
    {
        // Use the camera's right vector as a fallback horizontal direction
        f = -cam.transform.up;
        f.y = 0;
    }


    // Compute the rotation. Using Vector3.down as the forward parameter because the text is on the ceiling,
    // and -f as the up vector to keep it oriented relative to the camera's horizontal direction.
    targetObject.rotation = Quaternion.LookRotation(Vector3.down, -f);
}

}

One approach is to compute a target rotation that’s stable even when the camera is looking straight up, and then interpolate to that rotation using an exponential smoothing factor (or Slerp) each frame.

Below is an example that:

Projects the camera’s forward vector onto the horizontal plane (relative to the text’s “down” direction).
Falls back to the camera’s right vector if that projection is nearly zero.
Computes a target rotation where the text’s “forward” is fixed as Vector3.down (so it faces the ceiling) and its “up” is aligned with the negative of that horizontal vector.
Smoothly interpolates toward the target rotation using a Slerp with an exponential smoothing factor.

Try this code:

using UnityEngine;

public class OrientCeilingText : MonoBehaviour
{
    public Transform targetObject;
    // The smaller this value, the slower the smooth interpolation.
    public float smoothTime = 0.2f;

    private Camera cam;

    void Start()
    {
        cam = Camera.main;
    }

    void Update()
    {
        // Get the camera's forward direction.
        Vector3 camForward = cam.transform.forward;
        // Project it onto the plane perpendicular to Vector3.down (i.e. the horizontal plane)
        Vector3 projected = Vector3.ProjectOnPlane(camForward, Vector3.down);

        // If the camera is looking nearly vertically, the projection can vanish.
        // In that case, use the camera's right vector (projected onto the same plane) as a fallback.
        if (projected.sqrMagnitude < 0.001f)
        {
            projected = Vector3.ProjectOnPlane(cam.transform.right, Vector3.down);
        }

        projected.Normalize();

        // Create a target rotation:
        // - We want the text's "forward" to be Vector3.down (so the text's front is facing downward from the ceiling).
        // - We want the text's "up" to be aligned with the negative of the projected horizontal direction,
        //   ensuring the text is oriented for easy reading.
        Quaternion targetRotation = Quaternion.LookRotation(Vector3.down, -projected);

        // Smoothly interpolate from the current rotation to the target rotation.
        // Here, we use an exponential smoothing factor so that the rotation has a damped effect.
        float t = 1 - Mathf.Exp(-Time.deltaTime / smoothTime);
        targetObject.rotation = Quaternion.Slerp(targetObject.rotation, targetRotation, t);
    }
}

How This Helps

Stable Reference When Looking Up:
By projecting the camera’s forward onto the horizontal plane (and using a fallback when needed), you avoid a near-zero horizontal direction that can cause the rotation to flip.
Smooth Rotation:
The code computes a damping factor t based on smoothTime and uses Quaternion.Slerp to smoothly rotate from the current rotation to the target rotation.

Adjust smoothTime to control how quickly the text rotates to follow the camera’s changes. This approach should eliminate abrupt flips and provide smooth, damped rotations even when the user looks directly upward.

Below is one solution. Instead of fully following the computed target rotation, you can extract the Euler angles and clamp the Z rotation to a defined range. This creates a “blind cone” where the text’s Z rotation will never exceed your specified bounds. For example:

using UnityEngine;

public class OrientCeilingText : MonoBehaviour
{
    public Transform targetObject;
    public float smoothTime = 0.2f;   // Controls the smoothness of the rotation.
    public float minZAngle = -30f;    // Minimum allowed Z rotation (in degrees).
    public float maxZAngle = 30f;     // Maximum allowed Z rotation (in degrees).

    private Camera cam;

    void Start()
    {
        cam = Camera.main;
    }

    void Update()
    {
        // Get the camera's forward direction.
        Vector3 camForward = cam.transform.forward;
        // Project it onto the horizontal plane relative to the ceiling (using Vector3.down as "up").
        Vector3 projected = Vector3.ProjectOnPlane(camForward, Vector3.down);

        // Fallback: if the projection is nearly zero, use the camera's right vector.
        if (projected.sqrMagnitude < 0.001f)
        {
            projected = Vector3.ProjectOnPlane(cam.transform.right, Vector3.down);
        }
        projected.Normalize();

        // Create the target rotation.
        // We set the text's "forward" to Vector3.down (so it faces the ceiling)
        // and its "up" direction to -projected (so it's aligned for reading).
        Quaternion targetRotation = Quaternion.LookRotation(Vector3.down, -projected);

        // Convert the target rotation to Euler angles so we can clamp the Z axis.
        Vector3 euler = targetRotation.eulerAngles;
        // Normalize the Z angle to be in the range [-180, 180] for proper clamping.
        euler.z = NormalizeAngle(euler.z);

        // Clamp the Z angle to the specified blind-cone range.
        euler.z = Mathf.Clamp(euler.z, minZAngle, maxZAngle);

        // Convert back to a Quaternion.
        targetRotation = Quaternion.Euler(euler);

        // Smoothly interpolate from the current rotation to the target rotation.
        float t = 1 - Mathf.Exp(-Time.deltaTime / smoothTime);
        targetObject.rotation = Quaternion.Slerp(targetObject.rotation, targetRotation, t);
    }

    // Helper function to convert an angle to the range [-180, 180].
    float NormalizeAngle(float angle)
    {
        angle %= 360f;
        if(angle > 180f)
            angle -= 360f;
        return angle;
    }
}

Explanation

Projection of Camera Direction:
The camera’s forward vector is projected onto the horizontal plane (relative to the ceiling’s downward normal) so that we have a horizontal reference. If that projection is nearly zero (for example, if the camera is almost directly overhead), a fallback (the camera’s right vector) is used.
Determining the Target Rotation:
Using Quaternion.LookRotation(Vector3.down, -projected), the text is oriented so that its front (its local forward) points downward, while its up direction is influenced by the camera’s horizontal direction. This sets the basic orientation for reading.
Clamping the Z Axis:
By converting the quaternion to Euler angles, we can isolate and clamp the Z rotation (which controls how much the text is tilted/rotated around its forward axis). The helper function normalizes the Z angle to the range [-180, 180], and then Mathf.Clamp ensures the angle stays within your defined blind cone (between minZAngle and maxZAngle).
Smooth Dampening:
Instead of snapping directly to the target rotation, Quaternion.Slerp is used to interpolate smoothly toward the clamped target rotation.

You can adjust minZAngle and maxZAngle to control the extent of the “blind cone” where the text’s rotation on the Z axis is prevented from going beyond your preferred range.

In Unity you can use quaternions to rotate a vector around an axis. For example, you can use:

Vector3 rotatedVector = Quaternion.AngleAxis(angleInDegrees, axis) * originalVector;

Here,

angleInDegrees is the rotation angle in degrees.
axis is the axis of rotation (typically normalized).
originalVector is the vector you want to rotate.

This multiplies the quaternion by your vector, applying the rotation.

If you’re using the Oculus Integration package, you can reset (or “recenter”) the tracking by calling one of the built-in methods. For example, the simplest way is:

OVRManager.display.RecenterPose();

You might call that in response to a button press or another event to mimic the Oculus button behavior. Here’s a quick example that resets tracking when you press the R key:

using UnityEngine;

public class RecenterOculus : MonoBehaviour
{
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.R))
        {
            OVRManager.display.RecenterPose();
        }
    }
}

If you’re using Unity’s XR Plugin Management instead of the Oculus Integration package, you can recenter by accessing the XR input subsystem and calling its recenter method. For example:

using UnityEngine;
using UnityEngine.XR;
using System.Collections.Generic;

public class RecenterXR : MonoBehaviour
{
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.R))
        {
            List<XRInputSubsystem> subsystems = new List<XRInputSubsystem>();
            SubsystemManager.GetInstances(subsystems);
            foreach (var subsystem in subsystems)
            {
                subsystem.TryRecenter();
            }
        }
    }
}

Both approaches reset the position and rotation of the headset tracking in a way similar to pressing the Oculus button. Choose the one that fits your project’s setup.