Shape

Enumerations
enum class	doodle::EllipseMode { doodle::Center , doodle::Corner }
	With set_ellipse_mode(), modifies the location from which ellipses are drawn by changing the way in which parameters given to draw_ellipse() are interpreted. More...
enum class	doodle::RectMode { doodle::Corner , doodle::Center }
	With set_rectangle_mode(), modifies the location from which rectangles are drawn by changing the way in which parameters given to draw_rectangle() are interpreted. More...
enum class	doodle::FrameOfReference { doodle::RightHanded_OriginCenter , doodle::RightHanded_OriginBottomLeft , doodle::LeftHanded_OriginTopLeft }
	Used to define the coordinate system you would like to reference. More...

Functions
void	doodle::draw_ellipse (double x, double y, double width, double height=0) noexcept
	Draws an ellipse (oval) to the screen. More...
void	doodle::draw_line (double x1, double y1, double x2, double y2) noexcept
	Draws a line (a direct path between two points) to the screen. More...
void	doodle::draw_quad (double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) noexcept
	Draw a quad. More...
void	doodle::draw_rectangle (double x, double y, double width, double height=0) noexcept
	Draws a rectangle to the screen. More...
void	doodle::draw_triangle (double x1, double y1, double x2, double y2, double x3, double y3) noexcept
	Draw a triangle to the screen. More...
void	doodle::set_ellipse_mode (EllipseMode mode) noexcept
	Modifies the location from which ellipses are drawn by changing the way in which parameters given to draw_ellipse() are interpreted. More...
void	doodle::set_rectangle_mode (RectMode mode) noexcept
	Modifies the location from which rectangles are drawn by changing the way in which parameters given to draw_rectangle() are interpreted. More...
void	doodle::set_frame_of_reference (FrameOfReference frame_of_reference) noexcept
	Change the coordinate system you would like to use when describing your primitives. More...
void	doodle::smooth_drawing () noexcept
	Draws all geometry with smooth (anti-aliased) edges. More...
void	doodle::no_smoothing () noexcept
	Draws all geometry with jagged (aliased) edges. More...
void	doodle::set_outline_width (double line_width) noexcept
	Sets the width of the outline used for lines and the border around shapes. All widths are set in units of pixels. More...
void	doodle::push_settings () noexcept
	The push_settings() function saves the current drawing style settings and transformations, while pop_settings() restores these settings. More...
void	doodle::pop_settings () noexcept
	The pop_settings() function restores to the previous style settings and transformations, while push_settings() saves a new set these settings. More...

Detailed Description

• 2D Primitive shape drawing and Attributes about the shapes.

Enumeration Type Documentation

EllipseMode

enum doodle::EllipseMode

strong

With set_ellipse_mode(), modifies the location from which ellipses are drawn by changing the way in which parameters given to draw_ellipse() are interpreted.

Enumerator
Center	Interprets the first two parameters of draw_ellipse() as the shape's center point.
Corner	Interprets the first two parameters of draw_ellipse() as the upper-left or bottom-left corner of the shape in a left handed doodle::FrameOfReference and right handed doodle::FrameOfReference respectively.

Definition at line 661 of file drawing.hpp.

    {
        Center,
        Corner
    };

FrameOfReference

enum doodle::FrameOfReference

strong

Used to define the coordinate system you would like to reference.

Enumerator
RightHanded_OriginCenter	The Origin (0,0) is always in the center of the screen. Positive x goes to the right and Positive y goes up. This is the default reference frame. W = Width, H = Height (W/2,H/2) +--------o | | | 0,0 | | | o--------+ (-W/2,-H/2)
RightHanded_OriginBottomLeft	The Origin (0,0) is always in the bottom left of the screen. Positive x goes to the right and Positive y goes up. W = Width, H = Height (W,H) +--------o | | | | | | o--------+ (0,0)
LeftHanded_OriginTopLeft	The Origin (0,0) is always in the top left of the screen. Positive x goes to the right and Positive y goes down. W = Width, H = Height (0,0) o--------+ | | | | | | +--------o (W,H)

