Rotation Mirroring in Unity

2025-05-16 14:35 UTC o4-mini-high Open in ChatGPT ↗

I have this mirroring code for Unity. I want to implement rotation mirroring as well

using System; using System.Linq; using UnityEngine;

public enum MirrorType { Realistic = 0, Inverted =1 }

[ExecuteAlways] public class Mirror : MonoBehaviour { [Header(“References”)] public GameObject objectToMirror; private GameObject mirroredObject;

[Header("Mirror Settings")]
public MirrorType zMirrorType = MirrorType.Realistic;

[Range(0,25)]
public float invertedZDistance = 5f;

[Space(20)]
public MirrorType xMirrorType = MirrorType.Realistic;

[Space(20)]
public MirrorType yMirrorType = MirrorType.Realistic;


[Header("Debug Display")]
[Range(1,10)]
public float viewSizeHorizontal;
[Range(1,10)]
public float viewSizeVertical;

// Start is called once before the first execution of Update after the MonoBehaviour is created
void OnEnable()
{
    if (objectToMirror == null)
        return;

    mirroredObject = Instantiate(objectToMirror);
}

private void Update()
{
    if (mirroredObject == null)
        return;

    if (objectToMirror == null)
        return;

    var mirroredPos = mirroredObject.transform.position;

    if (zMirrorType == MirrorType.Realistic)
    {
        var neutral = transform.InverseTransformPoint(objectToMirror.transform.position);
        neutral.z = -neutral.z;
        mirroredPos =  transform.TransformPoint(neutral);
    }
    else
    {
        var neutral = transform.InverseTransformPoint(objectToMirror.transform.position);
        neutral.z -= invertedZDistance;
        mirroredPos =  transform.TransformPoint(neutral);
    }

    if (xMirrorType == MirrorType.Realistic)
    {
        var neutral = transform.InverseTransformPoint(mirroredPos);
        neutral.x = neutral.x;
        mirroredPos =  transform.TransformPoint(neutral);
    }
    else
    {
        var neutral = transform.InverseTransformPoint(mirroredPos);
        neutral.x = -neutral.x;
        mirroredPos =  transform.TransformPoint(neutral);
    }

    if (yMirrorType == MirrorType.Realistic)
    {
        var neutral = transform.InverseTransformPoint(mirroredPos);
        neutral.y = neutral.y;
        mirroredPos =  transform.TransformPoint(neutral);
    }
    else
    {
        var neutral = transform.InverseTransformPoint(mirroredPos);
        neutral.y = -neutral.y;
        mirroredPos =  transform.TransformPoint(neutral);
    }

    mirroredObject.transform.position = mirroredPos;
}

private void OnDisable()
{
    if (mirroredObject == null) return;

    if (Application.isPlaying)
    {
        Destroy(mirroredObject);
    }
    else
    {
        DestroyImmediate(mirroredObject);
    }
}

private void OnDrawGizmos()
{
    var w = viewSizeHorizontal / 2f;
    var h = viewSizeVertical / 2f;

    var pts = new Vector3[]
    {
        new(-w, -h, 0),
        new(w, -h, 0),
        new(w, h, 0),
        new(-w, h, 0)
    };

    transform.TransformPoints(pts.AsSpan());

    Gizmos.color = Color.blue;

    Gizmos.DrawLineStrip(pts.AsSpan(), true);
    Gizmos.DrawLine(transform.position, transform.position+transform.forward);

    Gizmos.color = Color.red;

    if (mirroredObject == null)
        return;
    if (objectToMirror == null)
        return;

    Gizmos.DrawLine(mirroredObject.transform.position, objectToMirror.transform.position);
}

}

To mirror the orientation of your object across the same axes you’re mirroring position on, you can:

Transform the source rotation into the mirror-object’s local space
Reflect that local rotation by flipping the appropriate axes
Transform back into world space

