Render rotated rectangle inside other rectangle bounds using Libgdx

Question

I have this code to generate a red rectangle inside a grey rectangle:

new Rectangle(grey_rectangle_position_x, Game.SCREEN_HEIGHT/2-Rectangle.height/2,0);

This code makes the following:

Now, I want to rotate the red rectangle and randomize his X coordinate but keeping it inside the grey rectangle.

This is my actual code of the rectangle:

public class Rectangle {

    public static int width=30;
    public static int height=60;
    public static Color color=Color.RED;

    public Rectangle(int x, int y, int angle) {
        super(x, y,angle);
    }

    public void render(ShapeRenderer shapeRenderer) {
        shapeRenderer.begin(ShapeType.Filled);
        shapeRenderer.setColor(color);
        shapeRenderer.identity();
        shapeRenderer.translate(pos_x+width/2, pos_y, 0.f);
        shapeRenderer.rotate(0.f, 0.f, 1.f, angle);
        shapeRenderer.rect(-width/2, -height/2, width, height);
        shapeRenderer.end();
    }
}

And this is what I should do to randomize the position of the rectangle:

new Rectangle(randomized_x_position, Game.SCREEN_HEIGHT/2-Rectangle.height/2,0);

The problem is that I don't know how to calculate the randomized_x_position in order to keep the rectangle inside the grey rectangle.

Another problem is that the current Rectangle.render() method is making my rectangle outside the grey rectangle after rotation:

When what I really want is:

Answer 1

• Pick random angle(a)

• Compute AABB: http://willperone.net/Code/coderr.php

  w' = h*abs(sin(a)) + w*abs(cos(a))

  h' = h*abs(cos(a)) + w*abs(sin(a))

• Pick random positions so aabb fits inside bigger rectangle. p_x <= Width - w' p_y <= Height - h'

Answer 2

You have a two options. (1) You can either make sure your rotation doesn't move the rectangle outside the bounds, or (2) you can move the rectangle back after the rotation.

1. To rotate it without leaving the gray box, pick the top or bottom left edge. If it's the top choose a rotation less than 90 degrees that rotates counter clockwise, if it's the bottom choose a rotation less than 90 degrees that rotates clockwise. Then rotate by the chosen rotate around the selected corner. This will essentially pivot the rectangle by a corner that's already on the edge, ensuring it doesn't rotate outside the grey rectangle. Unfortunately this option limits your choices a good deal.

2. Moving it back inside the grey rectangle isn't too bad, and gives you a lot more flexibility. Essentially, you'll need to either find the bounds of the rectangle after rotation, or maintain the bounds through rotation. Maintaining the bounds would be something like keeping track of the points that make up the corners and rotating those points when you rotate the rectangle. Either way, you'll end up with the bounds of the rectangle, and then you can easily compare its edges to that of the grey rectangle. Allowing you to easily translate the rectangle by the difference.

The first option is easier to implement, but less flexible. The second option will be harder to implement, but far more flexible.