Events

Functions
int	doodle::get_mouse_x () noexcept
	Get the mouse's X position relative to the currently set doodle::FrameOfReference. More...
int	doodle::get_mouse_y () noexcept
	Get the mouse's Y position relative to the currently set doodle::FrameOfReference. More...
int	doodle::get_previous_mouse_x () noexcept
	Get the previous mouse's X position relative to the currently set doodle::FrameOfReference. More...
int	doodle::get_previous_mouse_y () noexcept
	Get the previous mouse's Y position relative to the currently set doodle::FrameOfReference. More...
void	doodle::set_callback_key_pressed (std::function< void(KeyboardButtons)> &&callback) noexcept
	The provided callback function is called once every time a key is pressed. More...
void	doodle::set_callback_key_released (std::function< void(KeyboardButtons)> &&callback) noexcept
	The provided callback function is called once every time a key is released. More...
void	doodle::set_callback_mouse_moved (std::function< void(int, int)> &&callback) noexcept
	The provided callback function is called every time the mouse moves. More...
void	doodle::set_callback_mouse_pressed (std::function< void(MouseButtons)> &&callback) noexcept
	The provided callback is called whenever a mouse button is pressed. More...
void	doodle::set_callback_mouse_released (std::function< void(MouseButtons)> &&callback) noexcept
	The provided callback is called whenever a mouse button is released. More...
void	doodle::set_callback_mouse_wheel (std::function< void(int)> &&callback) noexcept
	The provided callback is called whenever the mouse wheel is scrolled. More...
EVENT_HOOK void	on_key_pressed (doodle::KeyboardButtons button)
	The declaration of the optional on_key_pressed function to implement in your doodle program. More...
EVENT_HOOK void	on_key_released (doodle::KeyboardButtons button)
	The declaration of the optional on_key_released function to implement in your doodle program. More...
EVENT_HOOK void	on_mouse_moved (int mouse_x, int mouse_y)
	The declaration of the optional on_mouse_moved function to implement in your doodle program. More...
EVENT_HOOK void	on_mouse_pressed (doodle::MouseButtons button)
	The declaration of the optional on_mouse_pressed function to implement in your doodle program. More...
EVENT_HOOK void	on_mouse_released (doodle::MouseButtons button)
	The declaration of the optional on_mouse_released function to implement in your doodle program. More...
EVENT_HOOK void	on_mouse_wheel (int scroll_amount)
	The declaration of the optional on_mouse_wheel function to implement in your doodle program. More...

Variables
bool	doodle::MouseIsPressed
	The boolean system variable MouseIsPressed is true if the mouse is pressed and false if not. More...
bool	doodle::KeyIsPressed
	The boolean system variable KeyIsPressed is true if any key is pressed and false if no keys are pressed. More...
KeyboardButtons	doodle::Key
	The system variable key always contains the value of the most recent key on the keyboard that was typed. More...
MouseButtons	doodle::MouseButton
	doodle automatically tracks if the mouse button is pressed and which button is pressed. The value of the system variable MouseButton is either LEFT, RIGHT, or CENTER depending on which button was pressed last. More...

Detailed Description

• global variables related to input Events

  You can register callback functions so you can immediately respond to input events. Also provides helper functions to get the mouse position.

Function Documentation

get_mouse_x()

int doodle::get_mouse_x ( )

noexcept

Get the mouse's X position relative to the currently set doodle::FrameOfReference.

Returns

the current horizontal position of the mouse, relative to the currently set doodle::FrameOfReference

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    while (!is_window_closed())
    {
        update_window();
        clear_background(244, 248, 252);
        const int mouseX = get_mouse_x();
        draw_line(mouseX, Height / 2.0, mouseX, -Height / 2.0);
    }
    return 0;
}

get_mouse_y()

int doodle::get_mouse_y ( )

noexcept

Get the mouse's Y position relative to the currently set doodle::FrameOfReference.

Returns

the current vertical position of the mouse, relative to the currently set doodle::FrameOfReference

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    while (!is_window_closed())
    {
        update_window();
        clear_background(244, 248, 252);
        const int mouseY = get_mouse_y();
        draw_line(-Width / 2.0, mouseY, Width / 2.0, mouseY);
    }
    return 0;
}