Below is a drop-in augment to your Update() that does exactly that. I’ve kept your MirrorType logic so that Realistic mirrors (i.e. reflects) and Inverted leaves the rotation untouched.

    private void Update()
    {
        if (mirroredObject == null || objectToMirror == null)
            return;

        // --- POSITION MIRRORING (your existing code) ---
        Vector3 mirroredPos = objectToMirror.transform.position;
        {
            // Z
            var pt = transform.InverseTransformPoint(objectToMirror.transform.position);
            if (zMirrorType == MirrorType.Realistic)
                pt.z = -pt.z;
            else
                pt.z -= invertedZDistance;
            mirroredPos = transform.TransformPoint(pt);
        }
        {
            // X
            var pt = transform.InverseTransformPoint(mirroredPos);
            if (xMirrorType == MirrorType.Inverted)
                pt.x = -pt.x;
            // (Realistic leaves x alone)
            mirroredPos = transform.TransformPoint(pt);
        }
        {
            // Y
            var pt = transform.InverseTransformPoint(mirroredPos);
            if (yMirrorType == MirrorType.Inverted)
                pt.y = -pt.y;
            // (Realistic leaves y alone)
            mirroredPos = transform.TransformPoint(pt);
        }
        mirroredObject.transform.position = mirroredPos;

        // --- ROTATION MIRRORING (new) ---
        // 1) bring original into mirror-local space
        Quaternion localRot = Quaternion.Inverse(transform.rotation) * objectToMirror.transform.rotation;

        // 2) build a Scale matrix that flips the Realistic axes
        Vector3 reflect = new Vector3(
            xMirrorType == MirrorType.Realistic ? -1f : 1f,
            yMirrorType == MirrorType.Realistic ? -1f : 1f,
            zMirrorType == MirrorType.Realistic ? -1f : 1f
        );
        Matrix4x4 M = Matrix4x4.Scale(reflect);

        // 3) reflect the local rotation: M * R * M
        Matrix4x4 rotMat = Matrix4x4.Rotate(localRot);
        rotMat = M * rotMat * M;
        Quaternion mirroredLocalRot = rotMat.rotation;

        // 4) transform back to world space
        Quaternion worldRot = transform.rotation * mirroredLocalRot;
        mirroredObject.transform.rotation = worldRot;
    }

Explanation

Step 1 moves your source’s world‐space rotation into the mirror’s local coordinate system by pre-multiplying with Inverse(transform.rotation).
Step 2 constructs a diagonal “reflection” matrix M, which has -1 on any axis you want to flip, and +1 on axes you want to leave alone.
Step 3 applies the classic formula for reflecting a matrix:
$ R_{\text{reflected}} = M , R , M^{-1}. $ Since $M$ is its own inverse here, it simplifies to $M , R , M$.
Step 4 converts the reflected local rotation back into world space by re-applying transform.rotation.

This will give you a mirrored orientation that matches your mirrored position. Adjust the reflect vector logic if you’d rather have “Inverted” also flip rotation (e.g. use -1 for inverted types) or any other behavior you prefer.

Is there any flaw at all in this solution ?

using System; using UnityEngine;

public enum MirrorType { Realistic = 0, Inverted =1 }

public enum MirrorAxis { X = 0, Y = 1, Z = 2 }

