applications/32blit_demo/main.cc - pigweed/kudzu - Git at Google

 // Copyright 2023 The Pigweed Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
 // use this file except in compliance with the License. You may obtain a copy of
 // the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 // License for the specific language governing permissions and limitations under
 // the License.
 #include <chrono>
 #include <cstdint>

 #define PW_LOG_LEVEL PW_LOG_LEVEL_DEBUG

 #include "app_common/common.h"
 #include "graphics/surface.hpp"
 #include "libkudzu/framecounter.h"
 #include "libkudzu/random.h"
 #include "pw_assert/assert.h"
 #include "pw_assert/check.h"
 #include "pw_color/color.h"
 #include "pw_color/colors_endesga32.h"
 #include "pw_color/colors_pico8.h"
 #include "pw_display/display.h"
 #include "pw_framebuffer/framebuffer.h"
 #include "pw_log/log.h"
 #include "pw_string/string_builder.h"
 #include "pw_sys_io/sys_io.h"
 #include "pw_system/target_hooks.h"
 #include "pw_thread/detached_thread.h"

 using pw::color::color_rgb565_t;
 using pw::color::kColorsPico8Rgb565;
 using pw::display::Display;
 using pw::framebuffer::Framebuffer;

 namespace {

 struct test_particle {
   blit::Vec2 pos;
   blit::Vec2 vel;
   int age;
   bool generated = false;
 };

 void rain_generate(test_particle& p, blit::Surface screen) {
   p.pos = blit::Vec2(GetRandomFloat(screen.bounds.w), -10 + GetRandomFloat(10));
   p.vel = blit::Vec2(0, 150);
   p.age = 0;
   p.generated = true;
 };

 void rain(blit::Surface screen,
           pw::chrono::SystemClock::duration elapsed_time,
           blit::Rect text_position) {
   static test_particle s[300];
   static int generate_index = 0;

   // Convert to fractional elapsed seconds.
   auto const elapsed_seconds =
       std::chrono::duration_cast<std::chrono::duration<float>>(elapsed_time);

   rain_generate(s[generate_index++], screen);
   if (generate_index >= 300)
     generate_index = 0;

   blit::Vec2 gvec = blit::Vec2(0, 9.8 * 5);
   blit::Vec2 gravity = gvec * elapsed_seconds.count();

   // Add a little padding to the text box.
   text_position.y -= 2;
   text_position.h += 2;

   for (auto& p : s) {
     if (p.generated) {
       p.vel += gravity;
       p.pos += p.vel * elapsed_seconds.count();

       int floor = screen.bounds.h - 3;

       // Rain lands on top of the text.
       if (text_position.contains(p.pos)) {
         floor = text_position.y;
       }

       if (p.pos.y >= floor) {
         p.pos.y = floor;
         float bounce = (GetRandomFloat(10)) / 80.0f;
         p.vel.y *= -bounce;
         p.vel.x = (GetRandomFloat(30) - 15);
       }
       p.age++;

       int a = p.age / 2;
       int r = 100 - (a / 2);
       int g = 255 - (a * 4);
       int b = 255 - (a / 2);

       if (p.vel.length() > 20) {
         screen.pen = blit::Pen(b, g, r, 100);
         screen.pixel(p.pos + blit::Point(0, -1));
         screen.pen = blit::Pen(b, g, r, 160);
         screen.pixel(p.pos + blit::Point(0, 1));
       }
       screen.pen = blit::Pen(b, g, r, 180);
       screen.pixel(p.pos);
     }
   }
 };

 void MainTask(void*) {
   // Timing variables
   kudzu::FrameCounter frame_counter = kudzu::FrameCounter();

   PW_CHECK_OK(Common::Init());

   Display& display = Common::GetDisplay();
   Framebuffer framebuffer = display.GetFramebuffer();
   PW_ASSERT(framebuffer.is_valid());

   kudzu::Buttons& kudzu_buttons = Common::GetButtons();

   blit::Surface screen = blit::Surface(
       (uint8_t*)framebuffer.data(),
       blit::PixelFormat::RGB565,
       blit::Size(framebuffer.size().width, framebuffer.size().height));
   screen.pen = blit::Pen(0, 0, 0, 255);
   screen.clear();

   display.ReleaseFramebuffer(std::move(framebuffer));
   const int32_t init_text_pos_x = screen.bounds.w / 2;
   int32_t text_pos_x = init_text_pos_x;
   const int32_t init_text_pos_y = screen.bounds.h * 0.75;
   int32_t text_pos_y = init_text_pos_y;

   // NOTE: colors are in BGR order
   static constexpr const std::array text_colors{
       blit::Pen(0xFF, 0xFF, 0xFF),
       blit::Pen(0xB8, 0xA9, 0xF5),
       blit::Pen(0xFA, 0xCE, 0x5B),
   };
   int text_color_index = 0;

   static const std::array fonts{
       blit::minimal_font,
       blit::outline_font,
       blit::fat_font,
   };
   int font_index = 0;

   // The display loop.
   while (1) {
     kudzu_buttons.Update();
     if (kudzu_buttons.Held(kudzu::button::up)) {
       text_pos_y -= 1;
     }
     if (kudzu_buttons.Held(kudzu::button::down)) {
       text_pos_y += 1;
     }
     if (kudzu_buttons.Held(kudzu::button::left)) {
       text_pos_x -= 1;
     }
     if (kudzu_buttons.Held(kudzu::button::right)) {
       text_pos_x += 1;
     }
     if (kudzu_buttons.Pressed(kudzu::button::a)) {
       text_color_index = (text_color_index + 1) % text_colors.size();
     }
     if (kudzu_buttons.Pressed(kudzu::button::b)) {
       font_index = (font_index + 1) % fonts.size();
     }
     if (kudzu_buttons.Pressed(kudzu::button::start)) {
       text_pos_x = init_text_pos_x;
       text_pos_y = init_text_pos_y;
     }

     frame_counter.StartFrame();

     framebuffer = display.GetFramebuffer();
     PW_ASSERT(framebuffer.is_valid());
     screen.data = (uint8_t*)framebuffer.data();

     // Draw Phase
     // Clear the screen
     screen.pen = blit::Pen(0, 0, 0);
     screen.clear();

     // Draw 32blit animation
     std::string text = "Pigweed + 32blit";
     auto text_size = screen.measure_text(text, fonts[font_index], true);

     // Ensure that the text stays on-screen by wrapping its position around.
     int32_t width = screen.bounds.w;
     int32_t height = screen.bounds.h;

     int32_t min_x = 0 - (text_size.w / 2);
     int32_t max_x = width + (text_size.w / 2);
     int32_t min_y = 0 - (text_size.h / 2);
     int32_t max_y = height + (text_size.h / 2);

     if (text_pos_x < min_x) {
       text_pos_x = max_x;
     }
     if (text_pos_x > max_x) {
       text_pos_x = min_x;
     }
     if (text_pos_y < min_y) {
       text_pos_y = max_y;
     }
     if (text_pos_y > max_y) {
       text_pos_y = min_y;
     }

     blit::Rect text_rect(blit::Point(text_pos_x - (text_size.w / 2),
                                      text_pos_y - (text_size.h / 2)),
                          text_size);

     rain(screen, frame_counter.LastFrameDuration(), text_rect);
     screen.pen = text_colors[text_color_index];
     screen.text(
         text, fonts[font_index], text_rect, true, blit::TextAlign::top_left);

     // Update timers
     frame_counter.EndDraw();

     display.ReleaseFramebuffer(std::move(framebuffer));
     frame_counter.EndFlush();

     // Every second make a log message.
     frame_counter.LogTiming();
   }
 }

 }  // namespace

 namespace pw::system {

 void UserAppInit() {
   PW_LOG_INFO("UserAppInit");
   pw::thread::DetachedThread(Common::DisplayDrawThreadOptions(), MainTask);
 }

 }  // namespace pw::system
	// Copyright 2023 The Pigweed Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License"); you may not
	// use this file except in compliance with the License. You may obtain a copy of
	// the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	// License for the specific language governing permissions and limitations under
	// the License.
	#include <chrono>
	#include <cstdint>

	#define PW_LOG_LEVEL PW_LOG_LEVEL_DEBUG

	#include "app_common/common.h"
	#include "graphics/surface.hpp"
	#include "libkudzu/framecounter.h"
	#include "libkudzu/random.h"
	#include "pw_assert/assert.h"
	#include "pw_assert/check.h"
	#include "pw_color/color.h"
	#include "pw_color/colors_endesga32.h"
	#include "pw_color/colors_pico8.h"
	#include "pw_display/display.h"
	#include "pw_framebuffer/framebuffer.h"
	#include "pw_log/log.h"
	#include "pw_string/string_builder.h"
	#include "pw_sys_io/sys_io.h"
	#include "pw_system/target_hooks.h"
	#include "pw_thread/detached_thread.h"

	using pw::color::color_rgb565_t;
	using pw::color::kColorsPico8Rgb565;
	using pw::display::Display;
	using pw::framebuffer::Framebuffer;

	namespace {

	struct test_particle {
	blit::Vec2 pos;
	blit::Vec2 vel;
	int age;
	bool generated = false;
	};

	void rain_generate(test_particle& p, blit::Surface screen) {
	p.pos = blit::Vec2(GetRandomFloat(screen.bounds.w), -10 + GetRandomFloat(10));
	p.vel = blit::Vec2(0, 150);
	p.age = 0;
	p.generated = true;
	};

	void rain(blit::Surface screen,
	pw::chrono::SystemClock::duration elapsed_time,
	blit::Rect text_position) {
	static test_particle s[300];
	static int generate_index = 0;

	// Convert to fractional elapsed seconds.
	auto const elapsed_seconds =
	std::chrono::duration_cast<std::chrono::duration<float>>(elapsed_time);

	rain_generate(s[generate_index++], screen);
	if (generate_index >= 300)
	generate_index = 0;

	blit::Vec2 gvec = blit::Vec2(0, 9.8 * 5);
	blit::Vec2 gravity = gvec * elapsed_seconds.count();

	// Add a little padding to the text box.
	text_position.y -= 2;
	text_position.h += 2;

	for (auto& p : s) {
	if (p.generated) {
	p.vel += gravity;
	p.pos += p.vel * elapsed_seconds.count();

	int floor = screen.bounds.h - 3;

	// Rain lands on top of the text.
	if (text_position.contains(p.pos)) {
	floor = text_position.y;
	}

	if (p.pos.y >= floor) {
	p.pos.y = floor;
	float bounce = (GetRandomFloat(10)) / 80.0f;
	p.vel.y *= -bounce;
	p.vel.x = (GetRandomFloat(30) - 15);
	}
	p.age++;

	int a = p.age / 2;
	int r = 100 - (a / 2);
	int g = 255 - (a * 4);
	int b = 255 - (a / 2);

	if (p.vel.length() > 20) {
	screen.pen = blit::Pen(b, g, r, 100);
	screen.pixel(p.pos + blit::Point(0, -1));
	screen.pen = blit::Pen(b, g, r, 160);
	screen.pixel(p.pos + blit::Point(0, 1));
	}
	screen.pen = blit::Pen(b, g, r, 180);
	screen.pixel(p.pos);
	}
	}
	};

	void MainTask(void*) {
	// Timing variables
	kudzu::FrameCounter frame_counter = kudzu::FrameCounter();

	PW_CHECK_OK(Common::Init());

	Display& display = Common::GetDisplay();
	Framebuffer framebuffer = display.GetFramebuffer();
	PW_ASSERT(framebuffer.is_valid());

	kudzu::Buttons& kudzu_buttons = Common::GetButtons();

	blit::Surface screen = blit::Surface(
	(uint8_t*)framebuffer.data(),
	blit::PixelFormat::RGB565,
	blit::Size(framebuffer.size().width, framebuffer.size().height));
	screen.pen = blit::Pen(0, 0, 0, 255);
	screen.clear();

	display.ReleaseFramebuffer(std::move(framebuffer));
	const int32_t init_text_pos_x = screen.bounds.w / 2;
	int32_t text_pos_x = init_text_pos_x;
	const int32_t init_text_pos_y = screen.bounds.h * 0.75;
	int32_t text_pos_y = init_text_pos_y;

	// NOTE: colors are in BGR order
	static constexpr const std::array text_colors{
	blit::Pen(0xFF, 0xFF, 0xFF),
	blit::Pen(0xB8, 0xA9, 0xF5),
	blit::Pen(0xFA, 0xCE, 0x5B),
	};
	int text_color_index = 0;

	static const std::array fonts{
	blit::minimal_font,
	blit::outline_font,
	blit::fat_font,
	};
	int font_index = 0;

	// The display loop.
	while (1) {
	kudzu_buttons.Update();
	if (kudzu_buttons.Held(kudzu::button::up)) {
	text_pos_y -= 1;
	}
	if (kudzu_buttons.Held(kudzu::button::down)) {
	text_pos_y += 1;
	}
	if (kudzu_buttons.Held(kudzu::button::left)) {
	text_pos_x -= 1;
	}
	if (kudzu_buttons.Held(kudzu::button::right)) {
	text_pos_x += 1;
	}
	if (kudzu_buttons.Pressed(kudzu::button::a)) {
	text_color_index = (text_color_index + 1) % text_colors.size();
	}
	if (kudzu_buttons.Pressed(kudzu::button::b)) {
	font_index = (font_index + 1) % fonts.size();
	}
	if (kudzu_buttons.Pressed(kudzu::button::start)) {
	text_pos_x = init_text_pos_x;
	text_pos_y = init_text_pos_y;
	}

	frame_counter.StartFrame();

	framebuffer = display.GetFramebuffer();
	PW_ASSERT(framebuffer.is_valid());
	screen.data = (uint8_t*)framebuffer.data();

	// Draw Phase
	// Clear the screen
	screen.pen = blit::Pen(0, 0, 0);
	screen.clear();

	// Draw 32blit animation
	std::string text = "Pigweed + 32blit";
	auto text_size = screen.measure_text(text, fonts[font_index], true);

	// Ensure that the text stays on-screen by wrapping its position around.
	int32_t width = screen.bounds.w;
	int32_t height = screen.bounds.h;

	int32_t min_x = 0 - (text_size.w / 2);
	int32_t max_x = width + (text_size.w / 2);
	int32_t min_y = 0 - (text_size.h / 2);
	int32_t max_y = height + (text_size.h / 2);

	if (text_pos_x < min_x) {
	text_pos_x = max_x;
	}
	if (text_pos_x > max_x) {
	text_pos_x = min_x;
	}
	if (text_pos_y < min_y) {
	text_pos_y = max_y;
	}
	if (text_pos_y > max_y) {
	text_pos_y = min_y;
	}

	blit::Rect text_rect(blit::Point(text_pos_x - (text_size.w / 2),
	text_pos_y - (text_size.h / 2)),
	text_size);

	rain(screen, frame_counter.LastFrameDuration(), text_rect);
	screen.pen = text_colors[text_color_index];
	screen.text(
	text, fonts[font_index], text_rect, true, blit::TextAlign::top_left);

	// Update timers
	frame_counter.EndDraw();

	display.ReleaseFramebuffer(std::move(framebuffer));
	frame_counter.EndFlush();

	// Every second make a log message.
	frame_counter.LogTiming();
	}
	}

	} // namespace

	namespace pw::system {

	void UserAppInit() {
	PW_LOG_INFO("UserAppInit");
	pw::thread::DetachedThread(Common::DisplayDrawThreadOptions(), MainTask);
	}

	} // namespace pw::system