get_previous_mouse_x()

int doodle::get_previous_mouse_x ( )

noexcept

Get the previous mouse's X position relative to the currently set doodle::FrameOfReference.

Returns

the previous horizontal position of the mouse, relative to the currently set doodle::FrameOfReference

#include <doodle/doodle.hpp>
#include <thread>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    while (!is_window_closed())
    {
        update_window();
        clear_background(244, 248, 252);
        const int mouseX     = get_mouse_x();
        const int mouseY     = get_mouse_y();
        const int prevMouseX = get_previous_mouse_x();
        const int prevMouseY = get_previous_mouse_y();
        draw_line(mouseX, mouseY, prevMouseX, prevMouseY);
 
        // slow down frame rate to make it more visible
        using namespace std::chrono_literals;
        std::this_thread::sleep_for(100ms);
    }
    return 0;
}

get_previous_mouse_y()

int doodle::get_previous_mouse_y ( )

noexcept

Get the previous mouse's Y position relative to the currently set doodle::FrameOfReference.

Returns

Get the previous mouse's Y position relative to the currently set doodle::FrameOfReference

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    set_fill_color(0);
    set_rectangle_mode(RectMode::Center);
    while (!is_window_closed())
    {
        update_window();
        clear_background(237, 34, 93);
        draw_line(-Width / 2.0 + 20, get_mouse_y(), Width / 2.0 - 20.0, get_previous_mouse_y());
    }
    return 0;
}

on_key_pressed()

EVENT_HOOK void on_key_pressed

(

doodle::KeyboardButtons

button

)

The declaration of the optional on_key_pressed function to implement in your doodle program.

If you define the function definition of this function then it will be called when a keyboard button is pressed.

Parameters

button

which button is being pressed

#include <doodle/doodle.hpp>
using namespace doodle;
 
int  main(void)
{
    create_window(480, 360);
    clear_background(220);
    set_frame_of_reference(FrameOfReference::RightHanded_OriginBottomLeft);
    while (!is_window_closed())
    {
        update_window();
    }
    return 0;
}
 
void on_key_pressed(KeyboardButtons button)
{
    if (button < KeyboardButtons::A || button > KeyboardButtons::Z)
    {
        clear_background(220); // if it's not a letter clear the screen
        return;
    }
    const auto r = random(0, 256);
    const auto g = random(0, 256);
    const auto b = random(0, 256);
    set_fill_color(r, g, b);
    const double rectWidth = Width / 4.0;
    const double key       = (static_cast<double>(button) - static_cast<double>(KeyboardButtons::A));
    const double x         = key / (25.0) * (Width - rectWidth);
    draw_rectangle(x, 0, rectWidth, Height * 1.0);
}

on_key_released()

EVENT_HOOK void on_key_released

(

doodle::KeyboardButtons

button

)

The declaration of the optional on_key_released function to implement in your doodle program.

If you define the function definition of this function then it will be called when a keyboard button is released.

Parameters

button

which button was released

#include <doodle/doodle.hpp>
using namespace doodle;
 
double grey{0};
 
void on_key_released(KeyboardButtons button)
{
    if (grey == 0)
        grey = 255;
    else
        grey = 0;
    if (button == KeyboardButtons::Escape)
        close_window();
}
 
int main(void)
{
    create_window(480, 360);
    set_rectangle_mode(RectMode::Center);
    grey = 0;
    while (!is_window_closed())
    {
        update_window();
        clear_background(220);
        set_fill_color(grey);
        draw_rectangle(0, 0, Width * 0.6, Height * 0.6);
    }
    return 0;
}

on_mouse_moved()

EVENT_HOOK void on_mouse_moved	(	int	mouse_x,
		int	mouse_y
	)

The declaration of the optional on_mouse_moved function to implement in your doodle program.

If you define the function definition of this function then it will be called whenever the mouse moves to a new position.

Parameters