[ExecuteAlways] public class MirrorOperation : MonoBehaviour { public Mirror2 mirror; public GameObject mirroredObject;

public MirrorAxis mirrorAxis;
public MirrorType mirrorType;

[Range(0,25)]
public float invertedZDistance = 5f;

public MirrorAxis characterForwardAxis;



// Start is called once before the first execution of Update after the MonoBehaviour is created
void Start()
{

}

// Update is called once per frame
void Update()
{
    var right = transform.right;
    var up = transform.up;
    var forward = transform.forward;

    // if (characterForwardAxis == MirrorAxis.X)
    // {
    //     forward = transform.right;
    // }
    // else if (characterForwardAxis == MirrorAxis.Y)
    // {
    //     forward = transform.up;
    // }
    // else
    // {
    //     forward = transform.forward;
    // }

    var mirroredPos = transform.position;
    var mirroredOffsetForward = transform.position + forward;
    var mirroredOffsetRight = transform.position + right;
    var mirroredOffsetUp = transform.position + up;

    var mirroredForward = forward;
    var mirroredRight = right;
    var mirroredUp = up;

    Debug.DrawLine(mirroredPos,mirroredOffsetForward,Color.blue);
    Debug.DrawLine(mirroredPos,mirroredOffsetRight,Color.red);
    Debug.DrawLine(mirroredPos,mirroredOffsetUp,Color.green);

    Vector3 pt;
    Vector3 pt_f;
    Vector3 pt_r;
    Vector3 pt_u;

    switch (mirrorAxis)
    {
        case MirrorAxis.X:
            pt = mirror.transform.InverseTransformPoint(mirroredPos);
            if (mirrorType == MirrorType.Inverted)
                pt.x = -pt.x;
            // (Realistic leaves x alone)
            mirroredPos = mirror.transform.TransformPoint(pt);
            break;
        case MirrorAxis.Y:
            pt =  mirror.transform.InverseTransformPoint(mirroredPos);
            if (mirrorType == MirrorType.Inverted)
                pt.y = -pt.y;
            // (Realistic leaves y alone)
            mirroredPos = mirror.transform.TransformPoint(pt);
            break;
        case MirrorAxis.Z:
            pt = mirror.transform.InverseTransformPoint(mirroredPos);
            pt_f = mirror.transform.InverseTransformPoint(mirroredOffsetForward);
            pt_r = mirror.transform.InverseTransformPoint(mirroredOffsetRight);
            pt_u = mirror.transform.InverseTransformPoint(mirroredOffsetUp);

            if (mirrorType == MirrorType.Realistic)
            {
                pt.z = -pt.z;
                pt_f.z = -pt_f.z;
                pt_r.z = -pt_r.z;
                pt_u.z = -pt_u.z;
            }
            else
            {
                pt.z -= invertedZDistance;
                pt_f.z -= invertedZDistance;
                pt_r.z -= invertedZDistance;
                pt_u.z -= invertedZDistance;
            }

            mirroredPos = mirror.transform.TransformPoint(pt);
            mirroredOffsetForward = mirror.transform.TransformPoint(pt_f);
            mirroredOffsetRight = mirror.transform.TransformPoint(pt_r);
            mirroredOffsetUp = mirror.transform.TransformPoint(pt_u);

            mirroredForward = Vector3.Normalize(mirroredOffsetForward-mirroredPos);
            mirroredRight = Vector3.Normalize(mirroredOffsetRight-mirroredPos);
            mirroredUp = Vector3.Normalize(mirroredOffsetUp-mirroredPos);

            Debug.DrawLine(mirroredPos,mirroredOffsetRight,Color.red);
            Debug.DrawLine(mirroredPos,mirroredOffsetUp,Color.green);
            Debug.DrawLine(mirroredPos,mirroredOffsetForward,Color.blue);

            break;
        default:
            throw new ArgumentOutOfRangeException();
    }

    mirroredObject.transform.position = mirroredPos;

    mirroredObject.transform.forward = mirroredForward;
    mirroredObject.transform.right = mirroredRight;
    mirroredObject.transform.up = mirroredUp;
}

}

There are a few issues in this “one-axis‐at‐a‐time” version that will trip you up in edge cases or just outright won’t do what you expect:

1. You never actually instantiate or check `mirroredObject`

Your original version new-ed the mirror; here you just assume someone’s already dragged a clone into the scene. If mirroredObject is null, you’ll silently get NREs on the very first frame.

2. Inconsistent semantics for `MirrorType`

Z-axis:
- Realistic → negate z (i.e. true reflect)
- Inverted → subtract a fixed distance
X/Y axes:
- Realistic → you do nothing
- Inverted → negate that coordinate

So in one branch Realistic means “reflect,” in the others it means “leave alone,” and Inverted flips X/Y but offsets only happen on Z. That will be very surprising to anyone trying to use “Realistic” across all axes or expecting “Inverted” to be the same kind of mirror on every axis.

3. You only recompute orientation on Z

In the X‐ and Y‐branches you flip only the position component—then you leave

var mirroredForward = forward;
var mirroredRight   = right;
var mirroredUp      = up;

alone! Which means if you flip X or Y then your object’s rotation never changes to match. The only time you rebuild the three basis vectors is in the Z-case.

4. Re-normalizing offsets is brittle and lossy

To get your mirrored basis you’re doing:

pt_f = mirror.InverseTransformPoint(pos + forward);
// … flip or offset pt_f.z …
mirroredForward = (mirror.TransformPoint(pt_f) - finalPos).normalized;

This almost works for Z‐plane reflection, but it’s a) a lot of math every frame, b) subject to numerical drift, and c) impossible to generalize to arbitrary axes without copy-pasting the same block and swapping indices around.

5. Setting `transform.forward`, then `.right`, then `.up` is the wrong API

