Add follow eyes

Author: karnkaul

src/context.cpp

@@ -1,5 +1,6 @@
 #include <cassert>
 #include <context.hpp>
+#include <maths/maths.hpp>
 #include <scene.hpp>
 
 namespace misc {
@@ -35,6 +36,13 @@ std::vector<sf::Event> context_t::poll() {
 	return ret;
 }
 
+sf::Vector2f context_t::mouse_pos() const noexcept {
+	static auto const offset = sf::Vector2f(f32(width) * 0.5f, f32(height) * 0.5f);
+	auto ret = maths::cast<sf::Vector2f>(sf::Mouse::getPosition(*this));
+	ret -= offset;
+	return {ret.x, -ret.y};
+}
+
 drawer_t::drawer_t(context_t* ctx, sf::Color clear_colour) : ctx(ctx) { ctx->clear(clear_colour); }
 drawer_t::~drawer_t() { ctx->display(); }
 } // namespace misc

src/context.hpp

@@ -23,6 +23,8 @@ class context_t : public sf::RenderWindow {
 
 	drawer_t drawer(sf::Color clear_colour = sf::Color::Black);
 
+	sf::Vector2f mouse_pos() const noexcept;
+
   private:
 	bool m_closed = false;
 };

src/gfx/follow_eye.cpp

@@ -0,0 +1,44 @@
+#include <context.hpp>
+#include <gfx/follow_eye.hpp>
+#include <maths/maths.hpp>
+
+namespace misc {
+namespace {
+struct circle_params_t {
+	sf::Vector2f position{};
+	sf::Color fill = sf::Color::White;
+	sf::Color outline = sf::Color::Transparent;
+	f32 radius = 25.0f;
+	u32 points = 64;
+};
+
+void draw_circle(drawer_t& drawer, circle_params_t const& params) {
+	sf::CircleShape circle;
+	circle.setFillColor(params.fill);
+	circle.setOutlineColor(params.outline);
+	circle.setPointCount(params.points);
+	circle.setRadius(params.radius);
+	circle.setOrigin(params.radius, params.radius);
+	circle.setPosition(params.position.x, -params.position.y);
+	drawer.draw(circle);
+}
+} // namespace
+
+sf::Vector2f follow_eye_t::update(sf::Vector2f target) noexcept { return (dir = maths::norm(target - pos)); }
+void follow_eye_t::draw(drawer_t& drawer, bool blink) {
+	circle_params_t params;
+	params.radius = 40.0f * scale;
+	params.outline = sf::Color(0x221100ff);
+	params.position = pos;
+	draw_circle(drawer, params);
+	if (!blink) {
+		auto const radius = params.radius * 0.25f;
+		auto const offset = dir * (params.radius - radius) * 0.80f; // 20% padding
+		params.radius *= 0.25f;
+		params.outline = sf::Color::Transparent;
+		params.fill = sf::Color::Black;
+		params.position += offset;
+		draw_circle(drawer, params);
+	}
+}
+} // namespace misc

src/gfx/follow_eye.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include <SFML/System/Vector2.hpp>
+#include <types.hpp>
+
+namespace misc {
+struct drawer_t;
+
+struct follow_eye_t {
+	sf::Vector2f dir = {0.0f, 1.0f};
+	sf::Vector2f pos = {0.0f, 0.0f};
+	f32 scale = 1.0f;
+
+	sf::Vector2f update(sf::Vector2f target) noexcept;
+	void draw(drawer_t& drawer, bool blink);
+};
+} // namespace misc

src/main.cpp

@@ -3,6 +3,8 @@
 #include <set>
 #include <context.hpp>
 #include <delta_time.hpp>
+#include <gfx/follow_eye.hpp>
+#include <maths/maths.hpp>
 #include <world_clock/gui.hpp>
 #include <world_clock/io.hpp>
 
@@ -58,21 +60,47 @@ class clock_ticker_t {
 			if (m_input->any_held(key_t::Up, key_t::Right, key_t::W, key_t::D)) { delta += 1.0f; }
 			add(translation_scale * delta * dt.count());
 		}