mouse_x	mouse x position relative to the current doodle::FrameOfReference
mouse_y	mouse y position relative to the current doodle::FrameOfReference

#include <doodle/doodle.hpp>
using namespace doodle;
 
double                   angle{0.0};
double                   grey{0};
double                   x{0.0};
double                   y{0.0};
 
void on_mouse_moved(int mouse_x, int mouse_y)
{
    angle += to_radians(3.0);
    grey   = 255 * (std::sin(angle) * 0.5 + 0.5);
    x      = mouse_x;
    y      = mouse_y;
}
 
int main(void)
{
    create_window(480, 360);
    set_rectangle_mode(RectMode::Center);
    while (!is_window_closed())
    {
        update_window();
        clear_background(220);
        set_fill_color(grey);
        draw_rectangle(x, y, Width * 0.4, Height * 0.4);
    }
    return 0;
}

on_mouse_pressed()

EVENT_HOOK void on_mouse_pressed

(

doodle::MouseButtons

button

)

The declaration of the optional on_mouse_pressed function to implement in your doodle program.

If you define the function definition of this function then it will be called whenever a mouse button is pressed.

Parameters

button

which button is being pressed

#include <doodle/doodle.hpp>
using namespace doodle;
 
bool shouldFollowMouse = false;
 
void on_mouse_pressed(MouseButtons button)
{
    if (button == MouseButtons::Left)
        shouldFollowMouse = true;
}
 
void on_mouse_released(MouseButtons button)
{
    if (button == MouseButtons::Left)
        shouldFollowMouse = false;
}
 
int main(void)
{
    double x{0.0};
    double y{0.0};
    create_window(480, 360);
    while (!is_window_closed())
    {
        update_window();
        if (shouldFollowMouse)
        {
            const double easing = 3.0 * DeltaTime;
            x += easing * (get_mouse_x() - x);
            y += easing * (get_mouse_y() - y);
        }
        clear_background(237, 34, 93);
        draw_ellipse(x, y, Width * 0.1);
    }
    return 0;
}

on_mouse_released()

EVENT_HOOK void on_mouse_released

(

doodle::MouseButtons

button

)

The declaration of the optional on_mouse_released function to implement in your doodle program.

If you define the function definition of this function then it will be called whenever a mouse button was released.

Parameters

button

which button was released

#include <doodle/doodle.hpp>
using namespace doodle;
 
bool shouldFollowMouse = false;
 
void on_mouse_pressed(MouseButtons button)
{
    if (button == MouseButtons::Left)
        shouldFollowMouse = true;
}
 
void on_mouse_released(MouseButtons button)
{
    if (button == MouseButtons::Left)
        shouldFollowMouse = false;
}
 
int main(void)
{
    double x{0.0};
    double y{0.0};
    create_window(480, 360);
    while (!is_window_closed())
    {
        update_window();
        if (shouldFollowMouse)
        {
            const double easing = 3.0 * DeltaTime;
            x += easing * (get_mouse_x() - x);
            y += easing * (get_mouse_y() - y);
        }
        clear_background(237, 34, 93);
        draw_ellipse(x, y, Width * 0.1);
    }
    return 0;
}

on_mouse_wheel()

EVENT_HOOK void on_mouse_wheel

(

int

scroll_amount

)

The declaration of the optional on_mouse_wheel function to implement in your doodle program.

If you define the function definition of this function then it will be called whenever the mouse wheel scrolls.

Parameters

scroll_amount

Positive for scroll up and negative for scroll down.

#include <doodle/doodle.hpp>
using namespace doodle;
 
double y{0.0};
 
void on_mouse_wheel(int scroll_amount) { y += scroll_amount * 2.0; }
 
int main(void)
{
    create_window(480, 360);
    set_fill_color(HexColor{0xc8d3d8ff});
 
    while (!is_window_closed())
    {
        update_window();
        clear_background(HexColor{0xf7fcfdff});
        draw_ellipse(0, y, Width * 0.3);
    }
    return 0;
}

set_callback_key_pressed()

void doodle::set_callback_key_pressed ( std::function< void(KeyboardButtons)> &&  callback )