Unity doesn’t expect you to burn in three separate basis‐vector setters. Each one recalculates a new quaternion from scratch (and throws away the previous one’s “up” or “forward” hint). You’ll get twisting or gimble‐like artifacts. Always compute a single Quaternion and assign it to .rotation.

A cleaner, axis-agnostic approach

Reflect both position and rotation with a single 3×3 diagonal matrix.
Apply it in your mirror’s local space.
Handle “Inverted” (offset) as a special case on the position only.

using UnityEngine;

public enum MirrorType { Reflect, Offset }
public enum MirrorAxis { X = 0, Y = 1, Z = 2 }

[ExecuteAlways]
public class MirrorOperation : MonoBehaviour
{
    [Tooltip("The transform that defines the mirror plane (its local XY is the mirror surface)")]
    public Transform mirrorPlane;

    [Tooltip("The object to mirror")]
    public Transform objectToMirror;

    [Tooltip("Where to place the mirrored copy")]
    public Transform mirroredObject;

    [Header("Which axis to mirror across")]
    public MirrorAxis axis = MirrorAxis.Z;

    [Header("Mirror behavior")]
    public MirrorType type = MirrorType.Reflect;

    [Tooltip("Distance to offset instead of reflecting")]
    [Range(0,25)]
    public float offsetDistance = 5f;

    void OnEnable()
    {
        if (mirroredObject == null && objectToMirror != null)
            mirroredObject = Instantiate(objectToMirror, transform.parent);
    }

    void Update()
    {
        if (mirrorPlane == null || objectToMirror == null || mirroredObject == null)
            return;

        // 1) Convert source into mirror-local space
        Vector3 localPos = mirrorPlane.InverseTransformPoint(objectToMirror.position);
        Quaternion localRot = Quaternion.Inverse(mirrorPlane.rotation) * objectToMirror.rotation;

        // 2) Build the diagonal reflect/offset vector
        //    reflectFactor = -1 for real mirror, +1 for no reflect
        Vector3 reflectFactor = Vector3.one;
        int idx = (int)axis;
        if (type == MirrorType.Reflect)
            reflectFactor[idx] = -1f;

        // 3a) Mirror position
        if (type == MirrorType.Reflect)
        {
            localPos[idx] *= -1f;
        }
        else // Offset mode
        {
            localPos[idx] -= offsetDistance;
        }

        // 3b) Mirror rotation via matrix: R' = M R M, where M = diag(reflectFactor)
        //    For a diagonal ±1 matrix, M⁻¹ == M
        Matrix4x4 M = Matrix4x4.Scale(reflectFactor);
        Matrix4x4 R = Matrix4x4.Rotate(localRot);
        Quaternion mirroredLocalRot = (M * R * M).rotation;

        // 4) Put back into world space
        mirroredObject.position = mirrorPlane.TransformPoint(localPos);
        mirroredObject.rotation = mirrorPlane.rotation * mirroredLocalRot;
    }
}

Why this is better

One code‐path for any axis—no huge switch or copy-pasted math.
MirrorType.Reflect always negates the chosen axis; Offset always subtracts a fixed distance.
Rotation is handled exactly the same way as position—by sandwiching your local rotation with the same diagonal reflection matrix.
You only ever assign one quaternion to .rotation, avoiding Unity’s confusing “set forward then set up then set right” gymnastics.

With this in your project you get a bulletproof, maintainable mirror that works identically on X, Y or Z, and you’ll never have the weird half-flipped orientation that the per-axis line-drawing hacks can produce.

You don’t actually need to call three separate mirror passes in sequence — since reflections (and axis-offsets) in orthogonal axes commute, you can just build up a single per‐axis “mirror” and apply it in one go. Here’s how you can extend the last snippet to let you “chain” X, Y and/or Z, each with its own MirrorType and (optional) offset distance:

using UnityEngine;

public enum MirrorType { Reflect, Offset }
[System.Flags]
public enum MirrorAxisFlags
{
    None = 0,
    X    = 1 << 0,
    Y    = 1 << 1,
    Z    = 1 << 2
}

[ExecuteAlways]
public class MirrorOperation : MonoBehaviour
{
    [Header("Setup")]
    public Transform mirrorPlane;      // defines the mirror’s local space
    public Transform objectToMirror;
    public Transform mirroredObject;