Definition at line 777 of file drawing.hpp.

    {
        RightHanded_OriginCenter,
        RightHanded_OriginBottomLeft,
        LeftHanded_OriginTopLeft
    };

RectMode

enum doodle::RectMode

strong

With set_rectangle_mode(), modifies the location from which rectangles are drawn by changing the way in which parameters given to draw_rectangle() are interpreted.

Enumerator
Corner	The default mode is RectMode::CORNER, which interprets the first two parameters of draw_rectangle() as the upper-left or bottom-left corner of the shape in a left handed doodle::FrameOfReference and right handed doodle::FrameOfReference respectively.
Center	RectMode::CENTER interprets the first two parameters of draw_rectangle() as the shape's center point.

Definition at line 718 of file drawing.hpp.

    {
        Corner,
        Center
    };

Function Documentation

draw_ellipse()

void doodle::draw_ellipse ( double  x, double  y, double  width, double  height = 0  )

noexcept

Draws an ellipse (oval) to the screen.

An ellipse with equal width and height is a circle. By default, the first two parameters set the location, and the third and fourth parameters set the shape's width and height. If no height is specified, the value of width is used for both the width and height. The origin may be changed with the set_ellipse_mode() function. By default the (x,y) location is in the center of the ellipse.

Parameters

x	x-coordinate of the ellipse.
y	y-coordinate of the ellipse.
width	width of the ellipse.
height	height of the ellipse.

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0xBF8679FF});
        set_fill_color(HexColor{0x8C2B2EFF});
        // opaque and wide ellipse
        draw_ellipse(0, 0, Width * 0.8, Height * 0.6);
        set_fill_color(HexColor{0xDDD3D680});
        // translucent circle
        draw_ellipse(0, 0, Width * 0.6);
    }
    return 0;
}

draw_line()

void doodle::draw_line ( double  x1, double  y1, double  x2, double  y2  )

noexcept

Draws a line (a direct path between two points) to the screen.

To color a line, use the set_outline_color() function. A line cannot be filled, therefore the set_fill_color() function will not affect the color of a line. Lines are drawn with a width of one pixel by default, but this can be changed with the set_outline_width() function.

Parameters

x1	the x-coordinate of the first point
y1	the y-coordinate of the first point
x2	the x-coordinate of the second point
y2	the y-coordinate of the second point

#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();
        clear_background(200);
        set_outline_color(0);
        const double top    = Height - 30.0;
        const double bottom = 30.0;
        const double left   = 30.0;
        const double right  = Width - 30.0;
        draw_line(left, top, right, top);
        set_outline_color(126);
        draw_line(right, top, right, bottom);
        set_outline_color(255);
        draw_line(left, bottom, right, bottom);
    }
    return 0;
}

draw_quad()

void doodle::draw_quad ( double  x1, double  y1, double  x2, double  y2, double  x3, double  y3, double  x4, double  y4  )

noexcept

Draw a quad.

A quad is a quadrilateral, a four sided polygon. It is similar to a rectangle, but the angles between its edges are not constrained to ninety degrees. The first pair of parameters (x1,y1) sets the first vertex and the subsequent pairs should proceed clockwise or counter-clockwise around the defined shape.

Parameters

x1	the x-coordinate of the first point
y1	the y-coordinate of the first point
x2	the x-coordinate of the second point
y2	the y-coordinate of the second point
x3	the x-coordinate of the third point
y3	the y-coordinate of the third point
x4	the x-coordinate of the fourth point
y4	the y-coordinate of the forth point

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_frame_of_reference(FrameOfReference::LeftHanded_OriginTopLeft);
    set_outline_color(HexColor{0xAD4A3BFF});
    set_fill_color(HexColor{0xEBE3C0FF});
    set_outline_width(3.0);
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0x457648FF});
        draw_quad(152, 124, 344, 80, 276, 252, 120, 304);
    }
    return 0;
}

draw_rectangle()

void doodle::draw_rectangle ( double  x, double  y, double  width, double  height = 0  )

noexcept

Draws a rectangle to the screen.