+		auto next_blink = [this]() { return maths::random_range(m_blink.interval.first.count(), m_blink.interval.second.count()); };
+		if (m_blink.next_blink_in <= sec_t{}) {
+			m_blink.next_blink_in = sec_t{next_blink()};
+			m_blink.stop_blink_in = m_blink.duration;
+			update(flag::blinking);
+		}
+		if (test(flag::blinking)) {
+			m_blink.stop_blink_in -= dt;
+			if (m_blink.stop_blink_in <= sec_t{}) {
+				m_blink.next_blink_in = sec_t{next_blink()};
+				update(flag::none, flag::blinking);
+			}
+		} else {
+			m_blink.next_blink_in -= dt;
+		}
 	}
 
+	bool blink() const noexcept { return test(flag::blinking); }
+
+	struct {
+		pair_t<sec_t> interval = {sec_t{3.0f}, sec_t{8.0f}};
+		sec_t duration = sec_t{0.15f};
+
+		sec_t next_blink_in{};
+		sec_t stop_blink_in{};
+	} m_blink;
+
   private:
 	using flags_t = u8;
-	enum flag : flags_t { none = 0, zeroing = 1 << 0 };
+	enum flag : flags_t { none = 0, zeroing = 1 << 0, blinking = 1 << 1 };
 
 	input_t const* m_input;
 	world_clock_t* m_clock;
 	world_hour_t m_offset;
-	flags_t flags = flag::none;
 