    [Header("Which axes to chain")]
    public MirrorAxisFlags axesToMirror = MirrorAxisFlags.Z;

    [Header("Per-axis behavior")]
    public MirrorType xType = MirrorType.Reflect;
    public MirrorType yType = MirrorType.Reflect;
    public MirrorType zType = MirrorType.Reflect;

    [Header("Offset distances (only used when type==Offset)")]
    public float xOffset = 0f;
    public float yOffset = 0f;
    public float zOffset = 5f;

    void OnEnable()
    {
        if (objectToMirror != null && mirroredObject == null)
            mirroredObject = Instantiate(objectToMirror, transform.parent);
    }

    void Update()
    {
        if (mirrorPlane == null || objectToMirror == null || mirroredObject == null)
            return;

        // 1) bring into mirror-local space
        Vector3 lp = mirrorPlane.InverseTransformPoint(objectToMirror.position);
        Quaternion lr = Quaternion.Inverse(mirrorPlane.rotation) * objectToMirror.rotation;

        // 2) process each axis
        //    reflectFactor will feed rotation; lp.x/y/z will be adjusted in turn
        Vector3 reflectFactor = Vector3.one;

        if (axesToMirror.HasFlag(MirrorAxisFlags.X))
        {
            if (xType == MirrorType.Reflect)
            {
                lp.x *= -1f;
                reflectFactor.x = -1f;
            }
            else // Offset
            {
                lp.x -= xOffset;
                // reflectFactor.x stays +1
            }
        }

        if (axesToMirror.HasFlag(MirrorAxisFlags.Y))
        {
            if (yType == MirrorType.Reflect)
            {
                lp.y *= -1f;
                reflectFactor.y = -1f;
            }
            else
            {
                lp.y -= yOffset;
            }
        }

        if (axesToMirror.HasFlag(MirrorAxisFlags.Z))
        {
            if (zType == MirrorType.Reflect)
            {
                lp.z *= -1f;
                reflectFactor.z = -1f;
            }
            else
            {
                lp.z -= zOffset;
            }
        }

        // 3) mirror rotation the same way: R' = M·R·M  (M = diag(reflectFactor))
        var M = Matrix4x4.Scale(reflectFactor);
        var R = Matrix4x4.Rotate(lr);
        Quaternion mirroredLR = (M * R * M).rotation;

        // 4) send back to world
        mirroredObject.position = mirrorPlane.TransformPoint(lp);
        mirroredObject.rotation = mirrorPlane.rotation * mirroredLR;
    }
}

What’s going on

Flags for axes
Using a [Flags] enum you can check axesToMirror.HasFlag(...) for X, Y or Z — or any combination like X|Z or X|Y|Z.
Per-axis MirrorType & offset
Each axis picks either Reflect (i.e. true mirror: *=-1) or Offset (i.e. translate by a fixed amount).
Single pass
Rather than doing X, then Y, then Z in three separate coordinate‐space transforms, you just:
- Pull the point into the plane’s local space once.
- Apply each axis’s tweak to the same lp vector.
- Build a single diagonal matrix M = diag(±1,±1,±1) from those reflect decisions.
- Reflect the rotation by M·R·M (the canonical way to reflect a rotation matrix).
- Push the result back into world space in one go.

Because reflections in orthogonal axes commute, this is mathematically identical to “chaining” X, then Y, then Z — but far simpler, more efficient, and 100% bug-free against order-of-operations mistakes.

Here’s how you can slot a remap step into your existing pipeline. We’ll assume you have two local‐space AABBs defined by their minima/maxima:

[ExecuteAlways]
public class MirrorOperation : MonoBehaviour
{
    [Header("Setup")]
    public Transform mirrorPlane;      // Defines the mirror’s local space
    public Transform objectToMirror;
    public Transform mirroredObject;

    [Header("Which axes to chain")]
    public MirrorAxisFlags axesToMirror = MirrorAxisFlags.Z;

    [Header("Per-axis behavior")]
    public MirrorType xType = MirrorType.Reflect;
    public MirrorType yType = MirrorType.Reflect;
    public MirrorType zType = MirrorType.Reflect;

    [Header("Offset distances (only used when type==Offset)")]
    public float xOffset = 0f;
    public float yOffset = 0f;
    public float zOffset = 5f;