A rectangle is a four-sided shape with every angle at ninety degrees. By default, the first two parameters set the location of a corner, the third sets the width, and the fourth sets the height. The way these parameters are interpreted, however, may be changed with the set_rectangle_mode() function. If the height is omitted then the height will be set to the width, thus creating a square.

Parameters

x	x-coordinate of the rectangle.
y	y-coordinate of the rectangle.
width	width of the rectangle.
height	height of the rectangle.

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0x9EA2B8FF});
        set_fill_color(HexColor{0x7E5873FF});
        // opaque and wide rectangle
        double left = Width * -0.4, bottom = Height * -0.3;
        draw_rectangle(left, bottom, Width * 0.8, Height * 0.6);
        set_fill_color(HexColor{0x372F4A80});
        // translucent square
        left = Width * -0.3, bottom = Width * -0.3;
        draw_rectangle(left, bottom, Width * 0.6);
    }
    return 0;
}

draw_triangle()

void doodle::draw_triangle ( double  x1, double  y1, double  x2, double  y2, double  x3, double  y3  )

noexcept

Draw a triangle to the screen.

A triangle is a plane created by connecting three points. The first two arguments specify the first point, the middle two arguments specify the second point, and the last two arguments specify the third point.

Parameters

x1	the x-coordinate of the first point
y1	the y-coordinate of the first point
x2	the x-coordinate of the second point
y2	the y-coordinate of the second point
x3	the x-coordinate of the third point
y3	the y-coordinate of the third point

#include <cmath>
#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_fill_color(HexColor{0xE5C8B4FF});
    set_outline_color(HexColor{0x483524FF});
    set_outline_width(3.0);
    double offset = 0.0;
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0xA47B56FF});
        const double angle1 = offset + TWO_PI / 3.0 + to_radians(60.0) * noise(ElapsedTime, 2.0);
        const double angle2 = offset + 2.0 * TWO_PI/3.0 + to_radians(30.0) * noise(ElapsedTime/2.0, 40.0);
        const double angle3 = offset + TWO_PI + to_radians(80.0) * noise(ElapsedTime, 200.0);
        offset += 0.25 * QUARTER_PI * DeltaTime;
        apply_scale(Height / 3.0);
        draw_triangle(cos(angle1), sin(angle1), cos(angle2), sin(angle2), cos(angle3), sin(angle3));
    }
    return 0;
}

no_smoothing()

void doodle::no_smoothing ( )

noexcept

Draws all geometry with jagged (aliased) edges.

Note that smooth_drawing() is active by default in; no_smoothing() can be used to disable smoothing of geometry, images, and fonts.

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_outline_color(HexColor{0xE7C0ABFF});
    set_outline_width(5.0);
    set_rectangle_mode(RectMode::Center);
    while (!is_window_closed())
    {
        update_window();
        const double shape_width  = Width * 0.4;
        const double shape_height = Height * 0.4;
        clear_background(HexColor{0xAC7476FF});
        smooth_drawing();
        draw_rectangle(-Width / 4.0, 0, shape_width, shape_height);
        no_smoothing();
        draw_rectangle(Width / 4.0, 0, shape_width, shape_height);
    }
    return 0;
}

pop_settings()

void doodle::pop_settings ( )

noexcept

The pop_settings() function restores to the previous style settings and transformations, while push_settings() saves a new set these settings.

Note that these functions are always used together. They allow you to change the style and transformation settings and later return to what you had. When a new state is started with push_settings(), it builds on the current style and transform information. The push_settings() and pop_settings() functions can be embedded to provide more control.