noexcept

The provided callback function is called once every time a key is pressed.

It takes in a std::function with a signature of something that returns nothing and takes in a doodle::KeyboardButtons. Something like

void keyPressed(doodle::KeyboardButtons button); 

Parameters

callback

what to call when a key is pressed

#include <doodle/doodle.hpp>
using namespace doodle;
void keyPressed(KeyboardButtons button);
int  main(void)
{
    create_window(480, 360);
    clear_background(220);
    set_frame_of_reference(FrameOfReference::RightHanded_OriginBottomLeft);
    set_callback_key_pressed(&keyPressed);
    while (!is_window_closed())
    {
        update_window();
    }
    return 0;
}
void keyPressed(KeyboardButtons button)
{
    if (button < KeyboardButtons::A || button > KeyboardButtons::Z)
    {
        clear_background(220); // if it's not a letter clear the screen
        return;
    }
    const auto r = random(0, 256);
    const auto g = random(0, 256);
    const auto b = random(0, 256);
    set_fill_color(r, g, b);
    const double rectWidth = Width / 4.0;
    const double key       = (static_cast<double>(button) - static_cast<double>(KeyboardButtons::A));
    const double x         = key / (25.0) * (Width - rectWidth);
    draw_rectangle(x, 0, rectWidth, Height * 1.0);
}

set_callback_key_released()

void doodle::set_callback_key_released ( std::function< void(KeyboardButtons)> &&  callback )

noexcept

The provided callback function is called once every time a key is released.

It takes in a std::function with a signature of something that returns nothing and takes in a doodle::KeyboardButtons. Something like

void keyReleased(doodle::KeyboardButtons button); 

Parameters

callback

what to call when a key is released

#include <doodle/doodle.hpp>
using namespace doodle;
class Logic
{
    double grey{0.0};
 
public:
    void Setup() noexcept
    {
        create_window(480, 360);
        set_rectangle_mode(RectMode::Center);
        grey = 0;
        set_callback_key_released([this](KeyboardButtons b) { OnKeyReleased(b); });
    }
    void Run() const noexcept
    {
        while (!is_window_closed())
        {
            update_window();
            Draw();
        }
    }
    void Draw() const noexcept
    {
        clear_background(220);
        set_fill_color(grey);
        draw_rectangle(0, 0, Width * 0.6, Height * 0.6);
    }
    void OnKeyReleased(KeyboardButtons button) noexcept
    {
        if (grey == 0)
            grey = 255;
        else
            grey = 0;
        if (button == KeyboardButtons::Escape)
            close_window();
    }
};
int main(void)
{
    Logic logic{};
    logic.Setup();
    logic.Run();
    return 0;
}

set_callback_mouse_moved()

void doodle::set_callback_mouse_moved ( std::function< void(int, int)> &&  callback )

noexcept

The provided callback function is called every time the mouse moves.

It takes in a std::function with a signature of something that returns nothing and takes in a two integers. Something like

void mouseMoved(int mouse_x, int mouse_y); 

Parameters

callback

what to call when the mouse moves

#include <doodle/doodle.hpp>
using namespace doodle;
class Logic
{
    double                   angle{0.0};
    double                   grey{0};
    double                   x{0.0};
    double                   y{0.0};
 
public:
    void Setup() noexcept
    {
        create_window(480, 360);
        set_rectangle_mode(RectMode::Center);
        set_callback_mouse_moved([this](int x, int y) { OnMouseMoved(x, y); });
    }
    void Run() const noexcept
    {
        while (!is_window_closed())
        {
            update_window();
            Draw();
        }
    }
    void Draw() const noexcept
    {
        clear_background(220);
        set_fill_color(grey);
        draw_rectangle(x, y, Width * 0.4, Height * 0.4);
    }
    void OnMouseMoved(int mouse_x, int mouse_y) noexcept
    {
        angle += to_radians(3.0);
        grey   = 255 * (std::sin(angle) * 0.5 + 0.5);
        x      = mouse_x;
        y      = mouse_y;
    }
};
int main(void)
{
    Logic logic{};
    logic.Setup();
    logic.Run();
    return 0;
}