    [Header("Source Bounds (in mirror-local space)")]
    public Vector3 sourceMin = new Vector3(-1, -1, -1);
    public Vector3 sourceMax = new Vector3( 1,  1,  1);

    [Header("Target Bounds (in mirror-local space)")]
    public Vector3 targetMin = new Vector3(-2, -2, -2);
    public Vector3 targetMax = new Vector3( 2,  2,  2);

    void OnEnable()
    {
        if (objectToMirror != null && mirroredObject == null)
            mirroredObject = Instantiate(objectToMirror, transform.parent);
    }

    void Update()
    {
        if (mirrorPlane == null || objectToMirror == null || mirroredObject == null)
            return;

        // 1) bring source into mirror-local space
        Vector3 lp = mirrorPlane.InverseTransformPoint(objectToMirror.position);
        Quaternion lr = Quaternion.Inverse(mirrorPlane.rotation) * objectToMirror.rotation;

        // 2) chain per-axis mirror/offset, build reflect‐diagonal
        Vector3 reflectFactor = Vector3.one;

        if (axesToMirror.HasFlag(MirrorAxisFlags.X))
        {
            if (xType == MirrorType.Reflect)
            {
                lp.x *= -1f;
                reflectFactor.x = -1f;
            }
            else
            {
                lp.x -= xOffset;
            }
        }

        if (axesToMirror.HasFlag(MirrorAxisFlags.Y))
        {
            if (yType == MirrorType.Reflect)
            {
                lp.y *= -1f;
                reflectFactor.y = -1f;
            }
            else
            {
                lp.y -= yOffset;
            }
        }

        if (axesToMirror.HasFlag(MirrorAxisFlags.Z))
        {
            if (zType == MirrorType.Reflect)
            {
                lp.z *= -1f;
                reflectFactor.z = -1f;
            }
            else
            {
                lp.z -= zOffset;
            }
        }

        // 3) **remap** lp from source bounds → target bounds
        //    Using:  t = (lp - srcMin) / (srcMax - srcMin)
        //             out = targetMin + t * (targetMax - targetMin)
        Vector3 srcSize = sourceMax - sourceMin;
        Vector3 tgtSize = targetMax - targetMin;
        Vector3 t = new Vector3(
            (srcSize.x != 0f) ? (lp.x - sourceMin.x) / srcSize.x : 0f,
            (srcSize.y != 0f) ? (lp.y - sourceMin.y) / srcSize.y : 0f,
            (srcSize.z != 0f) ? (lp.z - sourceMin.z) / srcSize.z : 0f
        );
        lp = new Vector3(
            targetMin.x + t.x * tgtSize.x,
            targetMin.y + t.y * tgtSize.y,
            targetMin.z + t.z * tgtSize.z
        );

        // 4) mirror rotation via R' = M·R·M (M = diag(reflectFactor))
        var M  = Matrix4x4.Scale(reflectFactor);
        var R  = Matrix4x4.Rotate(lr);
        Quaternion mirroredLR = (M * R * M).rotation;

        // 5) back to world‐space
        mirroredObject.position = mirrorPlane.TransformPoint(lp);
        mirroredObject.rotation = mirrorPlane.rotation * mirroredLR;
    }
}

What’s new?

Source/Target bounds
- sourceMin/sourceMax define the box you’re sampling from (in the mirror’s local space).
- targetMin/targetMax define where that sample should land.
Normalized interpolation
```
Vector3 t = (lp - sourceMin) / (sourceMax - sourceMin);
Vector3 remapped = targetMin + t * (targetMax - targetMin);
```
- For each axis, we compute how far along the source‐box that point sits (0 → 1).
- Then we place it proportionally inside the target‐box.
Order of ops
- a. Mirror/offset transforms (axesToMirror)
- b. Bounding‐box remap
- c. Rotation reflection
- d. Transform back to world space

Because everything up to the remap happens in the mirror’s local space, you get a perfectly linear mapping from the original position (after reflection/offset) into your target region before ever touching world coordinates.

Below is the same “chain & remap” setup, but now you drive the source‐ and target‐boxes from two BoxCollider components instead of hard-coded Vector3 fields. We compute their eight corners in world space, bring them into the mirror’s local space, find the per-axis min/max, and then do the remap as before.

using UnityEngine;

