What's the most efficient way to find the position of a point in relation to corners of a rectangle despite rectangle's scale

Question

I am struggling to achieve the following with C# (in Unity). I need to find the position of the points that lay at a given distance (let's say 1m) from the corners of a rectangle, in a way that the segment between these points and the given rectangle corners form 135 degrees with the corresponding sides the of rectangle - no matter where the rectangle goes, what is its rotation or what is its size. Like the following:

So, using the picture above as reference, it means that the red dotted line has always the same length and divides the angle ABC in the middle. So, the angle of the line with AB is 135 and with BC is also 135.

One of the ways to achieve that is the following code:

    Vector3 dotpos = rectangle.transform.TransformPoint(rectangle.transform.localPosition.x+1.5F,0,rectangle.transform.localPosition.z+1.5F);
    bluedot.transform.position = dotpos ; 

The problem is that in such solution the distance between the blue dot and the corner of the rectangle is not independent of the scale of the rectangle. It means, the greater the rectangle, the blue dot goes more distant from the corner.

Can anybody tell what is the most efficient way to achieve what I want, i.e. so the position of the blue dot is always at the same distance from the corner no matter the scale, position or rotation of the rectangle?

PS: blue dot is not an object that can be made child of the rectangle.

Answer 1

Assuming you know world position of corner B:

vec3 dotpos = B - (rectangle.transform.forward + rectangle.transform.right).Normalize() * distance;

note: did not checked up and right vectors are the "correct" ones(direction of AB and BC), if not just try one of the other pairs.
You can also replace normalization with multiplication by constant of value 1/sqrt(2) because you know the length of hypotenuse of unit square.
The -(rectangle.transform.up + rectangle.transform.right) is getting vector "between" AB and BC direction, minus is for inverting. It is effectively the same as computing angles.

Answer 2

I would do this using vectors and angles. You can get the angle that line segment AB makes with the x-axis, by doing the following:

angleAB = atan2(B.y - A.y, B.x - A.x);

You can add 45° (or π/4 radians) to that angle and project a point from B that is the length you desire by doing this:

newAngle = angleAB + (M_PI / 4.0);
newPoint.x = B.x + length * cos(newAngle);
newPoint.y = B.y + length * sin(newAngle);

Answer 3

You can do it like this:

bluedot.transform.localPosition = rectangle.transform.localPosition;
bluedot.transform.localRotation = rectangle.transform.localRotation;
bluedot.transform.localScale = Vector3.one;

Vector3 dotpos = bluedot.transform.TransformPoint(1.5f + rectangle.localScale.x / 2, 0.0f, 1.5f + rectangle.localScale.z / 2);
bluedot.transform.position = dotpos;
bluedot.transform.rotation = Quaternion.identity;

Here I use bluedot's transform to hold temporary values, because Unity doesn't allow using transforms without gameobjects. Rectangle.localScale.x / 2 is half the rectangle width... In the end I override temporary values with new ones. Hope you get the point.