set_callback_mouse_pressed()

void doodle::set_callback_mouse_pressed ( std::function< void(MouseButtons)> &&  callback )

noexcept

The provided callback is called whenever a mouse button is pressed.

It takes in a std::function with a signature of something that returns nothing and takes in a doodle::MouseButtons. Something like

void mousePressed(doodle::MouseButtons button); 

Parameters

callback

what to call when the mouse is pressed

#include <doodle/doodle.hpp>
using namespace doodle;
class Logic
{
    double x{0.0};
    double y{0.0};
    bool  shouldFollowMouse = false;
 
public:
    void Setup() noexcept
    {
        create_window(480, 360);
        set_callback_mouse_pressed([this](MouseButtons b) { OnMousePressed(b); });
        set_callback_mouse_released([this](MouseButtons b) { OnMouseReleased(b); });
    }
    void Run() noexcept
    {
        while (!is_window_closed())
        {
            update_window();
            if (shouldFollowMouse)
            {
                const double easing = 3.0 * DeltaTime;
                x += easing * (get_mouse_x() - x);
                y += easing * (get_mouse_y() - y);
            }
            Draw();
        }
    }
    void Draw() const noexcept
    {
        clear_background(237, 34, 93);
        draw_ellipse(x, y, Width * 0.1);
    }
    void OnMousePressed(MouseButtons button) noexcept
    {
        if (button == MouseButtons::Left)
            shouldFollowMouse = true;
    }
    void OnMouseReleased(MouseButtons button) noexcept
    {
        if (button == MouseButtons::Left)
            shouldFollowMouse = false;
    }
};
int main(void)
{
    Logic logic{};
    logic.Setup();
    logic.Run();
    return 0;
}

set_callback_mouse_released()

void doodle::set_callback_mouse_released ( std::function< void(MouseButtons)> &&  callback )

noexcept

The provided callback is called whenever a mouse button is released.

It takes in a std::function with a signature of something that returns nothing and takes in a doodle::MouseButtons. Something like

void mouseReleased(doodle::MouseButtons button); 

Parameters

callback

what to call when the mouse is released

#include <doodle/doodle.hpp>
using namespace doodle;
class Logic
{
    double x{0.0};
    double y{0.0};
    bool  shouldFollowMouse = false;
 
public:
    void Setup() noexcept
    {
        create_window(480, 360);
        set_callback_mouse_pressed([this](MouseButtons b) { OnMousePressed(b); });
        set_callback_mouse_released([this](MouseButtons b) { OnMouseReleased(b); });
    }
    void Run() noexcept
    {
        while (!is_window_closed())
        {
            update_window();
            if (shouldFollowMouse)
            {
                const double easing = 3.0 * DeltaTime;
                x += easing * (get_mouse_x() - x);
                y += easing * (get_mouse_y() - y);
            }
            Draw();
        }
    }
    void Draw() const noexcept
    {
        clear_background(237, 34, 93);
        draw_ellipse(x, y, Width * 0.1);
    }
    void OnMousePressed(MouseButtons button) noexcept
    {
        if (button == MouseButtons::Left)
            shouldFollowMouse = true;
    }
    void OnMouseReleased(MouseButtons button) noexcept
    {
        if (button == MouseButtons::Left)
            shouldFollowMouse = false;
    }
};
int main(void)
{
    Logic logic{};
    logic.Setup();
    logic.Run();
    return 0;
}

set_callback_mouse_wheel()

void doodle::set_callback_mouse_wheel ( std::function< void(int)> &&  callback )

noexcept

The provided callback is called whenever the mouse wheel is scrolled.

It takes in a std::function with a signature of something that returns nothing and takes in an integer. Something like

void mouseWheel(int scroll_amount); 

Parameters

callback

what to call when the mouse wheel is scrolled

