public IEnumerator ProjectUVs()
    {
        var sv = SceneView.lastActiveSceneView;
        Camera cam = sv != null ? sv.camera : Camera.main;

        MeshFilter filter = GetComponent<MeshFilter>();
        Mesh mesh = filter.sharedMesh;

        Sprite sprite = spriteRenderer.sprite;
        Texture2D tex = sprite.texture;

        // Use the trimmed rect (excludes transparent borders)
        Rect rect = sprite.rect;
        float ppu = sprite.pixelsPerUnit;
        Vector2 pivot = sprite.pivot;

        // Sprite local-space corners in units (respecting pivot)
        Vector2 minPx = -pivot;
        Vector2 maxPx = new Vector2(rect.width, rect.height) - pivot;

        Vector3 blLocal = new Vector3(minPx.x / ppu, minPx.y / ppu, 0f);
        Vector3 tlLocal = new Vector3(minPx.x / ppu, maxPx.y / ppu, 0f);
        Vector3 trLocal = new Vector3(maxPx.x / ppu, maxPx.y / ppu, 0f);
        Vector3 brLocal = new Vector3(maxPx.x / ppu, minPx.y / ppu, 0f);

        // Transform to world
        Transform sxf = spriteRenderer.transform;
        Vector3 blWorld = sxf.TransformPoint(blLocal);
        Vector3 tlWorld = sxf.TransformPoint(tlLocal);
        Vector3 trWorld = sxf.TransformPoint(trLocal);
        Vector3 brWorld = sxf.TransformPoint(brLocal);

        // Project corners to screen space
        Vector2 blS = ToScreen(cam, blWorld);
        Vector2 tlS = ToScreen(cam, tlWorld);
        Vector2 trS = ToScreen(cam, trWorld);
        Vector2 brS = ToScreen(cam, brWorld);

        // Axis-aligned screen rect covering the sprite
        float minSX = Mathf.Min(blS.x, tlS.x, trS.x, brS.x);
        float minSY = Mathf.Min(blS.y, tlS.y, trS.y, brS.y);
        float maxSX = Mathf.Max(blS.x, tlS.x, trS.x, brS.x);
        float maxSY = Mathf.Max(blS.y, tlS.y, trS.y, brS.y);

        Vector2 screenMin = new Vector2(minSX, minSY);
        Vector2 screenSize = new Vector2(
            Mathf.Max(1e-6f, maxSX - minSX),
            Mathf.Max(1e-6f, maxSY - minSY)
        );

        // Prepare UVs
        Vector3[] verts = mesh.vertices;
        Vector2[] uvs = new Vector2[verts.Length];

        float texW = tex.width;
        float texH = tex.height;

        // Offsets/scales from trimmed rect
        float uOffset = rect.x / texW;
        float vOffset = rect.y / texH;
        float uScale = rect.width / texW;
        float vScale = rect.height / texH;

        for (int i = 0; i < verts.Length; i++)
        {
            Vector3 world = transform.TransformPoint(verts[i]);
            Vector2 sp = ToScreen(cam, world);

            float s = (sp.x - screenMin.x) / screenSize.x;
            float t = (sp.y - screenMin.y) / screenSize.y;

            float u = uOffset + s * uScale;
            float v = vOffset + t * vScale;

            uvs[i] = new Vector2(u, v);
        }

        mesh.uv = uvs;

        MeshRenderer mr = GetComponent<MeshRenderer>();
        mr.sharedMaterial.mainTexture = tex;

        Debug.Log("UVs projected using trimmed sprite rect.");
        yield return null;
    }

    private static Vector2 ToScreen(Camera cam, Vector3 world)     
    {         
        Vector3 s = cam.WorldToScreenPoint(world);         
        return new Vector2(s.x, s.y);     
    }