Transform

Functions
void	doodle::apply_scale (double scale) noexcept
	Uniformly increases or decreases the size of a shape by expanding and contracting vertices. More...
void	doodle::apply_scale (double scale_x, double scale_y) noexcept
	Increases or decreases the size of a shape by expanding and contracting vertices. More...
void	doodle::apply_rotate (double angle_in_radians) noexcept
	Rotates a shape the amount specified by the angle in radians. More...
void	doodle::apply_translate (double translate_x, double translate_y) noexcept
	Specifies an amount to displace objects within the display window. More...
void	doodle::apply_matrix (double a, double b, double c, double d, double e, double f) noexcept
	Multiplies the current matrix by the one specified through the parameters. More...

Detailed Description

• Functions for transforming shapes

Function Documentation

apply_matrix()

void doodle::apply_matrix ( double  a, double  b, double  c, double  d, double  e, double  f  )

noexcept

Multiplies the current matrix by the one specified through the parameters.

This is a powerful operation that can perform the equivalent of translate, scale, shear and rotate all at once. You can learn more about transformation matrices on Wikipedia.

The naming of the arguments here follows the naming of the WHATWG specification and corresponds to a transformation matrix of the form:

\( \begin{bmatrix} a & c & e \\ b & d & f \\ 0 & 0 & 1 \end{bmatrix} \)

Parameters

a	1st Column 1 Row
b	1st Column 2nd Row
c	2nd Column 1st Row
d	2nd Column 2nd Row
e	3rd Column 1st Row
f	3rd Column 2nd Row

#include <cmath>
#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_outline_color(228, 63, 86);
    set_outline_width(3.0);
    set_fill_color(245, 170, 101);
    set_rectangle_mode(RectMode::Center);
 
 
    while (!is_window_closed())
    {
        update_window(); // resets transformations
        clear_background(97, 127, 235, 128);
        const double shapeWidth  = Height / 3.0;
        const double angle       = std::sin(ElapsedTime) * QUARTER_PI;
        const double shearFactor = 1.0 / std::tan(HALF_PI - angle);
        apply_matrix(1, 0, shearFactor, 1, 0, 0);
        draw_rectangle(0, 0, shapeWidth);
    }
    return 0;
}

apply_rotate()

void doodle::apply_rotate ( double  angle_in_radians )

noexcept

Rotates a shape the amount specified by the angle in radians.

Objects are always rotated around their relative position to the origin. If the doodle::FrameOfReference is right-handed then positive angles rotate counter-clockwise and if it is left-handed then positive angles rotate clockwise. Transformations apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling apply_rotate(HALF_PI) and then apply_rotate(HALF_PI) is the same as apply_rotate(PI). All transformations are reset when update_window() is called.

Technically, apply_rotate() multiplies the current transformation matrix by a rotation matrix. This function can be further controlled by the push_settings() and pop_settings().

Parameters

angle_in_radians

the angle of rotation

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    while (!is_window_closed())
    {
        update_window(); // resets transformations
        clear_background(97, 127, 235);
 
        apply_rotate(QUARTER_PI);
        set_fill_color(164, 183, 177);
        draw_ellipse(0, 0, 100, 40);
 
        set_fill_color(228, 63, 86);
        apply_rotate(HALF_PI);
        draw_rectangle(10, 10, 100, 75);
    }
    return 0;
}

apply_scale() [1/2]

void doodle::apply_scale ( double  scale )

noexcept

Uniformly increases or decreases the size of a shape by expanding and contracting vertices.

Objects always scale from their relative origin to the coordinate system. Scale values are specified as decimal percentages. For example, the function call apply_scale(2.0) increases the dimension of a shape by 200%.

Transformations apply to everything that happens after and subsequent calls to the function multiply the effect. For example, calling apply_scale(2.0) and then apply_scale(1.5) is the same as apply_scale(3.0). The transformation is reset when update_window() is called.

Parameters

scale

percent to scale the object

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_frame_of_reference(FrameOfReference::RightHanded_OriginBottomLeft);
    while (!is_window_closed())
    {
        update_window(); // resets transformations
        clear_background(97, 127, 235);
 
        set_fill_color(245, 170, 101);
        draw_rectangle(10, 10, 100, 75); // draw at normal size
 
        apply_scale(3.0);
        set_fill_color(228, 187, 142, 192);
        draw_rectangle(10, 10, 100, 75); // draw 3 times bigger
    }
    return 0;
}

apply_scale() [2/2]

void doodle::apply_scale ( double  scale_x, double  scale_y  )

noexcept

Increases or decreases the size of a shape by expanding and contracting vertices.

Objects always scale from their relative origin to the coordinate system. Scale values are specified as decimal percentages. For example, the function call apply_scale(2.0, 0.5) increases the dimension of a shape horizontally by 200% and vertically bu 50%.

Transformations apply to everything that happens after and subsequent calls to the function multiply the effect. For example, calling apply_scale(2.0, 1.0) and then apply_scale(1.5, 2.0) is the same as apply_scale(3.0, 2.0). The transformation is reset when update_window() is called.

Parameters

scale_x	percentage to scale the object in the x-axis
scale_y	percentage to scale the object in the y-axis

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_frame_of_reference(FrameOfReference::RightHanded_OriginBottomLeft);
    while (!is_window_closed())
    {
        update_window(); // resets transformations
        clear_background(97, 127, 235);
 
        set_fill_color(245, 170, 101);
        draw_rectangle(10, 10, 100, 75); // draw at normal size
 
        // 4x bigger in the x and 3x bigger in the y
        apply_scale(4.0, 3.0);
        set_fill_color(228, 187, 142, 192);
        draw_rectangle(10, 10, 100, 75);
    }
    return 0;
}

apply_translate()

void doodle::apply_translate ( double  translate_x, double  translate_y  )

noexcept

Specifies an amount to displace objects within the display window.

The x parameter specifies left/right translation, the y parameter specifies up/down translation.

Transformations are cumulative and apply to everything that happens after and subsequent calls to the function accumulates the effect. For example, calling apply_translate(50, 0) and then apply_translate(20, 0) is the same as apply_translate(70, 0). All transformations are reset when update_window() is called. This function can be further controlled by the push_settings() and pop_settings().

Parameters

translate_x	left/right translation
translate_y	up/down translation

#include <cmath>
#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    no_outline();
    set_fill_color(245, 170, 101);
    constexpr double shapeWidth = 50;
    while (!is_window_closed())
    {
        update_window(); // resets transformations
        clear_background(97, 127, 235, 128);
        const double radius = std::sqrt(Width * Width / 9.0 + Height * Height / 9.0) - shapeWidth;
        const double x      = std::cos(ElapsedTime) * radius;
        const double y      = std::sin(ElapsedTime) * radius;
        apply_translate(x, y);
        draw_ellipse(0, 0, shapeWidth);
    }
    return 0;
}