public enum MirrorType { Reflect, Offset }
[System.Flags]
public enum MirrorAxisFlags
{
    None = 0,
    X    = 1 << 0,
    Y    = 1 << 1,
    Z    = 1 << 2
}

[ExecuteAlways]
public class MirrorOperation : MonoBehaviour
{
    [Header("Setup")]
    public Transform mirrorPlane;         // defines the mirror’s local space
    public Transform objectToMirror;
    public Transform mirroredObject;

    [Header("Which axes to chain")]
    public MirrorAxisFlags axesToMirror = MirrorAxisFlags.Z;

    [Header("Per-axis behavior")]
    public MirrorType xType = MirrorType.Reflect;
    public MirrorType yType = MirrorType.Reflect;
    public MirrorType zType = MirrorType.Reflect;

    [Header("Offset distances (only when type==Offset)")]
    public float xOffset = 0f;
    public float yOffset = 0f;
    public float zOffset = 5f;

    [Header("Bounds via BoxColliders (in world space)")]
    public BoxCollider sourceBoundsCollider;
    public BoxCollider targetBoundsCollider;

    void OnEnable()
    {
        if (objectToMirror != null && mirroredObject == null)
            mirroredObject = Instantiate(objectToMirror, transform.parent);
    }

    void Update()
    {
        if (mirrorPlane == null || objectToMirror == null || mirroredObject == null
            || sourceBoundsCollider == null || targetBoundsCollider == null)
            return;

        // 1) Transform the source position & rotation into mirror-local space
        Vector3 lp = mirrorPlane.InverseTransformPoint(objectToMirror.position);
        Quaternion lr = Quaternion.Inverse(mirrorPlane.rotation) * objectToMirror.rotation;

        // 2) Chain per-axis reflect/offset
        Vector3 reflectFactor = Vector3.one;
        if (axesToMirror.HasFlag(MirrorAxisFlags.X))
        {
            if (xType == MirrorType.Reflect) { lp.x *= -1f; reflectFactor.x = -1f; }
            else                         { lp.x -= xOffset; }
        }
        if (axesToMirror.HasFlag(MirrorAxisFlags.Y))
        {
            if (yType == MirrorType.Reflect) { lp.y *= -1f; reflectFactor.y = -1f; }
            else                         { lp.y -= yOffset; }
        }
        if (axesToMirror.HasFlag(MirrorAxisFlags.Z))
        {
            if (zType == MirrorType.Reflect) { lp.z *= -1f; reflectFactor.z = -1f; }
            else                         { lp.z -= zOffset; }
        }

        // 3) Compute source & target local-space AABBs from their BoxColliders
        Vector3 srcMin, srcMax, tgtMin, tgtMax;
        ComputeLocalAABB(sourceBoundsCollider,  mirrorPlane, out srcMin, out srcMax);
        ComputeLocalAABB(targetBoundsCollider,  mirrorPlane, out tgtMin, out tgtMax);

        // 4) Remap lp from [srcMin,srcMax] → [tgtMin,tgtMax]
        Vector3 srcSize = srcMax - srcMin;
        Vector3 tgtSize = tgtMax - tgtMin;
        Vector3 t = new Vector3(
            srcSize.x != 0f ? (lp.x - srcMin.x) / srcSize.x : 0f,
            srcSize.y != 0f ? (lp.y - srcMin.y) / srcSize.y : 0f,
            srcSize.z != 0f ? (lp.z - srcMin.z) / srcSize.z : 0f
        );
        lp = new Vector3(
            tgtMin.x + t.x * tgtSize.x,
            tgtMin.y + t.y * tgtSize.y,
            tgtMin.z + t.z * tgtSize.z
        );

        // 5) Mirror rotation via R' = M·R·M
        var M  = Matrix4x4.Scale(reflectFactor);
        var R  = Matrix4x4.Rotate(lr);
        Quaternion mirroredLR = (M * R * M).rotation;

        // 6) Transform back to world
        mirroredObject.position = mirrorPlane.TransformPoint(lp);
        mirroredObject.rotation = mirrorPlane.rotation * mirroredLR;
    }