push_settings() stores information related to the current transformation (apply_scale(), apply_rotate(), apply_translate(), apply_matrix()) state and style settings controlled by the following functions: set_fill_color(), no_fill(), set_outline_color(), no_outline(), set_ellipse_mode(), set_rectangle_mode(), smooth_drawing(), no_smoothing(), set_outline_width(), set_tint_color(), no_tint(), set_image_mode(), set_font(), set_frame_of_reference()

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0xBB8F99FF});
        const double center = 0;
        const double left = -3.0 * Width / 8.0, left_middle = -Width / 8.0;
        const double right_middle = -left_middle, right = -left;
        const double shape_width = Width / 3.0;
 
        draw_ellipse(left, center, shape_width); // Left circle
 
        push_settings(); // Start a new drawing state
        set_outline_width(10.0);
        set_fill_color(204, 153, 0);
        draw_ellipse(left_middle, center, shape_width); // Left-middle circle
 
        push_settings(); // Start another new drawing state
        set_outline_color(0, 102, 153);
        draw_ellipse(right_middle, center, shape_width); // Right-middle circle
        pop_settings();                                  // Restore previous state
 
        pop_settings(); // Restore original state
 
        draw_ellipse(right, center, shape_width); // Right circle
    }
    return 0;
}

push_settings()

void doodle::push_settings ( )

noexcept

The push_settings() function saves the current drawing style settings and transformations, while pop_settings() restores these settings.

Note that these functions are always used together. They allow you to change the style and transformation settings and later return to what you had. When a new state is started with push_settings(), it builds on the current style and transform information. The push_settings() and pop_settings() functions can be embedded to provide more control.

push_settings() stores information related to the current transformation (apply_scale(), apply_rotate(), apply_translate(), apply_matrix()) state and style settings controlled by the following functions: set_fill_color(), no_fill(), set_outline_color(), no_outline(), set_ellipse_mode(), set_rectangle_mode(), smooth_drawing(), no_smoothing(), set_outline_width(), set_tint_color(), no_tint(), set_image_mode(), set_font(), set_frame_of_reference()

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    double           thetaOffset       = 0.0;
    constexpr double radiansPerSecond  = QUARTER_PI / 2.0;
    constexpr int   outerCircleSlices = 32;
    constexpr int   innerCircleSlices = 12;
    constexpr double outerIncrement    = TWO_PI / outerCircleSlices;
    constexpr double innerIncrement    = TWO_PI / innerCircleSlices;
    while (!is_window_closed())
    {
        update_window();
        clear_background(255, 128);
        // Loop from 0 to 360 degrees (2*PI radians)
        for (int i = 0; i < outerCircleSlices; ++i)
        {
            // Push, rotate and draw a line
            // The transformation state is saved at the beginning of each cycle through the for loop and
            // restored at the end. Try commenting out these lines to see the difference!
            push_settings();
            apply_rotate(thetaOffset + i * outerIncrement);
            draw_line(0, 0, 100, 0);
 
            // draw a "flower" of lines at the end of the ith parent line
            for (int j = 0; j < innerCircleSlices; ++j)
            {
                // Push, translate, rotate and draw a line!
                push_settings();
                apply_translate(100, 0);
                apply_rotate(-thetaOffset - j * innerIncrement);
                draw_line(0, 0, 50, 0);
                // We're done with the inside loop, pop!
                pop_settings();
            }
            // We're done with the outside loop, pop!
            pop_settings();
        }
        thetaOffset += radiansPerSecond * DeltaTime;
    }
    return 0;
}

set_ellipse_mode()

void doodle::set_ellipse_mode ( EllipseMode  mode )

noexcept

Modifies the location from which ellipses are drawn by changing the way in which parameters given to draw_ellipse() are interpreted.

The default mode is EllipseMode::CENTER, which interprets the first two parameters of draw_ellipse() as the shape's center point, while the third and fourth parameters are its width and height.

EllipseMode::CORNER interprets the first two parameters of draw_ellipse() as the upper-left or bottom-left corner of the shape in a left handed doodle::FrameOfReference and right handed doodle::FrameOfReference respectively, while the third and fourth parameters are its width and height.

Parameters

mode	either CENTER or CORNER

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_outline_color(HexColor{0x483524FF});
    set_outline_width(3.0);
    while (!is_window_closed())
    {
        update_window();
        const double circle_width = Width * 0.3;
        clear_background(HexColor{0xA47B56FF});
        set_ellipse_mode(EllipseMode::Center);
        set_fill_color(255);
        draw_ellipse(0, 0, circle_width);
        set_ellipse_mode(EllipseMode::Corner);
        set_fill_color(120);
        draw_ellipse(0, 0, circle_width);
    }
    return 0;
}