#include <doodle/doodle.hpp>
using namespace doodle;
class Logic
{
    double y{0.0};
 
public:
    void Setup() noexcept
    {
        create_window(480, 360);
        set_fill_color(HexColor{0xc8d3d8ff});
        set_callback_mouse_wheel([this](int s) { OnMouseWheel(s); });
    }
    void Run() const noexcept
    {
        while (!is_window_closed())
        {
            update_window();
            Draw();
        }
    }
    void Draw() const noexcept
    {
        clear_background(HexColor{0xf7fcfdff});
        draw_ellipse(0, y, Width * 0.3);
    }
    void OnMouseWheel(int scroll_amount) noexcept { y += scroll_amount * 2.0; }
};
int main(void)
{
    Logic logic{};
    logic.Setup();
    logic.Run();
    return 0;
}

Variable Documentation

Key

KeyboardButtons doodle::Key

extern

The system variable key always contains the value of the most recent key on the keyboard that was typed.

#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    set_fill_color(245, 123, 158);
    while (!is_window_closed())
    {
        update_window();
        clear_background(220);
        draw_text(to_string(Key), -60.0, -30.0);
        if (!KeyIsPressed && Key == KeyboardButtons::Escape)
            close_window();
    }
    return 0;
}

KeyIsPressed

bool doodle::KeyIsPressed

extern

The boolean system variable KeyIsPressed is true if any key is pressed and false if no keys are pressed.

#include <doodle/doodle.hpp>
#include <string>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    set_rectangle_mode(RectMode::Center);
    while (!is_window_closed())
    {
        update_window();
        clear_background(220);
        set_fill_color(0);
        set_frame_of_reference(FrameOfReference::RightHanded_OriginCenter);
        if (KeyIsPressed)
        {
            set_fill_color(0);
        }
        else
        {
            set_fill_color(255);
        }
        draw_rectangle(0, 0, Width / 2.0, Height / 2.0);
        set_fill_color(255);
        set_frame_of_reference(FrameOfReference::RightHanded_OriginBottomLeft);
        using namespace std::string_literals;
        draw_text("Pressed: "s + ((KeyIsPressed) ? "true"s : "false"s), 5, 0);
    }
    return 0;
}

MouseButton

MouseButtons doodle::MouseButton

extern

doodle automatically tracks if the mouse button is pressed and which button is pressed. The value of the system variable MouseButton is either LEFT, RIGHT, or CENTER depending on which button was pressed last.

#include <cmath>
#include <doodle/doodle.hpp>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    set_fill_color(0);
    set_rectangle_mode(RectMode::Center);
    while (!is_window_closed())
    {
        update_window();
        clear_background(237, 34, 93);
        switch (MouseButton)
        {
            case MouseButtons::Left: draw_ellipse(0, 0, Width / 2.0, Height / 2.0); break;
            case MouseButtons::Middle:
            {
                const double length = 0.5 * std::sqrt((Width * Width) / 4.0 + (Height * Height) / 4.0);
                draw_triangle(0, length, -0.866 * length, -0.5 * length, 0.866 * length, -0.5 * length);
            }
            break;
            case MouseButtons::Right: draw_rectangle(0, 0, Width / 2.0, Height / 2.0); break;
            default: break;
        }
    }
    return 0;
}

MouseIsPressed

bool doodle::MouseIsPressed

extern

The boolean system variable MouseIsPressed is true if the mouse is pressed and false if not.

#include <doodle/doodle.hpp>
#include <string>
using namespace doodle;
int main(void)
{
    create_window(480, 360);
    set_rectangle_mode(RectMode::Center);
    while (!is_window_closed())
    {
        update_window();
        clear_background(237, 34, 93);
        set_fill_color(0);
        set_frame_of_reference(FrameOfReference::RightHanded_OriginCenter);
        if (MouseIsPressed)
        {
            draw_ellipse(0, 0, Width / 2.0, Height / 2.0);
        }
        else
        {
            draw_rectangle(0, 0, Width / 2.0, Height / 2.0);
        }
        set_fill_color(255);
        set_frame_of_reference(FrameOfReference::RightHanded_OriginBottomLeft);
        using namespace std::string_literals;
        draw_text("Pressed: "s + ((MouseIsPressed) ? "true"s : "false"s), 5, 0);
    }
    return 0;
}