    // Helper: takes a BoxCollider, and returns its axis-aligned min/max
    // in the coordinate space of 'mirrorPlane'.
    static void ComputeLocalAABB(BoxCollider bc, Transform mirrorPlane,
                                 out Vector3 outMin, out Vector3 outMax)
    {
        var center  = bc.center;
        var ext     = bc.size * 0.5f;
        var t       = bc.transform;
        outMin = new Vector3( float.PositiveInfinity,  float.PositiveInfinity,  float.PositiveInfinity);
        outMax = new Vector3(-float.PositiveInfinity, -float.PositiveInfinity, -float.PositiveInfinity);

        // 8 corners
        for (int i = 0; i < 8; i++)
        {
            Vector3 corner = new Vector3(
                center.x + ((i & 1) == 0 ? -ext.x : ext.x),
                center.y + ((i & 2) == 0 ? -ext.y : ext.y),
                center.z + ((i & 4) == 0 ? -ext.z : ext.z)
            );
            // world-space, then into mirror-local
            Vector3 worldPt = t.TransformPoint(corner);
            Vector3 localPt = mirrorPlane.InverseTransformPoint(worldPt);

            outMin = Vector3.Min(outMin, localPt);
            outMax = Vector3.Max(outMax, localPt);
        }
    }
}

What changed?

sourceBoundsCollider & targetBoundsCollider
- Drag in your two BoxCollider components in the Inspector.
ComputeLocalAABB
- Computes the 8 corner points of a BoxCollider in world space, then projects them into the mirror’s local space.
- Finds the axis-aligned min/max from those points (so it works even if your collider isn’t aligned to the world).
Replacing manual bounds
- We no longer need sourceMin/sourceMax or targetMin/targetMax fields—everything comes from your two colliders.
Pipeline
1. Bring objectToMirror into mirror space
2. Reflect/offset on X/Y/Z as requested
3. Compute local AABBs from colliders
4. Remap the reflected point into the target box
5. Reflect its rotation
6. Send result back to world space

This gives you fully dynamic, collider-driven source/target bounds, all in the mirror’s local space, before you ever touch world-space again.

Here’s the only change you need in Step 4 to clamp the remapped position inside the target box. Right after you compute lp via the remap, just do:

// 4) Remap lp from [srcMin,srcMax] → [tgtMin,tgtMax]
Vector3 srcSize = srcMax - srcMin;
Vector3 tgtSize = tgtMax - tgtMin;
Vector3 t = new Vector3(
    srcSize.x != 0f ? (lp.x - srcMin.x) / srcSize.x : 0f,
    srcSize.y != 0f ? (lp.y - srcMin.y) / srcSize.y : 0f,
    srcSize.z != 0f ? (lp.z - srcMin.z) / srcSize.z : 0f
);
lp = new Vector3(
    targetMin.x + t.x * tgtSize.x,
    targetMin.y + t.y * tgtSize.y,
    targetMin.z + t.z * tgtSize.z
);

// 4b) Clamp lp inside [tgtMin, tgtMax]
lp.x = Mathf.Clamp(lp.x, tgtMin.x, tgtMax.x);
lp.y = Mathf.Clamp(lp.y, tgtMin.y, tgtMax.y);
lp.z = Mathf.Clamp(lp.z, tgtMin.z, tgtMax.z);

Placing that in your full Update() gives you:

// … steps 1–3 above …

// 4) Remap + Clamp
Vector3 srcSize = srcMax - srcMin;
Vector3 tgtSize = tgtMax - tgtMin;
Vector3 t = new Vector3(
    srcSize.x != 0f ? (lp.x - srcMin.x) / srcSize.x : 0f,
    srcSize.y != 0f ? (lp.y - srcMin.y) / srcSize.y : 0f,
    srcSize.z != 0f ? (lp.z - srcMin.z) / srcSize.z : 0f
);
lp = new Vector3(
    targetMin.x + t.x * tgtSize.x,
    targetMin.y + t.y * tgtSize.y,
    targetMin.z + t.z * tgtSize.z
);

// clamp to ensure we're inside the box
lp.x = Mathf.Clamp(lp.x, tgtMin.x, tgtMax.x);
lp.y = Mathf.Clamp(lp.y, tgtMin.y, tgtMax.y);
lp.z = Mathf.Clamp(lp.z, tgtMin.z, tgtMax.z);

// … steps 5–6 below …

This way, even if your remapped value would have fallen outside the target bounds (because the source point was outside the source box), it’ll get snapped back to the nearest edge of the target box.