set_frame_of_reference()

void doodle::set_frame_of_reference ( FrameOfReference  frame_of_reference )

noexcept

Change the coordinate system you would like to use when describing your primitives.

Parameters

frame_of_reference

The coordinate system you would like to use.

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    constexpr int   gridSize = 50;
    constexpr double x1 = 10, y1 = 10;   // left
    constexpr double x2 = 210, y2 = 10;  // right
    constexpr double x3 = 110, y3 = 140; // top
 
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0xD7A586ff});
        // Red
        set_fill_color(255, 0, 0);
        set_frame_of_reference(FrameOfReference::RightHanded_OriginCenter);
        draw_triangle(x1, y1, x2, y2, x3, y3);
 
        // green
        set_fill_color(0, 255, 0);
        set_frame_of_reference(FrameOfReference::RightHanded_OriginBottomLeft);
        draw_triangle(x1, y1, x2, y2, x3, y3);
 
        // blue
        set_fill_color(0, 0, 255);
        set_frame_of_reference(FrameOfReference::LeftHanded_OriginTopLeft);
        draw_triangle(x1, y1, x2, y2, x3, y3);
    }
    return 0;
}

set_outline_width()

void doodle::set_outline_width ( double  line_width )

noexcept

Sets the width of the outline used for lines and the border around shapes. All widths are set in units of pixels.

Parameters

line_width

how thick to make lines

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(250, 200);
    set_outline_color(HexColor{0x471623FF});
 
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0xBB8F99FF});
        const double top = Height / 3.0, bottom = -top, center = 0;
        const double left = -Width / 2.0 + 20, right = Width / 2.0 - 20;
 
        set_outline_width(1.0);
        draw_line(left, top, right, top);
        set_outline_width(5.0);
        draw_line(left, center, right, center);
        set_outline_width(10.0);
        draw_line(left, bottom, right, bottom);
    }
    return 0;
}

set_rectangle_mode()

void doodle::set_rectangle_mode ( RectMode  mode )

noexcept

Modifies the location from which rectangles are drawn by changing the way in which parameters given to draw_rectangle() are interpreted.

The default mode is RectMode::CORNER, which interprets the first two parameters of draw_rectangle() as upper-left or bottom-left corner of the shape in a left handed doodle::FrameOfReference and right handed doodle::FrameOfReference respectively, while the third and fourth parameters are its width and height.

RectMode::CENTER interprets the first two parameters of draw_rectangle() as the shape's center point, while the third and fourth parameters are its width and height.

Parameters

mode	either CORNER or CENTER

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_outline_color(HexColor{0xE7C0ABFF});
    set_outline_width(3.0);
    set_frame_of_reference(FrameOfReference::LeftHanded_OriginTopLeft);
    while (!is_window_closed())
    {
        update_window();
        const double shape_width = Width * 0.4;
        clear_background(HexColor{0xAC7476FF});
        set_rectangle_mode(RectMode::Center);
        set_fill_color(255);
        draw_rectangle(shape_width / 2, shape_width / 2, shape_width);
        set_rectangle_mode(RectMode::Corner);
        set_fill_color(120);
        draw_rectangle(shape_width / 2, shape_width / 2, shape_width);
    }
    return 0;
}

smooth_drawing()

void doodle::smooth_drawing ( )

noexcept

Draws all geometry with smooth (anti-aliased) edges.

Note that smooth_drawing() is active by default in; no_smoothing() can be used to disable smoothing of geometry, images, and fonts.

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 320);
    set_outline_color(HexColor{0xE7C0ABFF});
    set_outline_width(3.0);
    set_frame_of_reference(FrameOfReference::RightHanded_OriginCenter);
    while (!is_window_closed())
    {
        update_window();
        const double shape_width = Width * 0.4;
        const double shape_height = Height * 0.4;
        clear_background(HexColor{0xAC7476FF});
        smooth_drawing();
        draw_ellipse(-Width/4.0, 0, shape_width, shape_height);
        no_smoothing();
        draw_ellipse(Width/4.0, 0, shape_width, shape_height);
    }
    return 0;
}