-	bool test(flags_t f) const noexcept { return (flags & f) == f; }
+	flags_t m_flags = flag::none;
+
+	bool test(flags_t f) const noexcept { return (m_flags & f) == f; }
 	void update(flags_t set, flags_t unset = 0) noexcept {
-		flags |= set;
-		flags &= ~unset;
+		m_flags |= set;
+		m_flags &= ~unset;
 	}
 
 	void add(hour_t offset) noexcept {
@@ -96,7 +124,12 @@ int main() {
 	while (ctx.running()) {
 		input.update(ctx.poll());
 		tick(++dt);
-		if (auto drawer = ctx.drawer()) { world_clock_drawer_t{}(drawer, clock, {}); }
+		if (auto drawer = ctx.drawer()) {
+			world_clock_drawer_t::in_t in;
+			in.blink = tick.blink();
+			in.mouse_pos = ctx.mouse_pos();
+			world_clock_drawer_t{}(drawer, clock, in);
+		}
 	}
 	std::cout << "\nCompleted successfully\n";
 }

src/maths/maths.hpp

@@ -0,0 +1,87 @@
+#pragma once
+#include <cmath>
+#include <random>
+#include <type_traits>
+#include <SFML/System/Vector2.hpp>
+#include <types.hpp>
+
+namespace misc::maths {
+using rad_t = f32;
+
+template <bool V, typename...>
+constexpr bool value_v = V;
+
+constexpr f32 pi = 3.1415;
+sf::Vector2f const n_up = {0.0f, 1.0f};
+sf::Vector2f const n_down = {0.0f, -1.0f};
+sf::Vector2f const n_left = {-1.0f, 0.0f};
+sf::Vector2f const n_right = {1.0f, 0.0f};
+
+constexpr rad_t rad(f32 degrees) noexcept;
+constexpr f32 deg(rad_t rad) noexcept;
+
+f32 sqr_mag(sf::Vector2f vec) noexcept;
+f32 mag(sf::Vector2f vec) noexcept;
+f32 mag_or(sf::Vector2f vec, f32 fallback) noexcept;
+sf::Vector2f norm(sf::Vector2f vec) noexcept;
+sf::Vector2f safe_norm(sf::Vector2f vec) noexcept;
+
+sf::Vector2f dir(rad_t rad) noexcept;
+rad_t rad(sf::Vector2f n_dir) noexcept;
+
+template <typename Ret, typename In>
+Ret cast(sf::Vector2<In> in) noexcept;
+
+template <typename T>
+T random_range(T lo, T hi) noexcept;
+
+// impl
+
+constexpr rad_t rad(f32 degrees) noexcept { return degrees * pi / 180.0f; }
+constexpr f32 deg(rad_t radians) noexcept { return 180.0f * radians / pi; }
+inline f32 sqr_mag(sf::Vector2f vec) noexcept { return vec.x * vec.x + vec.y * vec.y; }
+inline f32 mag(sf::Vector2f vec) noexcept { return std::sqrt(sqr_mag(vec)); }
+
+inline f32 mag_or(sf::Vector2f vec, f32 fallback) noexcept {
+	f32 const ret = std::sqrt(sqr_mag(vec));
+	return ret == 0.0f ? fallback : ret;
+}
+
+inline sf::Vector2f norm(sf::Vector2f vec) noexcept {
+	auto const m = mag(vec);
+	return {vec.x / m, vec.y / m};
+}
+
+inline sf::Vector2f safe_norm(sf::Vector2f vec) noexcept {
+	auto const m = mag_or(vec, 1.0f);
+	return {vec.x / m, vec.y / m};
+}
+
+inline sf::Vector2f dir(rad_t rad) noexcept { return {std::sin(rad), std::cos(rad)}; }
+inline rad_t rad(sf::Vector2f n_dir) noexcept {
+	if (n_dir.y == 0.0f) { return rad(n_dir.x == 1.0f ? -90.0f : 90.0f); }
+	auto const atan = std::atan(n_dir.x / n_dir.y);
+	return n_dir.y > 0.0f ? atan : atan + rad(180.0f);
+}
+
+template <typename Ret, typename In>
+Ret cast(sf::Vector2<In> in) noexcept {
+	using type = decltype(std::declval<Ret>().x);
+	return Ret{static_cast<type>(in.x), static_cast<type>(in.y)};
+}
+
+template <typename T>
+T random_range(T lo, T hi) noexcept {
+	thread_local std::random_device rd;
+	thread_local std::default_random_engine eng{rd()};
+	if constexpr (std::is_integral_v<T>) {
+		std::uniform_int_distribution<T> dist(lo, hi);
+		return dist(eng);
+	} else if constexpr (std::is_floating_point_v<T>) {
+		std::uniform_real_distribution<T> dist(lo, hi);
+		return dist(eng);
+	} else {
+		static_assert(value_v<false, T>, "Invalid type");
+	}
+}
+} // namespace misc::maths

src/types.hpp

@@ -1,9 +1,13 @@
 #pragma once
 #include <cstdint>
+#include <utility>
 
 namespace misc {
 using s32 = std::uint32_t;
 using u8 = std::uint8_t;
 using u32 = std::uint32_t;
 using f32 = float;
+
+template <typename T, typename U = T>
+using pair_t = std::pair<T, U>;
 } // namespace misc

src/world_clock/gui.cpp

@@ -2,6 +2,7 @@
 #include <cmath>
 #include <SFML/Graphics.hpp>
 #include <context.hpp>
+#include <gfx/follow_eye.hpp>
 #include <world_clock/gui.hpp>
 
 namespace misc {
@@ -78,6 +79,18 @@ struct facade_t {
 		drawer.draw(t);
 	}
 
+	void draw_eyes(sf::Vector2f target, bool blink) const {
+		follow_eye_t left;
+		left.pos = {-80.0f, 50.0f};
+		left.pos *= in.scale;
+		left.update(target);
+		left.draw(drawer, blink);
+		follow_eye_t right;
+		right.pos = {-left.pos.x, left.pos.y};
+		right.update(target);
+		right.draw(drawer, blink);
+	}
+
 	void draw_clock() const {
 		if (in.face_tex) {
 			draw<sf::Sprite>();
@@ -105,6 +118,7 @@ struct facade_t {
 void world_clock_drawer_t::operator()(drawer_t& drawer, world_clock_t const& clock, in_t const& in) {
 	facade_t f{drawer, in};
 	f.draw_clock();
+	f.draw_eyes(in.mouse_pos, in.blink);
 	for (auto const& entry : clock) { f.draw_hand(entry); }
 }
 } // namespace misc

src/world_clock/gui.hpp

@@ -14,6 +14,7 @@ struct world_clock_drawer_t {
 	struct in_t {
 		sf::Vector2f centre{};
 		sf::Vector2f hand_pivot = {0.5f, 0.9f};
+		sf::Vector2f mouse_pos{};
 		sf::Color face_tint = sf::Color(0xccccbbff);
 		sf::Color marker_tint = sf::Color(0x555555ff);
 		sf::Texture const* face_tex{};
@@ -22,6 +23,7 @@ struct world_clock_drawer_t {
 		f32 marker_radius = 10.0f;
 		f32 face_pad = 0.2f;
 		f32 scale = 1.0f;
+		bool blink = false;
 	};
 
 	void operator()(drawer_t& drawer, world_clock_t const& clock, in_t const& in);