7797 lines
377 KiB
C++
7797 lines
377 KiB
C++
#include <SDL.h>
|
||
#include <SDL_image.h>
|
||
#include <SDL_mixer.h>
|
||
#include <SDL_ttf.h>
|
||
|
||
#ifdef __SWITCH__
|
||
#include <switch.h>
|
||
#endif
|
||
|
||
#include "sppm.hpp"
|
||
#include "export.hpp"
|
||
#include "audio_upload_server.hpp"
|
||
#include "branding_config_server.hpp"
|
||
#include "branding_bundle.hpp"
|
||
|
||
#include <algorithm>
|
||
#include <array>
|
||
#include <atomic>
|
||
#include <cerrno>
|
||
#include <cmath>
|
||
#include <cctype>
|
||
#include <cstdint>
|
||
#include <cstdio>
|
||
#include <cstdlib>
|
||
#include <cstring>
|
||
#include <ctime>
|
||
#include <dirent.h>
|
||
#include <fstream>
|
||
#include <map>
|
||
#include <limits>
|
||
#include <random>
|
||
#include <sstream>
|
||
#include <string>
|
||
#include <sys/stat.h>
|
||
#ifdef __SWITCH__
|
||
#include <arpa/inet.h>
|
||
#include <netdb.h>
|
||
#include <netinet/in.h>
|
||
#include <sys/socket.h>
|
||
#include <sys/time.h>
|
||
#include <unistd.h>
|
||
#endif
|
||
#ifdef _WIN32
|
||
#include <direct.h>
|
||
#endif
|
||
#include <unordered_map>
|
||
#include <utility>
|
||
#include <vector>
|
||
|
||
namespace {
|
||
|
||
constexpr int W = 1280;
|
||
constexpr int H = 720;
|
||
const SDL_Color ORANGE{255, 117, 30, 255};
|
||
const SDL_Color UPDATE_ORANGE{255, 100, 0, 255};
|
||
const SDL_Color CREAM{255, 211, 166, 255};
|
||
const SDL_Color GREEN{86, 166, 41, 255};
|
||
const SDL_Color PALE_GREEN{169, 235, 129, 255};
|
||
const SDL_Color INK{28, 30, 35, 255};
|
||
const SDL_Color DRAW_BLACK{28, 30, 35, 255};
|
||
const SDL_Color LIGHT{226, 230, 242, 255};
|
||
const SDL_Color WHITE{255, 255, 255, 255};
|
||
const SDL_Color GRAY{140, 145, 150, 255};
|
||
|
||
constexpr std::uint32_t kScreenFadeMs = 250;
|
||
constexpr float kCanvasChromeMs = 125.0f;
|
||
constexpr int kCanvasChromeTravel = 150;
|
||
constexpr std::array<int, 10> kInkPresetIndexes{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}};
|
||
constexpr const char* kGalleryServerHost = "reximemo.net";
|
||
constexpr const char* kGalleryServerBasePath = "/nswitch";
|
||
constexpr std::uint16_t kGalleryServerPort = 443;
|
||
constexpr const char* kInstalledAppVersion = "0.1.51";
|
||
std::atomic<std::uint64_t> galleryRequestCounter{0};
|
||
|
||
std::string jsonStringField(const std::string& json, const std::string& key) {
|
||
const std::string marker = "\"" + key + "\"";
|
||
std::size_t position = json.find(marker);
|
||
if (position == std::string::npos) return {};
|
||
position = json.find(':', position + marker.size());
|
||
if (position == std::string::npos) return {};
|
||
++position;
|
||
while (position < json.size() && std::isspace(static_cast<unsigned char>(json[position]))) ++position;
|
||
if (position >= json.size() || json[position++] != '"') return {};
|
||
std::string value;
|
||
while (position < json.size()) {
|
||
const char c = json[position++];
|
||
if (c == '"') return value;
|
||
if (c == '\\') {
|
||
if (position >= json.size()) return {};
|
||
const char escaped = json[position++];
|
||
switch (escaped) {
|
||
case '"': case '\\': case '/': value.push_back(escaped); break;
|
||
case 'n': value.push_back('\n'); break;
|
||
case 'r': value.push_back('\r'); break;
|
||
case 't': value.push_back('\t'); break;
|
||
default: return {};
|
||
}
|
||
} else value.push_back(c);
|
||
}
|
||
return {};
|
||
}
|
||
|
||
bool versionParts(const std::string& input, std::vector<unsigned long>& parts) {
|
||
std::string version = input;
|
||
if (version.rfind("Ver ", 0) == 0) version.erase(0, 4);
|
||
else if (!version.empty() && (version[0] == 'v' || version[0] == 'V')) version.erase(0, 1);
|
||
if (version.empty()) return false;
|
||
std::size_t begin = 0;
|
||
while (begin < version.size()) {
|
||
const std::size_t end = version.find('.', begin);
|
||
const std::size_t stop = end == std::string::npos ? version.size() : end;
|
||
if (stop == begin) return false;
|
||
unsigned long value = 0;
|
||
for (std::size_t i = begin; i < stop; ++i) {
|
||
if (version[i] < '0' || version[i] > '9') return false;
|
||
const unsigned digit = static_cast<unsigned>(version[i] - '0');
|
||
if (value > (std::numeric_limits<unsigned long>::max() - digit) / 10) return false;
|
||
value = value * 10 + digit;
|
||
}
|
||
parts.push_back(value);
|
||
if (end == std::string::npos) break;
|
||
begin = end + 1;
|
||
}
|
||
return !parts.empty() && version.back() != '.';
|
||
}
|
||
|
||
int compareVersions(const std::string& left, const std::string& right) {
|
||
std::vector<unsigned long> a, b;
|
||
if (!versionParts(left, a) || !versionParts(right, b)) return 0;
|
||
const std::size_t count = std::max(a.size(), b.size());
|
||
for (std::size_t i = 0; i < count; ++i) {
|
||
const unsigned long av = i < a.size() ? a[i] : 0;
|
||
const unsigned long bv = i < b.size() ? b[i] : 0;
|
||
if (av != bv) return av < bv ? -1 : 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
bool trustedUpdatePath(const std::string& url, std::string& path) {
|
||
constexpr const char* scheme = "https://";
|
||
if (url.rfind(scheme, 0) != 0) return false;
|
||
const std::size_t authorityStart = std::strlen(scheme);
|
||
const std::size_t slash = url.find('/', authorityStart);
|
||
if (slash == std::string::npos) return false;
|
||
const std::string authority = url.substr(authorityStart, slash - authorityStart);
|
||
if (authority != kGalleryServerHost && authority != std::string(kGalleryServerHost) + ":443") return false;
|
||
const std::string fullPath = url.substr(slash);
|
||
if (fullPath.rfind(std::string(kGalleryServerBasePath) + "/", 0) != 0) return false;
|
||
path = fullPath.substr(std::strlen(kGalleryServerBasePath));
|
||
return (path == "/api/download" || path.rfind("/api/download?", 0) == 0) &&
|
||
path.find('#') == std::string::npos;
|
||
}
|
||
|
||
bool validSha256Hex(const std::string& value) {
|
||
return value.size() == 64 && std::all_of(value.begin(), value.end(), [](unsigned char c) {
|
||
return std::isxdigit(c) != 0;
|
||
});
|
||
}
|
||
|
||
bool validNroFile(const std::string& path) {
|
||
std::ifstream input(path, std::ios::binary);
|
||
if (!input) return false;
|
||
input.seekg(0, std::ios::end);
|
||
const std::streamoff size = input.tellg();
|
||
if (size < 20 || size > 72LL * 1024LL * 1024LL) return false;
|
||
char magic[4]{};
|
||
input.seekg(16, std::ios::beg);
|
||
input.read(magic, sizeof(magic));
|
||
return input.gcount() == static_cast<std::streamsize>(sizeof(magic)) &&
|
||
std::memcmp(magic, "NRO0", sizeof(magic)) == 0;
|
||
}
|
||
|
||
std::string canonicalSdPath(std::string path) {
|
||
while (!path.empty() && std::isspace(static_cast<unsigned char>(path.front()))) path.erase(path.begin());
|
||
while (!path.empty() && std::isspace(static_cast<unsigned char>(path.back()))) path.pop_back();
|
||
if (path.size() >= 2 && path.front() == '"' && path.back() == '"')
|
||
path = path.substr(1, path.size() - 2);
|
||
std::replace(path.begin(), path.end(), '\\', '/');
|
||
std::transform(path.begin(), path.end(), path.begin(), [](unsigned char c) {
|
||
return static_cast<char>(std::tolower(c));
|
||
});
|
||
|
||
if (path.rfind("sdmc:", 0) == 0) {
|
||
path.erase(0, 5);
|
||
while (!path.empty() && path.front() == '/') path.erase(path.begin());
|
||
return "sdmc:/" + path;
|
||
}
|
||
while (!path.empty() && path.front() == '/') path.erase(path.begin());
|
||
if (path.rfind("switch/", 0) == 0) return "sdmc:/" + path;
|
||
return path;
|
||
}
|
||
|
||
bool sameSdPath(const std::string& left, const std::string& right) {
|
||
return canonicalSdPath(left) == canonicalSdPath(right);
|
||
}
|
||
|
||
int retryAfterSeconds(const std::string& headers) {
|
||
std::istringstream lines(headers);
|
||
std::string line;
|
||
while (std::getline(lines, line)) {
|
||
if (!line.empty() && line.back() == '\r') line.pop_back();
|
||
const std::size_t colon = line.find(':');
|
||
if (colon == std::string::npos) continue;
|
||
std::string name = line.substr(0, colon);
|
||
std::transform(name.begin(), name.end(), name.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
|
||
if (name != "retry-after") continue;
|
||
std::string value = line.substr(colon + 1);
|
||
while (!value.empty() && std::isspace(static_cast<unsigned char>(value.front()))) value.erase(value.begin());
|
||
if (value.empty()) return -1;
|
||
int seconds = 0;
|
||
for (const char c : value) {
|
||
if (c < '0' || c > '9') return -1;
|
||
if (seconds > 18000) return -1;
|
||
seconds = seconds * 10 + (c - '0');
|
||
}
|
||
return std::clamp(seconds, 0, 1800);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
enum class Screen { Title, Library, Details, Sequence, Canvas, Viewer, Settings, Gallery, GalleryDetails, GalleryProfile, GalleryComments, CommentCanvas, AppletWarning };
|
||
enum class GalleryLoadKind { Feed, Profile };
|
||
enum class UpdateTask { None, Check, Download };
|
||
enum class Tool { Pen, Brush, Eraser };
|
||
enum class Modal { None, Folder, Audio, Branding, Export, ConfirmDelete, ConfirmGalleryDelete, GalleryPostChoice, GalleryNotice, GalleryOffline, GalleryTerms, Credits, Help, TextInput, Options, PhotoProbe, PhotoChoice, PhotoAlbum, PhotoUpload, Photo, UpdateAvailable };
|
||
enum class ServerStartTask { None, Audio, Photo, Branding };
|
||
enum class Field { None, Title, Description, FolderName, CommentText, GalleryBio };
|
||
|
||
struct ScreenState {
|
||
enum class Phase { Idle, ToWhite, FromWhite };
|
||
Screen active = Screen::Title;
|
||
Screen target = Screen::Title;
|
||
Phase phase = Phase::Idle;
|
||
std::uint32_t phaseStart = 0;
|
||
|
||
operator Screen() const { return active; }
|
||
ScreenState& operator=(Screen next) {
|
||
if (phase == Phase::Idle && active == next) return *this;
|
||
if (phase != Phase::Idle && target == next) return *this;
|
||
target = next;
|
||
phase = Phase::ToWhite;
|
||
phaseStart = SDL_GetTicks();
|
||
return *this;
|
||
}
|
||
void beginTitleIntro() {
|
||
active = target = Screen::Title;
|
||
phase = Phase::FromWhite;
|
||
phaseStart = SDL_GetTicks();
|
||
}
|
||
bool transitioning() const { return phase != Phase::Idle; }
|
||
void advance(std::uint32_t now) {
|
||
if (!transitioning() || now - phaseStart < kScreenFadeMs) return;
|
||
if (phase == Phase::ToWhite) {
|
||
active = target;
|
||
phase = Phase::FromWhite;
|
||
phaseStart = now;
|
||
} else {
|
||
phase = Phase::Idle;
|
||
}
|
||
}
|
||
Uint8 whiteAlpha(std::uint32_t now) const {
|
||
if (phase == Phase::Idle) return 0;
|
||
const float progress = std::clamp((now - phaseStart) / static_cast<float>(kScreenFadeMs), 0.0f, 1.0f);
|
||
return static_cast<Uint8>(std::lround((phase == Phase::ToWhite ? progress : 1.0f - progress) * 255.0f));
|
||
}
|
||
};
|
||
|
||
struct Item {
|
||
std::string title;
|
||
std::string path;
|
||
std::string artwork;
|
||
std::string author;
|
||
bool sample = false;
|
||
std::string description;
|
||
std::string originalAuthor;
|
||
std::string authorFsid;
|
||
std::string originalAuthorFsid;
|
||
std::string currentId;
|
||
std::string rootId;
|
||
std::uint64_t createdUnixSeconds = 0;
|
||
std::uint64_t modifiedUnixSeconds = 0;
|
||
bool allowSpinoffs = true;
|
||
bool locked = false;
|
||
std::string galleryId;
|
||
std::string fsid;
|
||
std::string ownerIdentity;
|
||
int coins = 0;
|
||
int views = 0;
|
||
std::vector<std::uint8_t> previewBytes;
|
||
};
|
||
|
||
struct GalleryComment {
|
||
std::string author;
|
||
std::string text;
|
||
std::string created;
|
||
std::vector<std::uint8_t> drawing;
|
||
};
|
||
|
||
struct GalleryProfileData {
|
||
std::string identity;
|
||
std::string username;
|
||
std::string bio;
|
||
int switchnotes = 0;
|
||
int views = 0;
|
||
int coins = 0;
|
||
int followers = 0;
|
||
int following = 0;
|
||
bool followed = false;
|
||
bool blocked = false;
|
||
std::vector<std::uint8_t> avatar;
|
||
std::vector<Item> uploads;
|
||
};
|
||
|
||
struct UndoState {
|
||
std::size_t frame = 0;
|
||
int layer = 0;
|
||
std::vector<std::uint8_t> pixels;
|
||
};
|
||
|
||
struct FrameTexture {
|
||
SDL_Texture* texture = nullptr;
|
||
std::uint64_t revision = 0;
|
||
};
|
||
|
||
const std::array<int, 8> kSpeedFps{{1, 1, 2, 4, 6, 12, 20, 30}};
|
||
const std::array<int, 8> kLegacySpeedFps{{3, 5, 8, 12, 15, 18, 24, 30}};
|
||
const std::array<double, 8> kSpeedRates{{0.4985, 1.0, 2.0, 4.0, 5.9972, 11.986, 19.9459, 29.9275}};
|
||
|
||
double selectedFrameRate(int speed, int legacyFps) {
|
||
return speed >= 1 && speed <= 8 ? kSpeedRates[static_cast<std::size_t>(speed - 1)] : std::max(1, legacyFps);
|
||
}
|
||
|
||
int speedFromFps(int fps) {
|
||
int closest = 0;
|
||
for (int i = 1; i < static_cast<int>(kLegacySpeedFps.size()); ++i) {
|
||
if (std::abs(kLegacySpeedFps[i] - fps) < std::abs(kLegacySpeedFps[closest] - fps)) closest = i;
|
||
}
|
||
return closest + 1;
|
||
}
|
||
|
||
int documentSpeed(const sppm::Metadata& metadata) {
|
||
return metadata.speed >= 1 && metadata.speed <= 8 ? metadata.speed : speedFromFps(metadata.fps);
|
||
}
|
||
|
||
std::string join(const std::string& a, const std::string& b) {
|
||
return a + "/" + b;
|
||
}
|
||
|
||
std::string percentEncode(const std::string& input) {
|
||
constexpr char hex[] = "0123456789ABCDEF";
|
||
std::string out;
|
||
out.reserve(input.size() * 3);
|
||
for (unsigned char ch : input) {
|
||
if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') ||
|
||
(ch >= '0' && ch <= '9') || ch == '-' || ch == '_' || ch == '.' || ch == '~') {
|
||
out.push_back(static_cast<char>(ch));
|
||
} else {
|
||
out.push_back('%');
|
||
out.push_back(hex[ch >> 4]);
|
||
out.push_back(hex[ch & 15]);
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
int hexDigit(char ch) {
|
||
if (ch >= '0' && ch <= '9') return ch - '0';
|
||
if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
|
||
if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
|
||
return -1;
|
||
}
|
||
|
||
std::string hexEncode(const std::uint8_t* bytes, std::size_t size) {
|
||
constexpr char hex[] = "0123456789ABCDEF";
|
||
std::string encoded;
|
||
encoded.reserve(size * 2);
|
||
for (std::size_t i = 0; i < size; ++i) {
|
||
encoded.push_back(hex[bytes[i] >> 4]);
|
||
encoded.push_back(hex[bytes[i] & 15]);
|
||
}
|
||
return encoded;
|
||
}
|
||
|
||
bool hexDecode(const std::string& encoded, std::uint8_t* bytes, std::size_t size) {
|
||
if (encoded.size() != size * 2 || (size && !bytes)) return false;
|
||
for (std::size_t i = 0; i < size; ++i) {
|
||
const int high = hexDigit(encoded[i * 2]);
|
||
const int low = hexDigit(encoded[i * 2 + 1]);
|
||
if (high < 0 || low < 0) return false;
|
||
bytes[i] = static_cast<std::uint8_t>((high << 4) | low);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
std::string percentDecode(const std::string& input) {
|
||
std::string out;
|
||
out.reserve(input.size());
|
||
for (std::size_t i = 0; i < input.size(); ++i) {
|
||
if (input[i] == '%' && i + 2 < input.size()) {
|
||
const int hi = hexDigit(input[i + 1]), lo = hexDigit(input[i + 2]);
|
||
if (hi >= 0 && lo >= 0) { out.push_back(static_cast<char>((hi << 4) | lo)); i += 2; continue; }
|
||
}
|
||
if (input[i] == '+') out.push_back(' ');
|
||
else out.push_back(input[i]);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
std::vector<std::string> splitTabs(const std::string& line) {
|
||
std::vector<std::string> fields;
|
||
std::size_t start = 0;
|
||
while (true) {
|
||
const std::size_t end = line.find('\t', start);
|
||
fields.emplace_back(line.substr(start, end == std::string::npos ? std::string::npos : end - start));
|
||
if (end == std::string::npos) break;
|
||
start = end + 1;
|
||
}
|
||
return fields;
|
||
}
|
||
|
||
std::string base64Encode(const std::vector<std::uint8_t>& input) {
|
||
constexpr char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||
std::string out;
|
||
out.reserve(((input.size() + 2) / 3) * 4);
|
||
for (std::size_t i = 0; i < input.size(); i += 3) {
|
||
const std::uint32_t a = input[i];
|
||
const std::uint32_t b = i + 1 < input.size() ? input[i + 1] : 0;
|
||
const std::uint32_t c = i + 2 < input.size() ? input[i + 2] : 0;
|
||
const std::uint32_t n = (a << 16) | (b << 8) | c;
|
||
out.push_back(alphabet[(n >> 18) & 63]);
|
||
out.push_back(alphabet[(n >> 12) & 63]);
|
||
out.push_back(i + 1 < input.size() ? alphabet[(n >> 6) & 63] : '=');
|
||
out.push_back(i + 2 < input.size() ? alphabet[n & 63] : '=');
|
||
}
|
||
return out;
|
||
}
|
||
|
||
std::vector<std::uint8_t> base64Decode(const std::string& input) {
|
||
std::array<int, 256> values{};
|
||
values.fill(-1);
|
||
const std::string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||
for (int i = 0; i < static_cast<int>(alphabet.size()); ++i) values[static_cast<unsigned char>(alphabet[static_cast<std::size_t>(i)])] = i;
|
||
std::vector<std::uint8_t> out;
|
||
out.reserve((input.size() / 4) * 3);
|
||
std::uint32_t accumulator = 0;
|
||
int bits = 0;
|
||
for (unsigned char ch : input) {
|
||
if (ch == '=') break;
|
||
const int value = values[ch];
|
||
if (value < 0) continue;
|
||
accumulator = (accumulator << 6) | static_cast<std::uint32_t>(value);
|
||
bits += 6;
|
||
if (bits >= 8) {
|
||
bits -= 8;
|
||
out.push_back(static_cast<std::uint8_t>((accumulator >> bits) & 0xFF));
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
int blackInkIndex(const sppm::Palette& palette) {
|
||
int bestIndex = 2;
|
||
int bestDistance = std::numeric_limits<int>::max();
|
||
for (int i = 1; i < static_cast<int>(palette.size()); ++i) {
|
||
const auto& color = palette[static_cast<std::size_t>(i)];
|
||
if (!color.a) continue;
|
||
const int distance = static_cast<int>(color.r) * color.r +
|
||
static_cast<int>(color.g) * color.g +
|
||
static_cast<int>(color.b) * color.b;
|
||
if (distance < bestDistance) { bestDistance = distance; bestIndex = i; }
|
||
}
|
||
return bestIndex;
|
||
}
|
||
|
||
void logStartup(const std::string& message, bool reset = false) {
|
||
#ifdef __SWITCH__
|
||
const char* path = "sdmc:/switch/Switchnote/startup.log";
|
||
#else
|
||
const char* path = "data/startup.log";
|
||
#endif
|
||
std::ofstream log(path, std::ios::binary | (reset ? std::ios::trunc : std::ios::app));
|
||
if (log) log << message << '\n';
|
||
std::fprintf(stderr, "%s\n", message.c_str());
|
||
}
|
||
|
||
bool endsWith(const std::string& text, const std::string& suffix) {
|
||
return text.size() >= suffix.size() && text.compare(text.size() - suffix.size(), suffix.size(), suffix) == 0;
|
||
}
|
||
|
||
std::string utf8Prefix(const std::string& value, std::size_t maxCharacters) {
|
||
std::size_t offset = 0;
|
||
std::size_t characters = 0;
|
||
while (offset < value.size() && characters < maxCharacters) {
|
||
const auto lead = static_cast<unsigned char>(value[offset]);
|
||
const std::size_t bytes = lead < 0x80 ? 1 : (lead & 0xe0) == 0xc0 ? 2 : (lead & 0xf0) == 0xe0 ? 3 : (lead & 0xf8) == 0xf0 ? 4 : 1;
|
||
offset += std::min(bytes, value.size() - offset);
|
||
++characters;
|
||
}
|
||
return value.substr(0, offset);
|
||
}
|
||
|
||
void ensureDir(const std::string& path) {
|
||
std::string current;
|
||
current.reserve(path.size());
|
||
auto make = [](const std::string& directory) {
|
||
#ifdef _WIN32
|
||
_mkdir(directory.c_str());
|
||
#else
|
||
mkdir(directory.c_str(), 0777);
|
||
#endif
|
||
};
|
||
for (char ch : path) {
|
||
current.push_back(ch);
|
||
if (ch == '/' || ch == '\\') make(current);
|
||
}
|
||
make(current);
|
||
}
|
||
|
||
bool copyMissingTree(const std::string& source, const std::string& destination, bool renameLegacyNotes = false) {
|
||
struct stat sourceInfo{};
|
||
if (stat(source.c_str(), &sourceInfo) != 0) return true;
|
||
if (S_ISDIR(sourceInfo.st_mode)) {
|
||
ensureDir(destination);
|
||
DIR* directory = opendir(source.c_str());
|
||
if (!directory) return false;
|
||
bool ok = true;
|
||
while (dirent* entry = readdir(directory)) {
|
||
const std::string name = entry->d_name;
|
||
if (name == "." || name == "..") continue;
|
||
const std::string mappedName = renameLegacyNotes && name == "Flipnotes" ? "Switchnotes" : name;
|
||
if (!copyMissingTree(join(source, name), join(destination, mappedName), false)) ok = false;
|
||
}
|
||
closedir(directory);
|
||
return ok;
|
||
}
|
||
if (!S_ISREG(sourceInfo.st_mode)) return true;
|
||
struct stat destinationInfo{};
|
||
if (stat(destination.c_str(), &destinationInfo) == 0) return true;
|
||
std::ifstream input(source, std::ios::binary);
|
||
if (!input) return false;
|
||
const std::size_t separator = destination.find_last_of("/\\");
|
||
if (separator != std::string::npos) ensureDir(destination.substr(0, separator));
|
||
const std::string temporary = destination + ".migrating";
|
||
std::remove(temporary.c_str());
|
||
std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
|
||
if (!output) return false;
|
||
std::array<char, 16384> buffer{};
|
||
while (input) {
|
||
input.read(buffer.data(), static_cast<std::streamsize>(buffer.size()));
|
||
const std::streamsize count = input.gcount();
|
||
if (count > 0) output.write(buffer.data(), count);
|
||
}
|
||
output.flush();
|
||
output.close();
|
||
if (!input.eof() || !output) { std::remove(temporary.c_str()); return false; }
|
||
if (std::rename(temporary.c_str(), destination.c_str()) != 0) {
|
||
std::remove(temporary.c_str());
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool migrateLegacyStorage(const std::string& destination) {
|
||
#ifdef __SWITCH__
|
||
const std::string marker = join(destination, "storage-migrated-v1");
|
||
struct stat markerInfo{};
|
||
if (stat(marker.c_str(), &markerInfo) == 0) return true;
|
||
const std::string legacy = "sdmc:/switch/FlipnoteNX";
|
||
struct stat legacyInfo{};
|
||
if (stat(legacy.c_str(), &legacyInfo) != 0) return true;
|
||
DIR* directory = opendir(legacy.c_str());
|
||
if (!directory) return false;
|
||
bool ok = true;
|
||
while (dirent* entry = readdir(directory)) {
|
||
const std::string name = entry->d_name;
|
||
if (name == "." || name == "..") continue;
|
||
if (endsWith(name, ".nro")) continue;
|
||
const bool notes = name == "flipnotes";
|
||
if (!copyMissingTree(join(legacy, name), join(destination, notes ? "switchnotes" : name), notes)) ok = false;
|
||
}
|
||
closedir(directory);
|
||
if (!ok) return false;
|
||
std::ofstream complete(marker, std::ios::binary | std::ios::trunc);
|
||
if (!complete) return false;
|
||
complete << "1\n";
|
||
complete.flush();
|
||
return static_cast<bool>(complete);
|
||
#else
|
||
(void)destination;
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
std::uint64_t nowSeconds() { return static_cast<std::uint64_t>(std::time(nullptr)); }
|
||
|
||
std::string dateText(std::uint64_t seconds) {
|
||
if (!seconds) return "Unknown";
|
||
std::time_t value = static_cast<std::time_t>(seconds);
|
||
std::tm* tm = std::localtime(&value);
|
||
if (!tm) return "Unknown";
|
||
char buffer[64]{};
|
||
std::strftime(buffer, sizeof(buffer), "%B %d %Y %H:%M:%S", tm);
|
||
return buffer;
|
||
}
|
||
|
||
std::string defaultSwitchnoteTitle(const std::string& nickname, const std::string& noteName) {
|
||
return noteName + " by " + (nickname.empty() ? noteName + " User" : nickname);
|
||
}
|
||
|
||
bool randomBytes(void* out, std::size_t size) {
|
||
#ifdef __SWITCH__
|
||
return R_SUCCEEDED(csrngGetRandomBytes(out, size));
|
||
#else
|
||
try {
|
||
std::random_device rd;
|
||
auto* bytes = static_cast<std::uint8_t*>(out);
|
||
for (std::size_t i = 0; i < size; ++i) bytes[i] = static_cast<std::uint8_t>(rd());
|
||
return true;
|
||
} catch (...) {
|
||
return false;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void appendIdentityMaterial(std::vector<std::uint8_t>& out, std::uint8_t field,
|
||
const std::uint8_t* bytes, std::size_t length) {
|
||
out.push_back(field);
|
||
out.push_back(static_cast<std::uint8_t>(length));
|
||
out.insert(out.end(), bytes, bytes + length);
|
||
}
|
||
|
||
bool getDeviceMaterial(std::vector<std::uint8_t>& material) {
|
||
constexpr char domain[] = "FlipnoteStudio-console-binding-v2";
|
||
material.assign(domain, domain + sizeof(domain));
|
||
#ifdef __SWITCH__
|
||
bool found = false;
|
||
Uuid pseudoId{};
|
||
if (R_SUCCEEDED(appletGetPseudoDeviceId(&pseudoId))) {
|
||
appendIdentityMaterial(material, 1, pseudoId.uuid, sizeof(pseudoId.uuid));
|
||
found = true;
|
||
}
|
||
if (R_SUCCEEDED(setcalInitialize())) {
|
||
SetCalMacAddress mac{};
|
||
if (R_SUCCEEDED(setcalGetWirelessLanMacAddress(&mac))) {
|
||
appendIdentityMaterial(material, 2, mac.addr, sizeof(mac.addr));
|
||
found = true;
|
||
}
|
||
u64 calibratedDeviceId = 0;
|
||
if (R_SUCCEEDED(setcalGetDeviceId(&calibratedDeviceId)) && calibratedDeviceId != 0) {
|
||
const auto* bytes = reinterpret_cast<const std::uint8_t*>(&calibratedDeviceId);
|
||
appendIdentityMaterial(material, 3, bytes, sizeof(calibratedDeviceId));
|
||
found = true;
|
||
}
|
||
setcalExit();
|
||
}
|
||
if (R_SUCCEEDED(splInitialize())) {
|
||
u64 securityDeviceId = 0;
|
||
if (R_SUCCEEDED(splGetConfig(SplConfigItem_DeviceId, &securityDeviceId)) && securityDeviceId != 0) {
|
||
const auto* bytes = reinterpret_cast<const std::uint8_t*>(&securityDeviceId);
|
||
appendIdentityMaterial(material, 5, bytes, sizeof(securityDeviceId));
|
||
found = true;
|
||
}
|
||
splExit();
|
||
}
|
||
if (!found) {
|
||
material.clear();
|
||
return false;
|
||
}
|
||
return true;
|
||
#else
|
||
const char* machine = std::getenv("COMPUTERNAME");
|
||
if (!machine || !*machine) machine = std::getenv("HOSTNAME");
|
||
if (machine && *machine) {
|
||
appendIdentityMaterial(material, 4, reinterpret_cast<const std::uint8_t*>(machine), std::strlen(machine));
|
||
} else {
|
||
const std::string fallback = "local-development-profile";
|
||
appendIdentityMaterial(material, 4, reinterpret_cast<const std::uint8_t*>(fallback.data()), fallback.size());
|
||
}
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
bool readBinaryFile(const std::string& path, std::vector<std::uint8_t>& bytes) {
|
||
std::ifstream input(path, std::ios::binary | std::ios::ate);
|
||
if (!input) return false;
|
||
const std::streamoff size = input.tellg();
|
||
if (size < 0 || size > 4096) return false;
|
||
bytes.resize(static_cast<std::size_t>(size));
|
||
input.seekg(0, std::ios::beg);
|
||
if (!bytes.empty()) input.read(reinterpret_cast<char*>(bytes.data()), size);
|
||
return input.good() || (input.eof() && input.gcount() == size);
|
||
}
|
||
|
||
bool loadEncryptedIdentity(const std::string& path,
|
||
const std::vector<std::uint8_t>& deviceMaterial,
|
||
sppm::SigningIdentity& identity) {
|
||
constexpr std::size_t fileBytes = 4 + 16 + 24 + 32 + 16 + 128;
|
||
std::vector<std::uint8_t> bytes;
|
||
if (!readBinaryFile(path, bytes) || bytes.size() != fileBytes ||
|
||
std::memcmp(bytes.data(), "FNI2", 4) != 0) return false;
|
||
std::size_t at = 4;
|
||
std::array<std::uint8_t, 16> salt{};
|
||
std::array<std::uint8_t, 24> nonce{};
|
||
std::array<std::uint8_t, 128> sealed{};
|
||
std::copy_n(bytes.begin() + static_cast<std::ptrdiff_t>(at), salt.size(), salt.begin()); at += salt.size();
|
||
std::copy_n(bytes.begin() + static_cast<std::ptrdiff_t>(at), nonce.size(), nonce.begin()); at += nonce.size();
|
||
std::copy_n(bytes.begin() + static_cast<std::ptrdiff_t>(at), identity.publicIdentity.key.size(), identity.publicIdentity.key.begin()); at += identity.publicIdentity.key.size();
|
||
std::copy_n(bytes.begin() + static_cast<std::ptrdiff_t>(at), identity.publicIdentity.deviceTag.size(), identity.publicIdentity.deviceTag.begin()); at += identity.publicIdentity.deviceTag.size();
|
||
std::copy_n(bytes.begin() + static_cast<std::ptrdiff_t>(at), sealed.size(), sealed.begin());
|
||
std::vector<std::uint8_t> tagMaterial = deviceMaterial;
|
||
tagMaterial.insert(tagMaterial.end(), salt.begin(), salt.end());
|
||
if (sppm::deriveDeviceTag(tagMaterial) != identity.publicIdentity.deviceTag) return false;
|
||
const auto wrapKey = sppm::deriveDeviceWrapKey(deviceMaterial, salt);
|
||
std::string error;
|
||
if (!sppm::unsealSigningSecret(sealed, wrapKey, nonce, identity, error) ||
|
||
!std::equal(identity.publicIdentity.key.begin(), identity.publicIdentity.key.end(), identity.secretKey.begin() + 32)) return false;
|
||
return sppm::hasPublicIdentity(identity.publicIdentity);
|
||
}
|
||
|
||
bool createEncryptedIdentity(const std::string& dataRoot,
|
||
const std::vector<std::uint8_t>& deviceMaterial,
|
||
const std::array<std::uint8_t, 32>& legacyKey,
|
||
sppm::SigningIdentity& identity,
|
||
std::string& pathOut) {
|
||
std::array<std::uint8_t, 16> salt{};
|
||
std::array<std::uint8_t, 24> nonce{};
|
||
if (!randomBytes(salt.data(), salt.size()) || !randomBytes(nonce.data(), nonce.size())) return false;
|
||
std::vector<std::uint8_t> tagMaterial = deviceMaterial;
|
||
tagMaterial.insert(tagMaterial.end(), salt.begin(), salt.end());
|
||
std::string error;
|
||
if (!sppm::createSigningIdentity(sppm::deriveDeviceTag(tagMaterial), identity, error)) return false;
|
||
identity.legacyHmacKey = legacyKey;
|
||
const auto wrapKey = sppm::deriveDeviceWrapKey(deviceMaterial, salt);
|
||
std::array<std::uint8_t, 128> sealed{};
|
||
if (!sppm::sealSigningSecret(identity, wrapKey, nonce, sealed, error)) return false;
|
||
constexpr char hex[] = "0123456789ABCDEF";
|
||
std::string saltName;
|
||
saltName.reserve(32);
|
||
for (std::uint8_t byte : salt) { saltName.push_back(hex[byte >> 4]); saltName.push_back(hex[byte & 15]); }
|
||
pathOut = join(dataRoot, "identity-v2-" + saltName + ".bin");
|
||
std::vector<std::uint8_t> bytes{'F', 'N', 'I', '2'};
|
||
bytes.insert(bytes.end(), salt.begin(), salt.end());
|
||
bytes.insert(bytes.end(), nonce.begin(), nonce.end());
|
||
bytes.insert(bytes.end(), identity.publicIdentity.key.begin(), identity.publicIdentity.key.end());
|
||
bytes.insert(bytes.end(), identity.publicIdentity.deviceTag.begin(), identity.publicIdentity.deviceTag.end());
|
||
bytes.insert(bytes.end(), sealed.begin(), sealed.end());
|
||
std::ofstream output(pathOut, std::ios::binary | std::ios::out);
|
||
if (!output) return false;
|
||
output.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
|
||
return static_cast<bool>(output);
|
||
}
|
||
|
||
struct App {
|
||
SDL_Window* window = nullptr;
|
||
SDL_Renderer* renderer = nullptr;
|
||
SDL_GameController* controller = nullptr;
|
||
bool romfsReady = false;
|
||
bool csrngReady = false;
|
||
bool accountReady = false;
|
||
bool gallerySocketsReady = false;
|
||
bool gallerySslReady = false;
|
||
bool nifmReady = false;
|
||
bool sdlReady = false;
|
||
bool imageReady = false;
|
||
bool ttfReady = false;
|
||
bool audioReady = false;
|
||
bool appletMode = false;
|
||
#ifdef __SWITCH__
|
||
bool irsReady = false;
|
||
bool irCameraRunning = false;
|
||
IrsIrCameraHandle irCamera{};
|
||
Thread photoProbeThread{};
|
||
bool photoProbeThreadCreated = false;
|
||
bool photoProbeRunning = false;
|
||
std::atomic<bool> photoProbeFinished{false};
|
||
IrsImageTransferProcessorState irImageState{};
|
||
std::vector<std::uint8_t> irImage = std::vector<std::uint8_t>(320 * 240, 0);
|
||
std::vector<std::uint8_t> irPhoto = std::vector<std::uint8_t>(320 * 240, 0);
|
||
std::vector<std::uint8_t> irPreviewRgba = std::vector<std::uint8_t>(320 * 240 * 4, 255);
|
||
SDL_Texture* irPreviewTexture = nullptr;
|
||
bool irImageReady = false;
|
||
bool irPhotoTaken = false;
|
||
bool irRotatePhoto = false;
|
||
#endif
|
||
AudioUploadServer audioUploadServer;
|
||
BrandingConfigServer brandingConfigServer;
|
||
std::string audioUploadUrl;
|
||
std::string audioUploadCode;
|
||
std::string audioUploadStatus;
|
||
bool photoTransferActive = false;
|
||
bool photoImporting = false;
|
||
bool photoProbeHasCamera = false;
|
||
std::vector<std::uint8_t> photoImportRgba;
|
||
int photoImportRow = 0;
|
||
int photoImportLayer = 0;
|
||
int photoAlbumPage = 0;
|
||
bool galleryTermsAccepted = false;
|
||
#ifdef __SWITCH__
|
||
std::vector<CapsAlbumEntry> photoAlbumEntries;
|
||
std::array<SDL_Texture*, 6> photoAlbumThumbs{};
|
||
std::array<std::size_t, 6> photoAlbumThumbIndexes{};
|
||
#endif
|
||
std::string brandingUrl;
|
||
std::string brandingCode;
|
||
std::string brandingStatus;
|
||
std::string appDisplayName = "Switchnote Studio";
|
||
std::string noteSingular = "Switchnote";
|
||
std::string notePlural = "Switchnotes";
|
||
std::string brandingLogoPath;
|
||
SDL_Texture* brandingLogoTexture = nullptr;
|
||
bool renderingModal = false;
|
||
int loadingDepth = 0;
|
||
std::uint32_t loadingStartedAt = 0;
|
||
std::uint32_t loadingFinishedAt = 0;
|
||
std::uint32_t completedLoadingDuration = 0;
|
||
bool loadingCompletionVisible = false;
|
||
SDL_Thread* updateThread = nullptr;
|
||
std::atomic<bool> updateWorkerDone{false};
|
||
bool updateInProgress = false;
|
||
bool updateManualCheck = false;
|
||
bool updateOfferPending = false;
|
||
bool updateAvailable = false;
|
||
bool updateNoChange = false;
|
||
std::uint32_t updateStartedAt = 0;
|
||
UpdateTask updateTask = UpdateTask::None;
|
||
std::string updateServerVersion;
|
||
std::string updateDownloadUrl;
|
||
std::string updateSha256;
|
||
std::string updateError;
|
||
std::string updateDownloadedPath;
|
||
int updateHttpStatus = 0;
|
||
std::string launchNroPath;
|
||
std::string updateInstallSourcePath;
|
||
bool updateInstallPending = false;
|
||
std::uint32_t updateInstallReadyAt = 0;
|
||
bool photoModalTransitionDim = false;
|
||
std::uint32_t photoModalTransitionDimAt = 0;
|
||
std::array<SDL_Texture*, 8> loadingFrogFrames{};
|
||
bool running = true;
|
||
std::string assetsRoot;
|
||
std::string dataRoot;
|
||
std::string notesRoot;
|
||
std::string exportRoot;
|
||
std::string importRoot;
|
||
std::string folder = "Switchnotes";
|
||
std::string userName = "Switchnote User";
|
||
std::string myFsid;
|
||
std::vector<std::uint8_t> profileImageBytes;
|
||
SDL_Texture* profileTexture = nullptr;
|
||
SDL_Texture* profileCornerTexture = nullptr;
|
||
SDL_Texture* profileDetailTexture = nullptr;
|
||
sppm::SigningIdentity signingIdentity{};
|
||
std::map<std::string, SDL_Texture*> images;
|
||
std::map<std::string, SDL_Texture*> whiteImages;
|
||
std::map<std::pair<int, bool>, TTF_Font*> fonts;
|
||
std::unordered_map<std::string, SDL_Texture*> textCache;
|
||
std::unordered_map<std::uint64_t, float> hoverMotion;
|
||
std::map<std::string, Mix_Chunk*> cues;
|
||
std::array<Mix_Chunk*, 4> trackChunks{};
|
||
Mix_Chunk* bgmSeekChunk = nullptr;
|
||
std::array<std::vector<Uint8>, 4> trackAudioBuffers{};
|
||
std::map<std::size_t, FrameTexture> frameTextures;
|
||
std::uint64_t docRevision = 1;
|
||
ScreenState screen;
|
||
Modal modal = Modal::None;
|
||
Field editingField = Field::None;
|
||
std::string inputText;
|
||
std::string toast;
|
||
std::uint32_t toastUntil = 0;
|
||
std::vector<Item> library;
|
||
std::vector<Item> gallery;
|
||
std::vector<GalleryComment> galleryComments;
|
||
GalleryProfileData galleryProfile;
|
||
SDL_Texture* galleryProfileAvatarTexture = nullptr;
|
||
bool galleryProfileIsOwn = false;
|
||
Screen galleryProfileReturnScreen = Screen::Gallery;
|
||
int galleryProfilePage = 0;
|
||
bool galleryProfileActive = false;
|
||
bool galleryProfileDetailMode = false;
|
||
std::vector<Item> galleryBeforeProfile;
|
||
std::size_t gallerySelectedBeforeProfile = 0;
|
||
int galleryPageBeforeProfile = 0;
|
||
int galleryTotalBeforeProfile = 0;
|
||
std::size_t selected = 0;
|
||
std::size_t gallerySelected = 0;
|
||
int page = 0;
|
||
int galleryPage = 0;
|
||
int galleryTotal = 0;
|
||
bool galleryPopular = false;
|
||
bool galleryCommentsLoaded = false;
|
||
int galleryCommentScroll = 0;
|
||
bool galleryCommentTouchScroll = false;
|
||
int galleryCommentTouchStartY = 0;
|
||
int galleryCommentTouchStartOffset = 0;
|
||
std::uint32_t lastGalleryCommentScrollTick = 0;
|
||
std::string galleryStatus;
|
||
std::size_t pendingGalleryPublishIndex = 0;
|
||
bool galleryLoadRunning = false;
|
||
std::atomic<bool> galleryLoadFinished{false};
|
||
std::string galleryLoadPath;
|
||
GalleryLoadKind galleryLoadKind = GalleryLoadKind::Feed;
|
||
std::vector<std::uint8_t> galleryLoadResponse;
|
||
int galleryLoadHttpStatus = 0;
|
||
bool galleryLoadSucceeded = false;
|
||
std::string galleryLoadError;
|
||
bool serverStartRunning = false;
|
||
std::atomic<bool> serverStartFinished{false};
|
||
bool serverStartSucceeded = false;
|
||
ServerStartTask serverStartTask = ServerStartTask::None;
|
||
#ifdef __SWITCH__
|
||
Thread galleryLoadThread{};
|
||
bool galleryLoadThreadCreated = false;
|
||
Thread serverStartThread{};
|
||
bool serverStartThreadCreated = false;
|
||
#endif
|
||
std::string commentDraft;
|
||
std::unordered_map<std::string, SDL_Texture*> galleryCommentTextures;
|
||
sppm::Document doc;
|
||
bool docLoaded = false;
|
||
bool galleryViewing = false;
|
||
bool dirty = false;
|
||
std::uint32_t dirtyTick = 0;
|
||
std::string docPath;
|
||
std::size_t frame = 0;
|
||
int layer = 0;
|
||
int color = 2;
|
||
int defaultFps = 12;
|
||
int defaultSpeed = 6;
|
||
int modalSelection = 0;
|
||
Screen settingsReturnScreen = Screen::Library;
|
||
Modal lastRenderedModal = Modal::None;
|
||
Modal modalVisual = Modal::None;
|
||
bool modalClosing = false;
|
||
std::uint32_t modalTransitionStart = 0;
|
||
std::uint32_t lastScreenCueStart = 0;
|
||
int brush = 4;
|
||
int pattern = 0;
|
||
int eraserSlot = 1;
|
||
int penType = 0;
|
||
std::uint16_t penRngState = 0x1F01;
|
||
int squiggleAnchorX = -1;
|
||
int squiggleAnchorY = -1;
|
||
int ringPreviousX = -1;
|
||
int ringPreviousY = -1;
|
||
bool square = false;
|
||
bool advancedBrush = false;
|
||
Tool activeTool = Tool::Pen;
|
||
bool canvasYChordUsed = false;
|
||
bool penStabilisationEnabled = false;
|
||
bool penStabilisationAfter = false;
|
||
int penStabilisationStrength = 50;
|
||
bool stabilisedAfterReplay = false;
|
||
bool realtimeStrokeInitialized = false;
|
||
float realtimeStrokeX = 0.0f;
|
||
float realtimeStrokeY = 0.0f;
|
||
std::vector<std::pair<int, int>> afterStrokePoints;
|
||
bool onion = true;
|
||
bool canvasGrid = false;
|
||
bool copyToNewPage = false;
|
||
bool expandMetadata = false;
|
||
bool paintMenu = false;
|
||
bool colorMenu = false;
|
||
bool toolMenu = false;
|
||
bool canvasMenuOpen = false;
|
||
float canvasMenuProgress = 0.0f;
|
||
std::uint32_t lastCanvasMenuTick = 0;
|
||
bool playing = false;
|
||
float zoom = 1.0f;
|
||
int panX = 0;
|
||
int panY = 0;
|
||
std::uint32_t lastPlaybackTick = 0;
|
||
double playbackTickRemainder = 0.0;
|
||
sppm::Frame frameClipboard;
|
||
bool clipboardReady = false;
|
||
std::vector<UndoState> undoStack;
|
||
std::vector<UndoState> redoStack;
|
||
int audioTrack = 0;
|
||
int audioEraseArmedTrack = -1;
|
||
std::vector<std::string> importFiles;
|
||
std::size_t importSelection = 0;
|
||
std::vector<std::uint8_t> commentPixels = std::vector<std::uint8_t>(sppm::kPixelsPerLayer, 0);
|
||
bool commentDirty = true;
|
||
SDL_Texture* commentTexture = nullptr;
|
||
|
||
int pointerX = 0;
|
||
int pointerY = 0;
|
||
bool pointerDown = false;
|
||
bool pointerPressed = false;
|
||
bool pointerReleased = false;
|
||
bool clickConsumed = false;
|
||
bool touchHoverExpiryPending = false;
|
||
// A canvas press that began on visible chrome remains a chrome gesture for
|
||
// its entire lifetime. Once a drawing gesture starts, the chrome can move
|
||
// away without creating invisible "no draw" rectangles underneath it.
|
||
bool canvasControlGesture = false;
|
||
bool drawing = false;
|
||
bool hasLastStroke = false;
|
||
int lastStrokeX = 0;
|
||
int lastStrokeY = 0;
|
||
bool canvasTapPending = false;
|
||
bool canvasFillCommitted = false;
|
||
int canvasPressScreenX = 0;
|
||
int canvasPressScreenY = 0;
|
||
int canvasPressPixelX = 0;
|
||
int canvasPressPixelY = 0;
|
||
std::uint32_t canvasPressStartedAt = 0;
|
||
bool fillWaveActive = false;
|
||
int fillWaveOriginX = 0;
|
||
int fillWaveOriginY = 0;
|
||
float fillWaveRadius = 0.0f;
|
||
std::uint32_t fillWaveTick = 0;
|
||
std::size_t fillWaveFrame = 0;
|
||
int fillWaveLayer = -1;
|
||
std::uint8_t fillWaveColor = 0;
|
||
std::vector<std::pair<std::uint32_t, std::uint16_t>> fillWavePixels;
|
||
std::size_t fillWaveCursor = 0;
|
||
int wheel = 0;
|
||
std::uint32_t buttonsDown = 0;
|
||
std::uint32_t buttonsUp = 0;
|
||
std::uint32_t buttonsHeld = 0;
|
||
std::uint32_t rightDpadNextRepeatAt = 0;
|
||
bool rightDpadRepeating = false;
|
||
float pulse = 0;
|
||
float canvasChromeVisible = 1.0f;
|
||
std::uint32_t lastChromeTick = 0;
|
||
float leftStickX = 0.0f;
|
||
float leftStickY = 0.0f;
|
||
std::uint32_t lastPanTick = 0;
|
||
|
||
bool init(int argc, char** argv);
|
||
void shutdown();
|
||
void run();
|
||
void poll();
|
||
void handleKeys();
|
||
void update();
|
||
void startUpdateCheck(bool manual);
|
||
void startUpdateDownload();
|
||
bool requestUpdateHandoff();
|
||
void completeUpdateInstall();
|
||
void runUpdateTask();
|
||
void consumeUpdateTask();
|
||
static int updateThreadEntry(void* context);
|
||
void render();
|
||
void renderTitle();
|
||
void renderAppletWarning();
|
||
void renderLibrary();
|
||
void renderSettings();
|
||
void renderDetails(bool galleryMode);
|
||
void renderSequence();
|
||
void renderCanvas();
|
||
void renderViewer();
|
||
void renderGallery();
|
||
void renderGalleryProfile();
|
||
void renderComments();
|
||
void renderCommentCanvas();
|
||
void renderModal();
|
||
void drawPlayTriangle(int x, int y, int size, SDL_Color color = ORANGE);
|
||
void drawLockIcon(int x, int y);
|
||
void renderToast();
|
||
void renderLoadingOverlay();
|
||
void beginLoading();
|
||
void endLoading();
|
||
void beginFillWave(int x, int y);
|
||
void updateFillWave(std::uint32_t now);
|
||
void background();
|
||
SDL_Texture* image(const std::string& relative);
|
||
SDL_Texture* whiteImage(const std::string& relative);
|
||
SDL_Texture* loadBrandingLogo(const std::string& path);
|
||
void drawImage(const std::string& relative, int x, int y, int w, int h, bool nearest = false);
|
||
void drawTexture(SDL_Texture* texture, int x, int y, int w, int h);
|
||
TTF_Font* font(int px, bool bold);
|
||
std::string brandString(const std::string& label) const;
|
||
void rawText(const std::string& label, int x, int y, int px, SDL_Color color, bool bold);
|
||
void text(const std::string& label, int x, int y, int px, SDL_Color color, bool bold = false);
|
||
void centered(const std::string& label, int x, int y, int w, int h, int px, SDL_Color color, bool bold = false);
|
||
void fill(int x, int y, int w, int h, SDL_Color c);
|
||
void rounded(int x, int y, int w, int h, int radius, SDL_Color c);
|
||
void roundedOutline(int x, int y, int w, int h, int radius, int thickness, SDL_Color c);
|
||
bool hit(int x, int y, int w, int h);
|
||
int hoverLift(int x, int y, bool hovered);
|
||
bool pill(const std::string& label, int x, int y, int w, int h, bool green = false, int px = 22, bool enabled = true, const std::string& cue = "button_on");
|
||
bool actionPill(const std::string& icon, const std::string& label, int x, int y, int w, int h, bool green = false, bool enabled = true, const std::string& cue = "button_on");
|
||
bool dangerPill(const std::string& label, int x, int y, int w, int h, int px = 18, bool enabled = true);
|
||
bool dangerActionPill(const std::string& icon, const std::string& label, int x, int y, int w, int h, int px = 19, bool enabled = true);
|
||
bool imagePill(const std::string& icon, int x, int y, int w, int h, bool green = false, bool enabled = true, const std::string& cue = "button_on");
|
||
bool imageButton(const std::string& path, int x, int y, int w, int h, const std::string& cue = "button_on");
|
||
void showToast(const std::string& message);
|
||
void playCue(const std::string& name);
|
||
void playEvent(const std::string& event, const std::string& defaultCue);
|
||
void loadPreferences();
|
||
void savePreferences();
|
||
|
||
bool loadIdentity();
|
||
std::string newId(const char* domain);
|
||
void scanLibrary();
|
||
void scanImports();
|
||
void enterGallery();
|
||
void showGalleryNotice();
|
||
void confirmGalleryLeave();
|
||
void refreshGallery();
|
||
void loadGalleryProfile(const std::string& identity, Screen returnScreen, int pageIndex = 0);
|
||
void leaveGalleryProfile();
|
||
void finishGalleryRefresh(const std::vector<std::uint8_t>& response, int status, const std::string& error);
|
||
void finishGalleryProfile(const std::vector<std::uint8_t>& response, int status, const std::string& error);
|
||
void saveGalleryProfile(bool quiet = false);
|
||
void updateGalleryRelationship(const char* action);
|
||
void consumeGalleryLoad();
|
||
bool internetConnected();
|
||
#ifdef __SWITCH__
|
||
static void galleryLoadThreadEntry(void* argument);
|
||
void runGalleryLoadThread();
|
||
#endif
|
||
void refreshGalleryComments();
|
||
void openGalleryComments();
|
||
void openItem(std::size_t index, bool edit);
|
||
void openGalleryItem(std::size_t index);
|
||
void saveGalleryItem(std::size_t index);
|
||
void publishGalleryItem(std::size_t index);
|
||
void performGalleryUpload(std::size_t index, bool locked);
|
||
void addGalleryCoin();
|
||
void deleteGalleryItem();
|
||
void postGalleryComment();
|
||
SDL_Texture* galleryPreviewTexture(const Item& item);
|
||
SDL_Texture* galleryCommentTexture(const GalleryComment& comment, std::size_t index);
|
||
bool galleryRequest(const std::string& method, const std::string& path,
|
||
const std::vector<std::uint8_t>& requestBody,
|
||
const std::string& contentType,
|
||
std::vector<std::uint8_t>& responseBody, int& status,
|
||
std::string& error, std::string* responseHeaders = nullptr);
|
||
bool loadSample(const Item& item, sppm::Document& out);
|
||
bool startAudioUploadServer(bool photoTransfer = false);
|
||
void requestAudioUploadServer(bool photoTransfer = false);
|
||
void stopAudioUploadServer();
|
||
void closeAudioMenu();
|
||
void consumeAudioUpload();
|
||
bool startBrandingConfigServer();
|
||
void requestServerStart(ServerStartTask task);
|
||
void requestBrandingConfigServer();
|
||
void consumeServerStart();
|
||
void consumePhotoProbe();
|
||
#ifdef __SWITCH__
|
||
static void serverStartThreadEntry(void* argument);
|
||
void runServerStartThread();
|
||
static void photoProbeThreadEntry(void* argument);
|
||
void runPhotoProbeThread();
|
||
#endif
|
||
void stopBrandingConfigServer();
|
||
void closeBrandingMenu();
|
||
void consumeBrandingConfig();
|
||
void importBrandingConfig();
|
||
void exportBrandingConfig();
|
||
void newDocument();
|
||
bool saveDocument(bool force = false);
|
||
void closeDocument();
|
||
void deleteDocument();
|
||
void forkDocument();
|
||
void markDirty();
|
||
void invalidateFrames();
|
||
SDL_Texture* frameTexture(std::size_t index);
|
||
SDL_Texture* thumbTexture(const Item& item);
|
||
void drawCurrentFrame(int x, int y, int w, int h, bool withOnion = false);
|
||
void drawFrameImage(std::size_t index, int x, int y, int w, int h);
|
||
void drawDocumentControls(bool galleryColor = false);
|
||
void playControl(int x, int y, int w, int h);
|
||
void setFrame(std::size_t index, bool playNavigationCue = true, const char* event = nullptr);
|
||
void startPlayback();
|
||
void stopPlayback(bool playStopCue = true);
|
||
void updatePlayback(std::uint32_t now);
|
||
void playFrameSound();
|
||
void startBgmAtCurrentFrame();
|
||
void rebuildAudio();
|
||
void insertFrame(bool paste);
|
||
void eraseFrame();
|
||
void copyFrame();
|
||
void undo();
|
||
void redo();
|
||
void pushUndo();
|
||
bool paintPixel(int sx, int sy, std::vector<std::uint8_t>& pixels);
|
||
void strokeAt(int sx, int sy, bool comment = false);
|
||
void finishAfterStroke();
|
||
void beginText(Field field, const std::string& current);
|
||
void applyText();
|
||
void importAudio();
|
||
bool importAudioFile(const std::string& path, int track, const std::string& displayName);
|
||
void exportDocument(int destination);
|
||
void openPhotoCapture();
|
||
void closePhotoCapture();
|
||
void updatePhotoCapture();
|
||
void importPhoto();
|
||
void openPhotoUpload();
|
||
void openPhotoAlbum();
|
||
void importPhotoAlbumEntry(std::size_t index);
|
||
bool importUploadedPhoto();
|
||
void advancePhotoImport();
|
||
};
|
||
|
||
struct LoadingScope {
|
||
App& app;
|
||
explicit LoadingScope(App& target) : app(target) { app.beginLoading(); }
|
||
~LoadingScope() { app.endLoading(); }
|
||
};
|
||
|
||
enum ButtonBits : std::uint32_t {
|
||
BA = 1u << 0, BB = 1u << 1, BX = 1u << 2, BY = 1u << 3,
|
||
BL = 1u << 4, BR = 1u << 5, BZL = 1u << 6, BZR = 1u << 7,
|
||
BLEFT = 1u << 8, BRIGHT = 1u << 9, BUP = 1u << 10, BDOWN = 1u << 11,
|
||
BPLUS = 1u << 12, BMINUS = 1u << 13, BLS = 1u << 14, BRS = 1u << 15, BMISC = 1u << 16
|
||
};
|
||
|
||
std::uint32_t controllerBit(std::uint8_t b) {
|
||
switch (b) {
|
||
// SDL names the standardized Xbox-position buttons; Nintendo labels
|
||
// put A on the right, B on the bottom, X on top and Y on the left.
|
||
case SDL_CONTROLLER_BUTTON_B: return BA;
|
||
case SDL_CONTROLLER_BUTTON_A: return BB;
|
||
case SDL_CONTROLLER_BUTTON_Y: return BX;
|
||
case SDL_CONTROLLER_BUTTON_X: return BY;
|
||
case SDL_CONTROLLER_BUTTON_LEFTSHOULDER: return BL;
|
||
case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER: return BR;
|
||
case SDL_CONTROLLER_BUTTON_DPAD_LEFT: return BLEFT;
|
||
case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: return BRIGHT;
|
||
case SDL_CONTROLLER_BUTTON_DPAD_UP: return BUP;
|
||
case SDL_CONTROLLER_BUTTON_DPAD_DOWN: return BDOWN;
|
||
case SDL_CONTROLLER_BUTTON_START: return BPLUS;
|
||
case SDL_CONTROLLER_BUTTON_BACK: return BMINUS;
|
||
case SDL_CONTROLLER_BUTTON_LEFTSTICK: return BLS;
|
||
case SDL_CONTROLLER_BUTTON_RIGHTSTICK: return BRS;
|
||
case SDL_CONTROLLER_BUTTON_MISC1: return BMISC;
|
||
default: return 0;
|
||
}
|
||
}
|
||
|
||
} // namespace
|
||
|
||
int main(int argc, char** argv) {
|
||
App app;
|
||
if (!app.init(argc, argv)) { app.shutdown(); return 1; }
|
||
app.run();
|
||
app.shutdown();
|
||
return 0;
|
||
}
|
||
|
||
namespace {
|
||
|
||
bool App::init(int argc, char** argv) {
|
||
logStartup("startup: entering init", true);
|
||
#ifdef __SWITCH__
|
||
if (argc > 0 && argv && argv[0]) launchNroPath = argv[0];
|
||
logStartup("startup: loader NRO path=" + (launchNroPath.empty() ? std::string("<empty>") : launchNroPath));
|
||
assetsRoot = "romfs:";
|
||
dataRoot = "sdmc:/switch/Switchnote";
|
||
const Result romfsResult = romfsInit();
|
||
if (R_FAILED(romfsResult)) {
|
||
logStartup("startup: romfsInit failed: " + std::to_string(static_cast<unsigned int>(romfsResult)));
|
||
return false;
|
||
}
|
||
romfsReady = true;
|
||
logStartup("startup: romfs ready");
|
||
appletMode = appletGetAppletType() == AppletType_LibraryApplet;
|
||
if (appletMode) logStartup("startup: LibraryApplet mode detected; showing compatibility warning");
|
||
else {
|
||
// libnx mounts sdmc before main() as part of its default runtime startup.
|
||
const Result csrngResult = csrngInitialize();
|
||
if (R_FAILED(csrngResult)) {
|
||
logStartup("startup: csrngInitialize failed: " + std::to_string(static_cast<unsigned int>(csrngResult)));
|
||
return false;
|
||
}
|
||
csrngReady = true;
|
||
const Result accountResult = accountInitialize(AccountServiceType_Application);
|
||
logStartup("profile: accountInitialize=" + std::to_string(static_cast<unsigned int>(accountResult)));
|
||
if (R_SUCCEEDED(accountResult)) {
|
||
accountReady = true;
|
||
std::vector<AccountUid> candidates;
|
||
const auto addCandidate = [&candidates](const AccountUid& uid) {
|
||
if (!accountUidIsValid(&uid)) return;
|
||
const auto duplicate = std::find_if(candidates.begin(), candidates.end(), [&uid](const AccountUid& item) {
|
||
return item.uid[0] == uid.uid[0] && item.uid[1] == uid.uid[1];
|
||
});
|
||
if (duplicate == candidates.end()) candidates.push_back(uid);
|
||
};
|
||
AccountUid uid{};
|
||
const Result preselectedResult = accountGetPreselectedUser(&uid);
|
||
if (R_SUCCEEDED(preselectedResult)) addCandidate(uid);
|
||
logStartup("profile: preselected-user=" + std::to_string(static_cast<unsigned int>(preselectedResult)));
|
||
uid = {};
|
||
const Result lastOpenedResult = accountGetLastOpenedUser(&uid);
|
||
if (R_SUCCEEDED(lastOpenedResult)) addCandidate(uid);
|
||
logStartup("profile: last-opened-user=" + std::to_string(static_cast<unsigned int>(lastOpenedResult)));
|
||
uid = {};
|
||
const Result implicitResult = accountTrySelectUserWithoutInteraction(&uid, false);
|
||
if (R_SUCCEEDED(implicitResult)) addCandidate(uid);
|
||
logStartup("profile: implicit-user=" + std::to_string(static_cast<unsigned int>(implicitResult)));
|
||
std::array<AccountUid, ACC_USER_LIST_SIZE> users{};
|
||
s32 actualUserCount = 0;
|
||
const Result listResult = accountListAllUsers(users.data(), ACC_USER_LIST_SIZE, &actualUserCount);
|
||
if (R_SUCCEEDED(listResult)) {
|
||
for (s32 i = 0; i < std::clamp(actualUserCount, 0, ACC_USER_LIST_SIZE); ++i) addCandidate(users[static_cast<std::size_t>(i)]);
|
||
}
|
||
logStartup("profile: user-list=" + std::to_string(static_cast<unsigned int>(listResult)) +
|
||
" count=" + std::to_string(actualUserCount));
|
||
|
||
for (std::size_t candidateIndex = 0; candidateIndex < candidates.size(); ++candidateIndex) {
|
||
AccountProfile profile{};
|
||
const Result profileResult = accountGetProfile(&profile, candidates[candidateIndex]);
|
||
if (R_FAILED(profileResult)) {
|
||
logStartup("profile: get-profile failed candidate=" + std::to_string(candidateIndex) +
|
||
" result=" + std::to_string(static_cast<unsigned int>(profileResult)));
|
||
continue;
|
||
}
|
||
AccountProfileBase profileBase{};
|
||
const Result profileDataResult = accountProfileGet(&profile, nullptr, &profileBase);
|
||
if (R_FAILED(profileDataResult)) {
|
||
logStartup("profile: profile-data failed candidate=" + std::to_string(candidateIndex) +
|
||
" result=" + std::to_string(static_cast<unsigned int>(profileDataResult)));
|
||
accountProfileClose(&profile);
|
||
continue;
|
||
}
|
||
profileBase.nickname[sizeof(profileBase.nickname) - 1] = '\0';
|
||
const bool nicknameFound = profileBase.nickname[0] != '\0';
|
||
if (nicknameFound) userName = profileBase.nickname;
|
||
|
||
u32 imageSize = 0;
|
||
const Result imageSizeResult = accountProfileGetImageSize(&profile, &imageSize);
|
||
if (R_SUCCEEDED(imageSizeResult) && imageSize > 0 && imageSize <= 4U * 1024U * 1024U) {
|
||
std::vector<std::uint8_t> jpeg(imageSize);
|
||
u32 loadedSize = 0;
|
||
const Result imageLoadResult = accountProfileLoadImage(&profile, jpeg.data(), jpeg.size(), &loadedSize);
|
||
if (R_SUCCEEDED(imageLoadResult) && loadedSize > 0 && loadedSize <= jpeg.size()) {
|
||
jpeg.resize(loadedSize);
|
||
profileImageBytes = std::move(jpeg);
|
||
} else {
|
||
logStartup("profile: image-load failed candidate=" + std::to_string(candidateIndex) +
|
||
" result=" + std::to_string(static_cast<unsigned int>(imageLoadResult)));
|
||
}
|
||
} else {
|
||
logStartup("profile: image-size unavailable candidate=" + std::to_string(candidateIndex) +
|
||
" result=" + std::to_string(static_cast<unsigned int>(imageSizeResult)) +
|
||
" size=" + std::to_string(imageSize));
|
||
}
|
||
accountProfileClose(&profile);
|
||
if (nicknameFound || !profileImageBytes.empty()) {
|
||
logStartup("profile: loaded system profile candidate=" + std::to_string(candidateIndex) +
|
||
(profileImageBytes.empty() ? " (nickname only)" : " (nickname and image)"));
|
||
break;
|
||
}
|
||
}
|
||
if (userName == "Switchnote User" && profileImageBytes.empty()) logStartup("profile: no usable system profile; using fallback");
|
||
}
|
||
}
|
||
#else
|
||
assetsRoot = "romfs";
|
||
dataRoot = "data";
|
||
#endif
|
||
if (!appletMode) {
|
||
notesRoot = join(dataRoot, "switchnotes");
|
||
exportRoot = join(dataRoot, "exports");
|
||
importRoot = join(dataRoot, "import");
|
||
ensureDir(dataRoot);
|
||
if (!migrateLegacyStorage(dataRoot)) {
|
||
logStartup("startup: could not migrate existing Switchnote data");
|
||
return false;
|
||
}
|
||
ensureDir(notesRoot);
|
||
ensureDir(exportRoot);
|
||
ensureDir(importRoot);
|
||
ensureDir(join(notesRoot, folder));
|
||
const std::string updatePrefix = join(join(dataRoot, "updates"), "Switchnote-");
|
||
const std::string updateSuffix = ".nro";
|
||
const std::string canonicalLaunchPath = canonicalSdPath(launchNroPath);
|
||
const std::string canonicalUpdatePrefix = canonicalSdPath(updatePrefix);
|
||
if (argc > 1 && argv && argv[1] && std::string(argv[1]) == "--switchnote-update-handoff" &&
|
||
canonicalLaunchPath.rfind(canonicalUpdatePrefix, 0) == 0 &&
|
||
canonicalLaunchPath.size() > canonicalUpdatePrefix.size() + updateSuffix.size() &&
|
||
canonicalLaunchPath.compare(canonicalLaunchPath.size() - updateSuffix.size(), updateSuffix.size(), updateSuffix) == 0 &&
|
||
validNroFile(launchNroPath)) {
|
||
updateInstallPending = true;
|
||
updateInstallSourcePath = launchNroPath;
|
||
logStartup("update: launched verified NRO from update folder; install handoff armed");
|
||
}
|
||
if (!loadIdentity()) {
|
||
logStartup("startup: identity creation failed");
|
||
return false;
|
||
}
|
||
loadPreferences();
|
||
logStartup("startup: identity ready");
|
||
}
|
||
|
||
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
|
||
const Uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK |
|
||
(appletMode ? 0U : SDL_INIT_AUDIO);
|
||
if (SDL_Init(sdlFlags) != 0) {
|
||
logStartup("startup: SDL_Init failed: " + std::string(SDL_GetError()));
|
||
return false;
|
||
}
|
||
sdlReady = true;
|
||
const int imageFlags = IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG);
|
||
imageReady = true;
|
||
if ((imageFlags & IMG_INIT_PNG) == 0) {
|
||
logStartup("startup: SDL_image PNG initialization failed: " + std::string(IMG_GetError()));
|
||
return false;
|
||
}
|
||
if (TTF_Init() != 0) {
|
||
logStartup("startup: TTF_Init failed: " + std::string(TTF_GetError()));
|
||
return false;
|
||
}
|
||
ttfReady = true;
|
||
window = SDL_CreateWindow("Switchnote Studio", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
|
||
W, H, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
|
||
if (!window) { logStartup("startup: SDL_CreateWindow failed: " + std::string(SDL_GetError())); return false; }
|
||
SDL_SetWindowTitle(window, appDisplayName.c_str());
|
||
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
|
||
if (!renderer) renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
|
||
if (!renderer) { logStartup("startup: SDL_CreateRenderer failed: " + std::string(SDL_GetError())); return false; }
|
||
SDL_RenderSetLogicalSize(renderer, W, H);
|
||
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
|
||
if (appletMode) screen.active = screen.target = Screen::AppletWarning;
|
||
// Decode the complete frog loop before the first real loading event. Lazy
|
||
// PNG decoding here caused a hitch precisely when the overlay was needed.
|
||
if (!appletMode) {
|
||
for (std::size_t i = 0; i < loadingFrogFrames.size(); ++i) {
|
||
const std::string customFrame = join(dataRoot, "branding-loading" + std::to_string(i) + ".png");
|
||
std::ifstream custom(customFrame, std::ios::binary);
|
||
loadingFrogFrames[i] = custom ? loadBrandingLogo(customFrame)
|
||
: image("ui/loading/frog" + std::to_string(i) + ".png");
|
||
}
|
||
const std::string titleLogoPath = brandingLogoPath.empty()
|
||
? join(assetsRoot, "art/switchnotedefault.png") : brandingLogoPath;
|
||
if (!titleLogoPath.empty()) {
|
||
brandingLogoTexture = loadBrandingLogo(titleLogoPath);
|
||
if (!brandingLogoTexture) logStartup("title logo could not be decoded: " + titleLogoPath + " :: " + IMG_GetError());
|
||
}
|
||
}
|
||
if (!profileImageBytes.empty() && profileImageBytes.size() <= static_cast<std::size_t>(std::numeric_limits<int>::max())) {
|
||
SDL_RWops* stream = SDL_RWFromConstMem(profileImageBytes.data(), static_cast<int>(profileImageBytes.size()));
|
||
SDL_Surface* source = stream ? IMG_Load_RW(stream, 1) : nullptr;
|
||
if (!source) logStartup("profile: JPEG decode failed: " + std::string(IMG_GetError()));
|
||
auto createProfileTexture = [&](int edge) -> SDL_Texture* {
|
||
SDL_Surface* avatar = source ? SDL_CreateRGBSurfaceWithFormat(0, edge, edge, 32, SDL_PIXELFORMAT_RGBA32) : nullptr;
|
||
if (!avatar) return nullptr;
|
||
if (SDL_BlitScaled(source, nullptr, avatar, nullptr) != 0) { SDL_FreeSurface(avatar); return nullptr; }
|
||
if (SDL_MUSTLOCK(avatar)) SDL_LockSurface(avatar);
|
||
constexpr float radius = 3.0f;
|
||
for (int y = 0; y < avatar->h; ++y) {
|
||
auto* row = reinterpret_cast<std::uint32_t*>(static_cast<std::uint8_t*>(avatar->pixels) + y * avatar->pitch);
|
||
for (int x = 0; x < avatar->w; ++x) {
|
||
const bool left = x < static_cast<int>(radius);
|
||
const bool right = x >= avatar->w - static_cast<int>(radius);
|
||
const bool top = y < static_cast<int>(radius);
|
||
const bool bottom = y >= avatar->h - static_cast<int>(radius);
|
||
if (!((left || right) && (top || bottom))) continue;
|
||
const float cx = left ? radius : static_cast<float>(avatar->w) - radius;
|
||
const float cy = top ? radius : static_cast<float>(avatar->h) - radius;
|
||
const float dx = static_cast<float>(x) + 0.5f - cx;
|
||
const float dy = static_cast<float>(y) + 0.5f - cy;
|
||
const float edgeCoverage = std::clamp(radius + 0.5f - std::sqrt(dx * dx + dy * dy), 0.0f, 1.0f);
|
||
std::uint8_t r, g, b, a;
|
||
SDL_GetRGBA(row[x], avatar->format, &r, &g, &b, &a);
|
||
a = static_cast<std::uint8_t>(static_cast<float>(a) * edgeCoverage + 0.5f);
|
||
row[x] = SDL_MapRGBA(avatar->format, r, g, b, a);
|
||
}
|
||
}
|
||
if (SDL_MUSTLOCK(avatar)) SDL_UnlockSurface(avatar);
|
||
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, avatar);
|
||
SDL_FreeSurface(avatar);
|
||
if (texture) {
|
||
SDL_SetTextureScaleMode(texture, SDL_ScaleModeLinear);
|
||
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
|
||
}
|
||
return texture;
|
||
};
|
||
profileTexture = createProfileTexture(84);
|
||
profileCornerTexture = createProfileTexture(58);
|
||
profileDetailTexture = createProfileTexture(32);
|
||
if (source && !profileTexture) logStartup("profile: avatar texture creation failed: " + std::string(SDL_GetError()));
|
||
if (source) SDL_FreeSurface(source);
|
||
}
|
||
if (!appletMode && Mix_OpenAudio(48000, AUDIO_S16SYS, 2, 4096) == 0) {
|
||
audioReady = true;
|
||
Mix_AllocateChannels(52);
|
||
const std::array<std::pair<const char*, const char*>, 24> soundMap{{
|
||
{"button_on", "BUTTON_ON"}, {"button_off", "BUTTON_OFF"},
|
||
{"cursor_cancel", "CURSOR_CANCEL"}, {"undo", "UNDO"}, {"redo", "REDO"},
|
||
{"page_new", "EDIT_PAGE_INSERT"}, {"movie_play", "MOVIE_PLAY"}, {"movie_stop", "MOVIE_STOP"},
|
||
{"draw_tool_btn_on", "DRAW_TOOL_BTN_ON"}, {"folder_open", "FOLDER_OPEN"},
|
||
{"pic_stamp", "PIC_STAMP"}, {"paint", "PAINT"},
|
||
{"page_backward", "PAGE_BACKWARD"}, {"page_forward", "PAGE_FORWARD"},
|
||
{"page_first", "PAGE_FIRST"}, {"page_end", "PAGE_END"},
|
||
{"edit_page_copy", "EDIT_PAGE_COPY"}, {"edit_page_paste", "EDIT_PAGE_PASTE"},
|
||
{"edit_page_remove", "EDIT_PAGE_REMOVE"}, {"screen_swap", "SCREEN_SWAP"},
|
||
{"popup", "POPUP"}, {"popup_select", "POPUP_SELECT"}, {"save_ok", "SAVE_OK"},
|
||
{"delete_complete", "DELETE_COMPLETE"}
|
||
}};
|
||
int loadedCues = 0;
|
||
for (const auto& cue : soundMap) {
|
||
const std::string path = join(assetsRoot, std::string("sfx/") + cue.second + ".wav");
|
||
std::ifstream optionalCue(path, std::ios::binary);
|
||
if (!optionalCue) continue;
|
||
optionalCue.close();
|
||
cues[cue.first] = Mix_LoadWAV(path.c_str());
|
||
if (cues[cue.first]) ++loadedCues;
|
||
else logStartup("audio cue load failed: " + path + " :: " + Mix_GetError());
|
||
}
|
||
logStartup("audio ready: " + std::to_string(loadedCues) + "/" + std::to_string(soundMap.size()) + " cues loaded");
|
||
} else if (!appletMode) logStartup("audio open failed: " + std::string(Mix_GetError()));
|
||
for (int i = 0; i < SDL_NumJoysticks(); ++i) {
|
||
if (SDL_IsGameController(i)) {
|
||
controller = SDL_GameControllerOpen(i);
|
||
if (controller) break;
|
||
}
|
||
}
|
||
if (!appletMode) {
|
||
gallery.clear();
|
||
scanLibrary();
|
||
scanImports();
|
||
screen.beginTitleIntro();
|
||
if (updateInstallPending) updateInstallReadyAt = SDL_GetTicks() + 500;
|
||
else startUpdateCheck(false);
|
||
} else {
|
||
screen.active = screen.target = Screen::AppletWarning;
|
||
screen.phase = ScreenState::Phase::Idle;
|
||
}
|
||
logStartup("startup: initialization complete");
|
||
return true;
|
||
}
|
||
|
||
void App::shutdown() {
|
||
if (updateThread) {
|
||
SDL_WaitThread(updateThread, nullptr);
|
||
updateThread = nullptr;
|
||
}
|
||
#ifdef __SWITCH__
|
||
if (serverStartThreadCreated) {
|
||
threadWaitForExit(&serverStartThread);
|
||
threadClose(&serverStartThread);
|
||
serverStartThreadCreated = false;
|
||
}
|
||
if (galleryLoadThreadCreated) {
|
||
threadWaitForExit(&galleryLoadThread);
|
||
threadClose(&galleryLoadThread);
|
||
galleryLoadThreadCreated = false;
|
||
}
|
||
if (photoProbeThreadCreated) {
|
||
threadWaitForExit(&photoProbeThread);
|
||
threadClose(&photoProbeThread);
|
||
photoProbeThreadCreated = false;
|
||
}
|
||
#endif
|
||
if (dirty && docLoaded) saveDocument();
|
||
stopAudioUploadServer();
|
||
stopBrandingConfigServer();
|
||
stopPlayback();
|
||
closePhotoCapture();
|
||
#ifdef __SWITCH__
|
||
if (irPreviewTexture) SDL_DestroyTexture(irPreviewTexture);
|
||
for (SDL_Texture* texture : photoAlbumThumbs) if (texture) SDL_DestroyTexture(texture);
|
||
#endif
|
||
for (SDL_Texture* texture : loadingFrogFrames) if (texture) SDL_DestroyTexture(texture);
|
||
for (auto& it : frameTextures) SDL_DestroyTexture(it.second.texture);
|
||
frameTextures.clear();
|
||
if (commentTexture) SDL_DestroyTexture(commentTexture);
|
||
if (profileTexture) SDL_DestroyTexture(profileTexture);
|
||
if (profileCornerTexture) SDL_DestroyTexture(profileCornerTexture);
|
||
if (profileDetailTexture) SDL_DestroyTexture(profileDetailTexture);
|
||
if (galleryProfileAvatarTexture) SDL_DestroyTexture(galleryProfileAvatarTexture);
|
||
if (brandingLogoTexture) SDL_DestroyTexture(brandingLogoTexture);
|
||
for (auto& it : galleryCommentTextures) if (it.second) SDL_DestroyTexture(it.second);
|
||
galleryCommentTextures.clear();
|
||
for (auto& it : images) SDL_DestroyTexture(it.second);
|
||
for (auto& it : whiteImages) if (it.second) SDL_DestroyTexture(it.second);
|
||
for (auto& it : textCache) SDL_DestroyTexture(it.second);
|
||
for (auto& it : fonts) TTF_CloseFont(it.second);
|
||
for (auto& it : cues) if (it.second) Mix_FreeChunk(it.second);
|
||
for (auto* chunk : trackChunks) if (chunk) Mix_FreeChunk(chunk);
|
||
if (controller) SDL_GameControllerClose(controller);
|
||
if (audioReady) Mix_CloseAudio();
|
||
if (renderer) SDL_DestroyRenderer(renderer);
|
||
if (window) SDL_DestroyWindow(window);
|
||
if (ttfReady) TTF_Quit();
|
||
if (imageReady) IMG_Quit();
|
||
if (sdlReady) SDL_Quit();
|
||
#ifdef __SWITCH__
|
||
if (gallerySslReady) sslExit();
|
||
if (gallerySocketsReady) socketExit();
|
||
if (nifmReady) nifmExit();
|
||
if (accountReady) accountExit();
|
||
if (csrngReady) csrngExit();
|
||
if (romfsReady) romfsExit();
|
||
#endif
|
||
}
|
||
|
||
void App::beginLoading() {
|
||
if (loadingDepth++ == 0) {
|
||
loadingStartedAt = SDL_GetTicks();
|
||
loadingCompletionVisible = false;
|
||
}
|
||
}
|
||
|
||
void App::endLoading() {
|
||
if (loadingDepth <= 0) return;
|
||
if (--loadingDepth == 0) {
|
||
completedLoadingDuration = SDL_GetTicks() - loadingStartedAt;
|
||
if (completedLoadingDuration >= 1000) {
|
||
loadingFinishedAt = SDL_GetTicks();
|
||
loadingCompletionVisible = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
void App::renderLoadingOverlay() {
|
||
const std::uint32_t now = SDL_GetTicks();
|
||
if (photoModalTransitionDim) {
|
||
const std::uint32_t transitionElapsed = now - photoModalTransitionDimAt;
|
||
if (transitionElapsed < 125) {
|
||
const Uint8 alpha = static_cast<Uint8>(std::lround(72.0f * (1.0f - transitionElapsed / 125.0f)));
|
||
fill(0, 0, W, H, SDL_Color{18, 20, 28, alpha});
|
||
} else photoModalTransitionDim = false;
|
||
}
|
||
if (loadingDepth <= 0 && !loadingCompletionVisible) return;
|
||
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
|
||
const bool completed = loadingDepth <= 0;
|
||
const std::uint32_t completionElapsed = completed ? now - loadingFinishedAt : 0;
|
||
const std::uint32_t elapsed = completed ? completedLoadingDuration : now - loadingStartedAt;
|
||
if (!updateInProgress && elapsed < 1000) return;
|
||
if (completed && completionElapsed >= 800) { loadingCompletionVisible = false; return; }
|
||
// Keep the scene undimmed while a task is merely pending. Once the frog
|
||
// appears, dim behind it so loading feedback is visible without obscuring
|
||
// ordinary modal interactions.
|
||
fill(0, 0, W, H, SDL_Color{18, 20, 28, 72});
|
||
constexpr std::uint32_t frameMs = 90;
|
||
const std::size_t frameIndex = static_cast<std::size_t>((now / frameMs) % loadingFrogFrames.size());
|
||
float progress = updateInProgress ? 1.0f : std::clamp((elapsed - 1000) / 220.0f, 0.0f, 1.0f);
|
||
if (completed) {
|
||
progress = completionElapsed < 200 ? completionElapsed / 200.0f
|
||
: completionElapsed < 600 ? 1.0f : 1.0f - (completionElapsed - 600) / 200.0f;
|
||
}
|
||
const float eased = 1.0f - std::pow(1.0f - progress, 3.0f);
|
||
SDL_Texture* frog = loadingFrogFrames[frameIndex];
|
||
if (!frog) {
|
||
const std::string asset = "ui/loading/frog" + std::to_string(frameIndex) + ".png";
|
||
frog = image(asset);
|
||
loadingFrogFrames[frameIndex] = frog;
|
||
}
|
||
if (frog) {
|
||
int sourceW = 0, sourceH = 0;
|
||
SDL_QueryTexture(frog, nullptr, nullptr, &sourceW, &sourceH);
|
||
const float scale = sourceW > 0 && sourceH > 0 ? std::min(64.0f / sourceW, 64.0f / sourceH) : 1.0f;
|
||
const int drawW = std::max(1, static_cast<int>(std::lround(sourceW * scale)));
|
||
const int drawH = std::max(1, static_cast<int>(std::lround(sourceH * scale)));
|
||
const int x = W - drawW + static_cast<int>(std::lround((1.0f - eased) * drawW));
|
||
drawTexture(frog, x, H - drawH - 14, drawW, drawH);
|
||
}
|
||
}
|
||
|
||
bool App::loadIdentity() {
|
||
std::vector<std::uint8_t> hardware;
|
||
if (!getDeviceMaterial(hardware)) {
|
||
logStartup("identity: no console-specific device identifier is available");
|
||
return false;
|
||
}
|
||
|
||
// Keep old HMAC-signed .sppm files readable, but move this compatibility
|
||
// key into the new authenticated, device-wrapped identity record.
|
||
std::array<std::uint8_t, 32> legacyKey{};
|
||
const std::string legacyPath = join(dataRoot, "identity.bin");
|
||
std::vector<std::uint8_t> oldIdentity;
|
||
if (readBinaryFile(legacyPath, oldIdentity) && oldIdentity.size() == 48) {
|
||
std::copy_n(oldIdentity.begin(), legacyKey.size(), legacyKey.begin());
|
||
}
|
||
|
||
bool found = false;
|
||
bool legacyKeyIsWrapped = false;
|
||
if (DIR* dir = opendir(dataRoot.c_str())) {
|
||
while (dirent* entry = readdir(dir)) {
|
||
const std::string name = entry->d_name;
|
||
if (name.rfind("identity-v2-", 0) != 0 || !endsWith(name, ".bin")) continue;
|
||
if (loadEncryptedIdentity(join(dataRoot, name), hardware, signingIdentity)) {
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
closedir(dir);
|
||
}
|
||
if (!found) {
|
||
std::string identityPath;
|
||
if (!createEncryptedIdentity(dataRoot, hardware, legacyKey, signingIdentity, identityPath)) {
|
||
logStartup("identity: could not create encrypted console-bound signing identity");
|
||
return false;
|
||
}
|
||
sppm::SigningIdentity check{};
|
||
if (!loadEncryptedIdentity(identityPath, hardware, check) ||
|
||
check.secretKey != signingIdentity.secretKey || check.legacyHmacKey != signingIdentity.legacyHmacKey) {
|
||
std::remove(identityPath.c_str());
|
||
logStartup("identity: encrypted key could not be reopened after writing");
|
||
return false;
|
||
}
|
||
signingIdentity = check;
|
||
legacyKeyIsWrapped = true;
|
||
} else {
|
||
legacyKeyIsWrapped = signingIdentity.legacyHmacKey == legacyKey;
|
||
if (std::all_of(signingIdentity.legacyHmacKey.begin(), signingIdentity.legacyHmacKey.end(),
|
||
[](std::uint8_t value) { return value == 0; }) &&
|
||
std::any_of(legacyKey.begin(), legacyKey.end(), [](std::uint8_t value) { return value != 0; })) {
|
||
// Recover a pre-v2 profile created by an earlier build if it has
|
||
// the same persisted local key. Keep its plaintext source until
|
||
// a future encrypted migration can be safely confirmed.
|
||
signingIdentity.legacyHmacKey = legacyKey;
|
||
}
|
||
}
|
||
myFsid = sppm::deriveFsid(signingIdentity.publicIdentity);
|
||
if (oldIdentity.size() == 48 && legacyKeyIsWrapped) {
|
||
// The compatibility key has already been authenticated by the new
|
||
// device-bound encrypted record, so the old plaintext copy is no
|
||
// longer needed.
|
||
std::remove(legacyPath.c_str());
|
||
}
|
||
#ifndef __SWITCH__
|
||
std::ifstream nameFile(join(dataRoot, "profile.txt"), std::ios::binary);
|
||
if (nameFile) {
|
||
std::getline(nameFile, userName);
|
||
if (userName.empty() || userName.size() > 48) userName = "Switchnote User";
|
||
}
|
||
#endif
|
||
return true;
|
||
}
|
||
|
||
std::string App::newId(const char* domain) {
|
||
std::array<std::uint8_t, 32> idSecret{};
|
||
std::array<std::uint8_t, 16> nonce{};
|
||
if (!randomBytes(idSecret.data(), idSecret.size()) || !randomBytes(nonce.data(), nonce.size())) return {};
|
||
return sppm::deriveFsid(idSecret, nonce, domain);
|
||
}
|
||
|
||
void App::scanLibrary() {
|
||
library.clear();
|
||
const std::string currentDir = join(notesRoot, folder);
|
||
ensureDir(currentDir);
|
||
if (DIR* dir = opendir(currentDir.c_str())) {
|
||
while (dirent* entry = readdir(dir)) {
|
||
const std::string name = entry->d_name;
|
||
const std::size_t marker = name.find(".sppm.bak-");
|
||
if (marker == std::string::npos) continue;
|
||
const std::string target = join(currentDir, name.substr(0, marker + 5));
|
||
struct stat targetStat{};
|
||
if (stat(target.c_str(), &targetStat) != 0) {
|
||
const std::string backup = join(currentDir, name);
|
||
if (std::rename(backup.c_str(), target.c_str()) == 0)
|
||
logStartup("recovered previous Switchnote save: " + target);
|
||
}
|
||
}
|
||
closedir(dir);
|
||
}
|
||
if (DIR* dir = opendir(currentDir.c_str())) {
|
||
while (dirent* entry = readdir(dir)) {
|
||
std::string name = entry->d_name;
|
||
if (!endsWith(name, ".sppm")) continue;
|
||
sppm::Document file;
|
||
std::string error;
|
||
const std::string path = join(currentDir, name);
|
||
if (sppm::loadSignedFile(path, file, signingIdentity.legacyHmacKey, error)) {
|
||
Item item{};
|
||
item.title = file.metadata.title.empty() ? defaultSwitchnoteTitle(userName, noteSingular) : file.metadata.title;
|
||
item.path = path;
|
||
item.author = file.metadata.authorName;
|
||
item.description = file.metadata.description;
|
||
item.originalAuthor = file.metadata.originalAuthorName;
|
||
item.authorFsid = file.metadata.authorFsid;
|
||
item.originalAuthorFsid = file.metadata.originalAuthorFsid;
|
||
item.currentId = file.metadata.currentId;
|
||
item.rootId = file.metadata.rootId;
|
||
item.createdUnixSeconds = file.metadata.createdUnixSeconds;
|
||
item.modifiedUnixSeconds = file.metadata.modifiedUnixSeconds;
|
||
item.allowSpinoffs = file.metadata.allowSpinoffs;
|
||
item.locked = file.metadata.locked;
|
||
item.ownerIdentity = sppm::identityFingerprint(file.metadata.authorIdentity);
|
||
library.push_back(std::move(item));
|
||
}
|
||
}
|
||
closedir(dir);
|
||
}
|
||
std::sort(library.begin(), library.end(), [](const Item& a, const Item& b) {
|
||
if (a.modifiedUnixSeconds != b.modifiedUnixSeconds) return a.modifiedUnixSeconds > b.modifiedUnixSeconds;
|
||
if (a.createdUnixSeconds != b.createdUnixSeconds) return a.createdUnixSeconds > b.createdUnixSeconds;
|
||
return a.path < b.path;
|
||
});
|
||
if (library.empty()) selected = 0;
|
||
else selected = std::min(selected, library.size() - 1);
|
||
page = static_cast<int>(selected / 6);
|
||
}
|
||
|
||
void App::scanImports() {
|
||
importFiles.clear();
|
||
if (DIR* dir = opendir(importRoot.c_str())) {
|
||
while (dirent* entry = readdir(dir)) {
|
||
const std::string name = entry->d_name;
|
||
if (endsWith(name, ".wav") || endsWith(name, ".WAV")) importFiles.push_back(name);
|
||
}
|
||
closedir(dir);
|
||
}
|
||
std::sort(importFiles.begin(), importFiles.end());
|
||
importSelection = 0;
|
||
}
|
||
|
||
bool App::startAudioUploadServer(bool photoTransfer) {
|
||
#ifdef __SWITCH__
|
||
if (audioUploadServer.isRunning()) return photoTransferActive == photoTransfer;
|
||
if (!gallerySocketsReady) {
|
||
const Result sockets = socketInitializeDefault();
|
||
if (R_FAILED(sockets)) {
|
||
audioUploadStatus = "Network initialization failed.";
|
||
return false;
|
||
}
|
||
gallerySocketsReady = true;
|
||
}
|
||
if (!nifmReady) {
|
||
const Result network = nifmInitialize(NifmServiceType_User);
|
||
if (R_FAILED(network)) {
|
||
audioUploadStatus = "Could not read the Switch network address.";
|
||
return false;
|
||
}
|
||
nifmReady = true;
|
||
}
|
||
u32 rawAddress = 0;
|
||
if (R_FAILED(nifmGetCurrentIpAddress(&rawAddress))) {
|
||
audioUploadStatus = "Connect the Switch to your local Wi-Fi first.";
|
||
return false;
|
||
}
|
||
const std::uint32_t hostAddress = ntohl(rawAddress);
|
||
const bool privateAddress = (hostAddress >> 24) == 10 ||
|
||
(hostAddress & 0xfff00000U) == 0xac100000U ||
|
||
(hostAddress & 0xffff0000U) == 0xc0a80000U ||
|
||
(hostAddress & 0xffff0000U) == 0xa9fe0000U ||
|
||
(hostAddress & 0xffc00000U) == 0x64400000U;
|
||
if (!privateAddress) {
|
||
audioUploadStatus = "Connect to a private local network to upload audio.";
|
||
return false;
|
||
}
|
||
in_addr address{};
|
||
address.s_addr = rawAddress;
|
||
char addressText[INET_ADDRSTRLEN]{};
|
||
if (!::inet_ntop(AF_INET, &address, addressText, sizeof(addressText))) {
|
||
audioUploadStatus = "Could not format the Switch network address.";
|
||
return false;
|
||
}
|
||
// Rejection sampling keeps every six-digit code equally likely.
|
||
std::uint32_t randomValue = 0;
|
||
do {
|
||
if (!randomBytes(&randomValue, sizeof(randomValue))) {
|
||
audioUploadStatus = "Could not create a secure upload code.";
|
||
return false;
|
||
}
|
||
} while (randomValue >= 4294000000U);
|
||
const unsigned int pin = randomValue % 1000000U;
|
||
char formattedCode[8]{};
|
||
std::snprintf(formattedCode, sizeof(formattedCode), "%03u-%03u", pin / 1000U, pin % 1000U);
|
||
const std::string code = formattedCode;
|
||
std::string error;
|
||
if (!audioUploadServer.start(addressText, importRoot, assetsRoot, code, error, photoTransfer, noteSingular)) {
|
||
audioUploadStatus = error.empty() ? "Could not start the local upload page." : error;
|
||
return false;
|
||
}
|
||
audioUploadCode = code;
|
||
audioUploadUrl = "http://" + std::string(addressText) + ":8766";
|
||
photoTransferActive = photoTransfer;
|
||
audioUploadStatus = "Enter the code on your PC.";
|
||
return true;
|
||
#else
|
||
(void)photoTransfer;
|
||
audioUploadStatus = "The upload server is available in the Switch homebrew app.";
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
void App::requestServerStart(ServerStartTask task) {
|
||
if (serverStartRunning || task == ServerStartTask::None) return;
|
||
serverStartTask = task;
|
||
serverStartRunning = true;
|
||
serverStartSucceeded = false;
|
||
serverStartFinished.store(false, std::memory_order_relaxed);
|
||
beginLoading();
|
||
#ifdef __SWITCH__
|
||
if (R_FAILED(threadCreate(&serverStartThread, serverStartThreadEntry, this, nullptr, 0x10000, 0x3B, -2))) {
|
||
serverStartRunning = false;
|
||
serverStartTask = ServerStartTask::None;
|
||
endLoading();
|
||
showToast("Could not start the transfer service.");
|
||
return;
|
||
}
|
||
serverStartThreadCreated = true;
|
||
if (R_FAILED(threadStart(&serverStartThread))) {
|
||
threadClose(&serverStartThread);
|
||
serverStartThreadCreated = false;
|
||
serverStartRunning = false;
|
||
serverStartTask = ServerStartTask::None;
|
||
endLoading();
|
||
showToast("Could not start the transfer service.");
|
||
}
|
||
#else
|
||
serverStartSucceeded = task == ServerStartTask::Branding
|
||
? startBrandingConfigServer()
|
||
: startAudioUploadServer(task == ServerStartTask::Photo);
|
||
serverStartFinished.store(true, std::memory_order_release);
|
||
#endif
|
||
}
|
||
|
||
void App::requestAudioUploadServer(bool photoTransfer) {
|
||
requestServerStart(photoTransfer ? ServerStartTask::Photo : ServerStartTask::Audio);
|
||
}
|
||
|
||
void App::requestBrandingConfigServer() {
|
||
requestServerStart(ServerStartTask::Branding);
|
||
}
|
||
|
||
#ifdef __SWITCH__
|
||
void App::serverStartThreadEntry(void* argument) {
|
||
auto* app = static_cast<App*>(argument);
|
||
app->runServerStartThread();
|
||
threadExit();
|
||
}
|
||
|
||
void App::runServerStartThread() {
|
||
serverStartSucceeded = serverStartTask == ServerStartTask::Branding
|
||
? startBrandingConfigServer()
|
||
: startAudioUploadServer(serverStartTask == ServerStartTask::Photo);
|
||
serverStartFinished.store(true, std::memory_order_release);
|
||
}
|
||
#endif
|
||
|
||
void App::consumeServerStart() {
|
||
if (!serverStartRunning || !serverStartFinished.exchange(false, std::memory_order_acquire)) return;
|
||
#ifdef __SWITCH__
|
||
if (serverStartThreadCreated) {
|
||
threadWaitForExit(&serverStartThread);
|
||
threadClose(&serverStartThread);
|
||
serverStartThreadCreated = false;
|
||
}
|
||
#endif
|
||
const ServerStartTask completedTask = serverStartTask;
|
||
serverStartRunning = false;
|
||
serverStartTask = ServerStartTask::None;
|
||
endLoading();
|
||
if (serverStartSucceeded) {
|
||
if (completedTask == ServerStartTask::Branding) showToast("Branding portal is ready on your local network");
|
||
else showToast(completedTask == ServerStartTask::Photo
|
||
? "Photo upload page is ready on your local network"
|
||
: "Sound upload page is ready on your local network");
|
||
} else {
|
||
showToast(completedTask == ServerStartTask::Branding ? brandingStatus : audioUploadStatus);
|
||
}
|
||
}
|
||
|
||
void App::stopAudioUploadServer() {
|
||
audioUploadServer.stop();
|
||
photoTransferActive = false;
|
||
audioUploadUrl.clear();
|
||
audioUploadCode.clear();
|
||
}
|
||
|
||
void App::closeAudioMenu() {
|
||
consumeAudioUpload();
|
||
if (audioReady) Mix_HaltChannel(4);
|
||
stopAudioUploadServer();
|
||
audioEraseArmedTrack = -1;
|
||
modal = Modal::None;
|
||
}
|
||
|
||
void App::consumeAudioUpload() {
|
||
int track = -1;
|
||
if (!audioUploadServer.takeCompletedUpload(track)) return;
|
||
if (track == 4) {
|
||
if (photoImporting) return;
|
||
const bool started = importUploadedPhoto();
|
||
if (!started) {
|
||
std::remove(join(importRoot, "photo-transfer.rgba").c_str());
|
||
std::remove(join(importRoot, "photo-transfer.cfg").c_str());
|
||
audioUploadServer.finishCompletedUpload(false);
|
||
audioUploadStatus = "That image could not be imported.";
|
||
} else audioUploadStatus = "Adding image to your Switchnote…";
|
||
return;
|
||
}
|
||
const std::string path = join(importRoot, "audio-transfer-" + std::to_string(track) + ".wav");
|
||
const std::string name = track == 0 ? "BGM" : "SE" + std::to_string(track);
|
||
const bool imported = importAudioFile(path, track, name + " from PC");
|
||
audioEraseArmedTrack = -1;
|
||
std::remove(path.c_str());
|
||
audioUploadServer.finishCompletedUpload(imported);
|
||
if (imported) audioUploadStatus = name + " added from your PC.";
|
||
else audioUploadStatus = "That WAV could not be added. Check its duration and format.";
|
||
}
|
||
|
||
bool App::galleryRequest(const std::string& method, const std::string& path,
|
||
const std::vector<std::uint8_t>& requestBody,
|
||
const std::string& contentType,
|
||
std::vector<std::uint8_t>& responseBody, int& status,
|
||
std::string& error, std::string* responseHeaders) {
|
||
responseBody.clear();
|
||
status = 0;
|
||
if (responseHeaders) responseHeaders->clear();
|
||
#ifdef __SWITCH__
|
||
if (!gallerySocketsReady) {
|
||
const Result result = socketInitializeDefault();
|
||
if (R_FAILED(result)) {
|
||
error = "Network setup failed (" + std::to_string(static_cast<unsigned int>(result)) + ")";
|
||
return false;
|
||
}
|
||
gallerySocketsReady = true;
|
||
}
|
||
if (!gallerySslReady) {
|
||
const Result result = sslInitialize(1);
|
||
if (R_FAILED(result)) {
|
||
error = "Secure Gallery networking could not be initialized (" + std::to_string(static_cast<unsigned int>(result)) + ")";
|
||
return false;
|
||
}
|
||
gallerySslReady = true;
|
||
}
|
||
std::string authHeaders;
|
||
if ((method == "POST" && path != "/api/flipnotes") || method == "DELETE") {
|
||
std::vector<std::uint8_t> challengeResponse;
|
||
int challengeStatus = 0;
|
||
std::string authError;
|
||
if (!galleryRequest("GET", "/api/auth/challenge", {}, "text/plain",
|
||
challengeResponse, challengeStatus, authError)) {
|
||
error = "Gallery authentication challenge failed: " + authError;
|
||
return false;
|
||
}
|
||
std::string nonceHex(challengeResponse.begin(), challengeResponse.end());
|
||
while (!nonceHex.empty() && (nonceHex.back() == '\r' || nonceHex.back() == '\n')) nonceHex.pop_back();
|
||
std::array<std::uint8_t, 32> nonce{};
|
||
if (!hexDecode(nonceHex, nonce.data(), nonce.size())) {
|
||
error = "Gallery returned an invalid authentication challenge";
|
||
return false;
|
||
}
|
||
std::vector<std::uint8_t> signedRequest;
|
||
const std::string domain = "FlipnoteNX-Gallery-Request-v1";
|
||
signedRequest.insert(signedRequest.end(), domain.begin(), domain.end());
|
||
signedRequest.push_back(0);
|
||
signedRequest.insert(signedRequest.end(), method.begin(), method.end());
|
||
signedRequest.push_back(0);
|
||
signedRequest.insert(signedRequest.end(), path.begin(), path.end());
|
||
signedRequest.push_back(0);
|
||
signedRequest.insert(signedRequest.end(), nonce.begin(), nonce.end());
|
||
signedRequest.push_back(0);
|
||
signedRequest.insert(signedRequest.end(), myFsid.begin(), myFsid.end());
|
||
signedRequest.push_back(0);
|
||
signedRequest.insert(signedRequest.end(), requestBody.begin(), requestBody.end());
|
||
std::array<std::uint8_t, 64> signature{};
|
||
if (!sppm::signMessage(signingIdentity,
|
||
signedRequest.empty() ? nullptr : signedRequest.data(),
|
||
signedRequest.size(), signature, authError)) {
|
||
error = "Could not authenticate Gallery action: " + authError;
|
||
return false;
|
||
}
|
||
authHeaders = "X-FSNX-Nonce: " + nonceHex + "\r\n" +
|
||
"X-FSNX-FSID: " + myFsid + "\r\n" +
|
||
"X-FSNX-Key: " + hexEncode(signingIdentity.publicIdentity.key.data(), signingIdentity.publicIdentity.key.size()) + "\r\n" +
|
||
"X-FSNX-Device: " + hexEncode(signingIdentity.publicIdentity.deviceTag.data(), signingIdentity.publicIdentity.deviceTag.size()) + "\r\n" +
|
||
"X-FSNX-Signature: " + hexEncode(signature.data(), signature.size()) + "\r\n";
|
||
std::fill(signedRequest.begin(), signedRequest.end(), 0);
|
||
}
|
||
addrinfo hints{};
|
||
hints.ai_family = AF_INET;
|
||
hints.ai_socktype = SOCK_STREAM;
|
||
addrinfo* addresses = nullptr;
|
||
const std::string service = std::to_string(kGalleryServerPort);
|
||
if (::getaddrinfo(kGalleryServerHost, service.c_str(), &hints, &addresses) != 0 || !addresses) {
|
||
error = "Could not resolve the secure Gallery address " + std::string(kGalleryServerHost);
|
||
if (addresses) ::freeaddrinfo(addresses);
|
||
return false;
|
||
}
|
||
int fd = -1;
|
||
for (addrinfo* candidate = addresses; candidate; candidate = candidate->ai_next) {
|
||
fd = ::socket(candidate->ai_family, candidate->ai_socktype, candidate->ai_protocol);
|
||
if (fd < 0) continue;
|
||
timeval timeout{};
|
||
timeout.tv_sec = 6;
|
||
::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
|
||
::setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
|
||
if (::connect(fd, candidate->ai_addr, candidate->ai_addrlen) == 0) break;
|
||
::close(fd);
|
||
fd = -1;
|
||
}
|
||
::freeaddrinfo(addresses);
|
||
if (fd < 0) {
|
||
error = "Could not reach the secure Gallery at https://" + std::string(kGalleryServerHost) + "/nswitch/";
|
||
return false;
|
||
}
|
||
|
||
SslContext sslContext{};
|
||
SslConnection sslConnection{};
|
||
bool contextCreated = false;
|
||
bool connectionCreated = false;
|
||
bool socketAttached = false;
|
||
int sslSocketToClose = -1;
|
||
auto closeTls = [&]() {
|
||
if (connectionCreated) {
|
||
sslConnectionClose(&sslConnection);
|
||
connectionCreated = false;
|
||
}
|
||
if (contextCreated) {
|
||
sslContextClose(&sslContext);
|
||
contextCreated = false;
|
||
}
|
||
if (sslSocketToClose >= 0) {
|
||
::close(sslSocketToClose);
|
||
sslSocketToClose = -1;
|
||
} else if (!socketAttached && fd >= 0) {
|
||
::close(fd);
|
||
}
|
||
fd = -1;
|
||
};
|
||
const char* tlsStage = "TLS context creation";
|
||
Result tlsResult = sslCreateContext(&sslContext, SslVersion_TlsV12 | SslVersion_TlsV13);
|
||
contextCreated = R_SUCCEEDED(tlsResult);
|
||
if (R_SUCCEEDED(tlsResult)) {
|
||
tlsStage = "TLS connection setup";
|
||
tlsResult = sslContextCreateConnection(&sslContext, &sslConnection);
|
||
connectionCreated = R_SUCCEEDED(tlsResult);
|
||
}
|
||
if (R_SUCCEEDED(tlsResult)) {
|
||
tlsStage = "Gallery hostname setup";
|
||
tlsResult = sslConnectionSetHostName(&sslConnection, kGalleryServerHost, std::strlen(kGalleryServerHost));
|
||
}
|
||
if (R_SUCCEEDED(tlsResult)) {
|
||
tlsStage = "certificate verification setup";
|
||
tlsResult = sslConnectionSetVerifyOption(&sslConnection,
|
||
SslVerifyOption_PeerCa | SslVerifyOption_HostName | SslVerifyOption_DateCheck);
|
||
}
|
||
if (R_SUCCEEDED(tlsResult)) {
|
||
tlsStage = "secure socket setup";
|
||
errno = 0;
|
||
sslSocketToClose = socketSslConnectionSetSocketDescriptor(&sslConnection, fd);
|
||
socketAttached = true;
|
||
if (sslSocketToClose < 0 && errno != ENOENT) tlsResult = MAKERESULT(Module_Libnx, LibnxError_BadInput);
|
||
}
|
||
if (R_SUCCEEDED(tlsResult)) {
|
||
tlsStage = "TLS handshake/certificate verification";
|
||
tlsResult = sslConnectionDoHandshake(&sslConnection, nullptr, nullptr, nullptr, 0);
|
||
}
|
||
if (R_FAILED(tlsResult)) {
|
||
std::ostringstream detail;
|
||
detail << "Secure Gallery connection failed during " << tlsStage << " (" << static_cast<unsigned int>(tlsResult)
|
||
<< ", module " << R_MODULE(tlsResult) << ", description " << R_DESCRIPTION(tlsResult) << ")";
|
||
if (connectionCreated && std::strcmp(tlsStage, "TLS handshake/certificate verification") == 0) {
|
||
const Result verifyResult = sslConnectionGetVerifyCertError(&sslConnection);
|
||
if (R_FAILED(verifyResult)) {
|
||
detail << " [certificate check " << static_cast<unsigned int>(verifyResult)
|
||
<< ", module " << R_MODULE(verifyResult) << ", description " << R_DESCRIPTION(verifyResult) << "]";
|
||
} else {
|
||
detail << " [no certificate rejection reported]";
|
||
}
|
||
}
|
||
error = detail.str();
|
||
closeTls();
|
||
return false;
|
||
}
|
||
const std::string type = contentType.empty() ? "application/octet-stream" : contentType;
|
||
const std::string requestPath = std::string(kGalleryServerBasePath) + path;
|
||
const auto requestNumber = galleryRequestCounter.fetch_add(1, std::memory_order_relaxed) + 1;
|
||
const std::string requestId = "snx-" + std::to_string(SDL_GetTicks()) + "-" + std::to_string(requestNumber);
|
||
const std::string headers = method + " " + requestPath + " HTTP/1.1\r\nHost: " + kGalleryServerHost +
|
||
"\r\nUser-Agent: SwitchnoteStudio/0.1.51\r\nX-Switchnote-Client: Switchnote-Studio\r\nX-Switchnote-Request-ID: " + requestId +
|
||
"\r\nConnection: close\r\nContent-Type: " + type + "\r\nContent-Length: " +
|
||
std::to_string(requestBody.size()) + "\r\n" + authHeaders + "\r\n";
|
||
auto sendBytes = [&sslConnection](const std::uint8_t* data, std::size_t length) {
|
||
std::size_t sent = 0;
|
||
while (sent < length) {
|
||
u32 written = 0;
|
||
const std::size_t amount = std::min<std::size_t>(length - sent, 0x4000);
|
||
const Result result = sslConnectionWrite(&sslConnection, data + sent, static_cast<u32>(amount), &written);
|
||
if (R_FAILED(result) || written == 0) return false;
|
||
sent += written;
|
||
}
|
||
return true;
|
||
};
|
||
if (!sendBytes(reinterpret_cast<const std::uint8_t*>(headers.data()), headers.size()) ||
|
||
(!requestBody.empty() && !sendBytes(requestBody.data(), requestBody.size()))) {
|
||
error = "Could not send the Gallery request";
|
||
closeTls();
|
||
return false;
|
||
}
|
||
std::vector<std::uint8_t> received;
|
||
received.reserve(4096);
|
||
std::array<std::uint8_t, 16384> chunk{};
|
||
constexpr std::size_t maxResponse = 72U * 1024U * 1024U;
|
||
while (true) {
|
||
u32 count = 0;
|
||
const Result result = sslConnectionRead(&sslConnection, chunk.data(), chunk.size(), &count);
|
||
if (R_FAILED(result)) {
|
||
error = "Gallery response timed out or was interrupted";
|
||
closeTls();
|
||
return false;
|
||
}
|
||
if (count == 0) break;
|
||
if (received.size() + count > maxResponse) {
|
||
error = "Gallery response is too large";
|
||
closeTls();
|
||
return false;
|
||
}
|
||
received.insert(received.end(), chunk.begin(), chunk.begin() + count);
|
||
}
|
||
closeTls();
|
||
if (received.empty()) { error = "Gallery returned an empty response"; return false; }
|
||
const std::string headerText(reinterpret_cast<const char*>(received.data()), received.size());
|
||
const std::size_t headerEnd = headerText.find("\r\n\r\n");
|
||
if (headerEnd == std::string::npos) { error = "Gallery returned an invalid HTTP response"; return false; }
|
||
const std::size_t statusEnd = headerText.find("\r\n");
|
||
if (statusEnd == std::string::npos) { error = "Gallery returned an invalid HTTP status"; return false; }
|
||
const std::string statusLine = headerText.substr(0, statusEnd);
|
||
if (std::sscanf(statusLine.c_str(), "HTTP/%*s %d", &status) != 1) {
|
||
error = "Gallery returned an invalid HTTP status";
|
||
return false;
|
||
}
|
||
const std::size_t bodyStart = headerEnd + 4;
|
||
if (responseHeaders) responseHeaders->assign(headerText.data(), headerEnd);
|
||
responseBody.assign(received.begin() + static_cast<std::ptrdiff_t>(bodyStart), received.end());
|
||
if (status < 200 || status >= 300) {
|
||
error.assign(responseBody.begin(), responseBody.begin() + static_cast<std::ptrdiff_t>(std::min<std::size_t>(responseBody.size(), 300)));
|
||
while (!error.empty() && (error.back() == '\r' || error.back() == '\n')) error.pop_back();
|
||
if (error.empty()) error = "Gallery returned HTTP " + std::to_string(status);
|
||
return false;
|
||
}
|
||
error.clear();
|
||
return true;
|
||
#else
|
||
(void)method; (void)path; (void)requestBody; (void)contentType; (void)responseHeaders;
|
||
error = "Switchnote Gallery is available from the Switch app";
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
void App::enterGallery() {
|
||
galleryPage = 0;
|
||
gallerySelected = 0;
|
||
galleryStatus = "Loading Gallery…";
|
||
screen = Screen::Gallery;
|
||
refreshGallery();
|
||
}
|
||
|
||
void App::showGalleryNotice() {
|
||
modal = Modal::GalleryNotice;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
}
|
||
|
||
bool App::internetConnected() {
|
||
#ifdef __SWITCH__
|
||
if (!nifmReady) {
|
||
if (R_FAILED(nifmInitialize(NifmServiceType_User))) return false;
|
||
nifmReady = true;
|
||
}
|
||
NifmInternetConnectionType connectionType{};
|
||
NifmInternetConnectionStatus connectionStatus{};
|
||
u32 wifiStrength = 0;
|
||
return R_SUCCEEDED(nifmGetInternetConnectionStatus(&connectionType, &wifiStrength, &connectionStatus)) &&
|
||
connectionStatus == NifmInternetConnectionStatus_Connected;
|
||
#else
|
||
return true;
|
||
#endif
|
||
}
|
||
|
||
void App::confirmGalleryLeave() {
|
||
if (internetConnected()) {
|
||
modal = Modal::None;
|
||
enterGallery();
|
||
} else {
|
||
modal = Modal::GalleryOffline;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
}
|
||
}
|
||
|
||
void App::refreshGallery() {
|
||
if (galleryLoadRunning) return;
|
||
galleryLoadKind = GalleryLoadKind::Feed;
|
||
const std::string path = "/api/flipnotes?page=" + std::to_string(galleryPage) +
|
||
"&sort=" + (galleryPopular ? "popular" : "recent");
|
||
galleryStatus = "Loading Gallery…";
|
||
#ifdef __SWITCH__
|
||
if (galleryLoadThreadCreated) {
|
||
threadWaitForExit(&galleryLoadThread);
|
||
threadClose(&galleryLoadThread);
|
||
galleryLoadThreadCreated = false;
|
||
}
|
||
galleryLoadPath = path;
|
||
galleryLoadFinished.store(false, std::memory_order_relaxed);
|
||
galleryLoadRunning = true;
|
||
galleryLoadResponse.clear();
|
||
galleryLoadError.clear();
|
||
beginLoading();
|
||
if (R_FAILED(threadCreate(&galleryLoadThread, galleryLoadThreadEntry, this, nullptr, 0x10000, 0x3B, -2))) {
|
||
galleryLoadRunning = false;
|
||
endLoading();
|
||
galleryStatus = "Could not start the Gallery connection.";
|
||
showToast(galleryStatus);
|
||
return;
|
||
}
|
||
galleryLoadThreadCreated = true;
|
||
if (R_FAILED(threadStart(&galleryLoadThread))) {
|
||
threadClose(&galleryLoadThread);
|
||
galleryLoadThreadCreated = false;
|
||
galleryLoadRunning = false;
|
||
endLoading();
|
||
galleryStatus = "Could not start the Gallery connection.";
|
||
showToast(galleryStatus);
|
||
}
|
||
#else
|
||
std::vector<std::uint8_t> response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("GET", path, {}, "text/plain", response, status, error)) {
|
||
finishGalleryRefresh(response, status, error);
|
||
return;
|
||
}
|
||
finishGalleryRefresh(response, status, {});
|
||
#endif
|
||
}
|
||
|
||
void App::loadGalleryProfile(const std::string& identity, Screen returnScreen, int pageIndex) {
|
||
if (identity.size() != 64) { showToast("This Gallery user has no profile yet"); return; }
|
||
if (galleryLoadRunning) return;
|
||
if (!galleryProfileActive) {
|
||
galleryBeforeProfile = gallery;
|
||
gallerySelectedBeforeProfile = gallerySelected;
|
||
galleryPageBeforeProfile = galleryPage;
|
||
galleryTotalBeforeProfile = galleryTotal;
|
||
galleryProfileActive = true;
|
||
}
|
||
if (galleryProfile.identity != identity) galleryProfile = GalleryProfileData{};
|
||
galleryProfile.identity = identity;
|
||
galleryProfileReturnScreen = returnScreen;
|
||
galleryProfilePage = std::max(0, pageIndex);
|
||
galleryProfileDetailMode = false;
|
||
galleryProfileIsOwn = identity == sppm::identityFingerprint(signingIdentity.publicIdentity);
|
||
galleryLoadKind = GalleryLoadKind::Profile;
|
||
galleryLoadPath = "/api/profiles/" + identity + "?viewer=" +
|
||
sppm::identityFingerprint(signingIdentity.publicIdentity);
|
||
if (galleryProfilePage > 0) galleryLoadPath += "&page=" + std::to_string(galleryProfilePage - 1);
|
||
gallery.clear();
|
||
screen = Screen::GalleryProfile;
|
||
galleryLoadFinished.store(false, std::memory_order_relaxed);
|
||
galleryLoadRunning = true;
|
||
galleryLoadResponse.clear();
|
||
galleryLoadError.clear();
|
||
beginLoading();
|
||
#ifdef __SWITCH__
|
||
if (galleryLoadThreadCreated) {
|
||
threadWaitForExit(&galleryLoadThread);
|
||
threadClose(&galleryLoadThread);
|
||
galleryLoadThreadCreated = false;
|
||
}
|
||
if (R_FAILED(threadCreate(&galleryLoadThread, galleryLoadThreadEntry, this, nullptr, 0x10000, 0x3B, -2))) {
|
||
galleryLoadRunning = false;
|
||
endLoading();
|
||
galleryStatus = "Could not start the Gallery connection.";
|
||
return;
|
||
}
|
||
galleryLoadThreadCreated = true;
|
||
if (R_FAILED(threadStart(&galleryLoadThread))) {
|
||
threadClose(&galleryLoadThread);
|
||
galleryLoadThreadCreated = false;
|
||
galleryLoadRunning = false;
|
||
endLoading();
|
||
galleryStatus = "Could not start the Gallery connection.";
|
||
}
|
||
#else
|
||
int status = 0;
|
||
std::string error;
|
||
const bool ok = galleryRequest("GET", galleryLoadPath, {}, "text/plain", galleryLoadResponse, status, error);
|
||
galleryLoadRunning = false;
|
||
endLoading();
|
||
finishGalleryProfile(galleryLoadResponse, status, ok ? std::string{} : error);
|
||
#endif
|
||
}
|
||
|
||
void App::leaveGalleryProfile() {
|
||
if (galleryProfileDetailMode) {
|
||
galleryProfileDetailMode = false;
|
||
screen = Screen::GalleryProfile;
|
||
return;
|
||
}
|
||
if (galleryProfileActive) {
|
||
gallery = std::move(galleryBeforeProfile);
|
||
gallerySelected = gallery.empty() ? 0 : std::min(gallerySelectedBeforeProfile, gallery.size() - 1);
|
||
galleryPage = galleryPageBeforeProfile;
|
||
galleryTotal = galleryTotalBeforeProfile;
|
||
galleryProfileActive = false;
|
||
}
|
||
screen = galleryProfileReturnScreen;
|
||
}
|
||
|
||
#ifdef __SWITCH__
|
||
void App::galleryLoadThreadEntry(void* argument) {
|
||
auto* app = static_cast<App*>(argument);
|
||
app->runGalleryLoadThread();
|
||
threadExit();
|
||
}
|
||
|
||
void App::runGalleryLoadThread() {
|
||
galleryLoadSucceeded = galleryRequest("GET", galleryLoadPath, {}, "text/plain",
|
||
galleryLoadResponse, galleryLoadHttpStatus, galleryLoadError);
|
||
galleryLoadFinished.store(true, std::memory_order_release);
|
||
}
|
||
#endif
|
||
|
||
void App::consumeGalleryLoad() {
|
||
#ifdef __SWITCH__
|
||
if (!galleryLoadRunning || !galleryLoadFinished.exchange(false, std::memory_order_acquire)) return;
|
||
if (galleryLoadThreadCreated) {
|
||
threadWaitForExit(&galleryLoadThread);
|
||
threadClose(&galleryLoadThread);
|
||
galleryLoadThreadCreated = false;
|
||
}
|
||
galleryLoadRunning = false;
|
||
endLoading();
|
||
if (galleryLoadKind == GalleryLoadKind::Profile)
|
||
finishGalleryProfile(galleryLoadResponse, galleryLoadHttpStatus,
|
||
galleryLoadSucceeded ? std::string{} : galleryLoadError);
|
||
else finishGalleryRefresh(galleryLoadResponse, galleryLoadHttpStatus,
|
||
galleryLoadSucceeded ? std::string{} : galleryLoadError);
|
||
#endif
|
||
}
|
||
|
||
void App::finishGalleryProfile(const std::vector<std::uint8_t>& response, int status, const std::string& error) {
|
||
(void)status;
|
||
if (!error.empty()) { galleryStatus = error; showToast(error); return; }
|
||
std::string body(response.begin(), response.end());
|
||
if (!body.empty() && body.back() == '\n') body.pop_back();
|
||
std::istringstream lines(body);
|
||
std::string line;
|
||
if (!std::getline(lines, line)) line.clear();
|
||
const auto fields = splitTabs(line);
|
||
if (fields.size() < 11 || fields[0] != "PROFILE") {
|
||
galleryStatus = "Gallery returned an invalid profile.";
|
||
showToast(galleryStatus);
|
||
return;
|
||
}
|
||
galleryProfile.username = percentDecode(fields[1]);
|
||
galleryProfile.bio = percentDecode(fields[2]);
|
||
galleryProfile.switchnotes = std::max(0, std::atoi(fields[3].c_str()));
|
||
galleryProfile.views = std::max(0, std::atoi(fields[4].c_str()));
|
||
galleryProfile.coins = std::max(0, std::atoi(fields[5].c_str()));
|
||
galleryProfile.followers = std::max(0, std::atoi(fields[6].c_str()));
|
||
galleryProfile.following = std::max(0, std::atoi(fields[7].c_str()));
|
||
galleryProfile.followed = fields[8] == "1";
|
||
galleryProfile.blocked = fields[9] == "1";
|
||
if (fields[10].size() < 400U * 1024U) galleryProfile.avatar = base64Decode(fields[10]);
|
||
if (galleryProfileIsOwn) {
|
||
galleryProfile.username = userName;
|
||
galleryProfile.avatar = profileImageBytes;
|
||
}
|
||
galleryProfile.uploads.clear();
|
||
if (galleryProfilePage > 0) {
|
||
bool foundUploads = false;
|
||
while (std::getline(lines, line)) {
|
||
if (!foundUploads) {
|
||
if (line.rfind("UPLOADS\t", 0) == 0) foundUploads = true;
|
||
continue;
|
||
}
|
||
if (!line.empty() && line.back() == '\r') line.pop_back();
|
||
if (line.empty()) continue;
|
||
const auto noteFields = splitTabs(line);
|
||
if (noteFields.size() < 12) continue;
|
||
Item item{};
|
||
item.galleryId = noteFields[0];
|
||
item.title = percentDecode(noteFields[1]);
|
||
item.description = percentDecode(noteFields[2]);
|
||
item.author = percentDecode(noteFields[3]);
|
||
item.fsid = noteFields[4];
|
||
item.rootId = noteFields[5];
|
||
item.currentId = noteFields[6];
|
||
item.modifiedUnixSeconds = static_cast<std::uint64_t>(std::strtoull(noteFields[7].c_str(), nullptr, 10));
|
||
item.coins = std::max(0, std::atoi(noteFields[8].c_str()));
|
||
item.views = std::max(0, std::atoi(noteFields[9].c_str()));
|
||
item.allowSpinoffs = noteFields[10] == "1";
|
||
item.locked = noteFields.size() > 13 && noteFields[13] == "1";
|
||
if (noteFields[11].size() <= 1024U * 1024U) item.previewBytes = base64Decode(noteFields[11]);
|
||
if (noteFields.size() > 12) item.ownerIdentity = noteFields[12];
|
||
galleryProfile.uploads.push_back(std::move(item));
|
||
}
|
||
}
|
||
gallery = galleryProfile.uploads;
|
||
galleryTotal = galleryProfile.switchnotes;
|
||
galleryStatus.clear();
|
||
gallerySelected = gallery.empty() ? 0 : std::min(gallerySelected, gallery.size() - 1);
|
||
if (galleryProfileAvatarTexture) {
|
||
SDL_DestroyTexture(galleryProfileAvatarTexture);
|
||
galleryProfileAvatarTexture = nullptr;
|
||
}
|
||
if (!galleryProfile.avatar.empty() && galleryProfile.avatar.size() <= static_cast<std::size_t>(std::numeric_limits<int>::max())) {
|
||
SDL_RWops* stream = SDL_RWFromConstMem(galleryProfile.avatar.data(), static_cast<int>(galleryProfile.avatar.size()));
|
||
SDL_Surface* surface = stream ? IMG_Load_RW(stream, 1) : nullptr;
|
||
galleryProfileAvatarTexture = surface ? SDL_CreateTextureFromSurface(renderer, surface) : nullptr;
|
||
if (surface) SDL_FreeSurface(surface);
|
||
}
|
||
if (galleryProfileIsOwn && galleryProfilePage == 0) saveGalleryProfile(true);
|
||
}
|
||
|
||
void App::saveGalleryProfile(bool quiet) {
|
||
if (!galleryProfileIsOwn) return;
|
||
std::string body = "username=" + percentEncode(userName) + "&bio=" + percentEncode(galleryProfile.bio) + "&avatar=";
|
||
if (!profileImageBytes.empty()) body += percentEncode(base64Encode(profileImageBytes));
|
||
std::vector<std::uint8_t> request(body.begin(), body.end()), response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("POST", "/api/profiles/update", request, "application/x-www-form-urlencoded", response, status, error) || status < 200 || status >= 300) {
|
||
if (!quiet) showToast(error.empty() ? "Could not save Gallery profile." : error);
|
||
return;
|
||
}
|
||
if (!quiet) showToast("Gallery profile saved");
|
||
}
|
||
|
||
void App::updateGalleryRelationship(const char* action) {
|
||
if (galleryProfileIsOwn || galleryProfile.identity.empty()) return;
|
||
const std::string bodyText = "action=" + std::string(action) + "&target=" + galleryProfile.identity;
|
||
std::vector<std::uint8_t> body(bodyText.begin(), bodyText.end()), response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("POST", "/api/profiles/relationship", body, "application/x-www-form-urlencoded", response, status, error) || status < 200 || status >= 300) {
|
||
if (error.empty()) error.assign(response.begin(), response.end());
|
||
showToast(error.empty() ? "Gallery profile action failed." : error);
|
||
return;
|
||
}
|
||
if (std::string(action) == "follow") { galleryProfile.followed = true; ++galleryProfile.followers; }
|
||
else if (std::string(action) == "unfollow") { galleryProfile.followed = false; galleryProfile.followers = std::max(0, galleryProfile.followers - 1); }
|
||
else if (std::string(action) == "block") { galleryProfile.blocked = true; galleryProfile.followed = false; }
|
||
else if (std::string(action) == "unblock") galleryProfile.blocked = false;
|
||
}
|
||
|
||
void App::finishGalleryRefresh(const std::vector<std::uint8_t>& response, int status, const std::string& error) {
|
||
(void)status;
|
||
if (!error.empty()) {
|
||
gallery.clear();
|
||
galleryTotal = 0;
|
||
galleryStatus = error;
|
||
showToast(error);
|
||
return;
|
||
}
|
||
for (auto it = images.begin(); it != images.end();) {
|
||
if (it->first.rfind("gallery-preview:", 0) == 0) {
|
||
if (it->second) SDL_DestroyTexture(it->second);
|
||
it = images.erase(it);
|
||
} else ++it;
|
||
}
|
||
gallery.clear();
|
||
galleryTotal = 0;
|
||
const std::string textBody(response.begin(), response.end());
|
||
std::istringstream lines(textBody);
|
||
std::string line;
|
||
bool firstLine = true;
|
||
while (std::getline(lines, line)) {
|
||
if (!line.empty() && line.back() == '\r') line.pop_back();
|
||
if (line.empty()) continue;
|
||
if (firstLine) {
|
||
firstLine = false;
|
||
const auto header = splitTabs(line);
|
||
if (header.size() > 1 && header[0] == "TOTAL") galleryTotal = std::max(0, std::atoi(header[1].c_str()));
|
||
continue;
|
||
}
|
||
const auto fields = splitTabs(line);
|
||
if (fields.size() < 12) continue;
|
||
Item item{};
|
||
item.galleryId = fields[0];
|
||
item.title = percentDecode(fields[1]);
|
||
item.description = percentDecode(fields[2]);
|
||
item.author = percentDecode(fields[3]);
|
||
item.fsid = fields[4];
|
||
item.rootId = fields[5];
|
||
item.currentId = fields[6];
|
||
item.modifiedUnixSeconds = static_cast<std::uint64_t>(std::strtoull(fields[7].c_str(), nullptr, 10));
|
||
item.coins = std::max(0, std::atoi(fields[8].c_str()));
|
||
item.views = std::max(0, std::atoi(fields[9].c_str()));
|
||
item.allowSpinoffs = fields[10] == "1";
|
||
if (fields[11].size() <= 1024U * 1024U) item.previewBytes = base64Decode(fields[11]);
|
||
if (fields.size() > 12) item.ownerIdentity = fields[12];
|
||
item.locked = fields.size() > 13 && fields[13] == "1";
|
||
gallery.push_back(std::move(item));
|
||
}
|
||
gallerySelected = gallery.empty() ? 0 : std::min(gallerySelected, gallery.size() - 1);
|
||
galleryCommentsLoaded = false;
|
||
galleryStatus = gallery.empty()
|
||
? (galleryTotal > 0 ? "There are no Switchnotes on this page." : "No Switchnotes have been shared yet.")
|
||
: std::string{};
|
||
if (!galleryTermsAccepted && screen == Screen::Gallery) {
|
||
modal = Modal::GalleryTerms;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
}
|
||
}
|
||
|
||
void App::refreshGalleryComments() {
|
||
galleryComments.clear();
|
||
for (auto& entry : galleryCommentTextures) if (entry.second) SDL_DestroyTexture(entry.second);
|
||
galleryCommentTextures.clear();
|
||
if (gallery.empty()) { galleryCommentsLoaded = true; return; }
|
||
const Item& item = gallery[gallerySelected % gallery.size()];
|
||
std::vector<std::uint8_t> response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("GET", "/api/flipnotes/" + item.galleryId + "/comments", {}, "text/plain", response, status, error)) {
|
||
showToast(error);
|
||
galleryCommentsLoaded = false;
|
||
return;
|
||
}
|
||
std::istringstream lines(std::string(response.begin(), response.end()));
|
||
std::string line;
|
||
bool firstLine = true;
|
||
while (std::getline(lines, line)) {
|
||
if (!line.empty() && line.back() == '\r') line.pop_back();
|
||
if (line.empty()) continue;
|
||
if (firstLine) { firstLine = false; continue; }
|
||
const auto fields = splitTabs(line);
|
||
if (fields.size() < 4) continue;
|
||
GalleryComment comment;
|
||
comment.author = percentDecode(fields[0]);
|
||
comment.text = percentDecode(fields[1]);
|
||
const std::uint64_t created = static_cast<std::uint64_t>(std::strtoull(fields[2].c_str(), nullptr, 10));
|
||
comment.created = dateText(created);
|
||
if (fields[3].size() <= 450U * 1024U) comment.drawing = base64Decode(fields[3]);
|
||
if (comment.drawing.size() != 0 && comment.drawing.size() != sppm::kPixelsPerLayer) comment.drawing.clear();
|
||
galleryComments.push_back(std::move(comment));
|
||
}
|
||
galleryCommentsLoaded = true;
|
||
}
|
||
|
||
void App::openGalleryComments() {
|
||
refreshGalleryComments();
|
||
galleryCommentScroll = 0;
|
||
screen = Screen::GalleryComments;
|
||
}
|
||
|
||
SDL_Texture* App::galleryPreviewTexture(const Item& item) {
|
||
if (item.previewBytes.empty() || item.previewBytes.size() > static_cast<std::size_t>(std::numeric_limits<int>::max())) return nullptr;
|
||
const std::string key = "gallery-preview:" + item.galleryId;
|
||
auto found = images.find(key);
|
||
if (found != images.end()) return found->second;
|
||
SDL_RWops* stream = SDL_RWFromConstMem(item.previewBytes.data(), static_cast<int>(item.previewBytes.size()));
|
||
SDL_Surface* surface = stream ? IMG_Load_RW(stream, 1) : nullptr;
|
||
SDL_Texture* texture = surface ? SDL_CreateTextureFromSurface(renderer, surface) : nullptr;
|
||
if (surface) SDL_FreeSurface(surface);
|
||
if (texture) SDL_SetTextureScaleMode(texture, SDL_ScaleModeLinear);
|
||
else logStartup("gallery preview decode failed: " + std::string(IMG_GetError()));
|
||
images[key] = texture;
|
||
return texture;
|
||
}
|
||
|
||
SDL_Texture* App::galleryCommentTexture(const GalleryComment& comment, std::size_t index) {
|
||
if (comment.drawing.size() != sppm::kPixelsPerLayer) return nullptr;
|
||
const std::string key = "gallery-comment:" + (gallery.empty() ? std::string{} : gallery[gallerySelected % gallery.size()].galleryId) + ":" + std::to_string(index);
|
||
auto found = galleryCommentTextures.find(key);
|
||
if (found != galleryCommentTextures.end()) return found->second;
|
||
SDL_Surface* surface = SDL_CreateRGBSurfaceWithFormat(0, sppm::kWidth, sppm::kHeight, 32, SDL_PIXELFORMAT_RGBA32);
|
||
if (!surface) return nullptr;
|
||
auto* pixels = static_cast<std::uint32_t*>(surface->pixels);
|
||
for (std::size_t i = 0; i < comment.drawing.size(); ++i)
|
||
pixels[i] = comment.drawing[i] ? SDL_MapRGBA(surface->format, 20, 22, 28, 255) : SDL_MapRGBA(surface->format, 0, 0, 0, 0);
|
||
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||
SDL_FreeSurface(surface);
|
||
if (texture) {
|
||
SDL_SetTextureScaleMode(texture, SDL_ScaleModeNearest);
|
||
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
|
||
}
|
||
galleryCommentTextures[key] = texture;
|
||
return texture;
|
||
}
|
||
|
||
void App::publishGalleryItem(std::size_t index) {
|
||
if (index >= library.size()) return;
|
||
pendingGalleryPublishIndex = index;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
modal = Modal::GalleryPostChoice;
|
||
}
|
||
|
||
void App::performGalleryUpload(std::size_t index, bool locked) {
|
||
if (index >= library.size()) return;
|
||
const Item& item = library[index];
|
||
if (item.path.empty()) { showToast("This Switchnote cannot be sent to the Gallery"); return; }
|
||
sppm::Document upload;
|
||
std::string error;
|
||
if (docLoaded && !galleryViewing && docPath == item.path) {
|
||
if (dirty && !saveDocument(true)) return;
|
||
upload = doc;
|
||
} else if (!sppm::loadSignedFile(item.path, upload, signingIdentity.legacyHmacKey, error)) {
|
||
showToast("Could not open Switchnote: " + error);
|
||
return;
|
||
}
|
||
upload.metadata.lastEditorName = userName;
|
||
upload.metadata.lastEditorFsid = myFsid;
|
||
upload.metadata.lastEditorIdentity = signingIdentity.publicIdentity;
|
||
upload.metadata.locked = locked;
|
||
upload.metadata.modifiedUnixSeconds = nowSeconds();
|
||
const std::string tempId = newId("gallery-upload");
|
||
if (tempId.empty()) { showToast("Could not create a secure upload ID"); return; }
|
||
const std::string tempPath = join(dataRoot, ".gallery-upload-" + tempId + ".sppm");
|
||
if (!sppm::savePublicSignedFile(tempPath, upload, signingIdentity, error)) {
|
||
showToast("Could not sign Switchnote for Gallery: " + error);
|
||
return;
|
||
}
|
||
std::ifstream input(tempPath, std::ios::binary | std::ios::ate);
|
||
std::streamoff size = -1;
|
||
if (input) size = static_cast<std::streamoff>(input.tellg());
|
||
if (size <= 0 || static_cast<std::uint64_t>(size) > 64U * 1024U * 1024U) {
|
||
input.close();
|
||
std::remove(tempPath.c_str());
|
||
showToast("Switchnote is too large to send to Gallery");
|
||
return;
|
||
}
|
||
std::vector<std::uint8_t> bytes(static_cast<std::size_t>(size));
|
||
input.seekg(0, std::ios::beg);
|
||
if (!input) { input.close(); std::remove(tempPath.c_str()); showToast("Could not read signed Switchnote"); return; }
|
||
input.read(reinterpret_cast<char*>(bytes.data()), static_cast<std::streamsize>(size));
|
||
const bool readOk = input.gcount() == static_cast<std::streamsize>(bytes.size());
|
||
input.close();
|
||
std::remove(tempPath.c_str());
|
||
if (!readOk) { showToast("Could not read signed Switchnote"); return; }
|
||
std::vector<std::uint8_t> response;
|
||
int status = 0;
|
||
if (!galleryRequest("POST", "/api/flipnotes", bytes, "application/octet-stream", response, status, error)) {
|
||
showToast("Send failed: " + error);
|
||
return;
|
||
}
|
||
showToast("Switchnote sent to Gallery");
|
||
enterGallery();
|
||
}
|
||
|
||
void App::addGalleryCoin() {
|
||
if (gallery.empty()) return;
|
||
Item& item = gallery[gallerySelected % gallery.size()];
|
||
std::vector<std::uint8_t> body, response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("POST", "/api/flipnotes/" + item.galleryId + "/coins", body,
|
||
"application/x-www-form-urlencoded", response, status, error)) {
|
||
showToast(error);
|
||
return;
|
||
}
|
||
item.coins = std::max(0, std::atoi(std::string(response.begin(), response.end()).c_str()));
|
||
showToast("Coin added");
|
||
}
|
||
|
||
void App::deleteGalleryItem() {
|
||
if (gallery.empty()) return;
|
||
const std::string noteId = gallery[gallerySelected % gallery.size()].galleryId;
|
||
std::vector<std::uint8_t> response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("DELETE", "/api/flipnotes/" + noteId, {},
|
||
"application/octet-stream", response, status, error)) {
|
||
showToast("Could not remove Switchnote: " + error);
|
||
modal = Modal::None;
|
||
return;
|
||
}
|
||
modal = Modal::None;
|
||
screen = Screen::Gallery;
|
||
if (galleryTotal > 0) --galleryTotal;
|
||
if (galleryPage > 0 && static_cast<std::size_t>(galleryPage * 6) >= static_cast<std::size_t>(galleryTotal)) --galleryPage;
|
||
galleryStatus = "Loading Gallery…";
|
||
refreshGallery();
|
||
showToast("Switchnote removed from Gallery");
|
||
}
|
||
|
||
void App::postGalleryComment() {
|
||
if (gallery.empty()) return;
|
||
const bool hasDrawing = std::any_of(commentPixels.begin(), commentPixels.end(), [](std::uint8_t value) { return value != 0; });
|
||
if (commentDraft.empty() && !hasDrawing) { showToast("Write or draw a comment first"); return; }
|
||
const Item& item = gallery[gallerySelected % gallery.size()];
|
||
std::string form = "author=" + percentEncode(userName) + "&text=" + percentEncode(commentDraft);
|
||
if (hasDrawing) form += "&drawing=" + base64Encode(commentPixels);
|
||
std::vector<std::uint8_t> body(form.begin(), form.end()), response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("POST", "/api/flipnotes/" + item.galleryId + "/comments", body,
|
||
"application/x-www-form-urlencoded", response, status, error)) {
|
||
showToast("Comment failed: " + error);
|
||
return;
|
||
}
|
||
commentDraft.clear();
|
||
commentPixels.assign(sppm::kPixelsPerLayer, 0);
|
||
commentDirty = true;
|
||
refreshGalleryComments();
|
||
screen = Screen::GalleryComments;
|
||
showToast("Comment posted");
|
||
}
|
||
|
||
void App::openGalleryItem(std::size_t index) {
|
||
if (gallery.empty()) return;
|
||
gallerySelected = index % gallery.size();
|
||
const Item& item = gallery[gallerySelected];
|
||
std::vector<std::uint8_t> bytes;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("GET", "/api/flipnotes/" + item.galleryId + "/file", {}, "application/octet-stream", bytes, status, error)) {
|
||
showToast("Could not download Switchnote: " + error);
|
||
return;
|
||
}
|
||
sppm::Document downloaded;
|
||
if (!sppm::deserializeSigned(bytes, downloaded, signingIdentity.legacyHmacKey, error)) {
|
||
showToast("Gallery Switchnote failed verification: " + error);
|
||
return;
|
||
}
|
||
if (docLoaded && dirty && !galleryViewing && !saveDocument(true)) return;
|
||
stopPlayback();
|
||
doc = std::move(downloaded);
|
||
docLoaded = true;
|
||
docPath.clear();
|
||
galleryViewing = true;
|
||
dirty = false;
|
||
frame = 0;
|
||
zoom = 1.0f;
|
||
panX = panY = 0;
|
||
invalidateFrames();
|
||
rebuildAudio();
|
||
screen = Screen::Viewer;
|
||
}
|
||
|
||
void App::saveGalleryItem(std::size_t index) {
|
||
LoadingScope loading(*this);
|
||
if (index >= gallery.size()) return;
|
||
const Item& item = gallery[index];
|
||
for (const Item& local : library) {
|
||
if ((!item.currentId.empty() && local.currentId == item.currentId) ||
|
||
(!item.fsid.empty() && local.fsid == item.fsid)) {
|
||
showToast("This Switchnote is already saved locally");
|
||
return;
|
||
}
|
||
}
|
||
|
||
std::vector<std::uint8_t> bytes, response;
|
||
int status = 0;
|
||
std::string error;
|
||
if (!galleryRequest("GET", "/api/flipnotes/" + item.galleryId + "/file", {},
|
||
"application/octet-stream", bytes, status, error)) {
|
||
showToast("Could not save Switchnote: " + error);
|
||
return;
|
||
}
|
||
sppm::Document verified;
|
||
if (!sppm::deserializeSigned(bytes, verified, signingIdentity.legacyHmacKey, error)) {
|
||
showToast("Gallery Switchnote failed verification: " + error);
|
||
return;
|
||
}
|
||
|
||
const std::string directory = join(notesRoot, folder);
|
||
ensureDir(directory);
|
||
const std::string saveId = newId("gallery-save");
|
||
if (saveId.empty()) { showToast("Could not create a secure local filename"); return; }
|
||
const std::string destination = join(directory, saveId + ".sppm");
|
||
const std::string temporary = destination + ".saving";
|
||
std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
|
||
if (!output) { showToast("Could not save Switchnote to the SD card"); return; }
|
||
output.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
|
||
output.flush();
|
||
const bool written = static_cast<bool>(output);
|
||
output.close();
|
||
if (!written || std::rename(temporary.c_str(), destination.c_str()) != 0) {
|
||
std::remove(temporary.c_str());
|
||
showToast("Could not save Switchnote to the SD card");
|
||
return;
|
||
}
|
||
scanLibrary();
|
||
showToast(verified.metadata.locked ? "Locked Switchnote saved locally (read-only)" : "Switchnote saved locally");
|
||
}
|
||
|
||
void App::poll() {
|
||
pointerPressed = false;
|
||
pointerReleased = false;
|
||
touchHoverExpiryPending = false;
|
||
clickConsumed = false;
|
||
buttonsDown = 0;
|
||
buttonsUp = 0;
|
||
wheel = 0;
|
||
const auto canvasControlAt = [&](int x, int y) {
|
||
if (screen != Screen::Canvas || canvasChromeVisible < 0.999f) return false;
|
||
if (paintMenu || colorMenu || toolMenu) return true;
|
||
const int menuX = 154;
|
||
const int menuY = 635 + static_cast<int>(std::lround((1.0f - canvasMenuProgress) * 95.0f));
|
||
return (x >= 20 && x < 164 && y >= 18 && y < 72) ||
|
||
(x >= 20 && x < 92 && y >= 238 && y < 498) ||
|
||
(x >= 1200 && x < 1260 && y >= 12 && y < 212) ||
|
||
(x >= 20 && x < 164 && y >= 635 && y < 697) ||
|
||
(canvasMenuProgress > 0.0f && x >= menuX && x < menuX + 310 && y >= menuY - 9 && y < menuY + 71) ||
|
||
(x >= 474 && x < 800 && y >= 635 && y < 700) ||
|
||
(x >= 904 && x < 1230 && y >= 635 && y < 700);
|
||
};
|
||
const auto closeCanvasMenuOnOutsidePress = [&](int x, int y) {
|
||
if (screen != Screen::Canvas || !canvasMenuOpen) return;
|
||
const int menuX = 154;
|
||
const int menuY = 635 + static_cast<int>(std::lround((1.0f - canvasMenuProgress) * 95.0f));
|
||
const bool onToggle = x >= 92 && x < 156 && y >= 635 && y < 697;
|
||
const bool onPopup = canvasMenuProgress > 0.0f && x >= menuX && x < menuX + 310 && y >= menuY - 9 && y < menuY + 71;
|
||
if (!onToggle && !onPopup) canvasMenuOpen = false;
|
||
};
|
||
SDL_Event event;
|
||
while (SDL_PollEvent(&event)) {
|
||
switch (event.type) {
|
||
case SDL_QUIT: running = false; break;
|
||
case SDL_CONTROLLERDEVICEADDED:
|
||
if (!controller && SDL_IsGameController(event.cdevice.which)) controller = SDL_GameControllerOpen(event.cdevice.which);
|
||
break;
|
||
case SDL_CONTROLLERDEVICEREMOVED:
|
||
if (controller && SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(controller)) == event.cdevice.which) {
|
||
SDL_GameControllerClose(controller);
|
||
controller = nullptr;
|
||
}
|
||
break;
|
||
case SDL_CONTROLLERBUTTONDOWN: {
|
||
const auto bit = controllerBit(event.cbutton.button);
|
||
buttonsDown |= bit;
|
||
buttonsHeld |= bit;
|
||
break;
|
||
}
|
||
case SDL_CONTROLLERBUTTONUP: {
|
||
const auto bit = controllerBit(event.cbutton.button);
|
||
buttonsHeld &= ~bit;
|
||
buttonsUp |= bit;
|
||
break;
|
||
}
|
||
case SDL_KEYDOWN: {
|
||
if (event.key.repeat) break;
|
||
if (modal == Modal::TextInput) {
|
||
if (event.key.keysym.sym == SDLK_BACKSPACE && !inputText.empty()) inputText.pop_back();
|
||
else if (event.key.keysym.sym == SDLK_RETURN) applyText();
|
||
else if (event.key.keysym.sym == SDLK_ESCAPE) { modal = Modal::None; SDL_StopTextInput(); }
|
||
break;
|
||
}
|
||
std::uint32_t bit = 0;
|
||
switch (event.key.keysym.sym) {
|
||
case SDLK_RETURN: case SDLK_SPACE: case SDLK_a: bit = BA; break;
|
||
case SDLK_ESCAPE: case SDLK_b: bit = BB; break;
|
||
case SDLK_x: bit = BX; break;
|
||
case SDLK_y: bit = BY; break;
|
||
case SDLK_l: bit = BL; break;
|
||
case SDLK_r: bit = BR; break;
|
||
case SDLK_q: bit = BZL; break;
|
||
case SDLK_e: bit = BZR; break;
|
||
case SDLK_LEFT: bit = BLEFT; break;
|
||
case SDLK_RIGHT: bit = BRIGHT; break;
|
||
case SDLK_UP: bit = BUP; break;
|
||
case SDLK_DOWN: bit = BDOWN; break;
|
||
case SDLK_EQUALS: bit = BPLUS; break;
|
||
case SDLK_MINUS: bit = BMINUS; break;
|
||
default: break;
|
||
}
|
||
buttonsDown |= bit;
|
||
buttonsHeld |= bit;
|
||
break;
|
||
}
|
||
case SDL_KEYUP: {
|
||
std::uint32_t bit = 0;
|
||
switch (event.key.keysym.sym) {
|
||
case SDLK_RETURN: case SDLK_SPACE: case SDLK_a: bit = BA; break;
|
||
case SDLK_ESCAPE: case SDLK_b: bit = BB; break;
|
||
case SDLK_x: bit = BX; break;
|
||
case SDLK_y: bit = BY; break;
|
||
case SDLK_l: bit = BL; break;
|
||
case SDLK_r: bit = BR; break;
|
||
case SDLK_q: bit = BZL; break;
|
||
case SDLK_e: bit = BZR; break;
|
||
case SDLK_LEFT: bit = BLEFT; break;
|
||
case SDLK_RIGHT: bit = BRIGHT; break;
|
||
case SDLK_UP: bit = BUP; break;
|
||
case SDLK_DOWN: bit = BDOWN; break;
|
||
case SDLK_EQUALS: bit = BPLUS; break;
|
||
case SDLK_MINUS: bit = BMINUS; break;
|
||
default: break;
|
||
}
|
||
buttonsHeld &= ~bit;
|
||
buttonsUp |= bit;
|
||
break;
|
||
}
|
||
case SDL_TEXTINPUT:
|
||
if (modal == Modal::TextInput && inputText.size() < 240) inputText += event.text.text;
|
||
break;
|
||
case SDL_MOUSEMOTION:
|
||
if (event.motion.which != SDL_TOUCH_MOUSEID) { pointerX = event.motion.x; pointerY = event.motion.y; }
|
||
break;
|
||
case SDL_MOUSEBUTTONDOWN:
|
||
if (event.button.which != SDL_TOUCH_MOUSEID && event.button.button == SDL_BUTTON_LEFT) {
|
||
pointerX = event.button.x; pointerY = event.button.y; pointerDown = pointerPressed = true; hasLastStroke = false;
|
||
closeCanvasMenuOnOutsidePress(pointerX, pointerY);
|
||
canvasControlGesture = canvasControlAt(pointerX, pointerY);
|
||
const bool inkSurface = (screen == Screen::Canvas && !canvasControlGesture) ||
|
||
(screen == Screen::CommentCanvas && pointerY >= 72 && pointerY < 620);
|
||
if (!inkSurface) playEvent("ui_button_down", "none");
|
||
}
|
||
break;
|
||
case SDL_MOUSEBUTTONUP:
|
||
if (event.button.which != SDL_TOUCH_MOUSEID && event.button.button == SDL_BUTTON_LEFT) {
|
||
pointerX = event.button.x; pointerY = event.button.y; pointerDown = false; pointerReleased = true;
|
||
const bool inkSurface = (screen == Screen::Canvas && !canvasControlGesture) ||
|
||
(screen == Screen::CommentCanvas && pointerY >= 72 && pointerY < 620);
|
||
if (!inkSurface) playEvent("ui_button_up", "none");
|
||
}
|
||
break;
|
||
case SDL_FINGERDOWN:
|
||
pointerX = static_cast<int>(event.tfinger.x * W); pointerY = static_cast<int>(event.tfinger.y * H);
|
||
pointerDown = pointerPressed = true; hasLastStroke = false;
|
||
closeCanvasMenuOnOutsidePress(pointerX, pointerY);
|
||
canvasControlGesture = canvasControlAt(pointerX, pointerY);
|
||
if (!(screen == Screen::Canvas && !canvasControlGesture) &&
|
||
!(screen == Screen::CommentCanvas && pointerY >= 72 && pointerY < 620)) playEvent("ui_button_down", "none");
|
||
break;
|
||
case SDL_FINGERMOTION:
|
||
pointerX = static_cast<int>(event.tfinger.x * W); pointerY = static_cast<int>(event.tfinger.y * H);
|
||
break;
|
||
case SDL_FINGERUP:
|
||
pointerX = static_cast<int>(event.tfinger.x * W); pointerY = static_cast<int>(event.tfinger.y * H);
|
||
pointerDown = false; pointerReleased = true;
|
||
touchHoverExpiryPending = true;
|
||
if (!(screen == Screen::Canvas && !canvasControlGesture) &&
|
||
!(screen == Screen::CommentCanvas && pointerY >= 72 && pointerY < 620)) playEvent("ui_button_up", "none");
|
||
break;
|
||
case SDL_MOUSEWHEEL: wheel += event.wheel.y; break;
|
||
default: break;
|
||
}
|
||
}
|
||
if (controller) {
|
||
const std::uint32_t previousHeld = buttonsHeld;
|
||
const bool zl = SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERLEFT) > 16000;
|
||
const bool zr = SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT) > 16000;
|
||
if (zl && !(buttonsHeld & BZL)) buttonsDown |= BZL;
|
||
if (zr && !(buttonsHeld & BZR)) buttonsDown |= BZR;
|
||
if (!zl && (previousHeld & BZL)) buttonsUp |= BZL;
|
||
if (!zr && (previousHeld & BZR)) buttonsUp |= BZR;
|
||
buttonsHeld = (buttonsHeld & ~(BZL | BZR)) |
|
||
(zl ? static_cast<std::uint32_t>(BZL) : 0u) |
|
||
(zr ? static_cast<std::uint32_t>(BZR) : 0u);
|
||
const auto normalizedStick = [](Sint16 value) {
|
||
constexpr float deadZone = 0.18f;
|
||
const float normalized = value < 0 ? value / 32768.0f : value / 32767.0f;
|
||
if (std::abs(normalized) <= deadZone) return 0.0f;
|
||
return (normalized - (normalized < 0.0f ? -deadZone : deadZone)) / (1.0f - deadZone);
|
||
};
|
||
leftStickX = normalizedStick(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTX));
|
||
leftStickY = normalizedStick(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTY));
|
||
} else {
|
||
leftStickX = leftStickY = 0.0f;
|
||
}
|
||
const std::array<std::pair<std::uint32_t, const char*>, 17> inputButtons{{
|
||
{BA, "a"}, {BB, "b"}, {BX, "x"}, {BY, "y"}, {BL, "l"}, {BR, "r"},
|
||
{BZL, "zl"}, {BZR, "zr"}, {BLEFT, "left"}, {BRIGHT, "right"},
|
||
{BUP, "up"}, {BDOWN, "down"}, {BPLUS, "plus"}, {BMINUS, "minus"},
|
||
{BLS, "ls"}, {BRS, "rs"}, {BMISC, "misc"}
|
||
}};
|
||
for (const auto& button : inputButtons) {
|
||
if (buttonsDown & button.first) playEvent(std::string("button_") + button.second + "_down", "none");
|
||
if (buttonsUp & button.first) playEvent(std::string("button_") + button.second + "_up", "none");
|
||
}
|
||
}
|
||
|
||
void App::showToast(const std::string& message) {
|
||
toast = message;
|
||
toastUntil = SDL_GetTicks() + 2500;
|
||
}
|
||
|
||
void App::loadPreferences() {
|
||
std::ifstream in(join(dataRoot, "preferences.ini"));
|
||
int storedFps = defaultFps;
|
||
int storedOnion = onion ? 1 : 0;
|
||
int storedGrid = canvasGrid ? 1 : 0;
|
||
int storedCopy = copyToNewPage ? 1 : 0;
|
||
int storedStabilisation = penStabilisationEnabled ? 1 : 0;
|
||
int storedAfter = penStabilisationAfter ? 1 : 0;
|
||
int storedStrength = penStabilisationStrength;
|
||
if (in >> storedFps >> storedOnion >> storedGrid) {
|
||
defaultFps = std::clamp(storedFps, 1, 30);
|
||
defaultSpeed = speedFromFps(defaultFps);
|
||
onion = storedOnion != 0;
|
||
canvasGrid = storedGrid != 0;
|
||
if (in >> storedCopy) {
|
||
copyToNewPage = storedCopy != 0;
|
||
if (in >> storedStabilisation >> storedAfter >> storedStrength) {
|
||
penStabilisationEnabled = storedStabilisation != 0;
|
||
penStabilisationAfter = storedAfter != 0;
|
||
penStabilisationStrength = std::clamp(storedStrength, 0, 100);
|
||
}
|
||
}
|
||
int storedSpeed = 0;
|
||
if (in >> storedSpeed) {
|
||
if (storedSpeed >= 1 && storedSpeed <= 8) defaultSpeed = storedSpeed;
|
||
}
|
||
}
|
||
std::ifstream branding(join(dataRoot, "branding.ini"), std::ios::binary);
|
||
std::string line;
|
||
if (branding && std::getline(branding, line) && !line.empty() && line.size() <= 40) appDisplayName = line;
|
||
if (branding && std::getline(branding, line) && !line.empty() && line.size() <= 24) noteSingular = line;
|
||
if (branding && std::getline(branding, line) && !line.empty() && line.size() <= 24) notePlural = line;
|
||
const std::string savedLogo = join(dataRoot, "branding-logo.png");
|
||
std::ifstream logo(savedLogo, std::ios::binary);
|
||
if (logo) brandingLogoPath = savedLogo;
|
||
std::ifstream galleryTerms(join(dataRoot, "gallery-terms-accepted"), std::ios::binary);
|
||
galleryTermsAccepted = static_cast<bool>(galleryTerms);
|
||
}
|
||
|
||
bool App::startBrandingConfigServer() {
|
||
#ifdef __SWITCH__
|
||
if (brandingConfigServer.isRunning()) return true;
|
||
if (!gallerySocketsReady) {
|
||
const Result sockets = socketInitializeDefault();
|
||
if (R_FAILED(sockets)) { brandingStatus = "Network initialization failed."; return false; }
|
||
gallerySocketsReady = true;
|
||
}
|
||
if (!nifmReady) {
|
||
const Result network = nifmInitialize(NifmServiceType_User);
|
||
if (R_FAILED(network)) { brandingStatus = "Could not read the Switch network address."; return false; }
|
||
nifmReady = true;
|
||
}
|
||
u32 rawAddress = 0;
|
||
if (R_FAILED(nifmGetCurrentIpAddress(&rawAddress))) { brandingStatus = "Connect the Switch to local Wi-Fi first."; return false; }
|
||
const std::uint32_t hostAddress = ntohl(rawAddress);
|
||
const bool privateAddress = (hostAddress >> 24) == 10 || (hostAddress & 0xfff00000U) == 0xac100000U ||
|
||
(hostAddress & 0xffff0000U) == 0xc0a80000U || (hostAddress & 0xffff0000U) == 0xa9fe0000U ||
|
||
(hostAddress & 0xffc00000U) == 0x64400000U;
|
||
if (!privateAddress) { brandingStatus = "Connect to a private local network to use the portal."; return false; }
|
||
in_addr address{}; address.s_addr = rawAddress; char addressText[INET_ADDRSTRLEN]{};
|
||
if (!::inet_ntop(AF_INET, &address, addressText, sizeof(addressText))) { brandingStatus = "Could not format the Switch address."; return false; }
|
||
std::uint32_t randomValue = 0;
|
||
do { if (!randomBytes(&randomValue, sizeof(randomValue))) { brandingStatus = "Could not create a secure connection code."; return false; } }
|
||
while (randomValue >= 4294000000U);
|
||
const unsigned int pin = randomValue % 1000000U; char formattedCode[8]{};
|
||
std::snprintf(formattedCode, sizeof(formattedCode), "%03u-%03u", pin / 1000U, pin % 1000U);
|
||
std::string error;
|
||
if (!brandingConfigServer.start(addressText, dataRoot, assetsRoot, formattedCode, error,
|
||
appDisplayName, noteSingular, notePlural)) {
|
||
brandingStatus = error.empty() ? "Could not start the branding portal." : error; return false;
|
||
}
|
||
brandingCode = formattedCode; brandingUrl = "http://" + std::string(addressText) + ":8767";
|
||
brandingStatus = "Enter the code on your PC."; return true;
|
||
#else
|
||
brandingStatus = "The branding portal is available in the Switch homebrew app."; return false;
|
||
#endif
|
||
}
|
||
|
||
void App::stopBrandingConfigServer() {
|
||
brandingConfigServer.stop(); brandingUrl.clear(); brandingCode.clear();
|
||
}
|
||
|
||
void App::closeBrandingMenu() {
|
||
stopBrandingConfigServer(); modal = Modal::None;
|
||
}
|
||
|
||
void App::consumeBrandingConfig() {
|
||
if (!brandingConfigServer.takeConfigUpdate()) return;
|
||
const std::string configPath = join(dataRoot, "branding.ini");
|
||
std::ifstream in(configPath, std::ios::binary); std::string app, singular, plural;
|
||
if (!in || !std::getline(in, app) || !std::getline(in, singular) || !std::getline(in, plural)) {
|
||
brandingStatus = "Branding file could not be loaded."; return;
|
||
}
|
||
if (app.empty() || app.size() > 40 || singular.empty() || singular.size() > 24 || plural.empty() || plural.size() > 24) {
|
||
brandingStatus = "Branding values are invalid."; return;
|
||
}
|
||
const std::string pending = join(dataRoot, "branding-logo.pending");
|
||
std::ifstream logo(pending, std::ios::binary);
|
||
if (logo) {
|
||
logo.close();
|
||
SDL_Texture* validationTexture = loadBrandingLogo(pending);
|
||
if (!validationTexture) { brandingStatus = "The uploaded logo could not be decoded."; showToast(brandingStatus); return; }
|
||
SDL_DestroyTexture(validationTexture);
|
||
const std::string destination = join(dataRoot, "branding-logo.png");
|
||
// FAT/SD rename replacement is unreliable on Switch. The pending
|
||
// upload has already been decoded successfully, so copy it into the
|
||
// stable logo path and verify the completed file before accepting it.
|
||
std::ifstream uploaded(pending, std::ios::binary | std::ios::ate);
|
||
if (!uploaded) { brandingStatus = "The uploaded logo could not be opened."; showToast(brandingStatus); return; }
|
||
const std::streamoff logoSize = uploaded.tellg();
|
||
if (logoSize <= 0 || logoSize > 8 * 1024 * 1024) { brandingStatus = "The uploaded logo has an invalid size."; showToast(brandingStatus); return; }
|
||
std::vector<char> logoBytes(static_cast<std::size_t>(logoSize));
|
||
uploaded.seekg(0, std::ios::beg);
|
||
uploaded.read(logoBytes.data(), static_cast<std::streamsize>(logoBytes.size()));
|
||
if (!uploaded) { brandingStatus = "The uploaded logo could not be read."; showToast(brandingStatus); return; }
|
||
uploaded.close();
|
||
std::ofstream savedLogo(destination, std::ios::binary | std::ios::trunc);
|
||
if (!savedLogo) { brandingStatus = "The title logo could not be opened on the SD card."; showToast(brandingStatus); return; }
|
||
savedLogo.write(logoBytes.data(), static_cast<std::streamsize>(logoBytes.size()));
|
||
savedLogo.flush();
|
||
if (!savedLogo) { savedLogo.close(); brandingStatus = "The title logo could not be written to the SD card."; showToast(brandingStatus); return; }
|
||
savedLogo.close();
|
||
SDL_Texture* savedValidation = savedLogo ? loadBrandingLogo(destination) : nullptr;
|
||
if (savedValidation) SDL_DestroyTexture(savedValidation);
|
||
if (!savedLogo || !savedValidation) {
|
||
brandingStatus = "The title logo could not be verified after saving."; showToast(brandingStatus); return;
|
||
}
|
||
std::remove(pending.c_str());
|
||
brandingLogoPath = destination;
|
||
}
|
||
bool hasLoadingUpload = false;
|
||
for (std::size_t i = 0; i < loadingFrogFrames.size(); ++i) {
|
||
const std::string pendingFrame = join(dataRoot, "branding-loading" + std::to_string(i) + ".pending");
|
||
std::ifstream pending(pendingFrame, std::ios::binary | std::ios::ate);
|
||
if (!pending) continue;
|
||
hasLoadingUpload = true;
|
||
const std::streamoff length = pending.tellg();
|
||
if (length <= 8 || length > 128 * 1024) { brandingStatus = "A loading frame has an invalid size."; showToast(brandingStatus); return; }
|
||
pending.close();
|
||
SDL_Texture* check = loadBrandingLogo(pendingFrame);
|
||
if (!check) { brandingStatus = "A loading frame could not be decoded."; showToast(brandingStatus); return; }
|
||
int frameW = 0, frameH = 0;
|
||
SDL_QueryTexture(check, nullptr, nullptr, &frameW, &frameH);
|
||
SDL_DestroyTexture(check);
|
||
if (frameW != 64 || frameH != 64) { brandingStatus = "Loading frames must be 64 by 64 pixels."; showToast(brandingStatus); return; }
|
||
}
|
||
if (hasLoadingUpload) {
|
||
for (std::size_t i = 0; i < loadingFrogFrames.size(); ++i) {
|
||
const std::string pendingFrame = join(dataRoot, "branding-loading" + std::to_string(i) + ".pending");
|
||
std::ifstream inFrame(pendingFrame, std::ios::binary | std::ios::ate);
|
||
if (!inFrame) { brandingStatus = "The loading animation upload is incomplete."; showToast(brandingStatus); return; }
|
||
const std::streamoff length = inFrame.tellg();
|
||
std::vector<char> frameBytes(static_cast<std::size_t>(length));
|
||
inFrame.seekg(0); inFrame.read(frameBytes.data(), length);
|
||
if (!inFrame) { brandingStatus = "Could not read the loading animation."; showToast(brandingStatus); return; }
|
||
const std::string destination = join(dataRoot, "branding-loading" + std::to_string(i) + ".png");
|
||
std::ofstream outFrame(destination, std::ios::binary | std::ios::trunc);
|
||
if (!outFrame) { brandingStatus = "Could not open a loading frame on the SD card."; showToast(brandingStatus); return; }
|
||
outFrame.write(frameBytes.data(), static_cast<std::streamsize>(frameBytes.size()));
|
||
outFrame.close();
|
||
SDL_Texture* replacement = loadBrandingLogo(destination);
|
||
if (!outFrame || !replacement) { if (replacement) SDL_DestroyTexture(replacement); brandingStatus = "Could not save the loading animation."; showToast(brandingStatus); return; }
|
||
if (loadingFrogFrames[i]) SDL_DestroyTexture(loadingFrogFrames[i]);
|
||
loadingFrogFrames[i] = replacement;
|
||
std::remove(pendingFrame.c_str());
|
||
}
|
||
}
|
||
brandingStatus = "Branding saved. Restart the app for changes to apply.";
|
||
if (modal == Modal::Branding) showToast(brandingStatus);
|
||
}
|
||
|
||
void App::exportBrandingConfig() {
|
||
branding::Bundle bundle;
|
||
bundle.app = appDisplayName; bundle.singular = noteSingular; bundle.plural = notePlural;
|
||
const std::string logoPath = brandingLogoPath.empty()
|
||
? join(assetsRoot, "art/switchnotedefault.png") : brandingLogoPath;
|
||
std::ifstream logo(logoPath, std::ios::binary | std::ios::ate);
|
||
if (!logo) { showToast("Could not read the current title logo"); return; }
|
||
const std::streamoff size = logo.tellg();
|
||
if (size <= 0 || size > 8 * 1024 * 1024) { showToast("The current title logo has an invalid size"); return; }
|
||
bundle.logo.resize(static_cast<std::size_t>(size)); logo.seekg(0);
|
||
logo.read(reinterpret_cast<char*>(bundle.logo.data()), size);
|
||
if (!logo) { showToast("Could not read the current title logo"); return; }
|
||
const std::string directory = join(dataRoot, "exports");
|
||
mkdir(directory.c_str(), 0777);
|
||
std::string error;
|
||
if (!branding::writeConfig(join(directory, "branding.config"), bundle, error)) { showToast(error); return; }
|
||
showToast("Branding exported to exports/branding.config");
|
||
}
|
||
|
||
void App::importBrandingConfig() {
|
||
branding::Bundle bundle;
|
||
std::string error;
|
||
if (!branding::readConfig(join(dataRoot, "branding.config"), bundle, error)) { showToast(error); return; }
|
||
const std::string staging = join(dataRoot, "branding-logo.import");
|
||
{
|
||
std::ofstream image(staging, std::ios::binary | std::ios::trunc);
|
||
if (!image) { showToast("Could not stage the imported logo"); return; }
|
||
image.write(reinterpret_cast<const char*>(bundle.logo.data()), static_cast<std::streamsize>(bundle.logo.size()));
|
||
image.flush();
|
||
if (!image) { image.close(); std::remove(staging.c_str()); showToast("Could not write the imported logo"); return; }
|
||
}
|
||
SDL_Texture* validation = loadBrandingLogo(staging);
|
||
if (!validation) { std::remove(staging.c_str()); showToast("The imported logo is not a valid image"); return; }
|
||
SDL_DestroyTexture(validation);
|
||
const std::string configPath = join(dataRoot, "branding.ini");
|
||
std::ofstream config(configPath, std::ios::binary | std::ios::trunc);
|
||
if (!config) { std::remove(staging.c_str()); showToast("Could not save imported branding"); return; }
|
||
config << bundle.app << '\n' << bundle.singular << '\n' << bundle.plural << '\n';
|
||
config.flush();
|
||
if (!config) { config.close(); std::remove(staging.c_str()); showToast("Could not save imported branding"); return; }
|
||
config.close();
|
||
const std::string logoPath = join(dataRoot, "branding-logo.png");
|
||
std::ifstream src(staging, std::ios::binary);
|
||
std::ofstream dst(logoPath, std::ios::binary | std::ios::trunc);
|
||
dst << src.rdbuf(); dst.flush();
|
||
const bool logoSaved = static_cast<bool>(src) && static_cast<bool>(dst);
|
||
dst.close(); src.close(); std::remove(staging.c_str());
|
||
if (!logoSaved) { showToast("Branding was loaded, but the title logo could not be saved"); return; }
|
||
brandingStatus = "Branding imported. Restart the app for changes to apply.";
|
||
showToast(brandingStatus);
|
||
}
|
||
|
||
void App::savePreferences() {
|
||
std::ofstream out(join(dataRoot, "preferences.ini"), std::ios::trunc);
|
||
if (out) {
|
||
out << defaultFps << ' ' << (onion ? 1 : 0) << ' ' << (canvasGrid ? 1 : 0) << ' '
|
||
<< (copyToNewPage ? 1 : 0) << ' ' << (penStabilisationEnabled ? 1 : 0) << ' '
|
||
<< (penStabilisationAfter ? 1 : 0) << ' ' << penStabilisationStrength << ' ' << defaultSpeed << '\n';
|
||
}
|
||
}
|
||
|
||
void App::playCue(const std::string& name) {
|
||
playEvent("ui_action", name);
|
||
}
|
||
|
||
void App::playEvent(const std::string& event, const std::string& defaultCue) {
|
||
std::string cue = defaultCue;
|
||
if (event == "ui_button_down" || (event.rfind("button_", 0) == 0 && endsWith(event, "_down"))) cue = "button_on";
|
||
else if (event == "ui_button_up" || (event.rfind("button_", 0) == 0 && endsWith(event, "_up"))) cue = "button_off";
|
||
else if (event == "frame_previous") cue = "page_backward";
|
||
else if (event == "frame_next") cue = "page_forward";
|
||
else if (event == "frame_first") cue = "page_first";
|
||
else if (event == "frame_last") cue = "page_end";
|
||
else if (event == "frame_copy") cue = "edit_page_copy";
|
||
else if (event == "frame_paste") cue = "edit_page_paste";
|
||
else if (event == "frame_erase") cue = "edit_page_remove";
|
||
else if (event == "tool_color") cue = "popup_select";
|
||
if (cue.empty() || cue == "none") return;
|
||
if (!audioReady) return;
|
||
auto found = cues.find(cue);
|
||
if (found == cues.end() || !found->second) return;
|
||
const int channel = cue == "button_on" ? 50 : cue == "button_off" ? 51 : 15;
|
||
Mix_HaltChannel(channel);
|
||
Mix_PlayChannel(channel, found->second, 0);
|
||
}
|
||
|
||
SDL_Texture* App::image(const std::string& relative) {
|
||
auto found = images.find(relative);
|
||
if (found != images.end()) return found->second;
|
||
const std::string path = join(assetsRoot, relative);
|
||
SDL_Texture* tex = nullptr;
|
||
if (endsWith(relative, ".svg")) {
|
||
SDL_RWops* source = SDL_RWFromFile(path.c_str(), "rb");
|
||
SDL_Surface* surface = source ? IMG_LoadSVG_RW(source) : nullptr;
|
||
if (source) SDL_RWclose(source);
|
||
if (surface) {
|
||
tex = SDL_CreateTextureFromSurface(renderer, surface);
|
||
SDL_FreeSurface(surface);
|
||
}
|
||
} else tex = IMG_LoadTexture(renderer, path.c_str());
|
||
if (tex && relative.find("art/") == 0) SDL_SetTextureScaleMode(tex, SDL_ScaleModeNearest);
|
||
if (!tex) logStartup("asset load failed: " + path + " :: " + IMG_GetError());
|
||
images[relative] = tex;
|
||
return tex;
|
||
}
|
||
|
||
SDL_Texture* App::whiteImage(const std::string& relative) {
|
||
auto found = whiteImages.find(relative);
|
||
if (found != whiteImages.end()) return found->second;
|
||
const std::string path = join(assetsRoot, relative);
|
||
SDL_Surface* source = nullptr;
|
||
if (endsWith(relative, ".svg")) {
|
||
SDL_RWops* stream = SDL_RWFromFile(path.c_str(), "rb");
|
||
source = stream ? IMG_LoadSVG_RW(stream) : nullptr;
|
||
if (stream) SDL_RWclose(stream);
|
||
} else source = IMG_Load(path.c_str());
|
||
if (!source) {
|
||
logStartup("white icon load failed: " + path + " :: " + IMG_GetError());
|
||
whiteImages[relative] = nullptr;
|
||
return nullptr;
|
||
}
|
||
SDL_Surface* rgba = SDL_ConvertSurfaceFormat(source, SDL_PIXELFORMAT_RGBA32, 0);
|
||
SDL_FreeSurface(source);
|
||
if (!rgba) {
|
||
whiteImages[relative] = nullptr;
|
||
return nullptr;
|
||
}
|
||
if (SDL_MUSTLOCK(rgba)) SDL_LockSurface(rgba);
|
||
for (int y = 0; y < rgba->h; ++y) {
|
||
auto* row = reinterpret_cast<Uint32*>(static_cast<Uint8*>(rgba->pixels) + y * rgba->pitch);
|
||
for (int x = 0; x < rgba->w; ++x) {
|
||
Uint8 r, g, b, a;
|
||
SDL_GetRGBA(row[x], rgba->format, &r, &g, &b, &a);
|
||
row[x] = SDL_MapRGBA(rgba->format, 255, 255, 255, a);
|
||
}
|
||
}
|
||
if (SDL_MUSTLOCK(rgba)) SDL_UnlockSurface(rgba);
|
||
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, rgba);
|
||
SDL_FreeSurface(rgba);
|
||
if (texture) SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
|
||
whiteImages[relative] = texture;
|
||
return texture;
|
||
}
|
||
|
||
SDL_Texture* App::loadBrandingLogo(const std::string& path) {
|
||
std::ifstream file(path, std::ios::binary | std::ios::ate);
|
||
if (!file) return nullptr;
|
||
const std::streamoff length = file.tellg();
|
||
if (length < 8 || length > 8 * 1024 * 1024 || length > std::numeric_limits<int>::max()) return nullptr;
|
||
std::vector<Uint8> bytes(static_cast<std::size_t>(length));
|
||
file.seekg(0, std::ios::beg);
|
||
if (!file.read(reinterpret_cast<char*>(bytes.data()), length)) return nullptr;
|
||
file.close();
|
||
SDL_RWops* stream = SDL_RWFromConstMem(bytes.data(), static_cast<int>(bytes.size()));
|
||
SDL_Surface* surface = stream ? IMG_Load_RW(stream, 1) : nullptr;
|
||
if (!surface) return nullptr;
|
||
if (surface->w <= 0 || surface->h <= 0 || surface->w > 8192 || surface->h > 8192) {
|
||
SDL_FreeSurface(surface);
|
||
return nullptr;
|
||
}
|
||
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||
SDL_FreeSurface(surface);
|
||
if (texture) SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
|
||
return texture;
|
||
}
|
||
|
||
void App::drawTexture(SDL_Texture* texture, int x, int y, int w, int h) {
|
||
if (!texture || w <= 0 || h <= 0) return;
|
||
SDL_Rect dest{x, y, w, h};
|
||
SDL_RenderCopy(renderer, texture, nullptr, &dest);
|
||
}
|
||
|
||
void App::drawImage(const std::string& relative, int x, int y, int w, int h, bool nearest) {
|
||
SDL_Texture* tex = image(relative);
|
||
if (tex && nearest) SDL_SetTextureScaleMode(tex, SDL_ScaleModeNearest);
|
||
drawTexture(tex, x, y, w, h);
|
||
}
|
||
|
||
TTF_Font* App::font(int px, bool bold) {
|
||
(void)bold;
|
||
const auto key = std::make_pair(px, false);
|
||
auto found = fonts.find(key);
|
||
if (found != fonts.end()) {
|
||
return found->second;
|
||
}
|
||
const std::string regularPath = join(assetsRoot, "fonts/FOT-Seurat.otf");
|
||
TTF_Font* f = TTF_OpenFont(regularPath.c_str(), px);
|
||
fonts[key] = f;
|
||
return f;
|
||
}
|
||
|
||
std::string App::brandString(const std::string& label) const {
|
||
if (label == appDisplayName) return label;
|
||
std::string display = label;
|
||
auto replaceTerm = [&](const std::string& oldTerm, const std::string& newTerm) {
|
||
std::size_t at = 0;
|
||
while (!oldTerm.empty() && (at = display.find(oldTerm, at)) != std::string::npos) {
|
||
const bool left = at == 0 || !std::isalnum(static_cast<unsigned char>(display[at - 1]));
|
||
const std::size_t end = at + oldTerm.size();
|
||
const bool right = end == display.size() || !std::isalnum(static_cast<unsigned char>(display[end]));
|
||
if (left && right) { display.replace(at, oldTerm.size(), newTerm); at += newTerm.size(); }
|
||
else at = end;
|
||
}
|
||
};
|
||
replaceTerm("Switchnote Studio", appDisplayName);
|
||
replaceTerm("switchnote studio", appDisplayName);
|
||
replaceTerm("Switchnotes", notePlural);
|
||
replaceTerm("Switchnote", noteSingular);
|
||
replaceTerm("switchnotes", notePlural);
|
||
replaceTerm("switchnote", noteSingular);
|
||
return display;
|
||
}
|
||
|
||
void App::text(const std::string& label, int x, int y, int px, SDL_Color color, bool bold) {
|
||
rawText(brandString(label), x, y, px, color, bold);
|
||
}
|
||
|
||
void App::rawText(const std::string& display, int x, int y, int px, SDL_Color color, bool bold) {
|
||
if (display.empty()) return;
|
||
TTF_Font* f = font(px, bold);
|
||
if (!f) return;
|
||
const std::string key = std::to_string(px) + (bold ? "B" : "R") +
|
||
std::to_string(color.r) + ":" + std::to_string(color.g) + ":" + std::to_string(color.b) + ":" + display;
|
||
SDL_Texture* tex = nullptr;
|
||
auto found = textCache.find(key);
|
||
if (found != textCache.end()) tex = found->second;
|
||
else {
|
||
SDL_Surface* surf = TTF_RenderUTF8_Blended(f, display.c_str(), color);
|
||
if (!surf) return;
|
||
tex = SDL_CreateTextureFromSurface(renderer, surf);
|
||
SDL_FreeSurface(surf);
|
||
if (!tex) return;
|
||
textCache[key] = tex;
|
||
if (textCache.size() > 400) {
|
||
for (auto& old : textCache) if (old.second != tex) SDL_DestroyTexture(old.second);
|
||
textCache.clear();
|
||
textCache[key] = tex;
|
||
}
|
||
}
|
||
int w = 0, h = 0;
|
||
SDL_QueryTexture(tex, nullptr, nullptr, &w, &h);
|
||
drawTexture(tex, x - 3, y + 1, w, h);
|
||
}
|
||
|
||
void App::centered(const std::string& label, int x, int y, int w, int h, int px, SDL_Color color, bool bold) {
|
||
const std::string display = brandString(label);
|
||
TTF_Font* f = font(px, bold);
|
||
if (!f) return;
|
||
int tw = 0, th = 0;
|
||
TTF_SizeUTF8(f, display.c_str(), &tw, &th);
|
||
rawText(display, x + (w - tw) / 2, y + (h - th) / 2, px, color, bold);
|
||
}
|
||
|
||
void App::fill(int x, int y, int w, int h, SDL_Color c) {
|
||
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a);
|
||
SDL_Rect rect{x, y, w, h};
|
||
SDL_RenderFillRect(renderer, &rect);
|
||
}
|
||
|
||
void App::drawPlayTriangle(int x, int y, int size, SDL_Color color) {
|
||
if (!renderer || size <= 1) return;
|
||
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
|
||
for (int row = 0; row < size; ++row) {
|
||
const int extent = std::min(row, size - 1 - row);
|
||
SDL_RenderDrawLine(renderer, x, y + row, x + extent * 2, y + row);
|
||
}
|
||
}
|
||
|
||
void App::drawLockIcon(int x, int y) {
|
||
rounded(x, y, 28, 28, 14, SDL_Color{20, 22, 28, 220});
|
||
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
|
||
SDL_RenderDrawLine(renderer, x + 8, y + 13, x + 8, y + 10);
|
||
SDL_RenderDrawLine(renderer, x + 8, y + 10, x + 10, y + 7);
|
||
SDL_RenderDrawLine(renderer, x + 10, y + 7, x + 18, y + 7);
|
||
SDL_RenderDrawLine(renderer, x + 18, y + 7, x + 20, y + 10);
|
||
SDL_RenderDrawLine(renderer, x + 20, y + 10, x + 20, y + 13);
|
||
rounded(x + 6, y + 12, 16, 12, 3, WHITE);
|
||
rounded(x + 13, y + 16, 2, 5, 1, INK);
|
||
}
|
||
|
||
void App::rounded(int x, int y, int w, int h, int radius, SDL_Color c) {
|
||
if (w <= 0 || h <= 0) return;
|
||
radius = std::max(0, std::min(radius, std::min(w, h) / 2));
|
||
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a);
|
||
for (int row = 0; row < h; ++row) {
|
||
int inset = 0;
|
||
if (row < radius) {
|
||
const float dy = static_cast<float>(radius - row - 1);
|
||
inset = radius - static_cast<int>(std::sqrt(static_cast<float>(radius * radius) - dy * dy));
|
||
} else if (row >= h - radius) {
|
||
const float dy = static_cast<float>(row - (h - radius));
|
||
inset = radius - static_cast<int>(std::sqrt(static_cast<float>(radius * radius) - dy * dy));
|
||
}
|
||
SDL_RenderDrawLine(renderer, x + inset, y + row, x + w - inset - 1, y + row);
|
||
}
|
||
}
|
||
|
||
void App::roundedOutline(int x, int y, int w, int h, int radius, int thickness, SDL_Color c) {
|
||
if (w <= 0 || h <= 0 || thickness <= 0) return;
|
||
radius = std::clamp(radius, 0, std::min(w, h) / 2);
|
||
thickness = std::min(thickness, std::min(w, h) / 2);
|
||
const int innerW = w - thickness * 2;
|
||
const int innerH = h - thickness * 2;
|
||
const int innerRadius = std::max(0, radius - thickness);
|
||
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, c.a);
|
||
auto insetFor = [](int row, int height, int r) {
|
||
if (r <= 0) return 0;
|
||
if (row < r) {
|
||
const float dy = static_cast<float>(r - row - 1);
|
||
return r - static_cast<int>(std::sqrt(static_cast<float>(r * r) - dy * dy));
|
||
}
|
||
if (row >= height - r) {
|
||
const float dy = static_cast<float>(row - (height - r));
|
||
return r - static_cast<int>(std::sqrt(static_cast<float>(r * r) - dy * dy));
|
||
}
|
||
return 0;
|
||
};
|
||
for (int row = 0; row < h; ++row) {
|
||
const int outerInset = insetFor(row, h, radius);
|
||
const int outerLeft = x + outerInset;
|
||
const int outerRight = x + w - outerInset - 1;
|
||
const int innerRow = row - thickness;
|
||
if (innerRow < 0 || innerRow >= innerH) {
|
||
SDL_RenderDrawLine(renderer, outerLeft, y + row, outerRight, y + row);
|
||
continue;
|
||
}
|
||
const int innerInset = insetFor(innerRow, innerH, innerRadius);
|
||
const int innerLeft = x + thickness + innerInset;
|
||
const int innerRight = x + thickness + innerW - innerInset - 1;
|
||
if (outerLeft < innerLeft) SDL_RenderDrawLine(renderer, outerLeft, y + row, innerLeft - 1, y + row);
|
||
if (innerRight < outerRight) SDL_RenderDrawLine(renderer, innerRight + 1, y + row, outerRight, y + row);
|
||
}
|
||
}
|
||
|
||
bool App::hit(int x, int y, int w, int h) {
|
||
return !updateInProgress && !modalClosing && !screen.transitioning() && !(screen == Screen::Canvas && canvasChromeVisible < 0.999f) &&
|
||
(modal == Modal::None || renderingModal) && pointerReleased && !clickConsumed &&
|
||
pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
}
|
||
|
||
int App::hoverLift(int x, int y, bool hovered) {
|
||
const auto key = (static_cast<std::uint64_t>(static_cast<std::uint32_t>(x)) << 32) |
|
||
static_cast<std::uint32_t>(y);
|
||
float& amount = hoverMotion[key];
|
||
if (touchHoverExpiryPending && !pointerDown) {
|
||
amount = 0.0f;
|
||
return 0;
|
||
}
|
||
amount += ((hovered ? 1.0f : 0.0f) - amount) * 0.62f;
|
||
return static_cast<int>(std::lround(amount * 3.0f));
|
||
}
|
||
|
||
bool App::pill(const std::string& label, int x, int y, int w, int h, bool green, int px, bool enabled, const std::string& cue) {
|
||
const bool hovered = pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
const bool pressed = enabled && pointerDown && hovered;
|
||
const int lift = enabled ? hoverLift(x, y, hovered) : 0;
|
||
const int press = pressed ? 4 : 0;
|
||
const SDL_Color base = !enabled ? SDL_Color{230, 232, 239, 255} : (green ? PALE_GREEN : CREAM);
|
||
const SDL_Color fg = !enabled ? SDL_Color{175, 181, 193, 255} : (green ? GREEN : ORANGE);
|
||
rounded(x, y + 5 - lift + press, w, h, h / 2, SDL_Color{0, 0, 0, static_cast<Uint8>(pressed ? 30 : 45)});
|
||
rounded(x - 3, y - 3 - lift + press, w + 6, h + 6, (h + 6) / 2, WHITE);
|
||
rounded(x, y - lift + press, w, h, h / 2, base);
|
||
centered(label, x, y - lift + press, w, h, px, fg, false);
|
||
if (enabled && hit(x, y, w, h)) {
|
||
clickConsumed = true;
|
||
if (!cue.empty()) {
|
||
if (cue == "folder_open") playEvent("folder_open", cue);
|
||
else if (cue == "tool_color") playEvent("tool_color", "draw_tool_btn_on");
|
||
else playEvent("ui_action", cue);
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool App::actionPill(const std::string& icon, const std::string& label, int x, int y, int w, int h, bool green, bool enabled, const std::string& cue) {
|
||
const bool hovered = pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
const bool pressed = enabled && pointerDown && hovered;
|
||
const int lift = enabled ? hoverLift(x, y, hovered) : 0;
|
||
const int press = pressed ? 4 : 0;
|
||
const SDL_Color base = !enabled ? SDL_Color{230, 232, 239, 255} : (green ? PALE_GREEN : CREAM);
|
||
const SDL_Color fg = !enabled ? SDL_Color{175, 181, 193, 255} : (green ? GREEN : ORANGE);
|
||
rounded(x, y + 5 - lift + press, w, h, h / 2, SDL_Color{0, 0, 0, static_cast<Uint8>(pressed ? 30 : 45)});
|
||
rounded(x - 3, y - 3 - lift + press, w + 6, h + 6, (h + 6) / 2, WHITE);
|
||
rounded(x, y - lift + press, w, h, h / 2, base);
|
||
const int iconSize = std::min(32, h - 10);
|
||
SDL_Texture* tex = image(icon);
|
||
if (tex) {
|
||
int sourceW = 0, sourceH = 0;
|
||
SDL_QueryTexture(tex, nullptr, nullptr, &sourceW, &sourceH);
|
||
const float scale = sourceW > 0 && sourceH > 0 ? std::min(iconSize / static_cast<float>(sourceW), iconSize / static_cast<float>(sourceH)) : 1.0f;
|
||
const int iconW = std::max(1, static_cast<int>(sourceW * scale));
|
||
const int iconH = std::max(1, static_cast<int>(sourceH * scale));
|
||
if (!enabled) SDL_SetTextureAlphaMod(tex, 110);
|
||
drawTexture(tex, x + 13 + (iconSize - iconW) / 2, y + (h - iconH) / 2 - lift + press, iconW, iconH);
|
||
if (!enabled) SDL_SetTextureAlphaMod(tex, 255);
|
||
}
|
||
const int textLeft = x + (tex ? 48 : 10);
|
||
centered(label, textLeft, y - lift + press, x + w - textLeft, h, 19, fg, false);
|
||
if (enabled && hit(x, y, w, h)) {
|
||
clickConsumed = true;
|
||
if (!cue.empty()) playEvent("ui_action", cue);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool App::dangerPill(const std::string& label, int x, int y, int w, int h, int px, bool enabled) {
|
||
const bool hovered = pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
const bool pressed = enabled && pointerDown && hovered;
|
||
const int lift = enabled ? hoverLift(x, y, hovered) : 0;
|
||
const int press = pressed ? 4 : 0;
|
||
const SDL_Color base = enabled ? SDL_Color{218, 47, 57, 255} : SDL_Color{230, 232, 239, 255};
|
||
const SDL_Color fg = enabled ? WHITE : SDL_Color{175, 181, 193, 255};
|
||
rounded(x, y + 5 - lift + press, w, h, h / 2, SDL_Color{0, 0, 0, static_cast<Uint8>(pressed ? 30 : 45)});
|
||
rounded(x - 3, y - 3 - lift + press, w + 6, h + 6, (h + 6) / 2, WHITE);
|
||
rounded(x, y - lift + press, w, h, h / 2, base);
|
||
centered(label, x, y - lift + press, w, h, px, fg, false);
|
||
if (enabled && hit(x, y, w, h)) {
|
||
clickConsumed = true;
|
||
playEvent("ui_action", "button_on");
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool App::dangerActionPill(const std::string& icon, const std::string& label, int x, int y, int w, int h, int px, bool enabled) {
|
||
const bool hovered = pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
const bool pressed = enabled && pointerDown && hovered;
|
||
const int lift = enabled ? hoverLift(x, y, hovered) : 0;
|
||
const int press = pressed ? 4 : 0;
|
||
const SDL_Color base = enabled ? SDL_Color{218, 47, 57, 255} : SDL_Color{230, 232, 239, 255};
|
||
const SDL_Color fg = enabled ? WHITE : SDL_Color{175, 181, 193, 255};
|
||
rounded(x, y + 5 - lift + press, w, h, h / 2, SDL_Color{0, 0, 0, static_cast<Uint8>(pressed ? 30 : 45)});
|
||
rounded(x - 3, y - 3 - lift + press, w + 6, h + 6, (h + 6) / 2, WHITE);
|
||
rounded(x, y - lift + press, w, h, h / 2, base);
|
||
SDL_Texture* tex = image(icon);
|
||
if (tex) {
|
||
int sourceW = 0, sourceH = 0;
|
||
SDL_QueryTexture(tex, nullptr, nullptr, &sourceW, &sourceH);
|
||
const int iconSize = std::min(32, h - 10);
|
||
const float scale = sourceW > 0 && sourceH > 0 ? std::min(iconSize / static_cast<float>(sourceW), iconSize / static_cast<float>(sourceH)) : 1.0f;
|
||
const int iconW = std::max(1, static_cast<int>(sourceW * scale));
|
||
const int iconH = std::max(1, static_cast<int>(sourceH * scale));
|
||
if (!enabled) SDL_SetTextureAlphaMod(tex, 110);
|
||
drawTexture(tex, x + 13 + (iconSize - iconW) / 2, y + (h - iconH) / 2 - lift + press, iconW, iconH);
|
||
if (!enabled) SDL_SetTextureAlphaMod(tex, 255);
|
||
}
|
||
const int textLeft = x + (tex ? 48 : 10);
|
||
centered(label, textLeft, y - lift + press, x + w - textLeft, h, px, fg, false);
|
||
if (enabled && hit(x, y, w, h)) {
|
||
clickConsumed = true;
|
||
playEvent("ui_action", "button_on");
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool App::imagePill(const std::string& icon, int x, int y, int w, int h, bool green, bool enabled, const std::string& cue) {
|
||
const bool hovered = pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
const bool pressed = enabled && pointerDown && hovered;
|
||
const int lift = enabled ? hoverLift(x, y, hovered) : 0;
|
||
const int press = pressed ? 4 : 0;
|
||
const SDL_Color base = !enabled ? SDL_Color{230, 232, 239, 255} : (green ? PALE_GREEN : CREAM);
|
||
rounded(x, y + 5 - lift + press, w, h, h / 2, SDL_Color{0, 0, 0, static_cast<Uint8>(pressed ? 30 : 45)});
|
||
rounded(x - 3, y - 3 - lift + press, w + 6, h + 6, (h + 6) / 2, WHITE);
|
||
rounded(x, y - lift + press, w, h, h / 2, base);
|
||
SDL_Texture* tex = image(icon);
|
||
if (tex) {
|
||
int sourceW = 0, sourceH = 0;
|
||
SDL_QueryTexture(tex, nullptr, nullptr, &sourceW, &sourceH);
|
||
const float scale = sourceW > 0 && sourceH > 0
|
||
? std::min((w - 18) / static_cast<float>(sourceW), (h - 12) / static_cast<float>(sourceH)) : 1.0f;
|
||
const int iconW = std::max(1, static_cast<int>(sourceW * scale));
|
||
const int iconH = std::max(1, static_cast<int>(sourceH * scale));
|
||
if (!enabled) SDL_SetTextureAlphaMod(tex, 110);
|
||
drawTexture(tex, x + (w - iconW) / 2, y + (h - iconH) / 2 - lift + press, iconW, iconH);
|
||
if (!enabled) SDL_SetTextureAlphaMod(tex, 255);
|
||
}
|
||
if (enabled && hit(x, y, w, h)) {
|
||
clickConsumed = true;
|
||
if (!cue.empty()) playEvent("ui_action", cue);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool App::imageButton(const std::string& path, int x, int y, int w, int h, const std::string& cue) {
|
||
const bool hovered = pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
const bool pressed = pointerDown && hovered;
|
||
drawImage(path, x, y - hoverLift(x, y, hovered) + (pressed ? 4 : 0), w, h);
|
||
if (hit(x, y, w, h)) {
|
||
clickConsumed = true;
|
||
if (!cue.empty()) playEvent("ui_action", cue);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void App::background() {
|
||
if (screen == Screen::Canvas) fill(0, 0, W, H, WHITE);
|
||
else drawImage("ui/GridBackground.png", 0, 0, W, H);
|
||
}
|
||
|
||
void App::renderToast() {
|
||
if (toast.empty() || SDL_GetTicks() > toastUntil) return;
|
||
TTF_Font* body = font(19, false);
|
||
if (!body) return;
|
||
constexpr int maxTextWidth = W - 120;
|
||
auto measure = [body](const std::string& value) {
|
||
int width = 0, height = 0;
|
||
TTF_SizeUTF8(body, value.c_str(), &width, &height);
|
||
return width;
|
||
};
|
||
std::vector<std::string> lines;
|
||
std::istringstream words(toast);
|
||
std::string word, line;
|
||
while (words >> word) {
|
||
const std::string candidate = line.empty() ? word : line + " " + word;
|
||
if (!line.empty() && measure(candidate) > maxTextWidth) {
|
||
lines.push_back(line);
|
||
line = word;
|
||
} else line = candidate;
|
||
}
|
||
if (!line.empty()) lines.push_back(line);
|
||
if (lines.empty()) return;
|
||
int textWidth = 0;
|
||
for (const auto& part : lines) textWidth = std::max(textWidth, measure(part));
|
||
const int lineHeight = TTF_FontHeight(body) + 2;
|
||
const int width = std::min(W - 48, textWidth + 48);
|
||
const int height = static_cast<int>(lines.size()) * lineHeight + 22;
|
||
const int x = (W - width) / 2;
|
||
const int y = 82;
|
||
rounded(x, y, width, height, std::min(23, height / 2), SDL_Color{20, 24, 30, 225});
|
||
for (std::size_t i = 0; i < lines.size(); ++i) {
|
||
const int lineWidth = measure(lines[i]);
|
||
rawText(lines[i], (W - lineWidth) / 2, y + 10 + static_cast<int>(i) * lineHeight, 19, WHITE, false);
|
||
}
|
||
}
|
||
|
||
void App::run() {
|
||
logStartup("startup: entering main loop");
|
||
const std::uint32_t start = SDL_GetTicks();
|
||
while (running
|
||
#ifdef __SWITCH__
|
||
&& appletMainLoop()
|
||
#endif
|
||
) {
|
||
poll();
|
||
pulse = static_cast<float>(SDL_GetTicks() - start) / 1000.0f;
|
||
update();
|
||
render();
|
||
if (updateInstallPending && static_cast<std::int32_t>(SDL_GetTicks() - updateInstallReadyAt) >= 0)
|
||
completeUpdateInstall();
|
||
}
|
||
logStartup("startup: main loop ended");
|
||
}
|
||
|
||
void App::startUpdateCheck(bool manual) {
|
||
if (updateInProgress || updateThread) return;
|
||
if (manual && !internetConnected()) {
|
||
showToast("You're not connected to the internet.");
|
||
return;
|
||
}
|
||
updateTask = UpdateTask::Check;
|
||
updateManualCheck = manual;
|
||
updateAvailable = false;
|
||
updateNoChange = false;
|
||
updateServerVersion.clear();
|
||
updateDownloadUrl.clear();
|
||
updateSha256.clear();
|
||
updateError.clear();
|
||
updateHttpStatus = 0;
|
||
updateWorkerDone.store(false, std::memory_order_relaxed);
|
||
updateInProgress = true;
|
||
beginLoading();
|
||
updateStartedAt = SDL_GetTicks();
|
||
updateThread = SDL_CreateThread(updateThreadEntry, "switchnote-update", this);
|
||
if (!updateThread) {
|
||
updateInProgress = false;
|
||
endLoading();
|
||
loadingCompletionVisible = false;
|
||
updateError = "Could not start the update check.";
|
||
if (manual) showToast(updateError);
|
||
}
|
||
}
|
||
|
||
void App::startUpdateDownload() {
|
||
if (updateInProgress || updateThread || updateDownloadUrl.empty()) return;
|
||
updateTask = UpdateTask::Download;
|
||
updateManualCheck = false;
|
||
updateError.clear();
|
||
updateDownloadedPath.clear();
|
||
updateHttpStatus = 0;
|
||
updateWorkerDone.store(false, std::memory_order_relaxed);
|
||
updateInProgress = true;
|
||
modal = Modal::None;
|
||
beginLoading();
|
||
updateStartedAt = SDL_GetTicks();
|
||
updateThread = SDL_CreateThread(updateThreadEntry, "switchnote-download", this);
|
||
if (!updateThread) {
|
||
updateInProgress = false;
|
||
endLoading();
|
||
loadingCompletionVisible = false;
|
||
showToast("Could not start the update download.");
|
||
}
|
||
}
|
||
|
||
bool App::requestUpdateHandoff() {
|
||
#ifdef __SWITCH__
|
||
const std::string installTarget = join(dataRoot, "switchnote.nro");
|
||
if (!envHasNextLoad()) {
|
||
updateError = "This launch method cannot open the downloaded update automatically.";
|
||
return false;
|
||
}
|
||
if (!sameSdPath(launchNroPath, installTarget)) {
|
||
updateError = "Auto-install is only available when launched from switch/Switchnote/switchnote.nro.";
|
||
logStartup("update: launch path did not match install target; loader path=" +
|
||
(launchNroPath.empty() ? std::string("<empty>") : launchNroPath) + "; expected=" + installTarget);
|
||
return false;
|
||
}
|
||
if (!validNroFile(updateDownloadedPath)) {
|
||
updateError = "The downloaded update file could not be verified.";
|
||
return false;
|
||
}
|
||
const std::string nextArguments = updateDownloadedPath + " --switchnote-update-handoff";
|
||
const Result result = envSetNextLoad(updateDownloadedPath.c_str(), nextArguments.c_str());
|
||
if (R_FAILED(result)) {
|
||
updateError = "Could not start the downloaded update.";
|
||
logStartup("update: envSetNextLoad failed: " + std::to_string(static_cast<unsigned int>(result)));
|
||
return false;
|
||
}
|
||
logStartup("update: chained to downloaded NRO " + updateDownloadedPath);
|
||
running = false;
|
||
return true;
|
||
#else
|
||
return false;
|
||
#endif
|
||
}
|
||
|
||
void App::completeUpdateInstall() {
|
||
updateInstallPending = false;
|
||
#ifdef __SWITCH__
|
||
const std::string installTarget = join(dataRoot, "switchnote.nro");
|
||
const std::string backupPath = installTarget + ".oldbk";
|
||
auto exists = [](const std::string& path) {
|
||
struct stat st{};
|
||
return stat(path.c_str(), &st) == 0;
|
||
};
|
||
auto fail = [&](const std::string& message) {
|
||
updateError = message;
|
||
logStartup("update: " + message);
|
||
showToast(message);
|
||
};
|
||
|
||
if (!sameSdPath(updateInstallSourcePath, launchNroPath) ||
|
||
!validNroFile(updateInstallSourcePath)) {
|
||
fail("The running update file could not be verified; the installed app was left unchanged.");
|
||
return;
|
||
}
|
||
|
||
if (exists(backupPath)) {
|
||
if (validNroFile(installTarget)) {
|
||
if (std::remove(backupPath.c_str()) != 0) {
|
||
fail("Could not clear the previous update backup; the installed app was left unchanged.");
|
||
return;
|
||
}
|
||
} else {
|
||
if (exists(installTarget)) std::remove(installTarget.c_str());
|
||
if (!validNroFile(backupPath) || std::rename(backupPath.c_str(), installTarget.c_str()) != 0) {
|
||
fail("Could not restore the previous app backup; the update was not installed.");
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!validNroFile(installTarget)) {
|
||
fail("The installed Switchnote NRO was not found; the update was left in the updates folder.");
|
||
return;
|
||
}
|
||
if (std::rename(installTarget.c_str(), backupPath.c_str()) != 0) {
|
||
fail("Could not back up the current Switchnote NRO; the update was left in the updates folder.");
|
||
return;
|
||
}
|
||
if (std::rename(updateInstallSourcePath.c_str(), installTarget.c_str()) != 0) {
|
||
const bool restored = std::rename(backupPath.c_str(), installTarget.c_str()) == 0;
|
||
fail(restored ? "Could not install the update; the previous app was restored." :
|
||
"Could not install the update or restore the backup. Keep the .oldbk file for recovery.");
|
||
return;
|
||
}
|
||
if (!validNroFile(installTarget)) {
|
||
std::remove(installTarget.c_str());
|
||
const bool restored = std::rename(backupPath.c_str(), installTarget.c_str()) == 0;
|
||
fail(restored ? "The new NRO failed verification; the previous app was restored." :
|
||
"The new NRO failed verification and rollback failed. Keep the .oldbk file for recovery.");
|
||
return;
|
||
}
|
||
if (std::remove(backupPath.c_str()) == 0) {
|
||
logStartup("update: installed new NRO and removed backup");
|
||
showToast("Update installed successfully.");
|
||
} else {
|
||
logStartup("update: installed new NRO; backup cleanup failed");
|
||
showToast("Update installed. The old backup could not be removed.");
|
||
}
|
||
#endif
|
||
}
|
||
|
||
int App::updateThreadEntry(void* context) {
|
||
App* app = static_cast<App*>(context);
|
||
app->runUpdateTask();
|
||
app->updateWorkerDone.store(true, std::memory_order_release);
|
||
return 0;
|
||
}
|
||
|
||
void App::runUpdateTask() {
|
||
std::vector<std::uint8_t> response;
|
||
std::string responseHeaders;
|
||
std::string error;
|
||
if (updateTask == UpdateTask::Check) {
|
||
const bool ok = galleryRequest("GET", "/api/update", {}, "application/json",
|
||
response, updateHttpStatus, error, &responseHeaders);
|
||
if (!ok || updateHttpStatus == 503) {
|
||
updateError = updateHttpStatus == 503 ? "Update service is temporarily unavailable." : error;
|
||
return;
|
||
}
|
||
const std::string json(response.begin(), response.end());
|
||
updateServerVersion = jsonStringField(json, "version");
|
||
updateDownloadUrl = jsonStringField(json, "download_url");
|
||
updateSha256 = jsonStringField(json, "sha256");
|
||
if (!validSha256Hex(updateSha256)) updateSha256.clear();
|
||
std::vector<unsigned long> returnedParts, installedParts;
|
||
if (updateServerVersion.empty() || updateDownloadUrl.empty() ||
|
||
!versionParts(updateServerVersion, returnedParts) ||
|
||
!versionParts(kInstalledAppVersion, installedParts)) {
|
||
updateError = "The update service returned invalid version information.";
|
||
return;
|
||
}
|
||
updateAvailable = compareVersions(updateServerVersion, kInstalledAppVersion) > 0;
|
||
updateNoChange = !updateAvailable;
|
||
if (updateAvailable) {
|
||
std::string trustedPath;
|
||
if (!trustedUpdatePath(updateDownloadUrl, trustedPath)) {
|
||
updateAvailable = false;
|
||
updateNoChange = false;
|
||
updateError = "The update service returned an untrusted download address.";
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (updateTask != UpdateTask::Download) return;
|
||
std::string downloadPath;
|
||
if (!trustedUpdatePath(updateDownloadUrl, downloadPath)) {
|
||
updateError = "The update service returned an untrusted download address.";
|
||
return;
|
||
}
|
||
bool downloaded = false;
|
||
for (int attempt = 0; attempt < 3; ++attempt) {
|
||
response.clear();
|
||
responseHeaders.clear();
|
||
error.clear();
|
||
const bool ok = galleryRequest("GET", downloadPath, {}, "application/octet-stream",
|
||
response, updateHttpStatus, error, &responseHeaders);
|
||
if (ok) { downloaded = true; break; }
|
||
if (updateHttpStatus == 503) {
|
||
updateError = "The update download is temporarily unavailable. Try again later.";
|
||
return;
|
||
}
|
||
if (updateHttpStatus != 429) {
|
||
updateError = error.empty() ? "The update download failed." : error;
|
||
return;
|
||
}
|
||
const int waitSeconds = retryAfterSeconds(responseHeaders);
|
||
if (waitSeconds < 0 || attempt == 2) {
|
||
updateError = "The download limit was reached. Please try again later.";
|
||
return;
|
||
}
|
||
for (int second = 0; second < waitSeconds; ++second) SDL_Delay(1000);
|
||
}
|
||
if (!downloaded) { updateError = "The update download failed."; return; }
|
||
if (response.size() < 20 || response.size() > 72U * 1024U * 1024U ||
|
||
std::memcmp(response.data() + 16, "NRO0", 4) != 0) {
|
||
updateError = "The downloaded file is not a valid Switchnote NRO.";
|
||
return;
|
||
}
|
||
std::string versionComponent = updateServerVersion;
|
||
if (versionComponent.rfind("Ver ", 0) == 0) versionComponent.erase(0, 4);
|
||
else if (!versionComponent.empty() && (versionComponent[0] == 'v' || versionComponent[0] == 'V')) versionComponent.erase(0, 1);
|
||
const std::string directory = join(dataRoot, "updates");
|
||
ensureDir(directory);
|
||
std::string destination = join(directory, "Switchnote-" + versionComponent + ".nro");
|
||
struct stat existing{};
|
||
for (unsigned suffix = 1; stat(destination.c_str(), &existing) == 0 && suffix < 1000; ++suffix)
|
||
destination = join(directory, "Switchnote-" + versionComponent + "-" + std::to_string(suffix) + ".nro");
|
||
const std::string temporary = destination + ".part";
|
||
std::remove(temporary.c_str());
|
||
std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
|
||
if (!output) { updateError = "Could not create the update file on the SD card."; return; }
|
||
output.write(reinterpret_cast<const char*>(response.data()), static_cast<std::streamsize>(response.size()));
|
||
output.flush();
|
||
const bool writeOk = static_cast<bool>(output);
|
||
output.close();
|
||
if (!writeOk || std::rename(temporary.c_str(), destination.c_str()) != 0) {
|
||
std::remove(temporary.c_str());
|
||
updateError = "Could not save the update to the SD card.";
|
||
return;
|
||
}
|
||
updateDownloadedPath = destination;
|
||
}
|
||
|
||
void App::consumeUpdateTask() {
|
||
if (!updateInProgress || !updateWorkerDone.load(std::memory_order_acquire) ||
|
||
SDL_GetTicks() - updateStartedAt < 450) return;
|
||
if (updateThread) { SDL_WaitThread(updateThread, nullptr); updateThread = nullptr; }
|
||
const UpdateTask finishedTask = updateTask;
|
||
const bool wasManual = updateManualCheck;
|
||
updateTask = UpdateTask::None;
|
||
updateInProgress = false;
|
||
endLoading();
|
||
loadingCompletionVisible = false;
|
||
if (finishedTask == UpdateTask::Check) {
|
||
if (updateAvailable) {
|
||
if (wasManual) { modal = Modal::UpdateAvailable; modalTransitionStart = SDL_GetTicks(); }
|
||
else updateOfferPending = true;
|
||
}
|
||
else if (wasManual && updateNoChange) showToast("This version is up to date.");
|
||
else if (wasManual) showToast(updateError.empty() ? "Couldn't check for updates. Try again later." : updateError);
|
||
} else if (finishedTask == UpdateTask::Download) {
|
||
if (!updateDownloadedPath.empty()) {
|
||
if (!requestUpdateHandoff())
|
||
showToast(updateError.empty() ? "Update saved to " + updateDownloadedPath + ". Launch that NRO manually." : updateError);
|
||
}
|
||
else showToast(updateError.empty() ? "The update download failed." : updateError);
|
||
}
|
||
}
|
||
|
||
void App::update() {
|
||
const std::uint32_t now = SDL_GetTicks();
|
||
consumeUpdateTask();
|
||
updateFillWave(now);
|
||
consumeServerStart();
|
||
consumePhotoProbe();
|
||
consumeGalleryLoad();
|
||
if (screen != Screen::Canvas) canvasMenuOpen = false;
|
||
if (screen.phase == ScreenState::Phase::ToWhite && lastScreenCueStart != screen.phaseStart) {
|
||
lastScreenCueStart = screen.phaseStart;
|
||
playEvent("screen_swap", "screen_swap");
|
||
}
|
||
screen.advance(now);
|
||
if (updateOfferPending && screen.active == Screen::Title && screen.phase == ScreenState::Phase::Idle) {
|
||
updateOfferPending = false;
|
||
modal = Modal::UpdateAvailable;
|
||
modalTransitionStart = now;
|
||
}
|
||
if (modalClosing) {
|
||
if (now - modalTransitionStart >= 150) {
|
||
modalClosing = false;
|
||
modalVisual = Modal::None;
|
||
} else return;
|
||
}
|
||
if (!serverStartRunning) consumeAudioUpload();
|
||
if (!serverStartRunning) consumeBrandingConfig();
|
||
advancePhotoImport();
|
||
if (photoImporting) return;
|
||
updatePlayback(now);
|
||
if ((screen != Screen::Canvas && screen != Screen::Sequence) || modal != Modal::None ||
|
||
!(buttonsHeld & BRIGHT) || (screen == Screen::Canvas && (buttonsHeld & BY))) {
|
||
rightDpadRepeating = false;
|
||
} else if (rightDpadRepeating) {
|
||
const std::uint32_t interval = std::max<std::uint32_t>(1, static_cast<std::uint32_t>(std::lround(1000.0 / sppm::frameRate(doc.metadata))));
|
||
while (static_cast<std::int32_t>(now - rightDpadNextRepeatAt) >= 0) {
|
||
if (frame + 1 < doc.frames.size()) setFrame(frame + 1);
|
||
else insertFrame(false);
|
||
rightDpadNextRepeatAt += interval;
|
||
}
|
||
}
|
||
if (modal == Modal::Photo) updatePhotoCapture();
|
||
if (screen.transitioning()) return;
|
||
if (dirty && SDL_GetTicks() - dirtyTick > 1500) saveDocument();
|
||
auto canvasInputAllowed = [&]() {
|
||
if (pointerX < 0 || pointerX >= W || pointerY < 0 || pointerY >= H) return false;
|
||
if (canvasControlGesture || paintMenu || colorMenu || toolMenu) return false;
|
||
const float scale = 2.0f * zoom;
|
||
const int canvasW = static_cast<int>(sppm::kWidth * scale);
|
||
const int canvasH = static_cast<int>(sppm::kHeight * scale);
|
||
const int canvasX = (W - canvasW) / 2 + panX;
|
||
const int canvasY = (H - canvasH) / 2 + panY;
|
||
if (pointerX < canvasX || pointerX >= canvasX + canvasW ||
|
||
pointerY < canvasY || pointerY >= canvasY + canvasH) return false;
|
||
return true;
|
||
};
|
||
auto canvasPixelAt = [&](int sx, int sy, int& px, int& py) {
|
||
const float scale = 2.0f * zoom;
|
||
const int canvasW = static_cast<int>(sppm::kWidth * scale);
|
||
const int canvasH = static_cast<int>(sppm::kHeight * scale);
|
||
const int canvasX = (W - canvasW) / 2 + panX;
|
||
const int canvasY = (H - canvasH) / 2 + panY;
|
||
if (sx < canvasX || sx >= canvasX + canvasW || sy < canvasY || sy >= canvasY + canvasH) return false;
|
||
px = static_cast<int>((sx - canvasX) / (canvasW / static_cast<float>(sppm::kWidth)));
|
||
py = static_cast<int>((sy - canvasY) / (canvasH / static_cast<float>(sppm::kHeight)));
|
||
return px >= 0 && px < sppm::kWidth && py >= 0 && py < sppm::kHeight;
|
||
};
|
||
if (screen == Screen::Canvas && docLoaded && zoom > 1.0f && !drawing && modal == Modal::None) {
|
||
if (!lastPanTick) lastPanTick = now;
|
||
const float elapsed = std::min(0.050f, (now - lastPanTick) / 1000.0f);
|
||
const int maxPanX = std::max(0, (static_cast<int>(sppm::kWidth * 2.0f * zoom) - W) / 2);
|
||
const int maxPanY = std::max(0, (static_cast<int>(sppm::kHeight * 2.0f * zoom) - H) / 2);
|
||
constexpr float panPixelsPerSecond = 720.0f;
|
||
panX = std::clamp(panX + static_cast<int>(std::lround(leftStickX * panPixelsPerSecond * elapsed)), -maxPanX, maxPanX);
|
||
panY = std::clamp(panY + static_cast<int>(std::lround(leftStickY * panPixelsPerSecond * elapsed)), -maxPanY, maxPanY);
|
||
}
|
||
lastPanTick = now;
|
||
if (screen == Screen::Canvas && docLoaded && pointerPressed && modal == Modal::None && canvasInputAllowed()) {
|
||
int px = 0, py = 0;
|
||
if (canvasPixelAt(pointerX, pointerY, px, py)) {
|
||
afterStrokePoints.clear();
|
||
realtimeStrokeInitialized = false;
|
||
canvasTapPending = true;
|
||
canvasFillCommitted = false;
|
||
canvasPressScreenX = pointerX; canvasPressScreenY = pointerY;
|
||
canvasPressPixelX = px; canvasPressPixelY = py;
|
||
canvasPressStartedAt = now;
|
||
drawing = true; // lets the chrome slide away immediately, before ink is committed
|
||
hasLastStroke = false;
|
||
}
|
||
}
|
||
if (screen == Screen::Canvas && docLoaded && canvasTapPending && pointerDown && modal == Modal::None) {
|
||
const int touchDx = pointerX - canvasPressScreenX;
|
||
const int touchDy = pointerY - canvasPressScreenY;
|
||
if (touchDx * touchDx + touchDy * touchDy > 25) {
|
||
// Five display pixels of touch jitter do not cancel a stationary fill.
|
||
canvasTapPending = false;
|
||
pushUndo();
|
||
hasLastStroke = false;
|
||
strokeAt(canvasPressScreenX, canvasPressScreenY);
|
||
strokeAt(pointerX, pointerY);
|
||
} else if (now - canvasPressStartedAt >= 450) {
|
||
canvasTapPending = false;
|
||
canvasFillCommitted = true;
|
||
beginFillWave(canvasPressPixelX, canvasPressPixelY);
|
||
}
|
||
} else if (screen == Screen::Canvas && docLoaded && pointerDown && modal == Modal::None && !canvasTapPending) {
|
||
if (canvasInputAllowed()) {
|
||
if (!drawing) { pushUndo(); drawing = true; hasLastStroke = false; }
|
||
strokeAt(pointerX, pointerY);
|
||
} else hasLastStroke = false;
|
||
}
|
||
if (screen == Screen::Canvas && docLoaded && pointerReleased && modal == Modal::None) {
|
||
if (canvasTapPending) {
|
||
// A short stationary tap remains a normal single-point stroke.
|
||
pushUndo();
|
||
hasLastStroke = false;
|
||
strokeAt(canvasPressScreenX, canvasPressScreenY);
|
||
} else if (!canvasFillCommitted && canvasInputAllowed()) {
|
||
if (!drawing) { pushUndo(); drawing = true; hasLastStroke = false; }
|
||
strokeAt(pointerX, pointerY);
|
||
}
|
||
finishAfterStroke();
|
||
canvasTapPending = false;
|
||
canvasFillCommitted = false;
|
||
drawing = false;
|
||
hasLastStroke = false;
|
||
canvasControlGesture = false;
|
||
}
|
||
if (screen == Screen::CommentCanvas && pointerDown && modal == Modal::None) {
|
||
if (pointerY >= 72 && pointerY < 620) {
|
||
if (!drawing) { drawing = true; hasLastStroke = false; }
|
||
strokeAt(pointerX, pointerY, true);
|
||
}
|
||
}
|
||
if (screen == Screen::CommentCanvas && pointerReleased && modal == Modal::None) {
|
||
const bool onButtons = pointerY < 72 || pointerY >= 620;
|
||
if (!onButtons) strokeAt(pointerX, pointerY, true);
|
||
drawing = false;
|
||
hasLastStroke = false;
|
||
}
|
||
if (lastCanvasMenuTick == 0) lastCanvasMenuTick = now;
|
||
if (screen == Screen::GalleryComments) {
|
||
if (pointerPressed && pointerX >= 197 && pointerX < 1060 && pointerY >= 130 && pointerY < 620) {
|
||
galleryCommentTouchScroll = true;
|
||
galleryCommentTouchStartY = pointerY;
|
||
galleryCommentTouchStartOffset = galleryCommentScroll;
|
||
}
|
||
if (galleryCommentTouchScroll && pointerDown) {
|
||
galleryCommentScroll = std::max(0, galleryCommentTouchStartOffset + galleryCommentTouchStartY - pointerY);
|
||
}
|
||
if (pointerReleased) galleryCommentTouchScroll = false;
|
||
const float elapsed = lastGalleryCommentScrollTick == 0 ? 0.0f : std::min(0.05f, (now - lastGalleryCommentScrollTick) / 1000.0f);
|
||
if (!galleryCommentTouchScroll && std::abs(leftStickY) > 0.18f) {
|
||
galleryCommentScroll = std::max(0, galleryCommentScroll + static_cast<int>(std::lround(leftStickY * 700.0f * elapsed)));
|
||
}
|
||
lastGalleryCommentScrollTick = now;
|
||
} else {
|
||
galleryCommentTouchScroll = false;
|
||
lastGalleryCommentScrollTick = now;
|
||
}
|
||
constexpr float menuAnimationMs = 125.0f / 1.75f;
|
||
const float menuStep = std::min(0.05f, (now - lastCanvasMenuTick) / 1000.0f) / (menuAnimationMs / 1000.0f);
|
||
lastCanvasMenuTick = now;
|
||
canvasMenuProgress = std::clamp(canvasMenuProgress + (canvasMenuOpen ? menuStep : -menuStep), 0.0f, 1.0f);
|
||
if (lastChromeTick == 0) lastChromeTick = now;
|
||
const float chromeStep = std::min(1.0f, (now - lastChromeTick) / kCanvasChromeMs);
|
||
lastChromeTick = now;
|
||
const float chromeTarget = screen == Screen::Canvas && drawing ? 0.0f : 1.0f;
|
||
if (chromeTarget < canvasChromeVisible) canvasChromeVisible = std::max(chromeTarget, canvasChromeVisible - chromeStep);
|
||
else canvasChromeVisible = std::min(chromeTarget, canvasChromeVisible + chromeStep);
|
||
handleKeys();
|
||
}
|
||
|
||
void App::handleKeys() {
|
||
if (screen == Screen::AppletWarning) {
|
||
if (buttonsDown & (BA | BB | BPLUS)) running = false;
|
||
return;
|
||
}
|
||
if (updateInProgress) return;
|
||
if (modal == Modal::UpdateAvailable) {
|
||
if (buttonsDown & BB) { modal = Modal::None; playEvent("cancel", "cursor_cancel"); }
|
||
else if (buttonsDown & BA) startUpdateDownload();
|
||
return;
|
||
}
|
||
if (modal == Modal::TextInput) {
|
||
if (editingField == Field::None) return;
|
||
return;
|
||
}
|
||
if (modal == Modal::GalleryNotice) {
|
||
if (buttonsDown & BB) { modal = Modal::None; playEvent("cancel", "cursor_cancel"); }
|
||
else if (buttonsDown & BA) confirmGalleryLeave();
|
||
return;
|
||
}
|
||
if (modal == Modal::GalleryTerms) {
|
||
if (buttonsDown & BB) { modal = Modal::None; screen = Screen::Library; }
|
||
else if (buttonsDown & BA) {
|
||
galleryTermsAccepted = true;
|
||
std::ofstream accepted(join(dataRoot, "gallery-terms-accepted"), std::ios::binary | std::ios::trunc);
|
||
if (accepted) accepted << "1\n";
|
||
modal = Modal::None;
|
||
}
|
||
return;
|
||
}
|
||
if (modal == Modal::GalleryOffline) {
|
||
if (buttonsDown & (BB | BA)) { modal = Modal::None; playEvent("cancel", "cursor_cancel"); }
|
||
return;
|
||
}
|
||
if (modal == Modal::ConfirmDelete) {
|
||
if (buttonsDown & BB) { modal = Modal::None; playEvent("cancel", "cursor_cancel"); }
|
||
else if (buttonsDown & BZR) deleteDocument();
|
||
return;
|
||
}
|
||
if (modal == Modal::GalleryPostChoice) {
|
||
if (buttonsDown & BB) { modal = Modal::None; playEvent("cancel", "cursor_cancel"); }
|
||
else if (buttonsDown & BX) { modal = Modal::None; performGalleryUpload(pendingGalleryPublishIndex, true); }
|
||
else if (buttonsDown & BY) { modal = Modal::None; performGalleryUpload(pendingGalleryPublishIndex, false); }
|
||
return;
|
||
}
|
||
if (modal == Modal::PhotoProbe && (buttonsDown & BB)) return;
|
||
if ((modal == Modal::Photo || modal == Modal::PhotoChoice || modal == Modal::PhotoAlbum || modal == Modal::PhotoUpload) && (buttonsDown & BB)) {
|
||
if (modal == Modal::PhotoAlbum) { modal = Modal::PhotoChoice; return; }
|
||
if (serverStartRunning && serverStartTask == ServerStartTask::Photo) return;
|
||
closePhotoCapture();
|
||
return;
|
||
}
|
||
if (modal == Modal::PhotoChoice) {
|
||
if (buttonsDown & BA) { openPhotoAlbum(); }
|
||
else if (buttonsDown & BY) {
|
||
openPhotoUpload();
|
||
photoModalTransitionDim = true;
|
||
photoModalTransitionDimAt = SDL_GetTicks();
|
||
}
|
||
else if ((buttonsDown & BX) && photoProbeHasCamera) { modal = Modal::Photo; modalTransitionStart = SDL_GetTicks(); }
|
||
return;
|
||
}
|
||
if (modal == Modal::Audio && (buttonsDown & BB)) {
|
||
if (serverStartRunning && serverStartTask == ServerStartTask::Audio) return;
|
||
closeAudioMenu();
|
||
return;
|
||
}
|
||
if (modal == Modal::Branding && (buttonsDown & BB)) {
|
||
if (serverStartRunning && serverStartTask == ServerStartTask::Branding) return;
|
||
closeBrandingMenu();
|
||
return;
|
||
}
|
||
if (modal != Modal::None) {
|
||
if (buttonsDown & BB) { modal = Modal::None; playEvent("cancel", "cursor_cancel"); return; }
|
||
if (modal == Modal::Options) {
|
||
int speed = docLoaded ? documentSpeed(doc.metadata) : defaultSpeed;
|
||
if (buttonsDown & BLEFT) speed = std::max(1, speed - 1);
|
||
if (buttonsDown & BRIGHT) speed = std::min(8, speed + 1);
|
||
if (buttonsDown & (BLEFT | BRIGHT)) {
|
||
defaultSpeed = speed;
|
||
defaultFps = kSpeedFps[static_cast<std::size_t>(speed - 1)];
|
||
if (docLoaded) {
|
||
doc.metadata.fps = static_cast<std::uint8_t>(defaultFps);
|
||
doc.metadata.speed = static_cast<std::uint8_t>(speed);
|
||
markDirty();
|
||
if (doc.metadata.bgmFollowsSpeed) rebuildAudio();
|
||
}
|
||
savePreferences();
|
||
}
|
||
if (buttonsDown & BUP) { onion = !onion; savePreferences(); }
|
||
if (buttonsDown & BDOWN) { canvasGrid = !canvasGrid; savePreferences(); }
|
||
if (buttonsDown & BY) { copyToNewPage = !copyToNewPage; savePreferences(); }
|
||
if ((buttonsDown & BX) && docLoaded) { doc.metadata.loopPlayback = !doc.metadata.loopPlayback; markDirty(); }
|
||
if (buttonsDown & BA) modal = Modal::None;
|
||
return;
|
||
}
|
||
if (modal == Modal::Audio) {
|
||
if (buttonsDown & BLEFT) { audioTrack = std::max(0, audioTrack - 1); audioEraseArmedTrack = -1; }
|
||
if (buttonsDown & BRIGHT) { audioTrack = std::min(3, audioTrack + 1); audioEraseArmedTrack = -1; }
|
||
if ((buttonsDown & BY) && audioTrack == 0) {
|
||
doc.metadata.bgmFollowsSpeed = !doc.metadata.bgmFollowsSpeed;
|
||
markDirty();
|
||
rebuildAudio();
|
||
}
|
||
if (buttonsDown & BA) {
|
||
if (audioTrack < static_cast<int>(doc.audioTracks.size()) &&
|
||
!doc.audioTracks[static_cast<std::size_t>(audioTrack)].pcm.empty()) {
|
||
if (Mix_Playing(4)) Mix_HaltChannel(4);
|
||
else if (audioReady && trackChunks[static_cast<std::size_t>(audioTrack)])
|
||
Mix_PlayChannel(4, trackChunks[static_cast<std::size_t>(audioTrack)], 0);
|
||
} else showToast("No audio in this track yet");
|
||
}
|
||
if ((buttonsDown & (BPLUS | BMINUS)) && audioTrack > 0) {
|
||
while (doc.audioTracks.size() <= static_cast<std::size_t>(audioTrack)) {
|
||
sppm::AudioTrack blank;
|
||
blank.name = "SE" + std::to_string(doc.audioTracks.size());
|
||
blank.sampleRate = 48000;
|
||
blank.channels = 2;
|
||
doc.audioTracks.push_back(std::move(blank));
|
||
}
|
||
auto& triggers = doc.audioTracks[static_cast<std::size_t>(audioTrack)].frameTriggers;
|
||
const auto cue = static_cast<std::uint16_t>(frame);
|
||
auto it = std::lower_bound(triggers.begin(), triggers.end(), cue);
|
||
if (it != triggers.end() && *it == cue) triggers.erase(it);
|
||
else triggers.insert(it, cue);
|
||
markDirty();
|
||
}
|
||
return;
|
||
}
|
||
if (modal == Modal::Folder) {
|
||
if (buttonsDown & BUP) modalSelection = std::max(0, modalSelection - 1);
|
||
if (buttonsDown & BDOWN) modalSelection = std::min(5, modalSelection + 1);
|
||
if (buttonsDown & BA) {
|
||
std::vector<std::string> folders;
|
||
if (DIR* dir = opendir(notesRoot.c_str())) {
|
||
while (dirent* ent = readdir(dir)) {
|
||
const std::string name = ent->d_name;
|
||
if (name.empty() || name[0] == '.') continue;
|
||
struct stat st{};
|
||
if (stat(join(notesRoot, name).c_str(), &st) == 0 && (st.st_mode & S_IFDIR)) folders.push_back(name);
|
||
}
|
||
closedir(dir);
|
||
}
|
||
std::sort(folders.begin(), folders.end());
|
||
if (!folders.empty()) {
|
||
folder = folders[static_cast<std::size_t>(modalSelection) % folders.size()];
|
||
selected = 0;
|
||
scanLibrary();
|
||
modal = Modal::None;
|
||
playEvent("folder_open", "folder_open");
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
if (modal == Modal::Export && (buttonsDown & (BUP | BDOWN | BLEFT | BRIGHT))) modalSelection = (modalSelection + 1) % 2;
|
||
if ((modal == Modal::ConfirmDelete || modal == Modal::ConfirmGalleryDelete) &&
|
||
(buttonsDown & (BLEFT | BRIGHT))) modalSelection = (modalSelection + 1) % 2;
|
||
if (buttonsDown & BA) {
|
||
if (modal == Modal::Export) { exportDocument(modalSelection); modal = Modal::None; }
|
||
else if (modal == Modal::ConfirmGalleryDelete) {
|
||
if (modalSelection == 1) deleteGalleryItem();
|
||
else modal = Modal::None;
|
||
} else if (modal == Modal::Help) modal = Modal::None;
|
||
else if (modal == Modal::TextInput) applyText();
|
||
}
|
||
return;
|
||
}
|
||
if (buttonsDown & BB) {
|
||
switch (screen) {
|
||
case Screen::Title: break;
|
||
case Screen::Library: screen = Screen::Title; return;
|
||
case Screen::Details: screen = Screen::Library; return;
|
||
case Screen::Sequence: screen = Screen::Canvas; return;
|
||
case Screen::Canvas:
|
||
layer = (layer + 1) % 4;
|
||
playEvent("tool_layer", "draw_tool_btn_on");
|
||
return;
|
||
case Screen::Viewer:
|
||
stopPlayback();
|
||
screen = galleryViewing ? Screen::GalleryDetails : Screen::Details;
|
||
return;
|
||
case Screen::Settings: screen = settingsReturnScreen; return;
|
||
case Screen::Gallery: screen = Screen::Library; return;
|
||
case Screen::GalleryDetails:
|
||
if (galleryProfileDetailMode) { galleryProfileDetailMode = false; screen = Screen::GalleryProfile; }
|
||
else screen = Screen::Gallery;
|
||
return;
|
||
case Screen::GalleryProfile: leaveGalleryProfile(); return;
|
||
case Screen::GalleryComments: screen = Screen::GalleryDetails; return;
|
||
case Screen::CommentCanvas: screen = Screen::GalleryComments; return;
|
||
case Screen::AppletWarning: running = false; return;
|
||
}
|
||
}
|
||
if (buttonsDown & BMINUS) {
|
||
if (screen == Screen::Title) return;
|
||
if (screen == Screen::Settings) { screen = settingsReturnScreen; return; }
|
||
if (screen == Screen::Library || screen == Screen::Gallery) screen = Screen::Title;
|
||
else if (screen == Screen::Canvas || screen == Screen::Viewer) { stopPlayback(); screen = Screen::Sequence; }
|
||
else if (screen == Screen::GalleryComments) screen = Screen::GalleryDetails;
|
||
else if (screen == Screen::CommentCanvas) screen = Screen::GalleryComments;
|
||
else if (screen == Screen::Sequence) { closeDocument(); screen = Screen::Library; }
|
||
else if (screen == Screen::Details || screen == Screen::GalleryDetails) {
|
||
if (screen == Screen::GalleryDetails && galleryProfileDetailMode) {
|
||
galleryProfileDetailMode = false;
|
||
screen = Screen::GalleryProfile;
|
||
} else screen = (screen == Screen::GalleryDetails ? Screen::Gallery : Screen::Library);
|
||
}
|
||
}
|
||
if (screen == Screen::Title) {
|
||
if (buttonsDown & BR) { settingsReturnScreen = Screen::Title; screen = Screen::Settings; return; }
|
||
if ((buttonsDown & (BZL | BZR)) == (BZL | BZR) || (buttonsHeld & (BZL | BZR)) == (BZL | BZR) || (buttonsDown & BA)) {
|
||
screen = Screen::Library;
|
||
selected = 0;
|
||
playEvent("folder_open", "folder_open");
|
||
}
|
||
} else if (screen == Screen::Library || screen == Screen::Gallery) {
|
||
const bool galleryMode = screen == Screen::Gallery;
|
||
if (!galleryMode && (buttonsDown & BZR)) { showGalleryNotice(); return; }
|
||
if (galleryMode && (buttonsDown & BZL) && galleryPage > 0) {
|
||
--galleryPage; gallerySelected = 0; galleryStatus = "Loading Gallery…"; refreshGallery(); return;
|
||
}
|
||
if (galleryMode && (buttonsDown & BZR) && (galleryPage + 1) * 6 < galleryTotal) {
|
||
++galleryPage; gallerySelected = 0; galleryStatus = "Loading Gallery…"; refreshGallery(); return;
|
||
}
|
||
if (!galleryMode && (buttonsDown & BR)) {
|
||
settingsReturnScreen = Screen::Library;
|
||
screen = Screen::Settings;
|
||
return;
|
||
}
|
||
if (!galleryMode && (buttonsDown & BPLUS)) {
|
||
newDocument();
|
||
return;
|
||
}
|
||
auto& selection = galleryMode ? gallerySelected : selected;
|
||
const auto& items = galleryMode ? gallery : library;
|
||
if (buttonsDown & BLEFT) { if (selection > 0) --selection; }
|
||
if (buttonsDown & BRIGHT) { if (selection + 1 < items.size()) ++selection; }
|
||
if (buttonsDown & BUP) { if (selection >= 3) selection -= 3; }
|
||
if (buttonsDown & BDOWN) { if (selection + 3 < items.size()) selection += 3; }
|
||
if (buttonsDown & BY) {
|
||
if (!galleryMode && !items.empty()) openItem(selection, true);
|
||
else if (galleryMode) addGalleryCoin();
|
||
}
|
||
if (buttonsDown & BA) {
|
||
if (!items.empty()) {
|
||
if (galleryMode) screen = Screen::GalleryDetails;
|
||
else { expandMetadata = false; screen = Screen::Details; }
|
||
}
|
||
}
|
||
if (buttonsDown & BX && !galleryMode && !items.empty()) { modalSelection = 0; modal = Modal::ConfirmDelete; }
|
||
} else if (screen == Screen::Details || screen == Screen::GalleryDetails) {
|
||
const bool galleryOwner = screen == Screen::GalleryDetails && !gallery.empty() &&
|
||
gallery[gallerySelected % gallery.size()].ownerIdentity == sppm::identityFingerprint(signingIdentity.publicIdentity);
|
||
if (buttonsDown & BX && galleryOwner) { modalSelection = 0; modal = Modal::ConfirmGalleryDelete; }
|
||
if (buttonsDown & BY) {
|
||
if (screen == Screen::GalleryDetails) openGalleryComments();
|
||
else { openItem(selected, true); }
|
||
}
|
||
if (buttonsDown & BA) {
|
||
if (screen == Screen::GalleryDetails) openGalleryItem(gallerySelected);
|
||
else { openItem(selected, false); screen = Screen::Viewer; }
|
||
}
|
||
if (buttonsDown & BZL && screen == Screen::Details && !library.empty()) { modalSelection = 0; modal = Modal::ConfirmDelete; }
|
||
} else if (screen == Screen::Sequence) {
|
||
if (buttonsDown & BPLUS) { settingsReturnScreen = Screen::Sequence; screen = Screen::Settings; return; }
|
||
if (buttonsDown & BLEFT) setFrame(frame ? frame - 1 : 0);
|
||
if (buttonsDown & BRIGHT) {
|
||
const bool createsFirstHeldPage = frame + 1 >= doc.frames.size();
|
||
if (frame + 1 < doc.frames.size()) setFrame(frame + 1);
|
||
else insertFrame(false);
|
||
const std::uint32_t period = std::max<std::uint32_t>(1, static_cast<std::uint32_t>(std::lround(1000.0 / sppm::frameRate(doc.metadata))));
|
||
rightDpadNextRepeatAt = SDL_GetTicks() + period * (createsFirstHeldPage ? 3u : 1u);
|
||
rightDpadRepeating = (buttonsHeld & BRIGHT) != 0;
|
||
}
|
||
if (buttonsDown & BUP) setFrame(0, true, "frame_first");
|
||
if (buttonsDown & BDOWN) setFrame(doc.frames.size() - 1, true, "frame_last");
|
||
if (buttonsDown & BA) startPlayback();
|
||
if (buttonsDown & BY) {
|
||
if (doc.metadata.locked) showToast("This Switchnote is locked and cannot be edited");
|
||
else screen = Screen::Canvas;
|
||
}
|
||
if ((buttonsDown & BX) && !doc.metadata.locked) insertFrame(false);
|
||
if (buttonsDown & BZL) { modalSelection = 0; modal = Modal::ConfirmDelete; }
|
||
} else if (screen == Screen::Canvas || screen == Screen::Viewer) {
|
||
if (screen == Screen::Viewer && (buttonsDown & BLEFT)) { if (frame) setFrame(frame - 1); }
|
||
if (screen == Screen::Viewer && (buttonsDown & BRIGHT)) {
|
||
const bool createsFirstHeldPage = frame + 1 >= doc.frames.size();
|
||
if (frame + 1 < doc.frames.size()) setFrame(frame + 1);
|
||
else if (screen == Screen::Canvas) insertFrame(false);
|
||
if (screen == Screen::Canvas && modal == Modal::None) {
|
||
const std::uint32_t period = std::max<std::uint32_t>(1, static_cast<std::uint32_t>(std::lround(1000.0 / sppm::frameRate(doc.metadata))));
|
||
rightDpadNextRepeatAt = SDL_GetTicks() + period * (createsFirstHeldPage ? 3u : 1u);
|
||
rightDpadRepeating = (buttonsHeld & BRIGHT) != 0;
|
||
}
|
||
}
|
||
if (screen == Screen::Canvas && (buttonsDown & BUP)) { zoom = std::min(zoom * 1.25f, 8.0f); }
|
||
if (screen == Screen::Canvas && (buttonsDown & BDOWN)) { zoom = std::max(zoom / 1.25f, 0.5f); }
|
||
if (buttonsDown & BA) { if (playing) stopPlayback(); else startPlayback(); }
|
||
if (screen == Screen::Viewer && (buttonsDown & BB)) { stopPlayback(); screen = Screen::Sequence; }
|
||
if (screen == Screen::Canvas) {
|
||
const bool dpadDown = (buttonsDown & (BLEFT | BRIGHT)) != 0;
|
||
if (((buttonsHeld & BY) && dpadDown) || ((buttonsDown & BY) && (buttonsHeld & (BLEFT | BRIGHT))) ||
|
||
((buttonsUp & BY) && dpadDown)) {
|
||
canvasYChordUsed = true;
|
||
if (buttonsDown & BLEFT) undo();
|
||
if (buttonsDown & BRIGHT) redo();
|
||
if ((buttonsDown & BY) && (buttonsHeld & BLEFT)) undo();
|
||
if ((buttonsDown & BY) && (buttonsHeld & BRIGHT)) redo();
|
||
}
|
||
const bool suppressDpadForY = canvasYChordUsed || (buttonsHeld & BY) != 0;
|
||
if ((buttonsUp & BY) && !canvasYChordUsed) {
|
||
activeTool = activeTool == Tool::Pen ? Tool::Brush : activeTool == Tool::Brush ? Tool::Eraser : Tool::Pen;
|
||
playEvent(activeTool == Tool::Pen ? "tool_pen" : activeTool == Tool::Brush ? "tool_brush" : "tool_eraser", "draw_tool_btn_on");
|
||
}
|
||
if (buttonsUp & BY) canvasYChordUsed = false;
|
||
if (buttonsDown & BZL) undo();
|
||
if (buttonsDown & BZR) redo();
|
||
if (buttonsDown & BX) {
|
||
pushUndo();
|
||
auto& pixels = doc.frames[frame].layers[static_cast<std::size_t>(layer)];
|
||
std::fill(pixels.begin(), pixels.end(), 0);
|
||
markDirty();
|
||
playEvent("clear_layer", "erase");
|
||
}
|
||
if ((buttonsDown & BLEFT) && !suppressDpadForY) { if (frame) setFrame(frame - 1); }
|
||
if ((buttonsDown & BRIGHT) && !suppressDpadForY) {
|
||
const bool createsFirstHeldPage = frame + 1 >= doc.frames.size();
|
||
if (frame + 1 < doc.frames.size()) setFrame(frame + 1);
|
||
else insertFrame(false);
|
||
const std::uint32_t period = std::max<std::uint32_t>(1, static_cast<std::uint32_t>(std::lround(1000.0 / sppm::frameRate(doc.metadata))));
|
||
rightDpadNextRepeatAt = SDL_GetTicks() + period * (createsFirstHeldPage ? 3u : 1u);
|
||
rightDpadRepeating = (buttonsHeld & BRIGHT) != 0;
|
||
}
|
||
if (buttonsDown & BL) screen = Screen::Sequence;
|
||
if (buttonsDown & BPLUS) insertFrame(false);
|
||
}
|
||
} else if (screen == Screen::Settings) {
|
||
if (buttonsDown & BB) screen = settingsReturnScreen;
|
||
} else if (screen == Screen::GalleryProfile) {
|
||
const int profilePages = 1 + (galleryProfile.switchnotes + 5) / 6;
|
||
if ((buttonsDown & BLEFT) && galleryProfilePage > 0)
|
||
loadGalleryProfile(galleryProfile.identity, galleryProfileReturnScreen, galleryProfilePage - 1);
|
||
if ((buttonsDown & BRIGHT) && galleryProfilePage + 1 < profilePages)
|
||
loadGalleryProfile(galleryProfile.identity, galleryProfileReturnScreen, galleryProfilePage + 1);
|
||
if ((buttonsDown & BA) && galleryProfilePage > 0 && !gallery.empty()) {
|
||
galleryProfileDetailMode = true;
|
||
screen = Screen::GalleryDetails;
|
||
} else if ((buttonsDown & BA) && galleryProfilePage == 0 && !galleryProfileIsOwn) {
|
||
updateGalleryRelationship(galleryProfile.followed ? "unfollow" : "follow");
|
||
}
|
||
if (buttonsDown & BX) updateGalleryRelationship(galleryProfile.blocked ? "unblock" : "block");
|
||
if ((buttonsDown & BY) && galleryProfileIsOwn) beginText(Field::GalleryBio, galleryProfile.bio);
|
||
} else if (screen == Screen::GalleryComments) {
|
||
if (buttonsDown & BUP) galleryCommentScroll = std::max(0, galleryCommentScroll - 90);
|
||
if (buttonsDown & BDOWN) galleryCommentScroll += 90;
|
||
if (buttonsDown & BY) screen = Screen::CommentCanvas;
|
||
if (buttonsDown & BB) screen = Screen::GalleryDetails;
|
||
} else if (screen == Screen::CommentCanvas) {
|
||
if (buttonsDown & BB) screen = Screen::GalleryComments;
|
||
if (buttonsDown & BY) postGalleryComment();
|
||
if (buttonsDown & BX) { commentPixels.assign(sppm::kPixelsPerLayer, 0); commentDirty = true; }
|
||
}
|
||
if (wheel && screen == Screen::Canvas) zoom = std::clamp(zoom + wheel * 0.2f, 0.5f, 8.0f);
|
||
if (wheel && screen == Screen::GalleryComments)
|
||
galleryCommentScroll = std::max(0, galleryCommentScroll - wheel * 90);
|
||
if (screen == Screen::Canvas) {
|
||
const int maxPanX = std::max(0, (static_cast<int>(sppm::kWidth * 2.0f * zoom) - W) / 2);
|
||
const int maxPanY = std::max(0, (static_cast<int>(sppm::kHeight * 2.0f * zoom) - H) / 2);
|
||
panX = std::clamp(panX, -maxPanX, maxPanX);
|
||
panY = std::clamp(panY, -maxPanY, maxPanY);
|
||
}
|
||
}
|
||
|
||
void App::render() {
|
||
// Some custom canvas effects alter the renderer blend mode. Restore alpha
|
||
// blending every frame so loading dimmers and translucent UI always work.
|
||
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
|
||
if (screen == Screen::Canvas || screen == Screen::Viewer) SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
|
||
else SDL_SetRenderDrawColor(renderer, 245, 246, 248, 255);
|
||
SDL_RenderClear(renderer);
|
||
switch (screen) {
|
||
case Screen::Title: renderTitle(); break;
|
||
case Screen::Library: renderLibrary(); break;
|
||
case Screen::Details: renderDetails(false); break;
|
||
case Screen::Settings: renderSettings(); break;
|
||
case Screen::Sequence: renderSequence(); break;
|
||
case Screen::Canvas: renderCanvas(); break;
|
||
case Screen::Viewer: renderViewer(); break;
|
||
case Screen::Gallery: renderGallery(); break;
|
||
case Screen::GalleryDetails: renderDetails(true); break;
|
||
case Screen::GalleryProfile: renderGalleryProfile(); break;
|
||
case Screen::GalleryComments: renderComments(); break;
|
||
case Screen::CommentCanvas: renderCommentCanvas(); break;
|
||
case Screen::AppletWarning: renderAppletWarning(); break;
|
||
}
|
||
if (modal != lastRenderedModal) {
|
||
modalTransitionStart = SDL_GetTicks();
|
||
if (modal == Modal::None) {
|
||
modalVisual = lastRenderedModal;
|
||
modalClosing = modalVisual != Modal::None;
|
||
} else {
|
||
modalVisual = modal;
|
||
modalClosing = false;
|
||
playEvent("popup", "popup");
|
||
}
|
||
lastRenderedModal = modal;
|
||
}
|
||
if (modal != Modal::None) renderModal();
|
||
else if (modalClosing) {
|
||
const Modal savedModal = modal;
|
||
modal = modalVisual;
|
||
renderModal();
|
||
modal = savedModal;
|
||
}
|
||
renderToast();
|
||
const Uint8 transitionAlpha = screen.whiteAlpha(SDL_GetTicks());
|
||
if (transitionAlpha) fill(0, 0, W, H, SDL_Color{255, 255, 255, transitionAlpha});
|
||
renderLoadingOverlay();
|
||
SDL_RenderPresent(renderer);
|
||
if (touchHoverExpiryPending && !pointerDown) {
|
||
pointerX = pointerY = -1;
|
||
touchHoverExpiryPending = false;
|
||
}
|
||
}
|
||
|
||
void App::renderAppletWarning() {
|
||
background();
|
||
const SDL_Color panel{239, 119, 122, 255};
|
||
const SDL_Color darkRed{194, 24, 24, 255};
|
||
rounded(53, 43, 1174, 640, 28, SDL_Color{0, 0, 0, 35});
|
||
rounded(59, 47, 1162, 636, 28, WHITE);
|
||
rounded(61, 49, 1158, 632, 26, panel);
|
||
centered("Cannot run in Applet Mode", 210, 145, 860, 100, 48, darkRed, true);
|
||
centered(appDisplayName + " cannot run in Applet Mode.", 165, 268, 950, 52, 28, darkRed, false);
|
||
text("Please run the app from the Homebrew Menu in App Override mode, or", 168, 366, 27, darkRed, false);
|
||
text("install the homebrew NSP file.", 168, 402, 27, darkRed, false);
|
||
const bool hovered = pointerX >= 566 && pointerX < 714 && pointerY >= 524 && pointerY < 584;
|
||
const int press = pointerDown && hovered ? 2 : 0;
|
||
rounded(578, 530 + press, 124, 53, 28, SDL_Color{0, 0, 0, 35});
|
||
rounded(572, 524 + press, 136, 54, 28, WHITE);
|
||
rounded(574, 526 + press, 132, 50, 26, panel);
|
||
centered("Exit", 574, 526 + press, 132, 50, 24, darkRed, false);
|
||
if (hit(572, 524, 136, 54)) { clickConsumed = true; running = false; }
|
||
}
|
||
|
||
void App::renderTitle() {
|
||
background();
|
||
if (brandingLogoTexture) {
|
||
int sourceW = 0, sourceH = 0;
|
||
SDL_QueryTexture(brandingLogoTexture, nullptr, nullptr, &sourceW, &sourceH);
|
||
const float scale = sourceW > 0 && sourceH > 0 ? std::min(640.0f / sourceW, 218.0f / sourceH) : 1.0f;
|
||
const int logoW = static_cast<int>(sourceW * scale), logoH = static_cast<int>(sourceH * scale);
|
||
drawTexture(brandingLogoTexture, 640 - logoW / 2, 252 - logoH / 2, logoW, logoH);
|
||
}
|
||
else {
|
||
centered(appDisplayName, 240, 190, 800, 126, 72, CREAM, true);
|
||
centered(appDisplayName, 240, 184, 800, 126, 72, ORANGE, true);
|
||
}
|
||
if (actionPill("ui/icons/CanvasMenu_ConfigToggle.png", "Settings", 1022, 36, 214, 48, false, true, "")) {
|
||
settingsReturnScreen = Screen::Title;
|
||
screen = Screen::Settings;
|
||
}
|
||
const float focus = 0.5f + 0.5f * std::sin(pulse * 2.4f);
|
||
const auto promptTone = static_cast<Uint8>(220 + 10 * focus);
|
||
const bool promptHovered = pointerX >= 474 && pointerX < 806 && pointerY >= 469 && pointerY < 531;
|
||
const bool promptPressed = pointerDown && promptHovered;
|
||
const int promptLift = hoverLift(474, 469, promptHovered);
|
||
const int promptPress = promptPressed ? 4 : 0;
|
||
const int promptY = -promptLift + promptPress;
|
||
rounded(474, 474 + promptY, 332, 64, 14, SDL_Color{0, 0, 0, 38});
|
||
rounded(474, 469 + promptY, 332, 62, 14, WHITE);
|
||
rounded(480, 475 + promptY, 320, 50, 10, SDL_Color{255, promptTone, static_cast<Uint8>(197 + 8 * focus), 255});
|
||
centered("Press", 516, 475 + promptY, 100, 50, 25, ORANGE, true);
|
||
auto promptIcon = [&](const char* path, int x) {
|
||
SDL_Texture* texture = image(path);
|
||
if (!texture) return;
|
||
int sourceW = 0, sourceH = 0;
|
||
SDL_QueryTexture(texture, nullptr, nullptr, &sourceW, &sourceH);
|
||
const float iconScale = sourceW && sourceH ? std::min(42.0f / sourceW, 32.0f / sourceH) : 1.0f;
|
||
const int iconW = std::max(1, static_cast<int>(std::lround(sourceW * iconScale)));
|
||
const int iconH = std::max(1, static_cast<int>(std::lround(sourceH * iconScale)));
|
||
drawTexture(texture, x + (42 - iconW) / 2, 484 + (32 - iconH) / 2 + promptY, iconW, iconH);
|
||
};
|
||
promptIcon("ui/icons/ButtonZLText.png", 622);
|
||
centered("+", 666, 475 + promptY, 34, 50, 25, ORANGE, true);
|
||
promptIcon("ui/icons/ButtonZRText.png", 698);
|
||
if (hit(474, 469, 332, 62)) { clickConsumed = true; screen = Screen::Library; selected = 0; playEvent("folder_open", "folder_open"); }
|
||
centered("© 2026 RexiMemo!", 390, 634, 500, 44, 25, ORANGE, false);
|
||
text("Ver 0.1.51", 1130, 663, 18, ORANGE);
|
||
}
|
||
|
||
void App::renderLibrary() {
|
||
background();
|
||
drawImage("ui/FolderButton_Active.png", 40, 25, 68, 68);
|
||
drawImage("ui/FolderButton_New.png", 122, 25, 68, 68);
|
||
centered("Folders", 36, 88, 76, 21, 14, GRAY, true);
|
||
centered("New Folder", 115, 88, 84, 21, 13, GRAY, true);
|
||
if (pill("Switchnote Gallery", 788, 40, 205, 47, true, 19)) showGalleryNotice();
|
||
if (actionPill("ui/icons/FrameNew.png", "New Switchnote", 1017, 40, 220, 47, false, true, "")) newDocument();
|
||
if (hit(40, 24, 70, 70)) { clickConsumed = true; modalSelection = 0; modal = Modal::Folder; playEvent("folder_open", "folder_open"); }
|
||
if (hit(122, 24, 70, 70)) { clickConsumed = true; beginText(Field::FolderName, ""); }
|
||
const int start = static_cast<int>(page) * 6;
|
||
if (library.empty()) {
|
||
rounded(305, 190, 670, 315, 20, SDL_Color{0, 0, 0, 28});
|
||
rounded(305, 182, 670, 315, 20, WHITE);
|
||
drawImage("ui/icons/FrameNew.png", 594, 224, 92, 92);
|
||
centered("\"" + folder + "\" is empty", 355, 328, 570, 42, 27, INK, true);
|
||
centered("Switchnotes added to this folder will show here.", 345, 374, 590, 40, 18, GRAY);
|
||
if (actionPill("ui/icons/FrameNew.png", "Create Switchnote", 500, 434, 280, 50)) newDocument();
|
||
}
|
||
for (int cell = 0; cell < 6; ++cell) {
|
||
const int index = start + cell;
|
||
if (index >= static_cast<int>(library.size())) break;
|
||
const int col = cell % 3;
|
||
const int row = cell / 3;
|
||
const int x = 104 + col * 372;
|
||
const int y = 153 + row * 232;
|
||
const bool selectedNow = static_cast<std::size_t>(index) == selected;
|
||
const bool hovered = pointerX >= x - 5 && pointerX < x + 326 && pointerY >= y - 4 && pointerY < y + 194;
|
||
const int lift = hoverLift(x, y, hovered);
|
||
const SDL_Color border = selectedNow ? ORANGE : SDL_Color{210, 214, 220, 255};
|
||
rounded(x - 5, y + 4 - lift, 331, 198, 15, SDL_Color{0, 0, 0, 48});
|
||
rounded(x - 5, y - 4 - lift, 331, 198, 15, WHITE);
|
||
// Every Switchnote preview sits on the same solid paper background,
|
||
// regardless of whether its content uses transparent pixels.
|
||
rounded(x + 3, y + 4 - lift, 315, 182, 8, WHITE);
|
||
const Item& item = library[static_cast<std::size_t>(index)];
|
||
if (item.sample) drawImage("art/" + item.artwork, x + 3, y + 4 - lift, 315, 182, true);
|
||
else if (item.path == docPath && docLoaded) drawCurrentFrame(x + 3, y + 4 - lift, 315, 182);
|
||
else drawTexture(thumbTexture(item), x + 3, y + 4 - lift, 315, 182);
|
||
roundedOutline(x - 1, y - lift, 323, 190, 14, 4, border);
|
||
if (!item.sample && item.locked) drawLockIcon(x + 10, y + 10 - lift);
|
||
if (selectedNow) {
|
||
const int pop = lift;
|
||
rounded(x + 142 - pop / 2, y + 170 - pop / 2 - lift, 58 + pop, 58 + pop, 30 + pop / 2, SDL_Color{0, 0, 0, 42});
|
||
rounded(x + 138 - pop / 2, y + 164 - pop / 2 - lift, 58 + pop, 58 + pop, 30 + pop / 2, WHITE);
|
||
rounded(x + 143 - pop / 2, y + 169 - pop / 2 - lift, 48 + pop, 48 + pop, 24 + pop / 2, CREAM);
|
||
drawPlayTriangle(x + 158 - pop / 2, y + 182 - pop / 2 - lift, 20 + pop, ORANGE);
|
||
}
|
||
if (hit(x - 5, y - 4, 331, 198)) {
|
||
selected = static_cast<std::size_t>(index); page = selected / 6; clickConsumed = true;
|
||
if (selectedNow) { expandMetadata = false; screen = Screen::Details; }
|
||
else playCue("button_on");
|
||
}
|
||
}
|
||
const int totalPages = std::max(1, static_cast<int>((library.size() + 5) / 6));
|
||
if (totalPages > 1 && page > 0 && pill("<", 25, 327, 60, 78, false, 34)) --page;
|
||
if (totalPages > 1 && page + 1 < totalPages && pill(">", 1195, 327, 60, 78, false, 34)) ++page;
|
||
if (imageButton("ui/BackButton.png", 39, 620, 65, 65, "button_off")) screen = Screen::Title;
|
||
for (int i = 0; i < totalPages; ++i) rounded(582 + i * 18, 653, 12, 12, 6, i == page ? ORANGE : CREAM);
|
||
if (actionPill("ui/icons/ButtonYText.png", "Edit", 920, 635, 126, 50, false, !library.empty())) openItem(selected, true);
|
||
if (actionPill("ui/icons/ButtonAText.png", "Details", 1060, 635, 164, 50, false, !library.empty())) { expandMetadata = false; screen = Screen::Details; }
|
||
if (hit(40, 25, 68, 68)) { modalSelection = 0; modal = Modal::Folder; clickConsumed = true; }
|
||
if (hit(122, 25, 68, 68)) { beginText(Field::FolderName, ""); clickConsumed = true; }
|
||
}
|
||
|
||
void App::renderSettings() {
|
||
background();
|
||
if (imageButton("ui/BackButton.png", 39, 35, 65, 65, "button_off")) screen = settingsReturnScreen;
|
||
text("Settings", 132, 40, 34, INK, true);
|
||
|
||
rounded(103, 139, 514, 150, 18, SDL_Color{0, 0, 0, 28});
|
||
rounded(103, 132, 514, 150, 18, WHITE);
|
||
rounded(126, 165, 84, 84, 3, PALE_GREEN);
|
||
if (profileTexture) drawTexture(profileTexture, 126, 165, 84, 84);
|
||
else centered(userName.empty() ? "?" : utf8Prefix(userName, 1), 126, 165, 84, 84, 40, WHITE, true);
|
||
text("Nickname", 232, 162, 17, GRAY, true);
|
||
text(userName, 232, 196, 28, INK, true);
|
||
|
||
rounded(645, 139, 532, 150, 18, SDL_Color{0, 0, 0, 28});
|
||
rounded(645, 132, 532, 150, 18, LIGHT);
|
||
text("Creator FSID", 677, 158, 18, GRAY, true);
|
||
text(myFsid, 677, 193, 30, SDL_Color{125, 132, 146, 255}, true);
|
||
|
||
std::string freeSpace = "Unavailable";
|
||
#ifdef __SWITCH__
|
||
FsFileSystem sd{};
|
||
s64 freeBytes = 0;
|
||
if (R_SUCCEEDED(fsOpenSdCardFileSystem(&sd))) {
|
||
if (R_SUCCEEDED(fsFsGetFreeSpace(&sd, "/", &freeBytes))) {
|
||
const double gib = static_cast<double>(freeBytes) / (1024.0 * 1024.0 * 1024.0);
|
||
std::ostringstream amount;
|
||
amount.setf(std::ios::fixed);
|
||
amount.precision(gib >= 10.0 ? 0 : 1);
|
||
amount << gib << " GB free";
|
||
freeSpace = amount.str();
|
||
}
|
||
fsFsClose(&sd);
|
||
}
|
||
#endif
|
||
rounded(103, 329, 1074, 120, 18, SDL_Color{0, 0, 0, 28});
|
||
rounded(103, 322, 1074, 120, 18, WHITE);
|
||
text("SD Free Space", 138, 350, 19, GRAY, true);
|
||
text(freeSpace, 138, 385, 31, INK, true);
|
||
if (pill(std::string("Pen Stabilisation: ") + (penStabilisationEnabled ? "On" : "Off"),
|
||
103, 466, 330, 48, penStabilisationEnabled, 18)) {
|
||
penStabilisationEnabled = !penStabilisationEnabled;
|
||
savePreferences();
|
||
}
|
||
if (penStabilisationEnabled) {
|
||
text("Method", 480, 474, 18, GRAY);
|
||
if (pill(penStabilisationAfter ? "After" : "Real Time", 556, 466, 185, 48, true, 18)) {
|
||
penStabilisationAfter = !penStabilisationAfter;
|
||
afterStrokePoints.clear();
|
||
realtimeStrokeInitialized = false;
|
||
savePreferences();
|
||
}
|
||
text("Stabilisation", 103, 535, 18, GRAY);
|
||
const int sliderX = 263, sliderY = 550, sliderW = 650;
|
||
rounded(sliderX, sliderY + 8, sliderW, 8, 4, LIGHT);
|
||
rounded(sliderX, sliderY + 8, sliderW * penStabilisationStrength / 100, 8, 4, GREEN);
|
||
const int handleX = sliderX + sliderW * penStabilisationStrength / 100;
|
||
rounded(handleX - 13, sliderY, 26, 26, 13, WHITE);
|
||
rounded(handleX - 8, sliderY + 5, 16, 16, 8, GREEN);
|
||
text(std::to_string(penStabilisationStrength), 932, 544, 18, GREEN);
|
||
if (pointerDown && pointerX >= sliderX - 8 && pointerX <= sliderX + sliderW + 8 &&
|
||
pointerY >= sliderY - 8 && pointerY <= sliderY + 34) {
|
||
penStabilisationStrength = std::clamp((pointerX - sliderX) * 100 / sliderW, 0, 100);
|
||
}
|
||
if (hit(sliderX - 8, sliderY - 8, sliderW + 16, 42)) {
|
||
clickConsumed = true;
|
||
penStabilisationStrength = std::clamp((pointerX - sliderX) * 100 / sliderW, 0, 100);
|
||
savePreferences();
|
||
}
|
||
}
|
||
centered("Import from branding.config in the app folder · exports/branding.config", 300, 590, 650, 30, 15, GRAY);
|
||
if (pill("Credits", 1000, 582, 177, 42, false, 17)) { modal = Modal::Credits; modalTransitionStart = SDL_GetTicks(); }
|
||
if (pill("Import Branding", 103, 634, 250, 56, false, 17)) importBrandingConfig();
|
||
if (pill("Export Branding", 367, 634, 250, 56, false, 17)) exportBrandingConfig();
|
||
if (pill("Check for Updates", 631, 634, 246, 56, false, 17)) startUpdateCheck(true);
|
||
if (actionPill("ui/icons/CanvasMenu_ConfigToggle.png", "Branding Config Portal", 891, 634, 286, 56, false, true, "")) {
|
||
requestBrandingConfigServer(); modal = Modal::Branding; modalTransitionStart = SDL_GetTicks();
|
||
}
|
||
}
|
||
|
||
void App::renderGallery() {
|
||
background();
|
||
const std::string sortLabel = galleryPopular ? "Popular " + notePlural : "Recent " + notePlural;
|
||
if (pill(sortLabel, 40, 40, 274, 48, true, 18)) {
|
||
galleryPopular = !galleryPopular;
|
||
galleryPage = 0;
|
||
gallerySelected = 0;
|
||
galleryStatus = "Loading Gallery…";
|
||
refreshGallery();
|
||
}
|
||
rounded(1173, 37, 68, 68, 12, SDL_Color{0, 0, 0, 40});
|
||
rounded(1173, 32, 68, 68, 12, WHITE);
|
||
rounded(1178, 37, 58, 58, 3, PALE_GREEN);
|
||
if (profileCornerTexture) drawTexture(profileCornerTexture, 1178, 37, 58, 58);
|
||
else centered(userName.empty() ? "?" : utf8Prefix(userName, 1), 1178, 37, 58, 58, 30, GREEN, true);
|
||
rounded(1212, 78, 29, 29, 15, SDL_Color{10, 12, 15, 255});
|
||
centered("+", 1212, 76, 29, 29, 25, WHITE, true);
|
||
if (hit(1173, 32, 68, 68)) {
|
||
clickConsumed = true;
|
||
loadGalleryProfile(sppm::identityFingerprint(signingIdentity.publicIdentity), Screen::Gallery);
|
||
}
|
||
|
||
if (gallery.empty()) {
|
||
rounded(330, 226, 620, 258, 20, SDL_Color{0, 0, 0, 28});
|
||
rounded(330, 218, 620, 258, 20, WHITE);
|
||
const bool emptyGallery = galleryTotal == 0 && galleryStatus == "No Switchnotes have been shared yet.";
|
||
centered(emptyGallery ? "No Switchnotes yet" : "Gallery unavailable",
|
||
370, 270, 540, 42, 25, INK, true);
|
||
centered(emptyGallery ? "" : utf8Prefix(galleryStatus, 70),
|
||
365, 321, 550, 52, 17, GRAY);
|
||
if (pill("Refresh", 520, 400, 240, 48, true, 18)) {
|
||
galleryStatus = "Loading Gallery…";
|
||
refreshGallery();
|
||
}
|
||
} else {
|
||
for (int cell = 0; cell < 6; ++cell) {
|
||
const int index = cell;
|
||
if (index >= static_cast<int>(gallery.size())) break;
|
||
const int col = cell % 3;
|
||
const int row = cell / 3;
|
||
const int x = 104 + col * 372;
|
||
const int y = 153 + row * 232;
|
||
const bool selectedNow = static_cast<std::size_t>(index) == gallerySelected;
|
||
const bool hovered = pointerX >= x - 5 && pointerX < x + 326 && pointerY >= y - 4 && pointerY < y + 194;
|
||
const int lift = hoverLift(x, y, hovered);
|
||
const SDL_Color border = selectedNow ? GREEN : SDL_Color{210, 214, 220, 255};
|
||
rounded(x - 5, y + 4 - lift, 331, 198, 15, SDL_Color{0, 0, 0, 48});
|
||
rounded(x - 5, y - 4 - lift, 331, 198, 15, WHITE);
|
||
rounded(x + 3, y + 4 - lift, 315, 182, 8, WHITE);
|
||
drawTexture(galleryPreviewTexture(gallery[static_cast<std::size_t>(index)]), x + 3, y + 4 - lift, 315, 182);
|
||
roundedOutline(x - 1, y - lift, 323, 190, 12, 4, border);
|
||
if (gallery[static_cast<std::size_t>(index)].locked) drawLockIcon(x + 10, y + 10 - lift);
|
||
rounded(x + 228, y + 158 - lift, 94, 30, 15, SDL_Color{255, 237, 190, 245});
|
||
drawImage("ui/icons/Coin.png", x + 236, y + 162 - lift, 22, 22);
|
||
text(std::to_string(gallery[static_cast<std::size_t>(index)].coins), x + 265, y + 162 - lift, 17, ORANGE, true);
|
||
if (selectedNow) {
|
||
const int pop = lift;
|
||
rounded(x + 142 - pop / 2, y + 170 - pop / 2 - lift, 58 + pop, 58 + pop, 30 + pop / 2, SDL_Color{0, 0, 0, 42});
|
||
rounded(x + 138 - pop / 2, y + 164 - pop / 2 - lift, 58 + pop, 58 + pop, 30 + pop / 2, WHITE);
|
||
rounded(x + 143 - pop / 2, y + 169 - pop / 2 - lift, 48 + pop, 48 + pop, 24 + pop / 2, PALE_GREEN);
|
||
drawPlayTriangle(x + 158 - pop / 2, y + 182 - pop / 2 - lift, 20 + pop, WHITE);
|
||
}
|
||
if (hit(x - 5, y - 4, 331, 198)) {
|
||
clickConsumed = true;
|
||
gallerySelected = static_cast<std::size_t>(index);
|
||
if (selectedNow) screen = Screen::GalleryDetails;
|
||
else playCue("button_on");
|
||
}
|
||
}
|
||
const int totalPages = std::max(1, (galleryTotal + 5) / 6);
|
||
if (totalPages > 1 && galleryPage > 0 && pill("<", 25, 327, 60, 78, false, 34)) {
|
||
--galleryPage; gallerySelected = 0; galleryStatus = "Loading Gallery…"; refreshGallery();
|
||
}
|
||
if (totalPages > 1 && galleryPage + 1 < totalPages && pill(">", 1195, 327, 60, 78, false, 34)) {
|
||
++galleryPage; gallerySelected = 0; galleryStatus = "Loading Gallery…"; refreshGallery();
|
||
}
|
||
if (totalPages > 1) for (int i = 0; i < totalPages; ++i)
|
||
rounded(640 - totalPages * 9 + i * 18, 653, 12, 12, 6, i == galleryPage ? GREEN : PALE_GREEN);
|
||
if (actionPill("ui/icons/ButtonYGalleryText.png", "Add Coins", 932, 635, 174, 50, true)) addGalleryCoin();
|
||
if (actionPill("ui/icons/ButtonAGalleryText.png", "Details", 1118, 635, 120, 50, true)) screen = Screen::GalleryDetails;
|
||
}
|
||
if (imageButton("ui/BackButton_Gallery.png", 39, 620, 65, 65, "button_off")) {
|
||
galleryProfileActive = false;
|
||
screen = Screen::Library;
|
||
}
|
||
}
|
||
|
||
void App::renderGalleryProfile() {
|
||
background();
|
||
const std::string username = galleryProfile.username.empty()
|
||
? (galleryLoadRunning ? "Loading profile…" : "Gallery User") : galleryProfile.username;
|
||
if (pill(galleryProfile.followed ? "Following" : "Follow", 40, 40, 166, 48, true, 19, !galleryProfileIsOwn))
|
||
updateGalleryRelationship(galleryProfile.followed ? "unfollow" : "follow");
|
||
if (dangerPill(galleryProfile.blocked ? "Unblock" : "Block", 1074, 40, 166, 48, 19, !galleryProfileIsOwn))
|
||
updateGalleryRelationship(galleryProfile.blocked ? "unblock" : "block");
|
||
if (galleryProfileIsOwn && galleryProfilePage == 0 && pill("Edit Bio", 224, 40, 166, 48, true, 19)) {
|
||
beginText(Field::GalleryBio, galleryProfile.bio);
|
||
}
|
||
|
||
if (galleryProfilePage == 0) {
|
||
rounded(104, 146, 1072, 474, 22, SDL_Color{0, 0, 0, 30});
|
||
rounded(98, 136, 1084, 474, 22, WHITE);
|
||
const int avatarX = 132, avatarY = 173, avatarSize = 164;
|
||
rounded(avatarX - 4, avatarY - 4, avatarSize + 8, avatarSize + 8, 19, GREEN);
|
||
rounded(avatarX, avatarY, avatarSize, avatarSize, 15, WHITE);
|
||
SDL_Texture* avatar = galleryProfileIsOwn ? profileTexture : galleryProfileAvatarTexture;
|
||
if (avatar) drawTexture(avatar, avatarX + 3, avatarY + 3, avatarSize - 6, avatarSize - 6);
|
||
else centered(username.empty() ? "?" : utf8Prefix(username, 1), avatarX + 3, avatarY + 3,
|
||
avatarSize - 6, avatarSize - 6, 70, GREEN, true);
|
||
text(utf8Prefix(username, 24), 324, 174, 54, GREEN, true);
|
||
const std::string bio = galleryProfile.bio.empty() ? "No bio added" : galleryProfile.bio;
|
||
text(utf8Prefix(bio, 58), 326, 247, 25, galleryProfile.bio.empty() ? GRAY : INK);
|
||
rounded(128, 350, 1024, 4, 2, GREEN);
|
||
|
||
auto statCard = [&](int x, int y, const std::string& value, const std::string& label) {
|
||
rounded(x + 2, y + 4, 392, 82, 10, SDL_Color{0, 0, 0, 30});
|
||
rounded(x, y, 392, 82, 10, GREEN);
|
||
rounded(x + 2, y + 2, 388, 78, 8, WHITE);
|
||
centered(value, x + 10, y + 3, 372, 48, 37, GREEN, true);
|
||
centered(label, x + 10, y + 47, 372, 28, 16, PALE_GREEN, true);
|
||
};
|
||
statCard(182, 374, std::to_string(galleryProfile.switchnotes) + " " + brandString("Switchnotes"),
|
||
"Uploaded to " + appDisplayName + " Gallery");
|
||
statCard(706, 374, std::to_string(galleryProfile.views) + " Views", "Total on all uploaded " + brandString("Switchnotes"));
|
||
statCard(182, 474, std::to_string(galleryProfile.coins) + " Coins", "Added across all uploaded " + brandString("Switchnotes"));
|
||
statCard(706, 474, std::to_string(galleryProfile.followers) + " Followers", "Following this user on Gallery");
|
||
} else {
|
||
if (gallery.empty()) {
|
||
rounded(330, 226, 620, 258, 20, SDL_Color{0, 0, 0, 28});
|
||
rounded(330, 218, 620, 258, 20, WHITE);
|
||
centered(galleryLoadRunning ? "Loading uploads…" : "No uploads on this page",
|
||
370, 320, 540, 42, 25, INK, true);
|
||
}
|
||
for (int cell = 0; cell < 6 && cell < static_cast<int>(gallery.size()); ++cell) {
|
||
const int col = cell % 3, row = cell / 3;
|
||
const int x = 104 + col * 372, y = 153 + row * 232;
|
||
const bool selectedNow = static_cast<std::size_t>(cell) == gallerySelected;
|
||
const int lift = hoverLift(x, y, pointerX >= x - 5 && pointerX < x + 326 && pointerY >= y - 4 && pointerY < y + 194);
|
||
rounded(x - 5, y + 4 - lift, 331, 198, 15, SDL_Color{0, 0, 0, 48});
|
||
rounded(x - 5, y - 4 - lift, 331, 198, 15, WHITE);
|
||
rounded(x + 3, y + 4 - lift, 315, 182, 8, WHITE);
|
||
drawTexture(galleryPreviewTexture(gallery[static_cast<std::size_t>(cell)]), x + 3, y + 4 - lift, 315, 182);
|
||
roundedOutline(x - 1, y - lift, 323, 190, 14, 4, selectedNow ? GREEN : SDL_Color{210, 214, 220, 255});
|
||
if (gallery[static_cast<std::size_t>(cell)].locked) drawLockIcon(x + 10, y + 10 - lift);
|
||
rounded(x + 228, y + 158 - lift, 94, 30, 15, SDL_Color{255, 237, 190, 245});
|
||
drawImage("ui/icons/Coin.png", x + 236, y + 162 - lift, 22, 22);
|
||
text(std::to_string(gallery[static_cast<std::size_t>(cell)].coins), x + 265, y + 162 - lift, 17, ORANGE);
|
||
if (selectedNow) {
|
||
rounded(x + 137, y + 163 - lift, 59, 59, 30, SDL_Color{0, 0, 0, 42});
|
||
rounded(x + 133, y + 157 - lift, 59, 59, 30, WHITE);
|
||
rounded(x + 138, y + 162 - lift, 49, 49, 25, PALE_GREEN);
|
||
drawPlayTriangle(x + 153, y + 174 - lift, 21, WHITE);
|
||
}
|
||
if (hit(x - 5, y - 4, 331, 198)) {
|
||
clickConsumed = true;
|
||
if (selectedNow) { galleryProfileDetailMode = true; screen = Screen::GalleryDetails; }
|
||
else { gallerySelected = static_cast<std::size_t>(cell); playCue("button_on"); }
|
||
}
|
||
}
|
||
if (gallery.size() > 0 && actionPill("ui/icons/ButtonAGalleryText.png", "Details", 1100, 635, 138, 50, true)) {
|
||
galleryProfileDetailMode = true;
|
||
screen = Screen::GalleryDetails;
|
||
}
|
||
}
|
||
|
||
const int pageCount = 1 + (std::max(galleryProfile.switchnotes, galleryTotal) + 5) / 6;
|
||
if (pageCount > 1) {
|
||
const bool hasPrevious = galleryProfilePage > 0;
|
||
const bool hasNext = galleryProfilePage + 1 < pageCount;
|
||
if (pill("<", 24, 326, 60, 78, false, 34, hasPrevious) && hasPrevious)
|
||
loadGalleryProfile(galleryProfile.identity, galleryProfileReturnScreen, galleryProfilePage - 1);
|
||
if (pill(">", 1196, 326, 60, 78, true, 34, hasNext) && hasNext)
|
||
loadGalleryProfile(galleryProfile.identity, galleryProfileReturnScreen, galleryProfilePage + 1);
|
||
}
|
||
if (imageButton("ui/BackButton_Gallery.png", 39, 620, 65, 65, "button_off")) leaveGalleryProfile();
|
||
const int dotCount = std::max(1, std::min(10, pageCount));
|
||
for (int i = 0; i < dotCount; ++i) {
|
||
const int pageForDot = dotCount == pageCount ? i : i * (pageCount - 1) / std::max(1, dotCount - 1);
|
||
rounded(640 - dotCount * 13 + i * 26, 655, 18, 18, 9, pageForDot == galleryProfilePage ? GREEN : PALE_GREEN);
|
||
}
|
||
}
|
||
|
||
void App::renderDetails(bool galleryMode) {
|
||
background();
|
||
if (galleryMode && gallery.empty()) {
|
||
if (imageButton("ui/BackButton_Gallery.png", 39, 620, 65, 65, "button_off")) screen = Screen::Gallery;
|
||
return;
|
||
}
|
||
const Item* item = nullptr;
|
||
bool allowSpinoffs = false;
|
||
if (galleryMode) item = &gallery[gallerySelected % gallery.size()];
|
||
else if (!library.empty()) item = &library[selected % library.size()];
|
||
if (!item) { if (pill("Back", 40, 620, 100, 50, galleryMode)) screen = galleryMode ? Screen::Gallery : Screen::Library; return; }
|
||
const bool noteLocked = !galleryMode && ((docLoaded && docPath == item->path) ? doc.metadata.locked : item->locked);
|
||
const int ix = 108, iy = 260, iw = 338, ih = 197;
|
||
rounded(ix - 4, iy - 4, iw + 8, ih + 8, 14, WHITE);
|
||
rounded(ix, iy, iw, ih, 10, ORANGE);
|
||
rounded(ix + 4, iy + 4, iw - 8, ih - 8, 7, WHITE);
|
||
if (galleryMode) drawTexture(galleryPreviewTexture(*item), ix + 4, iy + 4, iw - 8, ih - 8);
|
||
else if (item->sample) drawImage("art/" + item->artwork, ix + 4, iy + 4, iw - 8, ih - 8, true);
|
||
else if (docLoaded && docPath == item->path) drawCurrentFrame(ix + 4, iy + 4, iw - 8, ih - 8);
|
||
else drawTexture(thumbTexture(*item), ix + 4, iy + 4, iw - 8, ih - 8);
|
||
if (galleryMode) {
|
||
if (item->locked) drawLockIcon(ix + 10, iy + 10);
|
||
rounded(508, 181, 665, 67, 13, SDL_Color{226, 230, 242, 255});
|
||
text(utf8Prefix(item->title, 38), 525, 197, 28, INK, true);
|
||
rounded(508, 262, 665, 110, 13, SDL_Color{226, 230, 242, 255});
|
||
text(item->description.empty() ? "No description added" : utf8Prefix(item->description, 48),
|
||
527, 284, 24, SDL_Color{112, 120, 141, 255});
|
||
rounded(508, 385, 665, 154, 13, SDL_Color{255, 234, 213, 255});
|
||
text("Author", 526, 402, 24, ORANGE);
|
||
const bool isCurrentAuthor = item->ownerIdentity.empty()
|
||
? item->author == userName
|
||
: item->ownerIdentity == sppm::identityFingerprint(signingIdentity.publicIdentity);
|
||
if (isCurrentAuthor && profileDetailTexture) drawTexture(profileDetailTexture, 932, 397, 32, 32);
|
||
text(utf8Prefix(item->author, 24), isCurrentAuthor && profileDetailTexture ? 975 : 930, 402, 24, ORANGE);
|
||
if (hit(925, 392, 235, 42) && !item->ownerIdentity.empty() && !galleryProfileDetailMode) {
|
||
clickConsumed = true;
|
||
loadGalleryProfile(item->ownerIdentity, Screen::GalleryDetails);
|
||
}
|
||
text("Creator FSID", 526, 441, 24, ORANGE);
|
||
text(item->fsid, 930, 441, 24, ORANGE);
|
||
text("Updated", 526, 480, 24, ORANGE);
|
||
text(dateText(item->modifiedUnixSeconds), 810, 480, 24, ORANGE);
|
||
text("Coins " + std::to_string(item->coins) + " Views " + std::to_string(item->views), 526, 554, 20, GREEN);
|
||
} else {
|
||
const bool isCurrentDocument = docLoaded && docPath == item->path;
|
||
if (isCurrentDocument ? doc.metadata.locked : item->locked) drawLockIcon(1127, 201);
|
||
allowSpinoffs = isCurrentDocument ? doc.metadata.allowSpinoffs : item->allowSpinoffs;
|
||
rounded(508, 183, 665, 67, 13, SDL_Color{226, 230, 242, 255});
|
||
text(item->title, 524, 197, 27, INK, true);
|
||
if (!noteLocked) drawImage("ui/icons/Edit.png", 1114, 195, 47, 47);
|
||
rounded(508, 262, 665, 110, 13, SDL_Color{226, 230, 242, 255});
|
||
const std::string description = isCurrentDocument && !doc.metadata.description.empty()
|
||
? doc.metadata.description : !item->description.empty() ? item->description : "No description added";
|
||
text(utf8Prefix(description, 42), 526, 284, 24, SDL_Color{112, 120, 141, 255});
|
||
if (!noteLocked) drawImage("ui/icons/Edit.png", 1114, 292, 47, 47);
|
||
const std::string authorName = isCurrentDocument ? doc.metadata.authorName : item->author;
|
||
const std::string originalAuthorName = isCurrentDocument ? doc.metadata.originalAuthorName
|
||
: (item->originalAuthor.empty() ? item->author : item->originalAuthor);
|
||
const std::string authorFsid = isCurrentDocument ? doc.metadata.authorFsid : item->authorFsid;
|
||
const std::string originalAuthorFsid = isCurrentDocument ? doc.metadata.originalAuthorFsid : item->originalAuthorFsid;
|
||
const std::uint64_t modifiedAt = isCurrentDocument ? doc.metadata.modifiedUnixSeconds : item->modifiedUnixSeconds;
|
||
const std::uint64_t createdAt = isCurrentDocument ? doc.metadata.createdUnixSeconds : item->createdUnixSeconds;
|
||
centered(expandMetadata ? "Less Details" : "More Details", 540, 326, 590, 35, 23, SDL_Color{112, 120, 141, 255});
|
||
rounded(508, 385, 665, expandMetadata ? 220 : 154, 13, SDL_Color{255, 234, 213, 255});
|
||
if (expandMetadata) {
|
||
text("Author FSID", 526, 397, 19, ORANGE);
|
||
text(authorFsid.empty() ? "Unknown" : authorFsid, 820, 397, 19, ORANGE);
|
||
text("Original Author FSID", 526, 427, 19, ORANGE);
|
||
text(originalAuthorFsid.empty() ? "Unknown" : originalAuthorFsid, 820, 427, 19, ORANGE);
|
||
text("Last Edited", 526, 457, 19, ORANGE);
|
||
text(dateText(modifiedAt), 820, 457, 19, ORANGE);
|
||
text("First Created", 526, 487, 19, ORANGE);
|
||
text(dateText(createdAt), 820, 487, 19, ORANGE);
|
||
text("Switchnote FSID", 526, 527, 17, GREEN, true);
|
||
text(isCurrentDocument ? doc.metadata.currentId : item->currentId, 810, 527, 17, GREEN, true);
|
||
text("Root FSID", 526, 553, 17, GREEN, true);
|
||
text(isCurrentDocument ? doc.metadata.rootId : item->rootId, 810, 553, 17, GREEN, true);
|
||
} else {
|
||
text("Author", 526, 402, 24, ORANGE);
|
||
const bool isCurrentAuthor = item->ownerIdentity.empty()
|
||
? authorName == userName
|
||
: item->ownerIdentity == sppm::identityFingerprint(signingIdentity.publicIdentity);
|
||
if (isCurrentAuthor && profileDetailTexture) drawTexture(profileDetailTexture, 932, 397, 32, 32);
|
||
text(authorName, isCurrentAuthor && profileDetailTexture ? 975 : 977, 402, 24, ORANGE);
|
||
text("Original Author", 526, 441, 24, ORANGE);
|
||
text(originalAuthorName, 977, 441, 24, ORANGE);
|
||
text("Last Edited", 526, 480, 24, ORANGE);
|
||
text(dateText(modifiedAt), 800, 480, 24, ORANGE);
|
||
}
|
||
}
|
||
if (imageButton(galleryMode ? "ui/BackButton_Gallery.png" : "ui/BackButton.png", 39, 620, 65, 65, "button_off")) {
|
||
if (galleryMode && galleryProfileDetailMode) { galleryProfileDetailMode = false; screen = Screen::GalleryProfile; }
|
||
else screen = galleryMode ? Screen::Gallery : Screen::Library;
|
||
}
|
||
if (galleryMode) {
|
||
const bool galleryOwner = item->ownerIdentity == sppm::identityFingerprint(signingIdentity.publicIdentity);
|
||
if (galleryOwner && dangerPill("Delete", 40, 36, 156, 50, 18)) {
|
||
modalSelection = 0;
|
||
modal = Modal::ConfirmGalleryDelete;
|
||
}
|
||
if (actionPill("ui/icons/ButtonYGalleryText.png", "Comments", 1040, 36, 198, 50, true)) openGalleryComments();
|
||
if (actionPill("ui/icons/Coin.png", "Add Coin", 796, 635, 174, 50, true)) addGalleryCoin();
|
||
if (pill("Save", 978, 635, 100, 50, true, 19)) saveGalleryItem(gallerySelected);
|
||
if (actionPill("ui/icons/ButtonAGalleryText.png", "Watch", 1088, 635, 150, 50, true)) openGalleryItem(gallerySelected);
|
||
} else {
|
||
if (pill("Upload to Gallery", 1022, 36, 216, 50, true, 17, !item->sample)) publishGalleryItem(selected);
|
||
if (actionPill("ui/icons/ButtonZLText.png", "Delete", 40, 36, 174, 50, false)) { modalSelection = 0; modal = Modal::ConfirmDelete; }
|
||
if (actionPill("ui/icons/ButtonYText.png", "Edit", 980, 635, 100, 50, false, !noteLocked)) openItem(selected, true);
|
||
if (actionPill("ui/icons/ButtonAText.png", "Watch", 1088, 635, 150, 50, false)) { openItem(selected, false); screen = Screen::Viewer; }
|
||
if (pill("Spin-off", 798, 635, 174, 50, false, 18, allowSpinoffs && !noteLocked)) { openItem(selected, false); forkDocument(); }
|
||
if (pill("Export", 580, 635, 174, 50, false, 19, !item->sample)) { modalSelection = 0; modal = Modal::Export; }
|
||
}
|
||
if (!galleryMode && !noteLocked && hit(1114, 195, 47, 47)) {
|
||
clickConsumed = true;
|
||
if (item->sample || !docLoaded || docPath != item->path) openItem(selected, true);
|
||
beginText(Field::Title, docLoaded ? doc.metadata.title : item->title);
|
||
}
|
||
if (!galleryMode && !noteLocked && hit(1114, 292, 47, 47)) {
|
||
clickConsumed = true;
|
||
if (item->sample || !docLoaded || docPath != item->path) openItem(selected, true);
|
||
beginText(Field::Description, docLoaded ? doc.metadata.description : "");
|
||
}
|
||
if (!galleryMode && hit(508, 262, 665, 110)) { clickConsumed = true; expandMetadata = !expandMetadata; }
|
||
if (hit(ix - 4, iy - 4, iw + 8, ih + 8) && !galleryMode) { clickConsumed = true; openItem(selected, false); screen = Screen::Viewer; }
|
||
}
|
||
|
||
bool App::loadSample(const Item& item, sppm::Document& out) {
|
||
SDL_Surface* input = IMG_Load(join(assetsRoot, "art/" + item.artwork).c_str());
|
||
if (!input) return false;
|
||
SDL_Surface* rgba = SDL_ConvertSurfaceFormat(input, SDL_PIXELFORMAT_RGBA32, 0);
|
||
SDL_FreeSurface(input);
|
||
if (!rgba) return false;
|
||
if (rgba->w != sppm::kWidth || rgba->h != sppm::kHeight) {
|
||
SDL_FreeSurface(rgba);
|
||
return false;
|
||
}
|
||
out = sppm::Document{};
|
||
out.metadata.title = item.title;
|
||
out.metadata.description = "Sample animation supplied with Fakenote Studio.";
|
||
out.metadata.authorName = item.author;
|
||
out.metadata.originalAuthorName = item.author;
|
||
out.metadata.lastEditorName = item.author;
|
||
out.metadata.authorFsid = newId("sample-creator");
|
||
out.metadata.currentId = newId("sample-note");
|
||
if (out.metadata.authorFsid.empty() || out.metadata.currentId.empty()) {
|
||
SDL_FreeSurface(rgba);
|
||
return false;
|
||
}
|
||
out.metadata.originalAuthorFsid = out.metadata.authorFsid;
|
||
out.metadata.lastEditorFsid = out.metadata.authorFsid;
|
||
out.metadata.rootId = out.metadata.currentId;
|
||
out.metadata.createdUnixSeconds = out.metadata.modifiedUnixSeconds = nowSeconds();
|
||
out.metadata.fps = 12;
|
||
out.metadata.speed = 6;
|
||
out.frames.emplace_back();
|
||
std::unordered_map<std::uint32_t, std::uint8_t> exact;
|
||
std::map<std::uint32_t, std::uint32_t> frequency;
|
||
for (int y = 0; y < rgba->h; ++y) {
|
||
const auto* row = reinterpret_cast<const std::uint32_t*>(static_cast<const std::uint8_t*>(rgba->pixels) + y * rgba->pitch);
|
||
for (int x = 0; x < rgba->w; ++x) {
|
||
const std::uint32_t p = row[x];
|
||
std::uint8_t r, g, b, a;
|
||
SDL_GetRGBA(p, rgba->format, &r, &g, &b, &a);
|
||
if (a >= 16) ++frequency[(static_cast<std::uint32_t>(a) << 24) | (static_cast<std::uint32_t>(r) << 16) | (static_cast<std::uint32_t>(g) << 8) | b];
|
||
}
|
||
}
|
||
std::vector<std::pair<std::uint32_t, std::uint32_t>> colors(frequency.begin(), frequency.end());
|
||
std::sort(colors.begin(), colors.end(), [](const auto& a, const auto& b) { return a.second > b.second; });
|
||
if (colors.size() > 255) colors.resize(255);
|
||
for (std::size_t i = 0; i < colors.size(); ++i) {
|
||
const auto key = colors[i].first;
|
||
out.palette[i + 1] = {static_cast<std::uint8_t>(key >> 16), static_cast<std::uint8_t>(key >> 8), static_cast<std::uint8_t>(key), static_cast<std::uint8_t>(key >> 24)};
|
||
exact[key] = static_cast<std::uint8_t>(i + 1);
|
||
}
|
||
auto& pixels = out.frames[0].layers[3];
|
||
for (int y = 0; y < rgba->h; ++y) {
|
||
const auto* row = reinterpret_cast<const std::uint32_t*>(static_cast<const std::uint8_t*>(rgba->pixels) + y * rgba->pitch);
|
||
for (int x = 0; x < rgba->w; ++x) {
|
||
std::uint8_t r, g, b, a;
|
||
SDL_GetRGBA(row[x], rgba->format, &r, &g, &b, &a);
|
||
if (a < 16) continue;
|
||
const std::uint32_t key = (static_cast<std::uint32_t>(a) << 24) | (static_cast<std::uint32_t>(r) << 16) | (static_cast<std::uint32_t>(g) << 8) | b;
|
||
auto found = exact.find(key);
|
||
if (found != exact.end()) pixels[static_cast<std::size_t>(y) * rgba->w + x] = found->second;
|
||
else {
|
||
int bestDistance = std::numeric_limits<int>::max();
|
||
std::uint8_t best = 1;
|
||
for (std::size_t i = 1; i <= colors.size(); ++i) {
|
||
const auto& c = out.palette[i];
|
||
int dr = static_cast<int>(r) - c.r, dg = static_cast<int>(g) - c.g, db = static_cast<int>(b) - c.b;
|
||
const int d = dr * dr + dg * dg + db * db;
|
||
if (d < bestDistance) { bestDistance = d; best = static_cast<std::uint8_t>(i); }
|
||
}
|
||
pixels[static_cast<std::size_t>(y) * rgba->w + x] = best;
|
||
}
|
||
}
|
||
}
|
||
SDL_FreeSurface(rgba);
|
||
return true;
|
||
}
|
||
|
||
void App::openItem(std::size_t index, bool edit) {
|
||
LoadingScope loading(*this);
|
||
if (index >= library.size()) return;
|
||
if (docLoaded && dirty) saveDocument();
|
||
const Item item = library[index];
|
||
if (edit && item.locked) { showToast("This Switchnote is locked and cannot be edited"); return; }
|
||
stopPlayback();
|
||
if (edit) {
|
||
color = 2;
|
||
activeTool = Tool::Pen;
|
||
paintMenu = colorMenu = false;
|
||
toolMenu = false;
|
||
brush = 4;
|
||
pattern = 0;
|
||
square = false;
|
||
layer = 0;
|
||
}
|
||
if (item.sample) {
|
||
sppm::Document sample;
|
||
if (!loadSample(item, sample)) { showToast("Could not load sample drawing"); return; }
|
||
if (edit) {
|
||
sppm::Document child;
|
||
const std::string childId = newId("spinoff");
|
||
if (childId.empty()) { showToast("Secure random ID generation failed"); return; }
|
||
std::string forkError;
|
||
if (!sppm::createSpinoff(sample, userName, myFsid, childId, nowSeconds(), child, forkError)) {
|
||
showToast("Could not create sample spin-off: " + forkError);
|
||
return;
|
||
}
|
||
child.metadata.authorIdentity = signingIdentity.publicIdentity;
|
||
child.metadata.lastEditorIdentity = signingIdentity.publicIdentity;
|
||
child.metadata.title = item.title + " (spin-off)";
|
||
doc = std::move(child);
|
||
color = blackInkIndex(doc.palette);
|
||
docPath.clear();
|
||
docLoaded = true;
|
||
dirty = false;
|
||
galleryViewing = false;
|
||
frame = 0;
|
||
screen = Screen::Canvas;
|
||
invalidateFrames();
|
||
rebuildAudio();
|
||
showToast("Editing an included sample; save it as a spin-off");
|
||
} else {
|
||
doc = std::move(sample);
|
||
docPath.clear();
|
||
docLoaded = true;
|
||
galleryViewing = false;
|
||
frame = 0;
|
||
screen = Screen::Viewer;
|
||
invalidateFrames();
|
||
rebuildAudio();
|
||
}
|
||
return;
|
||
}
|
||
std::string error;
|
||
if (!sppm::loadSignedFile(item.path, doc, signingIdentity.legacyHmacKey, error)) { showToast("Could not open Switchnote: " + error); return; }
|
||
docPath = item.path;
|
||
if (edit && doc.metadata.locked) { docLoaded = false; docPath.clear(); showToast("This Switchnote is locked and cannot be edited"); return; }
|
||
docLoaded = true;
|
||
galleryViewing = false;
|
||
dirty = false;
|
||
frame = 0;
|
||
if (edit) color = blackInkIndex(doc.palette);
|
||
screen = edit ? Screen::Canvas : Screen::Viewer;
|
||
invalidateFrames();
|
||
rebuildAudio();
|
||
}
|
||
|
||
void App::newDocument() {
|
||
if (docLoaded && dirty) saveDocument();
|
||
const std::string id = newId("note");
|
||
if (id.empty()) { showToast("Secure random ID generation failed"); return; }
|
||
stopPlayback();
|
||
doc = sppm::Document{};
|
||
rebuildAudio();
|
||
doc.frames.emplace_back();
|
||
doc.metadata.title = defaultSwitchnoteTitle(userName, noteSingular);
|
||
doc.metadata.authorName = userName;
|
||
doc.metadata.originalAuthorName = userName;
|
||
doc.metadata.lastEditorName = userName;
|
||
doc.metadata.authorFsid = myFsid;
|
||
doc.metadata.originalAuthorFsid = myFsid;
|
||
doc.metadata.lastEditorFsid = myFsid;
|
||
doc.metadata.authorIdentity = signingIdentity.publicIdentity;
|
||
doc.metadata.originalAuthorIdentity = signingIdentity.publicIdentity;
|
||
doc.metadata.lastEditorIdentity = signingIdentity.publicIdentity;
|
||
doc.metadata.currentId = id;
|
||
doc.metadata.rootId = doc.metadata.currentId;
|
||
doc.metadata.createdUnixSeconds = doc.metadata.modifiedUnixSeconds = nowSeconds();
|
||
doc.metadata.fps = static_cast<std::uint8_t>(defaultFps);
|
||
doc.metadata.speed = static_cast<std::uint8_t>(defaultSpeed);
|
||
docPath.clear();
|
||
docLoaded = true;
|
||
dirty = true;
|
||
frame = 0;
|
||
layer = 0;
|
||
color = blackInkIndex(doc.palette);
|
||
brush = 4;
|
||
pattern = 0;
|
||
square = false;
|
||
activeTool = Tool::Pen;
|
||
paintMenu = false;
|
||
colorMenu = toolMenu = false;
|
||
zoom = 1.0f;
|
||
panX = panY = 0;
|
||
undoStack.clear(); redoStack.clear();
|
||
invalidateFrames();
|
||
saveDocument();
|
||
for (std::size_t i = 0; i < library.size(); ++i) {
|
||
if (library[i].path == docPath) { selected = i; page = static_cast<int>(i / 6); break; }
|
||
}
|
||
screen = Screen::Canvas;
|
||
showToast("New Switchnote — draw now; use New to add frames");
|
||
playEvent("note_new", "page_new");
|
||
}
|
||
|
||
bool App::saveDocument(bool force) {
|
||
LoadingScope loading(*this);
|
||
if (!docLoaded) return false;
|
||
if (doc.metadata.locked && dirty) { showToast("This Switchnote is locked and cannot be edited"); return false; }
|
||
if (!dirty && !force) return true;
|
||
if (docPath.empty()) {
|
||
// A sample spin-off receives its persistent file only when explicitly saved.
|
||
doc.metadata.title = doc.metadata.title.empty() ? defaultSwitchnoteTitle(userName, noteSingular) : doc.metadata.title;
|
||
docPath = join(join(notesRoot, folder), doc.metadata.currentId + ".sppm");
|
||
}
|
||
doc.metadata.lastEditorName = userName;
|
||
doc.metadata.lastEditorFsid = myFsid;
|
||
doc.metadata.lastEditorIdentity = signingIdentity.publicIdentity;
|
||
doc.metadata.modifiedUnixSeconds = nowSeconds();
|
||
std::string error;
|
||
if (sppm::savePublicSignedFile(docPath, doc, signingIdentity, error)) {
|
||
const std::string thumbnailKey = "thumb:" + docPath;
|
||
auto thumbnail = images.find(thumbnailKey);
|
||
if (thumbnail != images.end()) {
|
||
if (thumbnail->second) SDL_DestroyTexture(thumbnail->second);
|
||
images.erase(thumbnail);
|
||
}
|
||
scanLibrary();
|
||
bool foundSavedItem = false;
|
||
for (std::size_t i = 0; i < library.size(); ++i) {
|
||
if (library[i].path == docPath) {
|
||
selected = i;
|
||
page = static_cast<int>(i / 6);
|
||
foundSavedItem = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!foundSavedItem) {
|
||
sppm::Document persisted;
|
||
std::string verifyError;
|
||
if (!sppm::loadSignedFile(docPath, persisted, signingIdentity.legacyHmacKey, verifyError)) {
|
||
showToast("Saved Switchnote could not be reopened: " + verifyError);
|
||
return false;
|
||
}
|
||
Item saved{};
|
||
saved.title = persisted.metadata.title.empty() ? defaultSwitchnoteTitle(userName, noteSingular) : persisted.metadata.title;
|
||
saved.path = docPath;
|
||
saved.author = persisted.metadata.authorName;
|
||
saved.description = persisted.metadata.description;
|
||
saved.originalAuthor = persisted.metadata.originalAuthorName;
|
||
saved.authorFsid = persisted.metadata.authorFsid;
|
||
saved.originalAuthorFsid = persisted.metadata.originalAuthorFsid;
|
||
saved.ownerIdentity = sppm::identityFingerprint(persisted.metadata.authorIdentity);
|
||
saved.currentId = persisted.metadata.currentId;
|
||
saved.rootId = persisted.metadata.rootId;
|
||
saved.createdUnixSeconds = persisted.metadata.createdUnixSeconds;
|
||
saved.modifiedUnixSeconds = persisted.metadata.modifiedUnixSeconds;
|
||
saved.allowSpinoffs = persisted.metadata.allowSpinoffs;
|
||
library.push_back(std::move(saved));
|
||
std::sort(library.begin(), library.end(), [](const Item& a, const Item& b) {
|
||
if (a.modifiedUnixSeconds != b.modifiedUnixSeconds) return a.modifiedUnixSeconds > b.modifiedUnixSeconds;
|
||
if (a.createdUnixSeconds != b.createdUnixSeconds) return a.createdUnixSeconds > b.createdUnixSeconds;
|
||
return a.path < b.path;
|
||
});
|
||
for (std::size_t i = 0; i < library.size(); ++i) {
|
||
if (library[i].path == docPath) {
|
||
selected = i;
|
||
page = static_cast<int>(i / 6);
|
||
foundSavedItem = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (!foundSavedItem) {
|
||
showToast("Switchnote saved, but could not be added to the library");
|
||
return false;
|
||
}
|
||
dirty = false;
|
||
return true;
|
||
}
|
||
showToast("Save failed: " + error);
|
||
return false;
|
||
}
|
||
|
||
void App::closeDocument() {
|
||
saveDocument();
|
||
stopPlayback();
|
||
docLoaded = false;
|
||
docPath.clear();
|
||
frame = 0;
|
||
doc = sppm::Document{};
|
||
rebuildAudio();
|
||
invalidateFrames();
|
||
}
|
||
|
||
void App::deleteDocument() {
|
||
if (library.empty() || selected >= library.size()) return;
|
||
const Item item = library[selected];
|
||
if (item.sample) { showToast("Bundled sample artwork cannot be deleted"); return; }
|
||
if (!item.path.empty() && std::remove(item.path.c_str()) != 0) { showToast("Could not delete this Switchnote"); return; }
|
||
if (docPath == item.path) {
|
||
stopPlayback();
|
||
docLoaded = false;
|
||
dirty = false;
|
||
docPath.clear();
|
||
doc = sppm::Document{};
|
||
rebuildAudio();
|
||
invalidateFrames();
|
||
}
|
||
scanLibrary();
|
||
screen = Screen::Library;
|
||
modal = Modal::None;
|
||
showToast("Switchnote deleted");
|
||
playEvent("delete", "delete_complete");
|
||
}
|
||
|
||
void App::forkDocument() {
|
||
if (!docLoaded && !library.empty()) openItem(selected, false);
|
||
if (!docLoaded) return;
|
||
const std::string id = newId("spinoff");
|
||
if (id.empty()) { showToast("Secure random ID generation failed"); return; }
|
||
sppm::Document child;
|
||
std::string error;
|
||
if (!sppm::createSpinoff(doc, userName, myFsid, id, nowSeconds(), child, error)) {
|
||
showToast("Spin-off unavailable: " + error);
|
||
return;
|
||
}
|
||
child.metadata.authorIdentity = signingIdentity.publicIdentity;
|
||
child.metadata.lastEditorIdentity = signingIdentity.publicIdentity;
|
||
stopPlayback();
|
||
doc = std::move(child);
|
||
color = blackInkIndex(doc.palette);
|
||
rebuildAudio();
|
||
doc.metadata.title = doc.metadata.title + " (spin-off)";
|
||
docPath.clear();
|
||
galleryViewing = false;
|
||
dirty = true;
|
||
frame = std::min(frame, doc.frames.size() - 1);
|
||
screen = Screen::Canvas;
|
||
saveDocument();
|
||
scanLibrary();
|
||
showToast("Spin-off created with the original author and lineage preserved");
|
||
}
|
||
|
||
void App::markDirty() {
|
||
dirty = true;
|
||
dirtyTick = SDL_GetTicks();
|
||
++docRevision;
|
||
invalidateFrames();
|
||
}
|
||
|
||
void App::invalidateFrames() {
|
||
for (auto& item : frameTextures) if (item.second.texture) SDL_DestroyTexture(item.second.texture);
|
||
frameTextures.clear();
|
||
++docRevision;
|
||
}
|
||
|
||
SDL_Texture* App::frameTexture(std::size_t index) {
|
||
if (!docLoaded || index >= doc.frames.size()) return nullptr;
|
||
auto& cache = frameTextures[index];
|
||
if (cache.texture && cache.revision == docRevision) return cache.texture;
|
||
if (cache.texture) SDL_DestroyTexture(cache.texture);
|
||
SDL_Surface* surface = SDL_CreateRGBSurfaceWithFormat(0, sppm::kWidth, sppm::kHeight, 32, SDL_PIXELFORMAT_RGBA32);
|
||
if (!surface) return nullptr;
|
||
const auto& frameData = doc.frames[index];
|
||
auto* pixels = static_cast<std::uint32_t*>(surface->pixels);
|
||
for (std::size_t i = 0; i < sppm::kPixelsPerLayer; ++i) {
|
||
std::uint32_t out = 0;
|
||
for (std::size_t l = sppm::kLayerCount; l-- > 0;) {
|
||
const std::uint8_t idx = frameData.layers[l][i];
|
||
if (!idx) continue;
|
||
const auto& c = doc.palette[idx];
|
||
if (!c.a) continue;
|
||
const std::uint8_t alpha = c.a;
|
||
std::uint8_t r, g, b, oldA;
|
||
SDL_GetRGBA(out, surface->format, &r, &g, &b, &oldA);
|
||
const int inv = 255 - alpha;
|
||
const int nextA = alpha + (oldA * inv + 127) / 255;
|
||
if (nextA == 0) { out = 0; continue; }
|
||
r = static_cast<std::uint8_t>((c.r * alpha + r * oldA * inv / 255 + nextA / 2) / nextA);
|
||
g = static_cast<std::uint8_t>((c.g * alpha + g * oldA * inv / 255 + nextA / 2) / nextA);
|
||
b = static_cast<std::uint8_t>((c.b * alpha + b * oldA * inv / 255 + nextA / 2) / nextA);
|
||
out = SDL_MapRGBA(surface->format, r, g, b, static_cast<std::uint8_t>(nextA));
|
||
}
|
||
pixels[i] = out;
|
||
}
|
||
cache.texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||
SDL_FreeSurface(surface);
|
||
if (cache.texture) {
|
||
SDL_SetTextureScaleMode(cache.texture, SDL_ScaleModeNearest);
|
||
SDL_SetTextureBlendMode(cache.texture, SDL_BLENDMODE_BLEND);
|
||
}
|
||
cache.revision = docRevision;
|
||
return cache.texture;
|
||
}
|
||
|
||
void App::drawFrameImage(std::size_t index, int x, int y, int w, int h) { drawTexture(frameTexture(index), x, y, w, h); }
|
||
|
||
void App::drawCurrentFrame(int x, int y, int w, int h, bool withOnion) {
|
||
if (!docLoaded || doc.frames.empty()) return;
|
||
if (withOnion && onion && frame > 0) {
|
||
SDL_Texture* previous = frameTexture(frame - 1);
|
||
if (previous) {
|
||
SDL_SetTextureColorMod(previous, 255, 96, 104);
|
||
SDL_SetTextureAlphaMod(previous, 55);
|
||
drawTexture(previous, x, y, w, h);
|
||
SDL_SetTextureColorMod(previous, 255, 255, 255);
|
||
SDL_SetTextureAlphaMod(previous, 255);
|
||
}
|
||
}
|
||
drawFrameImage(frame, x, y, w, h);
|
||
}
|
||
|
||
void App::playControl(int x, int y, int w, int h) {
|
||
if (!playing) {
|
||
if (imagePill("ui/icons/Play.png", x, y, w, h, false, true, "")) startPlayback();
|
||
return;
|
||
}
|
||
const bool hovered = pointerX >= x && pointerX < x + w && pointerY >= y && pointerY < y + h;
|
||
const bool pressed = pointerDown && hovered;
|
||
const int lift = hoverLift(x, y, hovered);
|
||
rounded(x, y + 5 - lift + (pressed ? 4 : 0), w, h, h / 2, SDL_Color{0, 0, 0, 42});
|
||
rounded(x - 3, y - 3 - lift + (pressed ? 4 : 0), w + 6, h + 6, h / 2 + 3, WHITE);
|
||
rounded(x, y - lift + (pressed ? 4 : 0), w, h, h / 2, CREAM);
|
||
const int barW = std::max(5, w / 10), barH = std::max(18, h / 3);
|
||
fill(x + w / 2 - barW - 3, y + (h - barH) / 2 - lift + (pressed ? 4 : 0), barW, barH, ORANGE);
|
||
fill(x + w / 2 + 3, y + (h - barH) / 2 - lift + (pressed ? 4 : 0), barW, barH, ORANGE);
|
||
if (hit(x, y, w, h)) { clickConsumed = true; stopPlayback(); }
|
||
}
|
||
|
||
void App::setFrame(std::size_t index, bool playNavigationCue, const char* event) {
|
||
if (!docLoaded || doc.frames.empty()) return;
|
||
const std::size_t previous = frame;
|
||
frame = std::min(index, doc.frames.size() - 1);
|
||
if (playNavigationCue && frame != previous) {
|
||
if (event) playEvent(event, "button_on");
|
||
else playEvent(frame > previous ? "frame_next" : "frame_previous", "button_on");
|
||
}
|
||
if (playing) playFrameSound();
|
||
}
|
||
|
||
void App::startPlayback() {
|
||
if (!docLoaded || doc.frames.empty()) return;
|
||
// Play always means replay from the beginning. Reset audio before changing
|
||
// the cursor so BGM and frame-zero cues share the animation's time origin.
|
||
stopPlayback(false);
|
||
frame = 0;
|
||
playing = true;
|
||
lastPlaybackTick = SDL_GetTicks();
|
||
playbackTickRemainder = 0;
|
||
playEvent("playback_start", "movie_play");
|
||
playFrameSound();
|
||
}
|
||
|
||
void App::updatePlayback(std::uint32_t now) {
|
||
if (!playing || !docLoaded || doc.frames.empty()) return;
|
||
const double exactFrameDuration = 1000.0 / sppm::frameRate(doc.metadata);
|
||
// Advance against the original frame clock rather than resetting it to
|
||
// `now`; if a render takes longer than one frame, catch up and keep the
|
||
// displayed counter synchronized with the animation.
|
||
while (playing) {
|
||
const double accumulated = exactFrameDuration + playbackTickRemainder;
|
||
const std::uint32_t frameDuration = std::max<std::uint32_t>(1, static_cast<std::uint32_t>(std::floor(accumulated)));
|
||
if (now - lastPlaybackTick < frameDuration) break;
|
||
playbackTickRemainder = accumulated - frameDuration;
|
||
lastPlaybackTick += frameDuration;
|
||
if (frame + 1 < doc.frames.size()) setFrame(frame + 1, false);
|
||
else if (!doc.metadata.loopPlayback) stopPlayback(false);
|
||
else {
|
||
if (audioReady) for (int channel = 0; channel < 4; ++channel) Mix_HaltChannel(channel);
|
||
setFrame(0, false);
|
||
}
|
||
}
|
||
}
|
||
|
||
void App::stopPlayback(bool playStopCue) {
|
||
if (playing && playStopCue) playEvent("playback_stop", "movie_stop");
|
||
playing = false;
|
||
if (audioReady) {
|
||
for (int channel = 0; channel < 5; ++channel) Mix_HaltChannel(channel);
|
||
}
|
||
if (bgmSeekChunk) { Mix_FreeChunk(bgmSeekChunk); bgmSeekChunk = nullptr; }
|
||
}
|
||
|
||
void App::startBgmAtCurrentFrame() {
|
||
if (!audioReady || !trackChunks[0]) return;
|
||
Mix_HaltChannel(0);
|
||
if (bgmSeekChunk) { Mix_FreeChunk(bgmSeekChunk); bgmSeekChunk = nullptr; }
|
||
if (!doc.metadata.bgmFollowsSpeed) { Mix_PlayChannel(0, trackChunks[0], 0); return; }
|
||
if (frame == 0) { Mix_PlayChannel(0, trackChunks[0], 0); return; }
|
||
const auto& buffer = trackAudioBuffers[0];
|
||
const std::size_t sampleFrame = static_cast<std::size_t>(
|
||
std::floor(frame * 48000.0 / sppm::frameRate(doc.metadata)));
|
||
const std::size_t offset = sampleFrame * 4;
|
||
if (offset + 4 > buffer.size()) return;
|
||
bgmSeekChunk = Mix_QuickLoad_RAW(const_cast<Uint8*>(buffer.data() + offset),
|
||
static_cast<Uint32>(buffer.size() - offset));
|
||
if (bgmSeekChunk) Mix_PlayChannel(0, bgmSeekChunk, 0);
|
||
}
|
||
|
||
void App::rebuildAudio() {
|
||
if (!audioReady) return;
|
||
Mix_HaltChannel(4);
|
||
for (int channel = 0; channel < static_cast<int>(trackChunks.size()); ++channel) Mix_HaltChannel(channel);
|
||
if (bgmSeekChunk) { Mix_FreeChunk(bgmSeekChunk); bgmSeekChunk = nullptr; }
|
||
for (auto* chunk : trackChunks) if (chunk) Mix_FreeChunk(chunk);
|
||
trackChunks.fill(nullptr);
|
||
for (auto& buffer : trackAudioBuffers) buffer.clear();
|
||
for (std::size_t i = 0; i < doc.audioTracks.size() && i < trackChunks.size(); ++i) {
|
||
auto& track = doc.audioTracks[i];
|
||
if (track.pcm.empty()) continue;
|
||
if (track.channels < 1 || track.channels > 2 || track.sampleRate < 8000 || track.sampleRate > 48000) continue;
|
||
SDL_AudioCVT cvt{};
|
||
if (SDL_BuildAudioCVT(&cvt, AUDIO_S16SYS, track.channels, static_cast<int>(track.sampleRate), AUDIO_S16SYS, 2, 48000) < 0) continue;
|
||
const auto bytes = track.pcm.size() * sizeof(std::int16_t);
|
||
if (bytes > static_cast<std::size_t>(std::numeric_limits<int>::max())) continue;
|
||
cvt.len = static_cast<int>(bytes);
|
||
cvt.buf = static_cast<Uint8*>(SDL_malloc(static_cast<std::size_t>(cvt.len) * cvt.len_mult));
|
||
if (!cvt.buf) continue;
|
||
std::memcpy(cvt.buf, track.pcm.data(), bytes);
|
||
if (cvt.needed) {
|
||
if (SDL_ConvertAudio(&cvt) != 0) { SDL_free(cvt.buf); continue; }
|
||
} else {
|
||
cvt.len_cvt = cvt.len;
|
||
}
|
||
if (cvt.len_cvt <= 0) { SDL_free(cvt.buf); continue; }
|
||
if (i == 0 && doc.metadata.bgmFollowsSpeed && cvt.len_cvt >= 4) {
|
||
const std::size_t inputFrames = static_cast<std::size_t>(cvt.len_cvt) / 4;
|
||
const double currentFps = sppm::frameRate(doc.metadata);
|
||
const double referenceFps = track.referenceSpeed ? selectedFrameRate(track.referenceSpeed, 0) :
|
||
(track.referenceFps ? track.referenceFps : currentFps);
|
||
const double playbackRate = currentFps / referenceFps;
|
||
constexpr std::size_t maxPlaybackSamples = 32ULL * 1024 * 1024;
|
||
const std::size_t maxOutputFrames = maxPlaybackSamples / 2;
|
||
const std::size_t requestedFrames = std::max<std::size_t>(
|
||
1, static_cast<std::size_t>(std::ceil(inputFrames / playbackRate)));
|
||
const std::size_t outputFrames = std::min(requestedFrames, maxOutputFrames);
|
||
trackAudioBuffers[i].resize(outputFrames * 4);
|
||
const auto* sourceSamples = reinterpret_cast<const std::int16_t*>(cvt.buf);
|
||
auto* outputSamples = reinterpret_cast<std::int16_t*>(trackAudioBuffers[i].data());
|
||
for (std::size_t outFrame = 0; outFrame < outputFrames; ++outFrame) {
|
||
const double sourcePosition = std::min(static_cast<double>(inputFrames - 1), outFrame * playbackRate);
|
||
const std::size_t sourceFrame = static_cast<std::size_t>(sourcePosition);
|
||
const std::size_t nextFrame = std::min(sourceFrame + 1, inputFrames - 1);
|
||
const double fraction = sourcePosition - sourceFrame;
|
||
for (int channel = 0; channel < 2; ++channel) {
|
||
const double a = sourceSamples[sourceFrame * 2 + channel];
|
||
const double b = sourceSamples[nextFrame * 2 + channel];
|
||
outputSamples[outFrame * 2 + channel] = static_cast<std::int16_t>(std::clamp(
|
||
static_cast<int>(std::lround(a + (b - a) * fraction)), -32768, 32767));
|
||
}
|
||
}
|
||
} else {
|
||
trackAudioBuffers[i].assign(cvt.buf, cvt.buf + cvt.len_cvt);
|
||
}
|
||
SDL_free(cvt.buf);
|
||
trackChunks[i] = Mix_QuickLoad_RAW(trackAudioBuffers[i].data(), static_cast<Uint32>(trackAudioBuffers[i].size()));
|
||
}
|
||
if (playing) startBgmAtCurrentFrame();
|
||
}
|
||
|
||
void App::playFrameSound() {
|
||
if (!audioReady || !docLoaded || !playing) return;
|
||
if (frame == 0 && trackChunks[0] && (doc.metadata.bgmFollowsSpeed || !Mix_Playing(0)))
|
||
startBgmAtCurrentFrame();
|
||
for (std::size_t i = 1; i < doc.audioTracks.size() && i < trackChunks.size(); ++i) {
|
||
const auto& cuesAt = doc.audioTracks[i].frameTriggers;
|
||
if (std::find(cuesAt.begin(), cuesAt.end(), static_cast<std::uint16_t>(frame)) != cuesAt.end() && trackChunks[i])
|
||
Mix_PlayChannel(static_cast<int>(i), trackChunks[i], 0);
|
||
}
|
||
}
|
||
|
||
void App::pushUndo() {
|
||
if (!docLoaded || frame >= doc.frames.size() || layer < 0 || layer >= 4) return;
|
||
if (fillWaveActive) { fillWaveActive = false; fillWavePixels.clear(); }
|
||
undoStack.push_back({frame, layer, doc.frames[frame].layers[layer]});
|
||
if (undoStack.size() > 32) undoStack.erase(undoStack.begin());
|
||
redoStack.clear();
|
||
}
|
||
|
||
void App::beginFillWave(int x, int y) {
|
||
if (!docLoaded || frame >= doc.frames.size() || layer < 0 || layer >= 4 ||
|
||
x < 0 || x >= sppm::kWidth || y < 0 || y >= sppm::kHeight) return;
|
||
auto& pixels = doc.frames[frame].layers[static_cast<std::size_t>(layer)];
|
||
const std::size_t seed = static_cast<std::size_t>(y) * sppm::kWidth + x;
|
||
const std::uint8_t target = pixels[seed];
|
||
const std::uint8_t replacement = activeTool == Tool::Eraser
|
||
? 0 : static_cast<std::uint8_t>(std::clamp(color, 1, 255));
|
||
if (target == replacement) return;
|
||
|
||
pushUndo();
|
||
fillWavePixels.clear();
|
||
fillWavePixels.reserve(pixels.size() / 4);
|
||
std::vector<std::uint32_t> queue;
|
||
queue.reserve(pixels.size() / 4);
|
||
std::vector<std::uint8_t> visited(pixels.size(), 0);
|
||
std::vector<std::uint16_t> distances(pixels.size(), std::numeric_limits<std::uint16_t>::max());
|
||
queue.push_back(static_cast<std::uint32_t>(seed));
|
||
visited[seed] = 1;
|
||
distances[seed] = 0;
|
||
for (std::size_t cursor = 0; cursor < queue.size(); ++cursor) {
|
||
const std::uint32_t index = queue[cursor];
|
||
const int px = static_cast<int>(index % sppm::kWidth);
|
||
const int py = static_cast<int>(index / sppm::kWidth);
|
||
fillWavePixels.emplace_back(index, distances[index]);
|
||
const std::array<int, 4> neighbors{{px > 0 ? static_cast<int>(index) - 1 : -1,
|
||
px + 1 < sppm::kWidth ? static_cast<int>(index) + 1 : -1,
|
||
py > 0 ? static_cast<int>(index) - sppm::kWidth : -1,
|
||
py + 1 < sppm::kHeight ? static_cast<int>(index) + sppm::kWidth : -1}};
|
||
for (const int next : neighbors) {
|
||
if (next < 0 || visited[static_cast<std::size_t>(next)] || pixels[static_cast<std::size_t>(next)] != target) continue;
|
||
visited[static_cast<std::size_t>(next)] = 1;
|
||
distances[static_cast<std::size_t>(next)] = static_cast<std::uint16_t>(distances[index] + 1);
|
||
queue.push_back(static_cast<std::uint32_t>(next));
|
||
}
|
||
}
|
||
std::sort(fillWavePixels.begin(), fillWavePixels.end(), [](const auto& a, const auto& b) {
|
||
return a.second < b.second;
|
||
});
|
||
fillWaveFrame = frame;
|
||
fillWaveLayer = layer;
|
||
fillWaveColor = replacement;
|
||
fillWaveOriginX = x;
|
||
fillWaveOriginY = y;
|
||
fillWaveRadius = 0.0f;
|
||
fillWaveCursor = 0;
|
||
fillWaveTick = SDL_GetTicks();
|
||
fillWaveActive = !fillWavePixels.empty();
|
||
}
|
||
|
||
void App::updateFillWave(std::uint32_t now) {
|
||
if (!fillWaveActive) return;
|
||
if (!docLoaded || frame != fillWaveFrame || layer != fillWaveLayer || frame >= doc.frames.size()) {
|
||
fillWaveActive = false;
|
||
fillWavePixels.clear();
|
||
return;
|
||
}
|
||
const float elapsed = std::min(0.1f, (now - fillWaveTick) / 1000.0f);
|
||
fillWaveTick = now;
|
||
// 25 drawing pixels every 0.25 seconds (100 pixels/second), staying within
|
||
// the connected region instead of crossing line-art boundaries.
|
||
fillWaveRadius += elapsed * 100.0f;
|
||
auto& pixels = doc.frames[frame].layers[static_cast<std::size_t>(layer)];
|
||
bool changed = false;
|
||
const auto radius = static_cast<std::uint16_t>(std::floor(fillWaveRadius));
|
||
while (fillWaveCursor < fillWavePixels.size() && fillWavePixels[fillWaveCursor].second <= radius) {
|
||
pixels[fillWavePixels[fillWaveCursor].first] = fillWaveColor;
|
||
++fillWaveCursor;
|
||
changed = true;
|
||
}
|
||
if (changed) markDirty();
|
||
if (fillWaveCursor >= fillWavePixels.size()) {
|
||
fillWaveActive = false;
|
||
fillWavePixels.clear();
|
||
}
|
||
}
|
||
|
||
void App::undo() {
|
||
if (undoStack.empty() || !docLoaded) return;
|
||
if (fillWaveActive) { fillWaveActive = false; fillWavePixels.clear(); }
|
||
UndoState state = std::move(undoStack.back()); undoStack.pop_back();
|
||
redoStack.push_back({state.frame, state.layer, doc.frames[state.frame].layers[state.layer]});
|
||
doc.frames[state.frame].layers[state.layer] = std::move(state.pixels);
|
||
frame = state.frame; layer = state.layer; markDirty(); playEvent("undo", "undo");
|
||
}
|
||
|
||
void App::redo() {
|
||
if (redoStack.empty() || !docLoaded) return;
|
||
if (fillWaveActive) { fillWaveActive = false; fillWavePixels.clear(); }
|
||
UndoState state = std::move(redoStack.back()); redoStack.pop_back();
|
||
undoStack.push_back({state.frame, state.layer, doc.frames[state.frame].layers[state.layer]});
|
||
doc.frames[state.frame].layers[state.layer] = std::move(state.pixels);
|
||
frame = state.frame; layer = state.layer; markDirty(); playEvent("redo", "redo");
|
||
}
|
||
|
||
void App::insertFrame(bool paste) {
|
||
if (!docLoaded || doc.frames.size() >= sppm::kMaxFrames) { showToast("This Switchnote has reached its 9999 frame limit"); return; }
|
||
const std::size_t insertAt = std::min(frame + 1, doc.frames.size());
|
||
sppm::Frame next;
|
||
if (paste && clipboardReady) next = frameClipboard;
|
||
else if (copyToNewPage && frame < doc.frames.size()) next = doc.frames[frame];
|
||
doc.frames.insert(doc.frames.begin() + static_cast<std::ptrdiff_t>(insertAt), std::move(next));
|
||
for (auto& track : doc.audioTracks) for (auto& cue : track.frameTriggers) if (cue >= insertAt) ++cue;
|
||
frame = insertAt;
|
||
markDirty(); playEvent(paste ? "frame_paste" : "frame_new", paste ? "pic_stamp" : "page_new");
|
||
}
|
||
|
||
void App::eraseFrame() {
|
||
if (!docLoaded || doc.frames.size() <= 1) { showToast("A Switchnote must keep at least one frame"); return; }
|
||
doc.frames.erase(doc.frames.begin() + static_cast<std::ptrdiff_t>(frame));
|
||
for (auto& track : doc.audioTracks) {
|
||
track.frameTriggers.erase(std::remove(track.frameTriggers.begin(), track.frameTriggers.end(), static_cast<std::uint16_t>(frame)), track.frameTriggers.end());
|
||
for (auto& cue : track.frameTriggers) if (cue > frame) --cue;
|
||
}
|
||
frame = std::min(frame, doc.frames.size() - 1);
|
||
markDirty();
|
||
playEvent("frame_erase", "draw_tool_btn_on");
|
||
}
|
||
|
||
void App::copyFrame() {
|
||
if (!docLoaded || frame >= doc.frames.size()) return;
|
||
frameClipboard = doc.frames[frame];
|
||
clipboardReady = true;
|
||
playEvent("frame_copy", "pic_stamp");
|
||
showToast("Frame copied");
|
||
}
|
||
|
||
SDL_Texture* App::thumbTexture(const Item& item) {
|
||
const std::string key = "thumb:" + item.path;
|
||
auto cached = images.find(key);
|
||
if (cached != images.end()) return cached->second;
|
||
sppm::Document source;
|
||
std::string error;
|
||
if (!sppm::loadSignedFile(item.path, source, signingIdentity.legacyHmacKey, error) || source.frames.empty()) return nullptr;
|
||
SDL_Surface* surface = SDL_CreateRGBSurfaceWithFormat(0, sppm::kWidth, sppm::kHeight, 32, SDL_PIXELFORMAT_RGBA32);
|
||
if (!surface) return nullptr;
|
||
auto* out = static_cast<std::uint32_t*>(surface->pixels);
|
||
const auto& frameData = source.frames[std::min<std::size_t>(source.metadata.coverFrame, source.frames.size() - 1)];
|
||
for (std::size_t i = 0; i < sppm::kPixelsPerLayer; ++i) {
|
||
unsigned r = 0, g = 0, b = 0, a = 0;
|
||
for (std::size_t layerIndex = frameData.layers.size(); layerIndex-- > 0;) {
|
||
const auto& layerPixels = frameData.layers[layerIndex];
|
||
const auto index = layerPixels[i];
|
||
if (!index) continue;
|
||
const auto c = source.palette[index];
|
||
const unsigned na = c.a + a * (255 - c.a) / 255;
|
||
if (na) {
|
||
r = (c.r * c.a + r * a * (255 - c.a) / 255) / na;
|
||
g = (c.g * c.a + g * a * (255 - c.a) / 255) / na;
|
||
b = (c.b * c.a + b * a * (255 - c.a) / 255) / na;
|
||
}
|
||
a = na;
|
||
}
|
||
out[i] = SDL_MapRGBA(surface->format, r, g, b, a);
|
||
}
|
||
SDL_Texture* result = SDL_CreateTextureFromSurface(renderer, surface);
|
||
SDL_FreeSurface(surface);
|
||
if (result) {
|
||
SDL_SetTextureScaleMode(result, SDL_ScaleModeNearest);
|
||
SDL_SetTextureBlendMode(result, SDL_BLENDMODE_BLEND);
|
||
}
|
||
images[key] = result;
|
||
return result;
|
||
}
|
||
|
||
void App::renderSequence() {
|
||
background();
|
||
if (!docLoaded) { if (pill("Back", 40, 620, 100, 48)) screen = Screen::Library; return; }
|
||
const bool canUndo = !undoStack.empty();
|
||
const bool canRedo = !redoStack.empty();
|
||
drawImage(canUndo ? "ui/CanvasUndoButton_Active.png" : "ui/CanvasUndoButton_Inactive.png", 20, 18, 68, 54);
|
||
drawImage(canRedo ? "ui/CanvasRedoButton_Active.png" : "ui/CanvasRedoButton_Inactive.png", 96, 18, 68, 54);
|
||
if (canUndo && hit(20, 18, 68, 54)) { clickConsumed = true; undo(); }
|
||
if (canRedo && hit(96, 18, 68, 54)) { clickConsumed = true; redo(); }
|
||
rounded(321, 36, 638, 362, 14, WHITE);
|
||
rounded(325, 40, 630, 354, 10, SDL_Color{210, 214, 220, 255});
|
||
rounded(329, 44, 622, 346, 8, WHITE);
|
||
drawCurrentFrame(331, 46, 618, 342, true);
|
||
const std::array<std::string, 4> tools{{"New", "Erase", "Copy", "Paste"}};
|
||
const std::array<std::string, 4> icons{{"FrameNew.png", "FrameErase.png", "FrameCopy.png", "FramePaste.png"}};
|
||
for (int i = 0; i < 4; ++i) {
|
||
const int y = 22 + i * 66;
|
||
if (actionPill("ui/icons/" + icons[i], tools[i], 1090, y, 166, 45, false, i != 3 || clipboardReady, "")) {
|
||
if (i == 0) insertFrame(false);
|
||
else if (i == 1) eraseFrame();
|
||
else if (i == 2) copyFrame();
|
||
else insertFrame(true);
|
||
}
|
||
}
|
||
rounded(1110, 366, 146, 40, 20, SDL_Color{0, 0, 0, 38});
|
||
rounded(1110, 361, 146, 40, 20, WHITE);
|
||
centered((frame + 1 < 10 ? "000" : frame + 1 < 100 ? "00" : "0") + std::to_string(frame + 1) + " / " +
|
||
(doc.frames.size() < 10 ? "000" : doc.frames.size() < 100 ? "00" : "0") + std::to_string(doc.frames.size()),
|
||
1110, 361, 146, 40, 18, ORANGE, true);
|
||
fill(0, 420, W, 196, SDL_Color{16, 16, 18, 255});
|
||
for (int x = 8; x < W; x += 28) {
|
||
rounded(x, 436, 14, 14, 3, WHITE);
|
||
rounded(x, 591, 14, 14, 3, WHITE);
|
||
}
|
||
const int visibleFrames = std::min(6, static_cast<int>(doc.frames.size()));
|
||
const int gap = 14;
|
||
constexpr int cardW = 174;
|
||
constexpr int cardH = 112;
|
||
const int firstFrame = std::clamp(static_cast<int>(frame) - 2, 0,
|
||
std::max(0, static_cast<int>(doc.frames.size()) - visibleFrames));
|
||
const int stripWidth = visibleFrames * cardW + std::max(0, visibleFrames - 1) * gap;
|
||
const int firstX = (W - stripWidth) / 2;
|
||
const int thumbY = 464;
|
||
for (int visible = 0; visible < visibleFrames; ++visible) {
|
||
const int idx = firstFrame + visible;
|
||
const int x = firstX + visible * (cardW + gap);
|
||
const int y = thumbY;
|
||
if (static_cast<std::size_t>(idx) == frame) rounded(x - 5, y - 5, cardW + 10, cardH + 10, 14, ORANGE);
|
||
rounded(x, y, cardW, cardH, 10, WHITE);
|
||
drawFrameImage(static_cast<std::size_t>(idx), x + 4, y + 4, cardW - 8, cardH - 8);
|
||
if (hit(x, y, cardW, cardH)) { setFrame(static_cast<std::size_t>(idx)); clickConsumed = true; }
|
||
}
|
||
if (imageButton("ui/BackButton.png", 20, 635, 62, 62, "button_off")) screen = Screen::Canvas;
|
||
drawImage("ui/SeekBar.png", 371, 649, 540, 30);
|
||
const int seekX = 373 + (doc.frames.size() > 1 ? static_cast<int>(frame * 535 / (doc.frames.size() - 1)) : 0);
|
||
drawImage("ui/SeekBarHandle.png", seekX - 8, 644, 16, 40);
|
||
if (hit(370, 640, 540, 48)) {
|
||
const float ratio = std::clamp((pointerX - 373.0f) / 535.0f, 0.0f, 1.0f);
|
||
setFrame(static_cast<std::size_t>(ratio * (doc.frames.size() - 1)));
|
||
clickConsumed = true;
|
||
}
|
||
if (imagePill("ui/icons/SkipFirst.png", 913, 645, 55, 48, false, frame > 0, "")) setFrame(0, true, "frame_first");
|
||
if (imagePill("ui/icons/SkipPrev.png", 974, 645, 55, 48, false, frame > 0, "")) setFrame(frame > 5 ? frame - 5 : 0, true, "frame_previous");
|
||
playControl(1044, 635, 62, 62);
|
||
if (imagePill("ui/icons/SkipNext.png", 1116, 645, 55, 48, false, true, "")) {
|
||
if (frame + 1 < doc.frames.size()) setFrame(frame + 1);
|
||
else insertFrame(false);
|
||
}
|
||
if (imagePill("ui/icons/SkipLast.png", 1177, 645, 58, 48, false, frame + 1 < doc.frames.size(), ""))
|
||
setFrame(doc.frames.size() - 1, true, "frame_last");
|
||
}
|
||
|
||
bool switchnoteBrushPattern(int id, int x, int y);
|
||
bool switchnoteEraserContains(int slot, int dx, int dy);
|
||
|
||
void App::renderCanvas() {
|
||
if (!docLoaded) { screen = Screen::Library; return; }
|
||
if (pointerReleased && !clickConsumed && (paintMenu || colorMenu || toolMenu)) {
|
||
const bool insidePopup = pointerX >= 836 && pointerX < 1192 && pointerY >= 76 && pointerY < 362;
|
||
const bool onTool = pointerX >= 1200 && pointerX < 1260 && pointerY >= 12 && pointerY < 72;
|
||
const bool onBrushDot = pointerX >= 1200 && pointerX < 1260 && pointerY >= 80 && pointerY < 140;
|
||
const bool onColorDot = pointerX >= 1200 && pointerX < 1260 && pointerY >= 147 && pointerY < 207;
|
||
if (!insidePopup && !onTool && !onBrushDot && !onColorDot) paintMenu = colorMenu = toolMenu = false;
|
||
}
|
||
background();
|
||
const float scale = 2.0f * zoom;
|
||
const int cw = static_cast<int>(sppm::kWidth * scale);
|
||
const int ch = static_cast<int>(sppm::kHeight * scale);
|
||
const int cx = (W - cw) / 2 + panX;
|
||
const int cy = (H - ch) / 2 + panY;
|
||
rounded(cx - 4, cy - 4, cw + 8, ch + 8, 10, SDL_Color{205, 210, 218, 255});
|
||
fill(cx, cy, cw, ch, WHITE);
|
||
drawCurrentFrame(cx, cy, cw, ch, true);
|
||
if (canvasGrid) {
|
||
SDL_Rect canvasClip{cx, cy, cw, ch};
|
||
SDL_RenderSetClipRect(renderer, &canvasClip);
|
||
SDL_SetRenderDrawColor(renderer, 82, 99, 124, 42);
|
||
// One line per image pixel: at 2x or above this is the actual drawing
|
||
// pixel grid, not a coarse design grid.
|
||
for (int x = 0; x <= sppm::kWidth; ++x) {
|
||
const int px = cx + static_cast<int>(x * cw / static_cast<float>(sppm::kWidth));
|
||
SDL_RenderDrawLine(renderer, px, cy, px, cy + ch);
|
||
}
|
||
for (int y = 0; y <= sppm::kHeight; ++y) {
|
||
const int py = cy + static_cast<int>(y * ch / static_cast<float>(sppm::kHeight));
|
||
SDL_RenderDrawLine(renderer, cx, py, cx + cw, py);
|
||
}
|
||
SDL_RenderSetClipRect(renderer, nullptr);
|
||
}
|
||
if (fillWaveActive && fillWaveRadius > 0.0f) {
|
||
SDL_Rect rippleClip{cx, cy, cw, ch};
|
||
SDL_RenderSetClipRect(renderer, &rippleClip);
|
||
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
|
||
const int front = static_cast<int>(std::floor(fillWaveRadius));
|
||
const int pixelW = std::max(1, static_cast<int>(std::ceil(cw / static_cast<float>(sppm::kWidth))));
|
||
const int pixelH = std::max(1, static_cast<int>(std::ceil(ch / static_cast<float>(sppm::kHeight))));
|
||
// Repeated narrow bands ride the fill front to read as an outward ripple,
|
||
// not a single uniform expanding disk.
|
||
for (const auto& entry : fillWavePixels) {
|
||
const int behindFront = front - static_cast<int>(entry.second);
|
||
if (behindFront < 0 || (behindFront > 2 && behindFront % 16 > 1)) continue;
|
||
SDL_SetRenderDrawColor(renderer, 255, 119, 43, behindFront <= 2 ? 235 : 155);
|
||
const int px = static_cast<int>(entry.first % sppm::kWidth);
|
||
const int py = static_cast<int>(entry.first / sppm::kWidth);
|
||
SDL_Rect dot{cx + static_cast<int>(px * cw / static_cast<float>(sppm::kWidth)),
|
||
cy + static_cast<int>(py * ch / static_cast<float>(sppm::kHeight)), pixelW, pixelH};
|
||
SDL_RenderFillRect(renderer, &dot);
|
||
}
|
||
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
|
||
SDL_RenderSetClipRect(renderer, nullptr);
|
||
}
|
||
const int chromeTravel = static_cast<int>(std::lround((1.0f - canvasChromeVisible) * kCanvasChromeTravel));
|
||
const int upOffset = -chromeTravel;
|
||
const int rightOffset = chromeTravel;
|
||
const int downOffset = chromeTravel;
|
||
const int leftOffset = -chromeTravel;
|
||
for (int i = 0; i < 4; ++i) {
|
||
const char c = static_cast<char>('A' + i);
|
||
const std::string path = std::string("ui/CanvasLayerButton") + c + ((layer == i) ? "_Active.png" : "_Inactive.png");
|
||
drawImage(path, 20 + leftOffset, 238 + i * 65, 72, 54);
|
||
if (hit(20, 238 + i * 65, 72, 54)) { layer = i; clickConsumed = true; playEvent("tool_layer", "draw_tool_btn_on"); }
|
||
}
|
||
const bool canUndo = !undoStack.empty();
|
||
const bool canRedo = !redoStack.empty();
|
||
drawImage(canUndo ? "ui/CanvasUndoButton_Active.png" : "ui/CanvasUndoButton_Inactive.png", 20, 18 + upOffset, 68, 54);
|
||
drawImage(canRedo ? "ui/CanvasRedoButton_Active.png" : "ui/CanvasRedoButton_Inactive.png", 96, 18 + upOffset, 68, 54);
|
||
if (canUndo && hit(20, 18, 68, 54)) { clickConsumed = true; undo(); }
|
||
if (canRedo && hit(96, 18, 68, 54)) { clickConsumed = true; redo(); }
|
||
const auto ink = doc.palette[static_cast<std::size_t>(std::clamp(color, 1, 255))];
|
||
auto drawToolIcon = [&](Tool tool, int x, int y, int size) {
|
||
if (tool == Tool::Eraser) {
|
||
drawImage("ui/icons/EraserTool_HQ.png", x + size / 8, y + size / 8,
|
||
size * 3 / 4, size * 3 / 4);
|
||
return;
|
||
}
|
||
const char* icon = tool == Tool::Pen ? "ui/icons/PenTool.png" : "ui/icons/PaintTool.png";
|
||
drawImage(icon, x, y, size, size);
|
||
};
|
||
const int toolsX = 1204 + rightOffset;
|
||
rounded(toolsX - 3, 14, 58, 58, 15, WHITE);
|
||
rounded(toolsX, 17, 52, 52, 12, activeTool == Tool::Pen ? CREAM : LIGHT);
|
||
drawToolIcon(activeTool, toolsX, 17, 52);
|
||
if (hit(1204, 17, 52, 52)) { toolMenu = !toolMenu; paintMenu = colorMenu = false; clickConsumed = true; playEvent("tool_pen", "draw_tool_btn_on"); }
|
||
rounded(toolsX, 84, 52, 52, 12, LIGHT);
|
||
const int dotSize = std::clamp(brush + 5, 8, 24);
|
||
const int displayedDotSize = activeTool == Tool::Brush ? (advancedBrush ? 24 : 12) :
|
||
activeTool == Tool::Eraser ? (eraserSlot == 0 ? 8 : eraserSlot < 4 ? 14 : 22) : dotSize;
|
||
rounded(toolsX + 26 - displayedDotSize / 2, 110 - displayedDotSize / 2, displayedDotSize, displayedDotSize, displayedDotSize / 2,
|
||
ink.a ? SDL_Color{ink.r, ink.g, ink.b, 255} : DRAW_BLACK);
|
||
if (hit(1204, 84, 52, 52)) { paintMenu = !paintMenu; colorMenu = toolMenu = false; clickConsumed = true; playEvent("tool_brush", "draw_tool_btn_on"); }
|
||
rounded(toolsX, 151, 52, 52, 26, WHITE);
|
||
rounded(toolsX + 3, 154, 46, 46, 23, SDL_Color{210, 214, 220, 255});
|
||
rounded(toolsX + 7, 158, 38, 38, 19, ink.a ? SDL_Color{ink.r, ink.g, ink.b, 255} : DRAW_BLACK);
|
||
if (hit(1204, 151, 52, 52)) { colorMenu = !colorMenu; paintMenu = toolMenu = false; clickConsumed = true; playEvent("color_menu", "popup"); }
|
||
rounded(1114, 587 + downOffset, 142, 39, 20, SDL_Color{0, 0, 0, 32});
|
||
rounded(1114, 582 + downOffset, 142, 39, 20, WHITE);
|
||
centered((frame + 1 < 10 ? "000" : frame + 1 < 100 ? "00" : "0") + std::to_string(frame + 1) + " / " +
|
||
(doc.frames.size() < 10 ? "000" : doc.frames.size() < 100 ? "00" : "0") + std::to_string(doc.frames.size()),
|
||
1114, 582 + downOffset, 142, 39, 18, ORANGE, true);
|
||
if (imageButton("ui/BackButton.png", 20, 635 + downOffset, 64, 62, "button_off")) {
|
||
if (saveDocument(true)) {
|
||
expandMetadata = false;
|
||
screen = Screen::Details;
|
||
clickConsumed = true;
|
||
}
|
||
}
|
||
const char* menuIcon = canvasMenuOpen ? "ui/CanvasMenuButton_Close.png" : "ui/CanvasMenuButton.png";
|
||
if (imageButton(menuIcon, 92, 635 + downOffset, 64, 62, "button_off")) {
|
||
canvasMenuOpen = !canvasMenuOpen;
|
||
clickConsumed = true;
|
||
}
|
||
if (actionPill("ui/icons/CanvasMenu_ConfigToggle.png", "Options", 474, 640 + downOffset, 142, 48, false, true, "")) {
|
||
modal = Modal::Options;
|
||
clickConsumed = true;
|
||
}
|
||
if (actionPill("ui/icons/FrameErase.png", "Erase", 630, 640 + downOffset, 162, 48, false, true, "")) {
|
||
auto& currentLayer = doc.frames[frame].layers[static_cast<std::size_t>(layer)];
|
||
if (std::any_of(currentLayer.begin(), currentLayer.end(), [](std::uint8_t value) { return value != 0; })) {
|
||
pushUndo();
|
||
std::fill(currentLayer.begin(), currentLayer.end(), 0);
|
||
markDirty();
|
||
playEvent("frame_erase", "edit_page_remove");
|
||
}
|
||
clickConsumed = true;
|
||
}
|
||
if (imagePill("ui/icons/SkipFirst.png", 904, 645 + downOffset, 55, 48, false, frame > 0, "")) setFrame(0, true, "frame_first");
|
||
if (imagePill("ui/icons/SkipPrev.png", 965, 645 + downOffset, 55, 48, false, frame > 0, "")) setFrame(frame > 5 ? frame - 5 : 0, true, "frame_previous");
|
||
playControl(1036, 635 + downOffset, 62, 62);
|
||
if (imagePill("ui/icons/SkipNext.png", 1108, 645 + downOffset, 55, 48, false, true, "")) {
|
||
if (frame + 1 < doc.frames.size()) setFrame(frame + 1);
|
||
else insertFrame(false);
|
||
}
|
||
if (imagePill("ui/icons/SkipLast.png", 1169, 645 + downOffset, 58, 48, false, frame + 1 < doc.frames.size(), ""))
|
||
setFrame(doc.frames.size() - 1, true, "frame_last");
|
||
if (canvasMenuProgress > 0.0f) {
|
||
const int menuX = 154;
|
||
const int menuY = 635 + downOffset + static_cast<int>(std::lround((1.0f - canvasMenuProgress) * 95.0f));
|
||
drawImage("ui/icons/CanvasMenu_PopoutBg.png", menuX, menuY - 9, 310, 80);
|
||
auto menuIconButton = [&](const char* icon, int x) {
|
||
drawTexture(whiteImage(icon), x + 4, menuY + 5, 50, 50);
|
||
return hit(x, menuY + 1, 58, 48);
|
||
};
|
||
if (menuIconButton("ui/icons/CanvasMenu_MusicToggle.png", menuX + 47)) {
|
||
clickConsumed = true;
|
||
canvasMenuOpen = false;
|
||
stopPlayback();
|
||
audioTrack = 0;
|
||
audioEraseArmedTrack = -1;
|
||
scanImports();
|
||
requestAudioUploadServer();
|
||
modal = Modal::Audio;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
} else if (menuIconButton("ui/icons/CanvasMenu_FrameToggle.png", menuX + 126)) {
|
||
canvasMenuOpen = false;
|
||
screen = Screen::Sequence;
|
||
clickConsumed = true;
|
||
} else if (menuIconButton("ui/icons/Camera.svg", menuX + 205)) {
|
||
canvasMenuOpen = false;
|
||
openPhotoCapture();
|
||
clickConsumed = true;
|
||
}
|
||
}
|
||
if (paintMenu) {
|
||
rounded(845, 88, 342, 270, 14, SDL_Color{0, 0, 0, 45});
|
||
rounded(842, 82, 342, 270, 14, WHITE);
|
||
rounded(846, 86, 334, 262, 11, LIGHT);
|
||
const auto inkPreview = ink.a ? SDL_Color{ink.r, ink.g, ink.b, 255} : DRAW_BLACK;
|
||
rounded(1144, 91, 26, 26, 13, inkPreview);
|
||
if (activeTool == Tool::Pen) {
|
||
text("Pen size", 858, 89, 17, INK, true);
|
||
const std::array<int, 6> brushSizes{{1, 2, 4, 8, 16, 32}};
|
||
int selectedBrush = 0;
|
||
for (int i = 1; i < static_cast<int>(brushSizes.size()); ++i)
|
||
if (std::abs(brushSizes[i] - brush) < std::abs(brushSizes[selectedBrush] - brush)) selectedBrush = i;
|
||
for (int i = 0; i < 6; ++i) {
|
||
const int bx = 866 + i * 51;
|
||
if (i == selectedBrush && !square) rounded(bx - 3, 109, 37, 37, 7, ORANGE);
|
||
if (i == selectedBrush && square) rounded(bx - 3, 158, 37, 37, 7, ORANGE);
|
||
const int markSize = std::clamp(brushSizes[i], 4, 29);
|
||
const int markOffset = (31 - markSize) / 2;
|
||
rounded(bx + markOffset, 112 + markOffset, markSize, markSize, markSize / 2, SDL_Color{28, 30, 35, 255});
|
||
rounded(bx + markOffset, 161 + markOffset, markSize, markSize, 2, SDL_Color{28, 30, 35, 255});
|
||
if (hit(bx, 112, 31, 31) || hit(bx, 161, 31, 31)) {
|
||
brush = brushSizes[i]; square = pointerY > 150; clickConsumed = true; playEvent("tool_brush", "draw_tool_btn_on");
|
||
}
|
||
}
|
||
static const std::array<const char*, 16> penNames{{
|
||
"1 px", "Dir 2 px", "3x3 square", "Squiggle",
|
||
"Directional =", "Sparse air", "Jitter line", "Dense spray",
|
||
"5x5 square", "7x7 square", "9x9 square", "Dynamic width",
|
||
"Hollow diamond", "Large air", "Wide jitter", "Heavy spray"
|
||
}};
|
||
for (int i = 0; i < static_cast<int>(penNames.size()); ++i) {
|
||
const int x = 855 + (i % 4) * 80;
|
||
const int y = 203 + (i / 4) * 20;
|
||
rounded(x, y, 77, 18, 5, penType == i ? ORANGE : WHITE);
|
||
centered(penNames[static_cast<std::size_t>(i)], x + 1, y, 75, 18, 11, penType == i ? WHITE : INK);
|
||
if (hit(x, y, 77, 18)) {
|
||
penType = i;
|
||
squiggleAnchorX = squiggleAnchorY = ringPreviousX = ringPreviousY = -1;
|
||
clickConsumed = true;
|
||
playEvent("tool_pen", "draw_tool_btn_on");
|
||
}
|
||
}
|
||
if (pill("−", 1093, 291, 38, 32, false, 20)) brush = std::max(1, brush - 1);
|
||
if (pill("+", 1134, 291, 38, 32, false, 20)) brush = std::min(32, brush + 1);
|
||
rounded(864, 287, 32, 32, 16, inkPreview);
|
||
} else if (activeTool == Tool::Brush) {
|
||
text("Brush patterns", 858, 89, 17, INK, true);
|
||
for (int i = 0; i < 8; ++i) {
|
||
const int x = 859 + (i % 4) * 78;
|
||
const int y = 124 + (i / 4) * 48;
|
||
rounded(x - 2, y - 2, 70, 42, 6, pattern == i ? ORANGE : WHITE);
|
||
rounded(x, y, 66, 38, 4, SDL_Color{255, 255, 255, 255});
|
||
SDL_Rect clip{x, y, 66, 38};
|
||
SDL_RenderSetClipRect(renderer, &clip);
|
||
for (int py = 0; py < 38; ++py) {
|
||
for (int px = 0; px < 66; ++px) {
|
||
if (switchnoteBrushPattern(i, px / 2, py / 2)) fill(x + px, y + py, 1, 1, inkPreview);
|
||
}
|
||
}
|
||
SDL_RenderSetClipRect(renderer, nullptr);
|
||
if (hit(x - 2, y - 2, 70, 42)) {
|
||
pattern = i; clickConsumed = true; playEvent("tool_brush", "draw_tool_btn_on");
|
||
}
|
||
}
|
||
rounded(859, 227, 183, 39, 11, advancedBrush ? CREAM : WHITE);
|
||
text(advancedBrush ? "Advanced brush ON" : "Advanced brush OFF", 873, 237, 16,
|
||
advancedBrush ? ORANGE : INK, true);
|
||
if (hit(859, 227, 183, 39)) {
|
||
advancedBrush = !advancedBrush; clickConsumed = true; playEvent("tool_brush", "draw_tool_btn_on");
|
||
}
|
||
} else {
|
||
text("Erase tools", 858, 89, 17, INK, true);
|
||
const std::array<const char*, 8> eraseLabels{{"Pixel", "3×3", "Round M", "Round L", "9×9", "15×15", "Vertical", "Horizontal"}};
|
||
for (int i = 0; i < 8; ++i) {
|
||
const int x = 854 + (i % 4) * 81;
|
||
const int y = 118 + (i / 4) * 83;
|
||
rounded(x, y, 72, 73, 9, eraserSlot == i ? CREAM : WHITE);
|
||
const int centerX = x + 36, centerY = y + 28;
|
||
for (int dy = -7; dy <= 7; ++dy) for (int dx = -7; dx <= 7; ++dx)
|
||
if (switchnoteEraserContains(i, dx, dy)) fill(centerX + dx * 2 - 1, centerY + dy * 2 - 1, 2, 2, INK);
|
||
centered(eraseLabels[static_cast<std::size_t>(i)], x + 2, y + 51, 68, 17, 12, INK);
|
||
if (hit(x, y, 72, 73)) {
|
||
eraserSlot = i; clickConsumed = true; playEvent("tool_brush", "draw_tool_btn_on");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (colorMenu) {
|
||
rounded(845, 88, 342, 162, 14, SDL_Color{0, 0, 0, 45});
|
||
rounded(842, 82, 342, 162, 14, WHITE);
|
||
rounded(846, 86, 334, 154, 11, LIGHT);
|
||
text("Ink color", 858, 89, 17, INK, true);
|
||
for (int i = 0; i < static_cast<int>(kInkPresetIndexes.size()); ++i) {
|
||
const int index = kInkPresetIndexes[static_cast<std::size_t>(i)];
|
||
const int x = 875 + (i % 5) * 57, y = 126 + (i / 5) * 54;
|
||
const auto c = doc.palette[static_cast<std::size_t>(index)];
|
||
if (index == color) rounded(x - 3, y - 3, 42, 42, 9, ORANGE);
|
||
rounded(x, y, 36, 36, 18, SDL_Color{c.r, c.g, c.b, 255});
|
||
if (hit(x - 3, y - 3, 42, 42)) {
|
||
color = index;
|
||
colorMenu = false;
|
||
clickConsumed = true;
|
||
playEvent("tool_color", "draw_tool_btn_on");
|
||
}
|
||
}
|
||
}
|
||
if (toolMenu) {
|
||
rounded(845, 88, 342, 154, 14, SDL_Color{0, 0, 0, 45});
|
||
rounded(842, 82, 342, 154, 14, WHITE);
|
||
rounded(846, 86, 334, 146, 11, LIGHT);
|
||
text("Tools", 858, 89, 17, INK, true);
|
||
const std::array<Tool, 3> tools{{Tool::Pen, Tool::Brush, Tool::Eraser}};
|
||
const std::array<const char*, 3> labels{{"Pen", "Brush", "Eraser"}};
|
||
for (int i = 0; i < 3; ++i) {
|
||
const int x = 856 + i * 106;
|
||
const int y = 121;
|
||
rounded(x - 2, y - 2, 96, 78, 12, activeTool == tools[i] ? CREAM : WHITE);
|
||
drawToolIcon(tools[i], x + 20, y + 1, 48);
|
||
centered(labels[i], x, y + 47, 92, 24, 15, activeTool == tools[i] ? ORANGE : INK);
|
||
if (hit(x - 2, y - 2, 96, 78)) {
|
||
activeTool = tools[i];
|
||
toolMenu = false;
|
||
clickConsumed = true;
|
||
playEvent("tool_pen", "draw_tool_btn_on");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void App::renderViewer() {
|
||
if (!docLoaded) { screen = Screen::Library; return; }
|
||
const float scale = std::min(W / static_cast<float>(sppm::kWidth), H / static_cast<float>(sppm::kHeight));
|
||
const int cw = static_cast<int>(sppm::kWidth * scale);
|
||
const int ch = static_cast<int>(sppm::kHeight * scale);
|
||
const int cx = (W - cw) / 2 + panX;
|
||
const int cy = (H - ch) / 2 + panY;
|
||
fill(0, 0, W, H, SDL_Color{255, 255, 255, 255});
|
||
drawCurrentFrame(cx, cy, cw, ch, false);
|
||
if (pill("Back", 20, 18, 104, 46)) {
|
||
stopPlayback();
|
||
screen = galleryViewing ? Screen::GalleryDetails : Screen::Details;
|
||
}
|
||
if (galleryViewing && pill("Comments", 1080, 18, 170, 46, true)) openGalleryComments();
|
||
if (imagePill("ui/icons/SkipFirst.png", 913, 645, 55, 48, false, frame > 0, "")) setFrame(0, true, "frame_first");
|
||
if (imagePill("ui/icons/SkipPrev.png", 974, 645, 55, 48, false, frame > 0, "")) setFrame(frame > 5 ? frame - 5 : 0, true, "frame_previous");
|
||
playControl(1044, 633, 70, 66);
|
||
if (imagePill("ui/icons/SkipNext.png", 1116, 645, 55, 48, false, frame + 1 < doc.frames.size(), "")) setFrame(frame + 1, true, "frame_next");
|
||
if (imagePill("ui/icons/SkipLast.png", 1177, 645, 58, 48, false, frame + 1 < doc.frames.size(), "")) setFrame(doc.frames.size() - 1, true, "frame_last");
|
||
rounded(1114, 584, 142, 40, 20, WHITE);
|
||
centered(std::to_string(frame + 1) + " / " + std::to_string(doc.frames.size()), 1114, 584, 142, 40, 18, ORANGE, true);
|
||
}
|
||
|
||
void App::renderComments() {
|
||
background();
|
||
if (gallery.empty()) { if (imageButton("ui/BackButton_Gallery.png", 39, 620, 65, 65)) screen = Screen::Gallery; return; }
|
||
const Item& item = gallery[gallerySelected % gallery.size()];
|
||
if (imageButton("ui/BackButton_Gallery.png", 39, 35, 65, 65)) screen = Screen::GalleryDetails;
|
||
text("Comments", 126, 39, 32, INK, true);
|
||
text(utf8Prefix(item.title, 44), 126, 79, 19, GRAY);
|
||
if (!galleryCommentsLoaded && galleryComments.empty()) centered("Connecting to Gallery…", 350, 245, 580, 45, 20, GRAY);
|
||
else if (galleryComments.empty()) centered("No comments yet.", 350, 245, 580, 45, 24, INK);
|
||
else {
|
||
constexpr int viewportTop = 130;
|
||
constexpr int viewportHeight = 490;
|
||
auto commentHasInk = [](const GalleryComment& comment) {
|
||
return comment.drawing.size() == sppm::kPixelsPerLayer &&
|
||
std::any_of(comment.drawing.begin(), comment.drawing.end(), [](std::uint8_t pixel) { return pixel != 0; });
|
||
};
|
||
std::vector<std::vector<std::string>> wrappedComments(galleryComments.size());
|
||
std::vector<int> heights;
|
||
heights.reserve(galleryComments.size());
|
||
int contentHeight = 0;
|
||
TTF_Font* commentFont = font(19, false);
|
||
for (std::size_t index = 0; index < galleryComments.size(); ++index) {
|
||
const auto& comment = galleryComments[index];
|
||
const bool hasDrawing = commentHasInk(comment);
|
||
if (!comment.text.empty() && commentFont) {
|
||
const std::string display = brandString(comment.text);
|
||
std::string line, word;
|
||
std::istringstream words(display);
|
||
while (words >> word) {
|
||
int wordWidth = 0, wordHeight = 0;
|
||
TTF_SizeUTF8(commentFont, word.c_str(), &wordWidth, &wordHeight);
|
||
if (wordWidth > 620) {
|
||
if (!line.empty()) { wrappedComments[index].push_back(line); line.clear(); }
|
||
std::string fragment;
|
||
for (std::size_t offset = 0; offset < word.size();) {
|
||
const unsigned char lead = static_cast<unsigned char>(word[offset]);
|
||
const std::size_t count = lead < 0x80 ? 1 : (lead & 0xE0) == 0xC0 ? 2 : (lead & 0xF0) == 0xE0 ? 3 : 4;
|
||
const std::string glyph = word.substr(offset, count);
|
||
const std::string candidate = fragment + glyph;
|
||
int width = 0, height = 0;
|
||
TTF_SizeUTF8(commentFont, candidate.c_str(), &width, &height);
|
||
if (!fragment.empty() && width > 620) { wrappedComments[index].push_back(fragment); fragment = glyph; }
|
||
else fragment = candidate;
|
||
offset += count;
|
||
}
|
||
line = fragment;
|
||
continue;
|
||
}
|
||
const std::string candidate = line.empty() ? word : line + " " + word;
|
||
int measured = 0, measuredHeight = 0;
|
||
TTF_SizeUTF8(commentFont, candidate.c_str(), &measured, &measuredHeight);
|
||
if (!line.empty() && measured > 620) {
|
||
wrappedComments[index].push_back(line);
|
||
line = word;
|
||
} else line = candidate;
|
||
}
|
||
if (!line.empty()) wrappedComments[index].push_back(line);
|
||
}
|
||
const int lineCount = static_cast<int>(wrappedComments[index].size());
|
||
const int textBottom = lineCount ? 43 + lineCount * 23 : 0;
|
||
const int drawingTop = std::max(88, textBottom + 6);
|
||
const int height = hasDrawing ? drawingTop + 332 + 10 : std::max(88, textBottom + 12);
|
||
heights.push_back(height);
|
||
contentHeight += height + 12;
|
||
}
|
||
const int maxScroll = std::max(0, contentHeight - viewportHeight);
|
||
galleryCommentScroll = std::clamp(galleryCommentScroll, 0, maxScroll);
|
||
SDL_Rect clip{197, viewportTop, 862, viewportHeight};
|
||
SDL_RenderSetClipRect(renderer, &clip);
|
||
int virtualY = viewportTop + 7 - galleryCommentScroll;
|
||
for (std::size_t index = 0; index < galleryComments.size(); ++index) {
|
||
const auto& comment = galleryComments[index];
|
||
const int cardHeight = heights[index];
|
||
const int y = virtualY;
|
||
if (y + cardHeight >= viewportTop && y <= viewportTop + viewportHeight) {
|
||
rounded(318, y + 5, 652, cardHeight, 13, SDL_Color{0, 0, 0, 35});
|
||
rounded(318, y, 652, cardHeight, 13, WHITE);
|
||
const bool hasDrawing = commentHasInk(comment);
|
||
const int avatarSize = hasDrawing ? 60 : 52;
|
||
rounded(208, y + 8, avatarSize, avatarSize, 10, LIGHT);
|
||
centered(comment.author.empty() ? "?" : utf8Prefix(comment.author, 1),
|
||
208, y + 8, avatarSize, avatarSize, hasDrawing ? 27 : 23, INK, true);
|
||
text(utf8Prefix(comment.author, 25), 284, y + 11, 21, INK, true);
|
||
text(comment.created, 784, y + 13, 17, GRAY);
|
||
for (std::size_t line = 0; line < wrappedComments[index].size(); ++line)
|
||
text(wrappedComments[index][line], 284, y + 43 + static_cast<int>(line) * 23, 19, INK);
|
||
if (hasDrawing) if (SDL_Texture* drawing = galleryCommentTexture(comment, index)) {
|
||
const int drawingY = y + std::max(88, (wrappedComments[index].empty() ? 0 : 43 + static_cast<int>(wrappedComments[index].size()) * 23) + 6);
|
||
// SPPM comment ink is 640x360. Keep its 16:9 drawing area intact.
|
||
drawTexture(drawing, 340, drawingY, 590, 332);
|
||
}
|
||
}
|
||
virtualY += cardHeight + 12;
|
||
}
|
||
SDL_RenderSetClipRect(renderer, nullptr);
|
||
if (maxScroll > 0) {
|
||
fill(1205, 146, 6, 450, SDL_Color{255, 190, 218, 255});
|
||
const int thumbHeight = std::max(54, viewportHeight * viewportHeight / contentHeight);
|
||
const int thumbY = 146 + ((viewportHeight - thumbHeight) * galleryCommentScroll / maxScroll);
|
||
fill(1205, thumbY, 6, thumbHeight, GREEN);
|
||
}
|
||
}
|
||
if (imageButton("ui/BackButton_Gallery.png", 39, 620, 65, 65)) screen = Screen::GalleryDetails;
|
||
if (pill("Post Comment Y", 1022, 633, 218, 47, true, 20)) screen = Screen::CommentCanvas;
|
||
}
|
||
|
||
void App::renderCommentCanvas() {
|
||
background();
|
||
if (!commentTexture || commentDirty) {
|
||
if (commentTexture) SDL_DestroyTexture(commentTexture);
|
||
SDL_Surface* surface = SDL_CreateRGBSurfaceWithFormat(0, sppm::kWidth, sppm::kHeight, 32, SDL_PIXELFORMAT_RGBA32);
|
||
if (surface) {
|
||
auto* rgba = static_cast<std::uint32_t*>(surface->pixels);
|
||
for (std::size_t i = 0; i < sppm::kPixelsPerLayer; ++i) rgba[i] = commentPixels[i] ? SDL_MapRGBA(surface->format, 20, 22, 28, 255) : SDL_MapRGBA(surface->format, 0, 0, 0, 0);
|
||
commentTexture = SDL_CreateTextureFromSurface(renderer, surface);
|
||
if (commentTexture) SDL_SetTextureScaleMode(commentTexture, SDL_ScaleModeNearest);
|
||
SDL_FreeSurface(surface);
|
||
}
|
||
commentDirty = false;
|
||
}
|
||
fill(0, 0, W, H, WHITE);
|
||
if (commentTexture) drawTexture(commentTexture, 0, 0, W, H);
|
||
if (pill("Text", 20, 20, 115, 44, true, 18)) beginText(Field::CommentText, "");
|
||
if (!commentDraft.empty()) text(utf8Prefix(commentDraft, 72), 158, 27, 19, INK);
|
||
if (pill("Cancel", 22, 644, 134, 45, true, 20)) screen = Screen::GalleryComments;
|
||
if (pill("Clear X", 1003, 644, 117, 45, true, 20)) { commentPixels.assign(sppm::kPixelsPerLayer, 0); commentDirty = true; }
|
||
if (pill("Send Y", 1142, 644, 116, 45, true, 20)) postGalleryComment();
|
||
}
|
||
|
||
void App::beginText(Field field, const std::string& current) {
|
||
#ifdef __SWITCH__
|
||
SwkbdConfig keyboard;
|
||
if (R_SUCCEEDED(swkbdCreate(&keyboard, 0))) {
|
||
swkbdConfigMakePresetDefault(&keyboard);
|
||
swkbdConfigSetInitialText(&keyboard, current.c_str());
|
||
const char* header = field == Field::Title ? "Switchnote title" : field == Field::Description ? "Description" :
|
||
field == Field::FolderName ? "New folder" : field == Field::GalleryBio ? "Gallery bio" : "Comment";
|
||
swkbdConfigSetHeaderText(&keyboard, header);
|
||
char buffer[257]{};
|
||
if (R_SUCCEEDED(swkbdShow(&keyboard, buffer, sizeof(buffer)))) {
|
||
editingField = field;
|
||
inputText = buffer;
|
||
applyText();
|
||
}
|
||
swkbdClose(&keyboard);
|
||
}
|
||
#else
|
||
editingField = field;
|
||
inputText = current;
|
||
modal = Modal::TextInput;
|
||
SDL_StartTextInput();
|
||
#endif
|
||
}
|
||
|
||
void App::applyText() {
|
||
SDL_StopTextInput();
|
||
const std::string value = inputText.substr(0, editingField == Field::GalleryBio ? 200 : 240);
|
||
switch (editingField) {
|
||
case Field::Title:
|
||
if (docLoaded && !value.empty()) { doc.metadata.title = value; markDirty(); }
|
||
break;
|
||
case Field::Description:
|
||
if (docLoaded) { doc.metadata.description = value; markDirty(); }
|
||
break;
|
||
case Field::FolderName: {
|
||
std::string safe;
|
||
for (unsigned char ch : value) if (std::isalnum(ch) || ch == ' ' || ch == '_' || ch == '-') safe.push_back(static_cast<char>(ch));
|
||
if (!safe.empty()) {
|
||
ensureDir(join(notesRoot, safe));
|
||
folder = safe;
|
||
selected = 0;
|
||
scanLibrary();
|
||
showToast("Folder created");
|
||
}
|
||
break;
|
||
}
|
||
case Field::CommentText:
|
||
if (!value.empty()) { commentDraft = value; screen = Screen::CommentCanvas; }
|
||
break;
|
||
case Field::GalleryBio:
|
||
if (galleryProfileIsOwn) { galleryProfile.bio = value; saveGalleryProfile(); }
|
||
break;
|
||
case Field::None: break;
|
||
}
|
||
inputText.clear();
|
||
editingField = Field::None;
|
||
modal = Modal::None;
|
||
}
|
||
|
||
bool App::importAudioFile(const std::string& path, int targetTrack, const std::string& displayName) {
|
||
if (!docLoaded || targetTrack < 0 || targetTrack >= 4) return false;
|
||
SDL_AudioSpec source{};
|
||
Uint8* raw = nullptr;
|
||
Uint32 rawLength = 0;
|
||
if (!SDL_LoadWAV(path.c_str(), &source, &raw, &rawLength)) {
|
||
showToast("Could not read WAV: " + std::string(SDL_GetError()));
|
||
return false;
|
||
}
|
||
const int bytesPerSample = SDL_AUDIO_BITSIZE(source.format) / 8;
|
||
if (source.freq <= 0 || source.channels < 1 || source.channels > 2 || bytesPerSample <= 0 ||
|
||
rawLength == 0 || rawLength > static_cast<Uint32>(std::numeric_limits<int>::max())) {
|
||
SDL_FreeWAV(raw);
|
||
showToast("Use a valid mono or stereo WAV file");
|
||
return false;
|
||
}
|
||
const std::size_t bytesPerFrame = static_cast<std::size_t>(source.channels) * bytesPerSample;
|
||
const std::size_t availableFrames = rawLength / bytesPerFrame;
|
||
const int maximumSeconds = targetTrack == 0 ? 60 : 2;
|
||
const std::size_t maximumFrames = static_cast<std::size_t>(maximumSeconds) * static_cast<std::size_t>(source.freq);
|
||
const std::size_t framesToKeep = std::min(availableFrames, maximumFrames);
|
||
if (!framesToKeep) {
|
||
SDL_FreeWAV(raw);
|
||
showToast("This audio file is empty");
|
||
return false;
|
||
}
|
||
const bool trimmed = framesToKeep < availableFrames;
|
||
SDL_AudioCVT cvt{};
|
||
const int build = SDL_BuildAudioCVT(&cvt, source.format, source.channels, source.freq, AUDIO_S16SYS, 2, 48000);
|
||
if (build < 0) { SDL_FreeWAV(raw); showToast("WAV format is not supported"); return false; }
|
||
cvt.len = static_cast<int>(framesToKeep * bytesPerFrame);
|
||
cvt.buf = static_cast<Uint8*>(SDL_malloc(static_cast<std::size_t>(cvt.len) * cvt.len_mult));
|
||
if (!cvt.buf) { SDL_FreeWAV(raw); showToast("Not enough memory to import audio"); return false; }
|
||
std::memcpy(cvt.buf, raw, static_cast<std::size_t>(cvt.len));
|
||
SDL_FreeWAV(raw);
|
||
if (cvt.needed && SDL_ConvertAudio(&cvt) != 0) { SDL_free(cvt.buf); showToast("Could not convert WAV audio"); return false; }
|
||
if (!cvt.needed) cvt.len_cvt = cvt.len;
|
||
const std::size_t sampleCount = static_cast<std::size_t>(cvt.len_cvt) / sizeof(std::int16_t);
|
||
constexpr std::size_t maxAudioSamples = 32ULL * 1024 * 1024;
|
||
std::size_t otherSamples = 0;
|
||
for (std::size_t i = 0; i < doc.audioTracks.size(); ++i)
|
||
if (i != static_cast<std::size_t>(targetTrack)) otherSamples += doc.audioTracks[i].pcm.size();
|
||
if (!cvt.len_cvt || sampleCount > maxAudioSamples || otherSamples > maxAudioSamples - sampleCount) {
|
||
SDL_free(cvt.buf);
|
||
showToast("There is not enough Switchnote space for this audio");
|
||
return false;
|
||
}
|
||
while (doc.audioTracks.size() <= static_cast<std::size_t>(targetTrack)) {
|
||
sppm::AudioTrack blank;
|
||
blank.name = doc.audioTracks.empty() ? "BGM" : "SE" + std::to_string(doc.audioTracks.size());
|
||
blank.sampleRate = 48000; blank.channels = 2;
|
||
doc.audioTracks.push_back(std::move(blank));
|
||
}
|
||
auto& track = doc.audioTracks[static_cast<std::size_t>(targetTrack)];
|
||
track.name = targetTrack == 0 ? "BGM" : "SE" + std::to_string(targetTrack);
|
||
track.sampleRate = 48000; track.channels = 2;
|
||
track.referenceFps = 0;
|
||
track.referenceSpeed = targetTrack == 0 ? doc.metadata.speed : 0;
|
||
track.pcm.resize(sampleCount);
|
||
std::memcpy(track.pcm.data(), cvt.buf, sampleCount * sizeof(std::int16_t));
|
||
SDL_free(cvt.buf);
|
||
if (targetTrack > 0 && track.frameTriggers.empty()) track.frameTriggers = {static_cast<std::uint16_t>(frame)};
|
||
markDirty();
|
||
rebuildAudio();
|
||
if (!saveDocument(true)) return false;
|
||
showToast("Imported " + displayName + " to " + track.name + (trimmed ? " (trimmed)" : ""));
|
||
return true;
|
||
}
|
||
|
||
void App::importAudio() {
|
||
if (!docLoaded || importFiles.empty()) { showToast("Add WAV files to the sdmc:/switch/Switchnote/import folder"); return; }
|
||
const std::string filename = importFiles[importSelection % importFiles.size()];
|
||
importAudioFile(join(importRoot, filename), audioTrack, filename);
|
||
}
|
||
|
||
void App::exportDocument(int destination) {
|
||
if (!docLoaded) return;
|
||
std::string base = doc.metadata.title.empty() ? "Switchnote" : doc.metadata.title;
|
||
for (char& ch : base) if (!std::isalnum(static_cast<unsigned char>(ch)) && ch != '-' && ch != '_') ch = '_';
|
||
std::string error;
|
||
if (destination == 0) {
|
||
const std::string directory = "sdmc:/Switchnotes";
|
||
ensureDir(directory);
|
||
const std::string path = join(directory, base + ".mp4");
|
||
const bool ok = sppm::exportMp4(doc, path, error);
|
||
showToast(ok ? "Silent MP4 exported to " + path : "Export failed: " + error);
|
||
return;
|
||
}
|
||
#ifdef __SWITCH__
|
||
std::vector<std::uint8_t> image(static_cast<std::size_t>(1280) * 720 * 4, 255);
|
||
const auto& cover = doc.frames[doc.metadata.coverFrame < doc.frames.size() ? doc.metadata.coverFrame : 0];
|
||
for (std::size_t y = 0; y < 720; ++y) {
|
||
for (std::size_t x = 0; x < 1280; ++x) {
|
||
const std::size_t pixel = (y / 2) * sppm::kWidth + x / 2;
|
||
unsigned red = 255, green = 255, blue = 255;
|
||
for (std::size_t layerIndex = cover.layers.size(); layerIndex-- > 0;) {
|
||
const std::uint8_t index = cover.layers[layerIndex][pixel];
|
||
if (!index) continue;
|
||
const auto& color = doc.palette[index];
|
||
const unsigned alpha = color.a;
|
||
red = (color.r * alpha + red * (255 - alpha) + 127) / 255;
|
||
green = (color.g * alpha + green * (255 - alpha) + 127) / 255;
|
||
blue = (color.b * alpha + blue * (255 - alpha) + 127) / 255;
|
||
}
|
||
const std::size_t offset = (y * 1280 + x) * 4;
|
||
image[offset] = static_cast<std::uint8_t>(red);
|
||
image[offset + 1] = static_cast<std::uint8_t>(green);
|
||
image[offset + 2] = static_cast<std::uint8_t>(blue);
|
||
image[offset + 3] = 255;
|
||
}
|
||
}
|
||
Result initResult = capssuInitialize();
|
||
if (R_FAILED(initResult)) {
|
||
showToast("Could not open System Captures (" + std::to_string(initResult) + ")");
|
||
return;
|
||
}
|
||
CapsApplicationAlbumEntry entry{};
|
||
const Result saveResult = capssuSaveScreenShot(image.data(), image.size(),
|
||
AlbumReportOption_Enable, AlbumImageOrientation_Unknown0, &entry);
|
||
capssuExit();
|
||
showToast(R_SUCCEEDED(saveResult) ? "Cover saved to System Captures" :
|
||
"System Captures export failed (" + std::to_string(saveResult) + ")");
|
||
#else
|
||
const std::string path = join(exportRoot, base + ".png");
|
||
const bool ok = sppm::exportPngCover(doc, path, error);
|
||
showToast(ok ? "System Captures export is Switch-only; saved cover to " + path : "Export failed: " + error);
|
||
#endif
|
||
}
|
||
|
||
void App::openPhotoCapture() {
|
||
if (!docLoaded || frame >= doc.frames.size()) return;
|
||
stopPlayback(false);
|
||
#ifdef __SWITCH__
|
||
if (photoProbeRunning) return;
|
||
irPhotoTaken = false;
|
||
irRotatePhoto = false;
|
||
irImageReady = false;
|
||
irImageState = {};
|
||
photoProbeRunning = true;
|
||
photoProbeHasCamera = false;
|
||
photoProbeFinished.store(false, std::memory_order_relaxed);
|
||
beginLoading();
|
||
modal = Modal::PhotoProbe;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
if (R_FAILED(threadCreate(&photoProbeThread, photoProbeThreadEntry, this, nullptr, 0x10000, 0x3B, -2))) {
|
||
photoProbeRunning = false;
|
||
endLoading();
|
||
modal = Modal::None;
|
||
openPhotoUpload();
|
||
return;
|
||
}
|
||
photoProbeThreadCreated = true;
|
||
if (R_FAILED(threadStart(&photoProbeThread))) {
|
||
threadClose(&photoProbeThread);
|
||
photoProbeThreadCreated = false;
|
||
photoProbeRunning = false;
|
||
endLoading();
|
||
modal = Modal::None;
|
||
openPhotoUpload();
|
||
}
|
||
#else
|
||
openPhotoUpload();
|
||
#endif
|
||
}
|
||
|
||
#ifdef __SWITCH__
|
||
void App::photoProbeThreadEntry(void* argument) {
|
||
auto* app = static_cast<App*>(argument);
|
||
app->runPhotoProbeThread();
|
||
threadExit();
|
||
}
|
||
|
||
void App::runPhotoProbeThread() {
|
||
irCameraRunning = false;
|
||
irsReady = irsInitialize() == 0;
|
||
if (irsReady) {
|
||
// IR probing can take several service round-trips on consoles with
|
||
// detached/reassigned Joy-Cons. Keep all of it off the render thread.
|
||
const bool handheld = (hidGetNpadStyleSet(HidNpadIdType_Handheld) & HidNpadStyleTag_NpadHandheld) != 0;
|
||
const std::array<HidNpadIdType, 9> cameraCandidates = handheld
|
||
? std::array<HidNpadIdType, 9>{HidNpadIdType_Handheld, HidNpadIdType_No1, HidNpadIdType_No2,
|
||
HidNpadIdType_No3, HidNpadIdType_No4, HidNpadIdType_No5, HidNpadIdType_No6, HidNpadIdType_No7, HidNpadIdType_No8}
|
||
: std::array<HidNpadIdType, 9>{HidNpadIdType_No1, HidNpadIdType_No2, HidNpadIdType_No3,
|
||
HidNpadIdType_No4, HidNpadIdType_No5, HidNpadIdType_No6, HidNpadIdType_No7, HidNpadIdType_No8, HidNpadIdType_Handheld};
|
||
IrsImageTransferProcessorConfig config{};
|
||
irsGetDefaultImageTransferProcessorConfig(&config);
|
||
config.format = IrsImageTransferProcessorFormat_320x240;
|
||
for (const HidNpadIdType id : cameraCandidates) {
|
||
IrsIrCameraHandle candidate{};
|
||
if (R_FAILED(irsGetIrCameraHandle(&candidate, id))) continue;
|
||
IrsIrCameraStatus status{};
|
||
if (R_FAILED(irsGetIrCameraStatus(candidate, &status)) || status != IrsIrCameraStatus_Available) continue;
|
||
if (R_FAILED(irsRunImageTransferProcessor(candidate, &config, 0x100000))) continue;
|
||
irCamera = candidate;
|
||
irCameraRunning = true;
|
||
break;
|
||
}
|
||
if (!irCameraRunning) for (const HidNpadIdType id : cameraCandidates) {
|
||
IrsIrCameraHandle candidate{};
|
||
if (R_FAILED(irsGetIrCameraHandle(&candidate, id))) continue;
|
||
if (R_FAILED(irsRunImageTransferProcessor(candidate, &config, 0x100000))) continue;
|
||
irCamera = candidate;
|
||
irCameraRunning = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!irCameraRunning && irsReady) {
|
||
irsExit();
|
||
irsReady = false;
|
||
}
|
||
photoProbeHasCamera = irCameraRunning;
|
||
photoProbeFinished.store(true, std::memory_order_release);
|
||
}
|
||
#endif
|
||
|
||
void App::consumePhotoProbe() {
|
||
#ifdef __SWITCH__
|
||
if (!photoProbeRunning || !photoProbeFinished.exchange(false, std::memory_order_acquire)) return;
|
||
if (photoProbeThreadCreated) {
|
||
threadWaitForExit(&photoProbeThread);
|
||
threadClose(&photoProbeThread);
|
||
photoProbeThreadCreated = false;
|
||
}
|
||
photoProbeRunning = false;
|
||
endLoading();
|
||
if (photoProbeHasCamera) {
|
||
if (!irPreviewTexture && renderer)
|
||
irPreviewTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_STREAMING, 320, 240);
|
||
modal = Modal::PhotoChoice;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
} else {
|
||
modal = Modal::None;
|
||
openPhotoUpload();
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void App::openPhotoUpload() {
|
||
stopPlayback(false);
|
||
modal = Modal::PhotoUpload;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
requestAudioUploadServer(true);
|
||
}
|
||
|
||
void App::openPhotoAlbum() {
|
||
#ifdef __SWITCH__
|
||
for (SDL_Texture*& texture : photoAlbumThumbs) {
|
||
if (texture) SDL_DestroyTexture(texture);
|
||
texture = nullptr;
|
||
}
|
||
photoAlbumEntries.clear();
|
||
photoAlbumPage = 0;
|
||
photoAlbumThumbIndexes.fill(std::numeric_limits<std::size_t>::max());
|
||
if (R_FAILED(capsaInitialize())) { showToast("Could not open the Switch photo album."); return; }
|
||
u64 count = 0;
|
||
Result result = capsaGetAlbumFileCount(CapsAlbumStorage_Sd, &count);
|
||
if (R_FAILED(result) || count == 0) result = capsaGetAlbumFileCount(CapsAlbumStorage_Nand, &count);
|
||
if (R_FAILED(result) || count == 0) {
|
||
capsaExit();
|
||
showToast(count == 0 ? "No photos were found in the album." : "Could not read the Switch photo album.");
|
||
return;
|
||
}
|
||
count = std::min<u64>(count, 2048);
|
||
std::vector<CapsAlbumEntry> entries(static_cast<std::size_t>(count));
|
||
u64 written = 0;
|
||
result = capsaGetAlbumFileList(CapsAlbumStorage_Sd, &written, entries.data(), entries.size());
|
||
if (R_FAILED(result) || written == 0) result = capsaGetAlbumFileList(CapsAlbumStorage_Nand, &written, entries.data(), entries.size());
|
||
capsaExit();
|
||
if (R_FAILED(result) || written == 0) { showToast("Could not read photos from the Switch album."); return; }
|
||
entries.resize(static_cast<std::size_t>(std::min<u64>(written, entries.size())));
|
||
for (const auto& entry : entries) if (entry.file_id.content == CapsContentType_Screenshot) photoAlbumEntries.push_back(entry);
|
||
std::sort(photoAlbumEntries.begin(), photoAlbumEntries.end(), [](const CapsAlbumEntry& a, const CapsAlbumEntry& b) {
|
||
const auto& x = a.file_id.datetime; const auto& y = b.file_id.datetime;
|
||
if (x.year != y.year) return x.year > y.year;
|
||
if (x.month != y.month) return x.month > y.month;
|
||
if (x.day != y.day) return x.day > y.day;
|
||
if (x.hour != y.hour) return x.hour > y.hour;
|
||
if (x.minute != y.minute) return x.minute > y.minute;
|
||
if (x.second != y.second) return x.second > y.second;
|
||
return x.id > y.id;
|
||
});
|
||
if (photoAlbumEntries.empty()) { showToast("No screenshots were found in the Switch photo album."); return; }
|
||
modal = Modal::PhotoAlbum;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
#else
|
||
showToast("The Switch photo album is only available on Nintendo Switch.");
|
||
#endif
|
||
}
|
||
|
||
void App::importPhotoAlbumEntry(std::size_t index) {
|
||
#ifdef __SWITCH__
|
||
if (!docLoaded || frame >= doc.frames.size() || index >= photoAlbumEntries.size()) return;
|
||
if (R_FAILED(capsaInitialize())) { showToast("Could not open the Switch photo album."); return; }
|
||
const CapsAlbumEntry& entry = photoAlbumEntries[index];
|
||
if (entry.size == 0 || entry.size > 32U * 1024U * 1024U) {
|
||
capsaExit(); showToast("That album image is too large to import."); return;
|
||
}
|
||
std::vector<std::uint8_t> encoded(static_cast<std::size_t>(entry.size));
|
||
u64 loaded = 0;
|
||
const Result result = capsaLoadAlbumFile(&entry.file_id, &loaded, encoded.data(), encoded.size());
|
||
capsaExit();
|
||
if (R_FAILED(result) || loaded == 0 || loaded > encoded.size()) { showToast("Could not load that album image."); return; }
|
||
SDL_RWops* stream = SDL_RWFromConstMem(encoded.data(), static_cast<int>(loaded));
|
||
SDL_Surface* decoded = stream ? IMG_Load_RW(stream, 1) : nullptr;
|
||
if (!decoded || decoded->w <= 0 || decoded->h <= 0 || decoded->w > 8192 || decoded->h > 8192) {
|
||
if (decoded) SDL_FreeSurface(decoded);
|
||
showToast("That album image could not be decoded."); return;
|
||
}
|
||
SDL_Surface* rgba = SDL_ConvertSurfaceFormat(decoded, SDL_PIXELFORMAT_RGBA32, 0);
|
||
SDL_FreeSurface(decoded);
|
||
if (!rgba) { showToast("Could not prepare the album image."); return; }
|
||
photoImportRgba.assign(600U * sppm::kHeight * 4U, 0);
|
||
const float scale = std::min(600.0f / rgba->w, static_cast<float>(sppm::kHeight) / rgba->h);
|
||
const int drawW = std::max(1, static_cast<int>(std::lround(rgba->w * scale)));
|
||
const int drawH = std::max(1, static_cast<int>(std::lround(rgba->h * scale)));
|
||
const int left = (600 - drawW) / 2, top = (static_cast<int>(sppm::kHeight) - drawH) / 2;
|
||
if (SDL_MUSTLOCK(rgba)) SDL_LockSurface(rgba);
|
||
for (int y = 0; y < drawH; ++y) {
|
||
const int sy = std::min(rgba->h - 1, y * rgba->h / drawH);
|
||
const auto* row = static_cast<const std::uint8_t*>(rgba->pixels) + static_cast<std::size_t>(sy) * rgba->pitch;
|
||
for (int x = 0; x < drawW; ++x) {
|
||
const int sx = std::min(rgba->w - 1, x * rgba->w / drawW);
|
||
const auto* src = row + static_cast<std::size_t>(sx) * 4U;
|
||
auto* dst = photoImportRgba.data() + (static_cast<std::size_t>(top + y) * 600U + left + x) * 4U;
|
||
std::memcpy(dst, src, 4U);
|
||
}
|
||
}
|
||
if (SDL_MUSTLOCK(rgba)) SDL_UnlockSurface(rgba);
|
||
SDL_FreeSurface(rgba);
|
||
photoImportLayer = std::clamp(layer, 0, 3);
|
||
photoImportRow = 0;
|
||
pushUndo();
|
||
std::fill(doc.frames[frame].layers[static_cast<std::size_t>(photoImportLayer)].begin(),
|
||
doc.frames[frame].layers[static_cast<std::size_t>(photoImportLayer)].end(), 0);
|
||
photoImporting = true;
|
||
modal = Modal::None;
|
||
beginLoading();
|
||
#else
|
||
(void)index;
|
||
#endif
|
||
}
|
||
|
||
void App::closePhotoCapture() {
|
||
#ifdef __SWITCH__
|
||
if (irCameraRunning) {
|
||
irsStopImageProcessor(irCamera);
|
||
irCameraRunning = false;
|
||
}
|
||
if (irsReady) {
|
||
irsExit();
|
||
irsReady = false;
|
||
}
|
||
#endif
|
||
if (photoTransferActive) stopAudioUploadServer();
|
||
modal = Modal::None;
|
||
}
|
||
|
||
void App::updatePhotoCapture() {
|
||
#ifdef __SWITCH__
|
||
if (!irsReady || !irCameraRunning || irPhotoTaken) return;
|
||
const std::uint64_t previousSample = irImageState.sampling_number;
|
||
if (R_FAILED(irsGetImageTransferProcessorState(irCamera, irImage.data(), irImage.size(), &irImageState))) return;
|
||
if (irImageReady && irImageState.sampling_number == previousSample) return;
|
||
irImageReady = true;
|
||
for (std::size_t i = 0; i < irImage.size(); ++i) {
|
||
irPreviewRgba[i * 4] = irImage[i];
|
||
irPreviewRgba[i * 4 + 1] = irImage[i];
|
||
irPreviewRgba[i * 4 + 2] = irImage[i];
|
||
}
|
||
if (irPreviewTexture) SDL_UpdateTexture(irPreviewTexture, nullptr, irPreviewRgba.data(), 320 * 4);
|
||
#endif
|
||
}
|
||
|
||
void App::importPhoto() {
|
||
#ifdef __SWITCH__
|
||
if (!docLoaded || !irPhotoTaken || frame >= doc.frames.size()) return;
|
||
pushUndo();
|
||
auto& pixels = doc.frames[frame].layers[static_cast<std::size_t>(layer)];
|
||
std::fill(pixels.begin(), pixels.end(), 0);
|
||
// Keep the IR image's 4:3 proportions, centered on the 16:9 Switchnote
|
||
// canvas. Its native 320x240 pixels are doubled without interpolation.
|
||
const int targetW = irRotatePhoto ? 270 : 480;
|
||
constexpr int targetH = 360;
|
||
const int left = (sppm::kWidth - targetW) / 2;
|
||
const auto palette = doc.palette;
|
||
std::array<std::uint8_t, 256> grayToPalette{};
|
||
for (int shade = 0; shade < 256; ++shade) {
|
||
int bestError = std::numeric_limits<int>::max();
|
||
std::uint8_t bestIndex = 1;
|
||
for (int index = 16; index < 256; ++index) {
|
||
const auto& c = palette[static_cast<std::size_t>(index)];
|
||
const int luminance = (c.r * 299 + c.g * 587 + c.b * 114) / 1000;
|
||
const int error = std::abs(luminance - shade);
|
||
if (error < bestError) { bestError = error; bestIndex = static_cast<std::uint8_t>(index); }
|
||
}
|
||
grayToPalette[static_cast<std::size_t>(shade)] = bestIndex;
|
||
}
|
||
for (int y = 0; y < targetH; ++y) {
|
||
for (int x = 0; x < targetW; ++x) {
|
||
const int rotatedX = irRotatePhoto ? x * 240 / targetW : 0;
|
||
const int rotatedY = irRotatePhoto ? y * 320 / targetH : 0;
|
||
const int sourceX = irRotatePhoto ? rotatedY : x / 1.5;
|
||
const int sourceY = irRotatePhoto ? 239 - rotatedX : y / 1.5;
|
||
const auto gray = irPhoto[static_cast<std::size_t>(sourceY) * 320 + sourceX];
|
||
pixels[static_cast<std::size_t>(y) * sppm::kWidth + left + x] = grayToPalette[gray];
|
||
}
|
||
}
|
||
markDirty();
|
||
invalidateFrames();
|
||
showToast("Photo imported to the selected layer");
|
||
#endif
|
||
closePhotoCapture();
|
||
}
|
||
|
||
bool App::importUploadedPhoto() {
|
||
if (photoImporting) return false;
|
||
if (!docLoaded || frame >= doc.frames.size()) return false;
|
||
const std::string imagePath = join(importRoot, "photo-transfer.rgba");
|
||
const std::string optionsPath = join(importRoot, "photo-transfer.cfg");
|
||
std::ifstream image(imagePath, std::ios::binary | std::ios::ate);
|
||
constexpr std::size_t photoBytes = 600U * sppm::kHeight * 4U;
|
||
if (!image || image.tellg() != static_cast<std::streamoff>(photoBytes)) return false;
|
||
photoImportRgba.resize(photoBytes);
|
||
image.seekg(0, std::ios::beg);
|
||
image.read(reinterpret_cast<char*>(photoImportRgba.data()), static_cast<std::streamsize>(photoImportRgba.size()));
|
||
if (!image) return false;
|
||
std::ifstream options(optionsPath, std::ios::binary);
|
||
int targetLayer = -1;
|
||
std::string mode, dither, size, offsetX, offsetY;
|
||
std::string line;
|
||
if (!std::getline(options, line)) return false;
|
||
targetLayer = std::atoi(line.c_str());
|
||
if (!std::getline(options, mode) || !std::getline(options, dither) ||
|
||
!std::getline(options, size) || !std::getline(options, offsetX) || !std::getline(options, offsetY) ||
|
||
targetLayer < 0 || targetLayer >= 4) return false;
|
||
(void)mode; (void)dither; (void)size; (void)offsetX; (void)offsetY;
|
||
photoImportLayer = targetLayer;
|
||
photoImportRow = 0;
|
||
layer = targetLayer;
|
||
pushUndo();
|
||
std::fill(doc.frames[frame].layers[static_cast<std::size_t>(targetLayer)].begin(),
|
||
doc.frames[frame].layers[static_cast<std::size_t>(targetLayer)].end(), 0);
|
||
photoImporting = true;
|
||
beginLoading();
|
||
return true;
|
||
}
|
||
|
||
void App::advancePhotoImport() {
|
||
if (!photoImporting) return;
|
||
constexpr int rowsPerUpdate = 4;
|
||
auto& pixels = doc.frames[frame].layers[static_cast<std::size_t>(photoImportLayer)];
|
||
const int endRow = std::min<int>(sppm::kHeight, photoImportRow + rowsPerUpdate);
|
||
for (int y = photoImportRow; y < endRow; ++y) {
|
||
for (int x = 0; x < sppm::kWidth; ++x) {
|
||
// The browser preview is 600x360 while the Switchnote canvas is
|
||
// 640x360. Center that one preview exactly and never walk through
|
||
// the next row or past the uploaded buffer.
|
||
const int sourceX = x - 20;
|
||
if (sourceX < 0 || sourceX >= 600) continue;
|
||
const std::size_t source = (static_cast<std::size_t>(y) * 600U + static_cast<std::size_t>(sourceX)) * 4U;
|
||
if (photoImportRgba[source + 3] < 24) continue;
|
||
int bestError = std::numeric_limits<int>::max();
|
||
std::uint8_t bestIndex = 1;
|
||
for (int index : kInkPresetIndexes) {
|
||
const auto& candidate = doc.palette[static_cast<std::size_t>(index)];
|
||
const int dr = static_cast<int>(candidate.r) - photoImportRgba[source];
|
||
const int dg = static_cast<int>(candidate.g) - photoImportRgba[source + 1];
|
||
const int db = static_cast<int>(candidate.b) - photoImportRgba[source + 2];
|
||
const int error = dr * dr * 3 + dg * dg * 6 + db * db * 2;
|
||
if (error < bestError) { bestError = error; bestIndex = static_cast<std::uint8_t>(index); }
|
||
}
|
||
pixels[static_cast<std::size_t>(y) * sppm::kWidth + static_cast<std::size_t>(x)] = bestIndex;
|
||
}
|
||
}
|
||
photoImportRow = endRow;
|
||
if (photoImportRow < sppm::kHeight) return;
|
||
markDirty();
|
||
invalidateFrames();
|
||
const bool saved = saveDocument();
|
||
std::remove(join(importRoot, "photo-transfer.rgba").c_str());
|
||
std::remove(join(importRoot, "photo-transfer.cfg").c_str());
|
||
audioUploadServer.finishCompletedUpload(saved);
|
||
audioUploadStatus = saved ? "Photo added to your Switchnote." : "Photo import could not be saved.";
|
||
if (saved) showToast("Photo imported to layer " + std::string(1, static_cast<char>('A' + photoImportLayer)));
|
||
photoImportRgba.clear();
|
||
photoImporting = false;
|
||
endLoading();
|
||
}
|
||
|
||
void App::renderModal() {
|
||
renderingModal = true;
|
||
fill(0, 0, W, H, SDL_Color{10, 15, 24, 126});
|
||
const float progress = std::clamp((SDL_GetTicks() - modalTransitionStart) / 150.0f, 0.0f, 1.0f);
|
||
const float eased = modalClosing ? progress * progress * progress
|
||
: 1.0f - (1.0f - progress) * (1.0f - progress) * (1.0f - progress);
|
||
const bool galleryTerms = modal == Modal::GalleryTerms;
|
||
const bool updateScreen = modal == Modal::UpdateAvailable;
|
||
const int x = (galleryTerms || updateScreen) ? 42 : 330;
|
||
const int w = (galleryTerms || updateScreen) ? 1196 : 620;
|
||
const int h = (galleryTerms || updateScreen) ? 630 : 460;
|
||
const int targetY = (galleryTerms || updateScreen) ? 45 : 130;
|
||
const int y = modalClosing ? targetY - static_cast<int>(eased * (targetY + h))
|
||
: -h + static_cast<int>(eased * (targetY + h));
|
||
rounded(x, y + 6, w, h, 22, SDL_Color{0, 0, 0, 55});
|
||
rounded(x, y, w, h, 22, WHITE);
|
||
auto title = [&](const std::string& value) { centered(value, x + 24, y + 20, w - 48, 42, 28, INK, true); };
|
||
auto dismiss = [&]() {
|
||
if (pill("Close", x + w - 135, y + h - 64, 108, 42, false, 18)) {
|
||
if (modal == Modal::Photo || modal == Modal::PhotoChoice || modal == Modal::PhotoUpload) closePhotoCapture();
|
||
else if (modal == Modal::Audio) closeAudioMenu();
|
||
else if (modal == Modal::Branding) closeBrandingMenu();
|
||
else modal = Modal::None;
|
||
}
|
||
};
|
||
switch (modal) {
|
||
case Modal::GalleryTerms: {
|
||
centered("Switchnote Gallery: Alpha Server!", x + 56, y + 64, w - 112, 62, 39, INK, true);
|
||
text("By using services provided by RexiMemo, you agree to the Terms of Use", x + 128, y + 170, 23, INK);
|
||
text("and acknowledge the Privacy Policy.", x + 128, y + 204, 23, INK);
|
||
text("You must be 13 years of age or older to use RexiMemo, including", x + 128, y + 258, 23, INK);
|
||
text("Switchnote Gallery.", x + 128, y + 292, 23, INK);
|
||
text("Switchnote/RexiMemo does not sell personal information or use it for", x + 128, y + 346, 23, INK);
|
||
text("targeted advertising.", x + 128, y + 380, 23, INK);
|
||
text("Terms:", x + 128, y + 436, 22, INK);
|
||
text("https://reximemo.net/terms", x + 690, y + 436, 22, INK);
|
||
text("Privacy:", x + 128, y + 474, 22, INK);
|
||
text("https://reximemo.net/privacy", x + 690, y + 474, 22, INK);
|
||
if (actionPill("ui/icons/ButtonBText.png", "Back", x + 415, y + 548, 170, 54, false, true, "cursor_cancel")) {
|
||
modal = Modal::None;
|
||
screen = Screen::Library;
|
||
}
|
||
if (actionPill("ui/icons/ButtonAGalleryText.png", "I agree", x + 610, y + 548, 190, 54, true, true, "cursor_select")) {
|
||
galleryTermsAccepted = true;
|
||
std::ofstream accepted(join(dataRoot, "gallery-terms-accepted"), std::ios::binary | std::ios::trunc);
|
||
if (accepted) accepted << "1\n";
|
||
modal = Modal::None;
|
||
}
|
||
break;
|
||
}
|
||
case Modal::Credits:
|
||
title("Credits");
|
||
centered("Homebrew application by: RexiMemo!", x + 36, y + 120, w - 72, 36, 20, INK);
|
||
centered("Testing during development: meulin, LatteWiiU", x + 36, y + 180, w - 72, 36, 20, INK);
|
||
centered("UI Design originally by: Jaames", x + 36, y + 240, w - 72, 36, 20, INK);
|
||
dismiss();
|
||
break;
|
||
case Modal::GalleryPostChoice:
|
||
title("Post to Gallery");
|
||
centered("Choose whether other users can edit this Switchnote.", x + 34, y + 116, w - 68, 54, 18, INK);
|
||
centered("A locked Switchnote stays read-only when downloaded.", x + 34, y + 166, w - 68, 42, 16, GRAY);
|
||
if (actionPill("ui/icons/ButtonXText.png", "Post with Lock", x + 58, y + 258, 240, 56, false, true, "cursor_select")) {
|
||
modal = Modal::None; performGalleryUpload(pendingGalleryPublishIndex, true);
|
||
}
|
||
if (actionPill("ui/icons/ButtonYText.png", "Post without Lock", x + 322, y + 258, 240, 56, false, true, "cursor_select")) {
|
||
modal = Modal::None; performGalleryUpload(pendingGalleryPublishIndex, false);
|
||
}
|
||
if (actionPill("ui/icons/ButtonBText.png", "Cancel", x + 226, y + 350, 168, 52, false, true, "cursor_cancel")) modal = Modal::None;
|
||
break;
|
||
case Modal::GalleryNotice: {
|
||
title("Leaving " + appDisplayName);
|
||
centered("You are now leaving " + appDisplayName + ".", x + 42, y + 112, w - 84, 38, 20, INK);
|
||
centered("The following services are provided by", x + 42, y + 165, w - 84, 34, 19, GRAY);
|
||
centered("RexiMemo.net.", x + 42, y + 201, w - 84, 34, 20, INK, true);
|
||
if (actionPill("ui/icons/ButtonBText.png", "Back", x + 95, y + h - 82, 170, 54, false, true, "cursor_cancel")) {
|
||
modal = Modal::None;
|
||
}
|
||
if (actionPill("ui/icons/ButtonAText.png", "OK", x + 355, y + h - 82, 170, 54, false, true, "cursor_select")) {
|
||
confirmGalleryLeave();
|
||
}
|
||
break;
|
||
}
|
||
case Modal::GalleryOffline: {
|
||
title("No Internet Connection");
|
||
centered("You don't have an active internet connection.", x + 38, y + 118, w - 76, 34, 18, INK);
|
||
const std::string before = "Please ";
|
||
const std::string emphasized = "safely";
|
||
const std::string after = " connect your Nintendo Switch";
|
||
TTF_Font* bodyFont = font(18, false);
|
||
int beforeWidth = 0, emphasizedWidth = 0, afterWidth = 0, ignoredHeight = 0;
|
||
if (bodyFont) {
|
||
TTF_SizeUTF8(bodyFont, before.c_str(), &beforeWidth, &ignoredHeight);
|
||
TTF_SizeUTF8(bodyFont, emphasized.c_str(), &emphasizedWidth, &ignoredHeight);
|
||
TTF_SizeUTF8(bodyFont, after.c_str(), &afterWidth, &ignoredHeight);
|
||
}
|
||
const int lineWidth = beforeWidth + emphasizedWidth + afterWidth;
|
||
const int lineX = x + (w - lineWidth) / 2;
|
||
rawText(before, lineX, y + 177, 18, INK, false);
|
||
rawText(emphasized, lineX + beforeWidth, y + 177, 18, INK, false);
|
||
rawText(emphasized, lineX + beforeWidth + 1, y + 177, 18, INK, false);
|
||
rawText(after, lineX + beforeWidth + emphasizedWidth, y + 177, 18, INK, false);
|
||
centered("to the internet, then try again.", x + 38, y + 207, w - 76, 34, 18, INK);
|
||
if (actionPill("ui/icons/ButtonBText.png", "Back", x + 95, y + h - 82, 170, 54, false, true, "cursor_cancel")) {
|
||
modal = Modal::None;
|
||
}
|
||
if (actionPill("ui/icons/ButtonAText.png", "OK", x + 355, y + h - 82, 170, 54, false, true, "cursor_select")) {
|
||
modal = Modal::None;
|
||
}
|
||
break;
|
||
}
|
||
case Modal::Folder: {
|
||
title("Folder Options");
|
||
std::vector<std::string> folders;
|
||
if (DIR* dir = opendir(notesRoot.c_str())) {
|
||
while (dirent* ent = readdir(dir)) {
|
||
const std::string name = ent->d_name;
|
||
if (name.empty() || name[0] == '.') continue;
|
||
const std::string full = join(notesRoot, name);
|
||
struct stat st{};
|
||
if (stat(full.c_str(), &st) == 0 && (st.st_mode & S_IFDIR)) folders.push_back(name);
|
||
}
|
||
closedir(dir);
|
||
}
|
||
std::sort(folders.begin(), folders.end());
|
||
for (std::size_t i = 0; i < folders.size() && i < 6; ++i) {
|
||
const int by = y + 92 + static_cast<int>(i) * 50;
|
||
if (pill(folders[i], x + 52, by, w - 104, 42,
|
||
folders[i] == folder || static_cast<int>(i) == modalSelection, 19, true, "folder_open")) {
|
||
folder = folders[i]; selected = 0; scanLibrary(); modal = Modal::None;
|
||
}
|
||
}
|
||
if (pill("New Folder +", x + 70, y + h - 67, 220, 42, false, 19)) { modal = Modal::None; beginText(Field::FolderName, ""); }
|
||
dismiss();
|
||
break;
|
||
}
|
||
case Modal::Audio: {
|
||
title("Sound");
|
||
rounded(x + 40, y + 75, w - 80, 75, 12, LIGHT);
|
||
if (serverStartRunning && serverStartTask == ServerStartTask::Audio) {
|
||
centered("Starting the local sound server…", x + 52, y + 84, w - 104, 54, 18, GRAY);
|
||
} else if (audioUploadServer.isRunning()) {
|
||
text(audioUploadUrl, x + 53, y + 82, 18, INK);
|
||
if (audioUploadServer.isConnected()) text("Connected", x + 53, y + 111, 22, GREEN, true);
|
||
else text("Code " + audioUploadCode, x + 53, y + 111, 22, ORANGE, true);
|
||
} else {
|
||
centered(audioUploadStatus, x + 52, y + 83, w - 104, 56, 17, GRAY);
|
||
}
|
||
for (int i = 0; i < 4; ++i) {
|
||
const int bx = x + 46 + i * 132;
|
||
if (pill(i == 0 ? "BGM" : "SE" + std::to_string(i), bx, y + 164, 122, 42, i == audioTrack, 17)) {
|
||
audioTrack = i;
|
||
audioEraseArmedTrack = -1;
|
||
if (audioReady) Mix_HaltChannel(4);
|
||
}
|
||
}
|
||
const bool trackPresent = audioTrack < static_cast<int>(doc.audioTracks.size()) &&
|
||
!doc.audioTracks[static_cast<std::size_t>(audioTrack)].pcm.empty();
|
||
const sppm::AudioTrack* selectedTrack = trackPresent ? &doc.audioTracks[static_cast<std::size_t>(audioTrack)] : nullptr;
|
||
const double seconds = selectedTrack && selectedTrack->channels && selectedTrack->sampleRate
|
||
? selectedTrack->pcm.size() / static_cast<double>(selectedTrack->channels * selectedTrack->sampleRate) : 0.0;
|
||
const std::string durationText = std::to_string(static_cast<int>(std::lround(seconds * 10)) / 10) + "." +
|
||
std::to_string(static_cast<int>(std::lround(seconds * 10)) % 10) + " s";
|
||
text(trackPresent ? "Audio: " + durationText : "No audio in this track", x + 53, y + 221, 18,
|
||
trackPresent ? INK : GRAY);
|
||
if (audioTrack == 0) {
|
||
text("Music timing", x + 53, y + 255, 17, GRAY);
|
||
if (pill("Attached to speed", x + 48, y + 282, 241, 43, doc.metadata.bgmFollowsSpeed, 16)) {
|
||
if (!doc.metadata.bgmFollowsSpeed) { doc.metadata.bgmFollowsSpeed = true; markDirty(); rebuildAudio(); }
|
||
}
|
||
if (pill("Loose timing", x + 312, y + 282, 241, 43, !doc.metadata.bgmFollowsSpeed, 16)) {
|
||
if (doc.metadata.bgmFollowsSpeed) { doc.metadata.bgmFollowsSpeed = false; markDirty(); rebuildAudio(); }
|
||
}
|
||
} else {
|
||
bool cueHere = false;
|
||
if (audioTrack < static_cast<int>(doc.audioTracks.size())) {
|
||
const auto& cues = doc.audioTracks[static_cast<std::size_t>(audioTrack)].frameTriggers;
|
||
cueHere = std::find(cues.begin(), cues.end(), static_cast<std::uint16_t>(frame)) != cues.end();
|
||
}
|
||
text("Frame " + std::to_string(frame + 1) + " sound effect", x + 53, y + 255, 17, GRAY);
|
||
if (pill(cueHere ? "Cue on this frame: On" : "Cue on this frame: Off", x + 48, y + 282, 260, 43, cueHere, 16)) {
|
||
while (doc.audioTracks.size() <= static_cast<std::size_t>(audioTrack)) {
|
||
sppm::AudioTrack blank;
|
||
blank.name = doc.audioTracks.empty() ? "BGM" : "SE" + std::to_string(doc.audioTracks.size());
|
||
blank.sampleRate = 48000; blank.channels = 2;
|
||
doc.audioTracks.push_back(std::move(blank));
|
||
}
|
||
auto& cues = doc.audioTracks[static_cast<std::size_t>(audioTrack)].frameTriggers;
|
||
const auto cue = static_cast<std::uint16_t>(frame);
|
||
auto it = std::lower_bound(cues.begin(), cues.end(), cue);
|
||
if (it != cues.end() && *it == cue) cues.erase(it); else cues.insert(it, cue);
|
||
markDirty();
|
||
}
|
||
text("SE stays at its recorded speed.", x + 329, y + 293, 15, GRAY);
|
||
}
|
||
if (actionPill("ui/icons/Play.png", audioReady && Mix_Playing(4) ? "Stop" : "Preview",
|
||
x + 48, y + 342, 180, 42, false,
|
||
trackPresent && audioReady && trackChunks[static_cast<std::size_t>(audioTrack)], "")) {
|
||
if (Mix_Playing(4)) Mix_HaltChannel(4);
|
||
else if (trackChunks[static_cast<std::size_t>(audioTrack)])
|
||
Mix_PlayChannel(4, trackChunks[static_cast<std::size_t>(audioTrack)], 0);
|
||
}
|
||
if (!importFiles.empty()) {
|
||
const std::string& filename = importFiles[importSelection % importFiles.size()];
|
||
centered(filename, x + 245, y + 342, 225, 42, 14, INK);
|
||
if (pill("<", x + 475, y + 342, 38, 42, false, 17))
|
||
importSelection = importSelection ? importSelection - 1 : importFiles.size() - 1;
|
||
if (pill(">", x + 518, y + 342, 38, 42, false, 17))
|
||
importSelection = (importSelection + 1) % importFiles.size();
|
||
}
|
||
if (audioEraseArmedTrack == audioTrack) {
|
||
if (dangerPill("Confirm erase", x + 48, y + 405, 145, 42, 15, trackPresent)) {
|
||
if (audioReady) Mix_HaltChannel(4);
|
||
auto& removed = doc.audioTracks[static_cast<std::size_t>(audioTrack)];
|
||
removed.pcm.clear();
|
||
removed.frameTriggers.clear();
|
||
removed.referenceFps = 0;
|
||
removed.referenceSpeed = 0;
|
||
markDirty();
|
||
rebuildAudio();
|
||
saveDocument(true);
|
||
audioEraseArmedTrack = -1;
|
||
}
|
||
} else if (pill("Erase track", x + 48, y + 405, 145, 42, false, 16, trackPresent)) {
|
||
audioEraseArmedTrack = audioTrack;
|
||
}
|
||
if (pill("Import SD WAV", x + 208, y + 405, 195, 42, false, 16, !importFiles.empty())) {
|
||
audioEraseArmedTrack = -1;
|
||
importAudio();
|
||
}
|
||
if (pill("Close", x + 478, y + 405, 108, 42, false, 18,
|
||
!(serverStartRunning && serverStartTask == ServerStartTask::Audio))) closeAudioMenu();
|
||
break;
|
||
}
|
||
case Modal::Branding: {
|
||
title("Branding Config Portal");
|
||
rounded(x + 40, y + 92, w - 80, 105, 12, LIGHT);
|
||
if (serverStartRunning && serverStartTask == ServerStartTask::Branding) {
|
||
centered("Starting the branding portal…", x + 56, y + 113, w - 112, 56, 18, GRAY);
|
||
} else if (brandingConfigServer.isRunning()) {
|
||
text(brandingUrl, x + 58, y + 108, 21, INK);
|
||
if (brandingConfigServer.isConnected()) text("Connected", x + 58, y + 150, 22, GREEN, true);
|
||
else text("Code " + brandingCode, x + 58, y + 150, 22, ORANGE, true);
|
||
} else centered(brandingStatus, x + 56, y + 111, w - 112, 68, 18, GRAY);
|
||
centered("Open the address on your PC, then enter the code", x + 56, y + 225, w - 112, 32, 18, INK);
|
||
centered("to change the app name, logo, and Switchnote names.", x + 56, y + 256, w - 112, 32, 18, INK);
|
||
centered("Restart the app before branding changes appear.", x + 56, y + 327, w - 112, 42, 16, GRAY);
|
||
if (pill("Close", x + w - 135, y + h - 64, 108, 42, false, 18,
|
||
!(serverStartRunning && serverStartTask == ServerStartTask::Branding))) closeBrandingMenu();
|
||
break;
|
||
}
|
||
case Modal::Export: {
|
||
title("Export Switchnote");
|
||
text("Choose where to export this Switchnote.", x + 60, y + 100, 20, INK);
|
||
if (pill("Export to SD:\\Switchnotes · MP4", x + 74, y + 151, 465, 58, modalSelection == 0, 20)) {
|
||
modal = Modal::None; exportDocument(0);
|
||
}
|
||
if (pill("Export to System Captures", x + 74, y + 226, 465, 58, modalSelection == 1, 20)) {
|
||
modal = Modal::None; exportDocument(1);
|
||
}
|
||
text("MP4 export includes animation only; audio is not included.", x + 60, y + 306, 17, GRAY);
|
||
dismiss();
|
||
break;
|
||
}
|
||
case Modal::ConfirmDelete:
|
||
title("Delete this Switchnote?");
|
||
centered("This action cannot be undone.", x + 25, y + 126, w - 50, 38, 20, GRAY);
|
||
if (actionPill("ui/icons/ButtonBText.png", "Cancel", x + 108, y + 234, 160, 52, false, true, "cursor_cancel")) modal = Modal::None;
|
||
if (dangerActionPill("ui/icons/ButtonZRText.png", "Delete", x + 342, y + 234, 160, 52, 19)) deleteDocument();
|
||
break;
|
||
case Modal::ConfirmGalleryDelete:
|
||
title("Remove from Switchnote Gallery?");
|
||
centered("Only the original poster can remove this Switchnote.", x + 25, y + 126, w - 50, 38, 18, GRAY);
|
||
if (pill("Cancel", x + 108, y + 234, 160, 52, modalSelection == 0, 20)) modal = Modal::None;
|
||
if (dangerPill("Remove", x + 342, y + 234, 160, 52, 20)) deleteGalleryItem();
|
||
break;
|
||
case Modal::Options: {
|
||
title("Editor Options");
|
||
auto setSpeed = [&](int speed) {
|
||
defaultSpeed = speed;
|
||
defaultFps = kSpeedFps[static_cast<std::size_t>(speed - 1)];
|
||
if (docLoaded) {
|
||
doc.metadata.fps = static_cast<std::uint8_t>(defaultFps);
|
||
doc.metadata.speed = static_cast<std::uint8_t>(speed);
|
||
markDirty();
|
||
if (doc.metadata.bgmFollowsSpeed) rebuildAudio();
|
||
}
|
||
savePreferences();
|
||
};
|
||
text("Animation speed", x + 60, y + 88, 18, GRAY);
|
||
const int currentSpeed = docLoaded ? documentSpeed(doc.metadata) : defaultSpeed;
|
||
for (int speed = 1; speed <= 8; ++speed) {
|
||
const int bx = x + 58 + (speed - 1) * 64;
|
||
if (pill(std::to_string(speed), bx, y + 118, 54, 46, currentSpeed == speed, 20)) setSpeed(speed);
|
||
}
|
||
if (pill(std::string("Onion skin: ") + (onion ? "On" : "Off"), x + 58, y + 202, 220, 50, onion, 18)) {
|
||
onion = !onion;
|
||
savePreferences();
|
||
}
|
||
if (pill(std::string("Canvas grid: ") + (canvasGrid ? "On" : "Off"), x + 312, y + 202, 220, 50, canvasGrid, 18)) {
|
||
canvasGrid = !canvasGrid;
|
||
savePreferences();
|
||
}
|
||
if (pill(std::string("Copy to new page: ") + (copyToNewPage ? "On" : "Off"),
|
||
x + 58, y + 274, 260, 48, copyToNewPage, 17)) {
|
||
copyToNewPage = !copyToNewPage;
|
||
savePreferences();
|
||
}
|
||
if (pill(std::string("Loop: ") + (docLoaded && doc.metadata.loopPlayback ? "On" : "Off"),
|
||
x + 312, y + 274, 220, 48, docLoaded && doc.metadata.loopPlayback, 18, docLoaded)) {
|
||
doc.metadata.loopPlayback = !doc.metadata.loopPlayback;
|
||
markDirty();
|
||
}
|
||
if (pill(std::string("Allow spin-offs: ") + (docLoaded && doc.metadata.allowSpinoffs ? "On" : "Off"),
|
||
x + 58, y + 338, 260, 48, docLoaded && doc.metadata.allowSpinoffs, 17, docLoaded)) {
|
||
doc.metadata.allowSpinoffs = !doc.metadata.allowSpinoffs;
|
||
markDirty();
|
||
}
|
||
dismiss();
|
||
break;
|
||
}
|
||
case Modal::PhotoProbe: {
|
||
title("Add a Photo");
|
||
centered("Checking for an IR camera…", x + 52, y + 155, w - 104, 68, 20, GRAY);
|
||
break;
|
||
}
|
||
case Modal::PhotoChoice: {
|
||
title("Add a Photo");
|
||
centered("Choose how to add an image to this Switchnote.", x + 55, y + 88, w - 110, 36, 18, GRAY);
|
||
if (pill("Import Image from Album", x + 80, y + 135, 460, 58, false, 20)) openPhotoAlbum();
|
||
if (pill("Upload from Another Device", x + 80, y + 207, 460, 58, false, 20)) {
|
||
openPhotoUpload();
|
||
photoModalTransitionDim = true;
|
||
photoModalTransitionDimAt = SDL_GetTicks();
|
||
}
|
||
#ifdef __SWITCH__
|
||
if (irCameraRunning && pill("Take Photo with IR Camera", x + 80, y + 279, 460, 58, false, 20)) {
|
||
modal = Modal::Photo;
|
||
modalTransitionStart = SDL_GetTicks();
|
||
}
|
||
#endif
|
||
if (pill("Cancel", x + 440, y + 377, 120, 48, false, 16)) closePhotoCapture();
|
||
break;
|
||
}
|
||
case Modal::PhotoAlbum: {
|
||
title("Import Image from Album");
|
||
#ifdef __SWITCH__
|
||
const std::size_t pageStart = static_cast<std::size_t>(photoAlbumPage) * photoAlbumThumbs.size();
|
||
if (R_SUCCEEDED(capsaInitialize())) {
|
||
for (std::size_t slot = 0; slot < photoAlbumThumbs.size(); ++slot) {
|
||
const std::size_t index = pageStart + slot;
|
||
if (photoAlbumThumbIndexes[slot] == index || index >= photoAlbumEntries.size()) continue;
|
||
if (photoAlbumThumbs[slot]) SDL_DestroyTexture(photoAlbumThumbs[slot]);
|
||
photoAlbumThumbs[slot] = nullptr;
|
||
std::vector<std::uint8_t> jpeg(1024U * 1024U);
|
||
u64 bytes = 0;
|
||
if (R_SUCCEEDED(capsaLoadAlbumFileThumbnail(&photoAlbumEntries[index].file_id, &bytes,
|
||
jpeg.data(), jpeg.size())) && bytes > 0 && bytes <= jpeg.size()) {
|
||
SDL_RWops* thumbStream = SDL_RWFromConstMem(jpeg.data(), static_cast<int>(bytes));
|
||
SDL_Surface* thumbSurface = thumbStream ? IMG_Load_RW(thumbStream, 1) : nullptr;
|
||
if (thumbSurface) {
|
||
photoAlbumThumbs[slot] = SDL_CreateTextureFromSurface(renderer, thumbSurface);
|
||
SDL_FreeSurface(thumbSurface);
|
||
}
|
||
}
|
||
photoAlbumThumbIndexes[slot] = index;
|
||
}
|
||
capsaExit();
|
||
}
|
||
if (photoAlbumEntries.empty()) centered("No screenshots in the album.", x + 45, y + 150, w - 90, 46, 19, GRAY);
|
||
for (std::size_t slot = 0; slot < photoAlbumThumbs.size(); ++slot) {
|
||
const std::size_t index = pageStart + slot;
|
||
if (index >= photoAlbumEntries.size()) break;
|
||
const int col = static_cast<int>(slot % 3), row = static_cast<int>(slot / 3);
|
||
const int tx = x + 35 + col * 182, ty = y + 82 + row * 124;
|
||
rounded(tx - 2, ty - 2, 168, 104, 10, SDL_Color{210, 214, 220, 255});
|
||
rounded(tx, ty, 164, 100, 8, WHITE);
|
||
if (photoAlbumThumbs[slot]) drawTexture(photoAlbumThumbs[slot], tx + 2, ty + 2, 160, 96);
|
||
else centered("Image", tx + 2, ty + 25, 160, 40, 17, GRAY);
|
||
if (hit(tx - 3, ty - 3, 170, 106)) importPhotoAlbumEntry(index);
|
||
}
|
||
const int pages = std::max(1, static_cast<int>((photoAlbumEntries.size() + photoAlbumThumbs.size() - 1) / photoAlbumThumbs.size()));
|
||
if (photoAlbumPage > 0 && pill("<", x + 35, y + 350, 64, 44, false, 22)) {
|
||
--photoAlbumPage;
|
||
photoAlbumThumbIndexes.fill(std::numeric_limits<std::size_t>::max());
|
||
}
|
||
centered(std::to_string(photoAlbumPage + 1) + " / " + std::to_string(pages), x + 225, y + 350, 170, 44, 17, GRAY);
|
||
if (photoAlbumPage + 1 < pages && pill(">", x + 521, y + 350, 64, 44, false, 22)) {
|
||
++photoAlbumPage;
|
||
photoAlbumThumbIndexes.fill(std::numeric_limits<std::size_t>::max());
|
||
}
|
||
#else
|
||
centered("The Switch photo album is only available on Nintendo Switch.", x + 45, y + 150, w - 90, 56, 18, GRAY);
|
||
#endif
|
||
break;
|
||
}
|
||
case Modal::PhotoUpload: {
|
||
title("Upload Photo");
|
||
const bool photoServerStarting = serverStartRunning && serverStartTask == ServerStartTask::Photo;
|
||
if (photoServerStarting) centered("Starting the local photo server…", x + 42, y + 108, w - 84, 40, 18, GRAY);
|
||
else {
|
||
if (!audioUploadUrl.empty()) centered(audioUploadUrl, x + 42, y + 94, w - 84, 36, 19, INK);
|
||
if (audioUploadServer.isConnected()) centered("Connected", x + 70, y + 139, 200, 34, 19, GREEN, true);
|
||
else centered("Code " + audioUploadCode, x + 70, y + 139, 300, 34, 19, ORANGE, true);
|
||
}
|
||
centered("Open this address on your PC to choose an image and set", x + 42, y + 202, w - 84, 28, 16, GRAY);
|
||
centered("size, position, layer, color mode and dithering.", x + 42, y + 229, w - 84, 28, 16, GRAY);
|
||
centered(photoServerStarting ? "Preparing transfer page…" : audioUploadStatus,
|
||
x + 42, y + 281, w - 84, 32, 17, INK);
|
||
if (pill("Close", x + 440, y + 372, 120, 48, false, 16, !photoServerStarting)) closePhotoCapture();
|
||
break;
|
||
}
|
||
case Modal::Photo: {
|
||
title("IR Photo Import");
|
||
#ifdef __SWITCH__
|
||
if (irPhotoTaken || irImageReady) {
|
||
if (irPreviewTexture) {
|
||
SDL_Rect previewRect{x + 150, y + 78, 320, 240};
|
||
SDL_RenderCopyEx(renderer, irPreviewTexture, nullptr, &previewRect, irRotatePhoto ? 90.0 : 0.0, nullptr, SDL_FLIP_NONE);
|
||
}
|
||
else centered("Camera preview unavailable", x + 50, y + 100, w - 100, 180, 20, GRAY);
|
||
if (!irRotatePhoto) centered("Photo replaces the selected layer. Undo is available.", x + 45, y + 322, w - 90, 30, 15, GRAY);
|
||
} else centered(irsReady ? "Starting IR camera…" : "Connect a Right Joy-Con with an IR camera.",
|
||
x + 50, y + 112, w - 100, 150, 19, INK);
|
||
if (!irPhotoTaken) {
|
||
if (pill(irImageReady ? "Take Photo" : "Waiting…", x + 40, y + 372, 120, 48, false, 16, irImageReady)) {
|
||
irPhoto = irImage;
|
||
irPhotoTaken = true;
|
||
for (std::size_t i = 0; i < irPhoto.size(); ++i) {
|
||
irPreviewRgba[i * 4] = irPhoto[i]; irPreviewRgba[i * 4 + 1] = irPhoto[i]; irPreviewRgba[i * 4 + 2] = irPhoto[i];
|
||
}
|
||
if (irPreviewTexture) SDL_UpdateTexture(irPreviewTexture, nullptr, irPreviewRgba.data(), 320 * 4);
|
||
}
|
||
if (pill(std::string("Rotate: ") + (irRotatePhoto ? "On" : "Off"), x + 170, y + 372, 120, 48, irRotatePhoto, 16)) irRotatePhoto = !irRotatePhoto;
|
||
} else {
|
||
if (pill("Retake", x + 40, y + 372, 120, 48, false, 16)) irPhotoTaken = false;
|
||
if (pill(std::string("Rotate: ") + (irRotatePhoto ? "On" : "Off"), x + 170, y + 372, 120, 48, irRotatePhoto, 16)) irRotatePhoto = !irRotatePhoto;
|
||
if (pill("Use Photo", x + 300, y + 372, 120, 48, true, 16)) importPhoto();
|
||
}
|
||
#else
|
||
centered("Photo capture is available on Nintendo Switch.", x + 50, y + 125, w - 100, 130, 19, INK);
|
||
#endif
|
||
if (pill("Cancel", x + 440, y + 372, 120, 48, false, 16)) closePhotoCapture();
|
||
break;
|
||
}
|
||
case Modal::Help:
|
||
title("Controls");
|
||
text("Touch / mouse", x + 52, y + 90, 19, ORANGE, true);
|
||
text("Draw on the canvas, select tools, colors and frames.", x + 52, y + 121, 17, INK);
|
||
text("A / Enter Select or play", x + 52, y + 164, 18, INK);
|
||
text("B / Esc Back", x + 52, y + 200, 18, INK);
|
||
text("Y Edit selected Switchnote", x + 52, y + 236, 18, INK);
|
||
text("L / R Previous / next layer", x + 52, y + 272, 18, INK);
|
||
text("ZL / ZR Undo / redo", x + 52, y + 308, 18, INK);
|
||
dismiss();
|
||
break;
|
||
case Modal::UpdateAvailable: {
|
||
rounded(x, y + 7, w, h, 24, SDL_Color{0, 0, 0, 45});
|
||
rounded(x, y, w, h, 24, UPDATE_ORANGE);
|
||
roundedOutline(x, y, w, h, 24, 2, WHITE);
|
||
centered("Update Available", x + 36, y + 48, w - 72, 62, 39, WHITE);
|
||
text("A new update is available for " + appDisplayName + ":", x + 134, y + 194, 27, WHITE);
|
||
centered(appDisplayName + ", " + updateServerVersion, x + 100, y + 276, w - 200, 42, 27, WHITE);
|
||
text("Author:", x + 134, y + 344, 26, WHITE);
|
||
text("Version:", x + 134, y + 373, 26, WHITE);
|
||
text("File SHA256:", x + 134, y + 402, 26, WHITE);
|
||
text("RexiMemo!", x + 922, y + 344, 26, WHITE);
|
||
text(updateServerVersion, x + 946, y + 373, 26, WHITE);
|
||
text(updateSha256.empty() ? "Not provided by update service" : updateSha256,
|
||
x + 448, y + 410, updateSha256.empty() ? 18 : 15, WHITE);
|
||
text("Please run the app from the Homebrew Menu in App Override mode, or", x + 134, y + 462, 25, WHITE);
|
||
text("install the official NSP file.", x + 134, y + 491, 25, WHITE);
|
||
if (pill("Update", x + 528, y + 548, 140, 50, true, 26, true, "cursor_select")) startUpdateDownload();
|
||
break;
|
||
}
|
||
case Modal::TextInput:
|
||
title(editingField == Field::Title ? "Switchnote Title" : editingField == Field::Description ? "Description" :
|
||
editingField == Field::FolderName ? "New Folder" : editingField == Field::GalleryBio ? "Gallery Bio" : "Comment");
|
||
rounded(x + 44, y + 118, w - 88, 64, 12, LIGHT);
|
||
text(inputText + "▏", x + 60, y + 132, 21, INK);
|
||
if (pill("Cancel", x + 92, y + 244, 160, 48, false, 19)) { modal = Modal::None; editingField = Field::None; SDL_StopTextInput(); }
|
||
if (pill("Done", x + 365, y + 244, 160, 48, false, 19)) applyText();
|
||
break;
|
||
case Modal::None: break;
|
||
}
|
||
renderingModal = false;
|
||
}
|
||
|
||
bool switchnoteBrushPattern(int id, int x, int y) {
|
||
switch (id & 7) {
|
||
case 0: return x % 3 == 1 && y % 3 == 1;
|
||
case 1: return (x & 1) == 0 && (y & 1) == 0;
|
||
case 2: return (x & 1) == 1;
|
||
case 3: return (y & 1) == 1;
|
||
case 4: return ((x + y) & 1) == 1;
|
||
case 5: return (x & 1) != 0 || (y & 1) != 0;
|
||
case 6: return !(x % 3 == 1 && y % 3 == 1);
|
||
case 7: return ((x - y) % 5 == 0) || ((x + y) % 5 == 0);
|
||
default: return false;
|
||
}
|
||
}
|
||
|
||
bool switchnoteEraserContains(int slot, int dx, int dy) {
|
||
switch (slot & 7) {
|
||
case 0: return dx == 0 && dy == 0;
|
||
case 1: return std::abs(dx) <= 1 && std::abs(dy) <= 1;
|
||
case 2: return dx * dx + dy * dy <= 12;
|
||
case 3: return dx * dx + dy * dy <= 42;
|
||
case 4: return std::abs(dx) <= 4 && std::abs(dy) <= 4;
|
||
case 5: return std::abs(dx) <= 7 && std::abs(dy) <= 7;
|
||
case 6: return std::abs(dx) <= 1 && std::abs(dy) <= 6;
|
||
case 7: return std::abs(dy) <= 1 && std::abs(dx) <= 6;
|
||
default: return false;
|
||
}
|
||
}
|
||
|
||
bool App::paintPixel(int sx, int sy, std::vector<std::uint8_t>& pixels) {
|
||
const float scale = screen == Screen::CommentCanvas ? 2.0f : 2.0f * zoom;
|
||
const int width = static_cast<int>(sppm::kWidth * scale);
|
||
const int left = screen == Screen::CommentCanvas ? 0 : (W - width) / 2 + panX;
|
||
const int height = static_cast<int>(sppm::kHeight * scale);
|
||
const int top = screen == Screen::CommentCanvas ? 0 : (H - height) / 2 + panY;
|
||
// Use the same rounded destination dimensions as the renderer. Dividing
|
||
// by the requested float scale drifted by a pixel at fractional zoom.
|
||
const float pixelWidth = width / static_cast<float>(sppm::kWidth);
|
||
const float pixelHeight = height / static_cast<float>(sppm::kHeight);
|
||
const int px = static_cast<int>(std::floor((sx - left) / pixelWidth));
|
||
const int py = static_cast<int>(std::floor((sy - top) / pixelHeight));
|
||
if (px < 0 || py < 0 || px >= sppm::kWidth || py >= sppm::kHeight) return false;
|
||
int previousPx = px, previousPy = py;
|
||
if (hasLastStroke) {
|
||
previousPx = static_cast<int>(std::floor((lastStrokeX - left) / pixelWidth));
|
||
previousPy = static_cast<int>(std::floor((lastStrokeY - top) / pixelHeight));
|
||
}
|
||
const int motionX = hasLastStroke ? px - previousPx : 0;
|
||
const int motionY = hasLastStroke ? py - previousPy : 0;
|
||
const bool usePattern = screen != Screen::CommentCanvas && activeTool == Tool::Brush;
|
||
const bool erase = screen != Screen::CommentCanvas && activeTool == Tool::Eraser;
|
||
const bool usePen = screen != Screen::CommentCanvas && activeTool == Tool::Pen;
|
||
bool changed = false;
|
||
const std::uint8_t value = screen == Screen::CommentCanvas ? 1 :
|
||
(erase ? 0 : static_cast<std::uint8_t>(std::clamp(color, 1, 255)));
|
||
auto write = [&](int x, int y) {
|
||
if (x < 0 || y < 0 || x >= sppm::kWidth || y >= sppm::kHeight) return;
|
||
const auto index = static_cast<std::size_t>(y) * sppm::kWidth + x;
|
||
if (pixels[index] != value) { pixels[index] = value; changed = true; }
|
||
};
|
||
auto clearInk = [&](int x, int y) {
|
||
if (x < 0 || y < 0 || x >= sppm::kWidth || y >= sppm::kHeight) return;
|
||
const auto index = static_cast<std::size_t>(y) * sppm::kWidth + x;
|
||
if (pixels[index] != 0) { pixels[index] = 0; changed = true; }
|
||
};
|
||
auto writePen = [&](int x, int y) {
|
||
const int size = std::clamp(brush, 1, 32);
|
||
const int start = -((size - 1) / 2);
|
||
const float center = static_cast<float>(start) + (size - 1) / 2.0f;
|
||
const float radius = std::max(0.5f, size / 2.0f);
|
||
for (int oy = 0; oy < size; ++oy) for (int ox = 0; ox < size; ++ox) {
|
||
const int dx = start + ox, dy = start + oy;
|
||
const float ddx = dx - center, ddy = dy - center;
|
||
if (!square && ddx * ddx + ddy * ddy > radius * radius) continue;
|
||
write(x + dx, y + dy);
|
||
}
|
||
};
|
||
auto stampSquare = [&](int x, int y, int radius) {
|
||
for (int dy = -radius; dy <= radius; ++dy)
|
||
for (int dx = -radius; dx <= radius; ++dx) writePen(x + dx, y + dy);
|
||
};
|
||
if (usePattern) {
|
||
// Match the web editor's eight paint predicates on absolute canvas
|
||
// coordinates. Normal paint is a 3x3 mask; Advanced is a 15x15 mask.
|
||
const int radius = advancedBrush ? 7 : 1;
|
||
for (int dy = -radius; dy <= radius; ++dy)
|
||
for (int dx = -radius; dx <= radius; ++dx)
|
||
if (switchnoteBrushPattern(pattern, px + dx, py + dy)) write(px + dx, py + dy);
|
||
} else if (erase) {
|
||
static constexpr std::array<int, 8> radii{{0, 1, 3, 6, 4, 7, 6, 6}};
|
||
const int radius = radii[static_cast<std::size_t>(eraserSlot & 7)];
|
||
for (int dy = -radius; dy <= radius; ++dy)
|
||
for (int dx = -radius; dx <= radius; ++dx)
|
||
if (switchnoteEraserContains(eraserSlot, dx, dy)) write(px + dx, py + dy);
|
||
} else if (!usePen) {
|
||
const int size = std::clamp(brush, 1, 32);
|
||
const int start = -((size - 1) / 2);
|
||
const float center = static_cast<float>(start) + (size - 1) / 2.0f;
|
||
const float radius = std::max(0.5f, size / 2.0f);
|
||
for (int oy = 0; oy < size; ++oy) for (int ox = 0; ox < size; ++ox) {
|
||
const int dx = start + ox, dy = start + oy;
|
||
const float ddx = dx - center, ddy = dy - center;
|
||
if (!square && ddx * ddx + ddy * ddy > radius * radius) continue;
|
||
write(px + dx, py + dy);
|
||
}
|
||
} else {
|
||
auto random16 = [&]() -> std::uint16_t {
|
||
const std::uint16_t old = penRngState;
|
||
const std::uint16_t bit0 = old & 1u;
|
||
const std::uint16_t bit3 = (old >> 3) & 1u;
|
||
penRngState = old >> 1;
|
||
if (bit0 == bit3) penRngState = static_cast<std::uint16_t>(penRngState | 0x8000u);
|
||
return penRngState;
|
||
};
|
||
auto randomRange = [&](int range) { return static_cast<int>(random16() % static_cast<std::uint16_t>(std::max(1, range))); };
|
||
auto drawLine = [&](int x0, int y0, int x1, int y1, bool includeStart) {
|
||
int x = x0, y = y0;
|
||
const int dx = std::abs(x1 - x), stepX = x < x1 ? 1 : -1;
|
||
const int dyAbs = std::abs(y1 - y), stepY = y < y1 ? 1 : -1;
|
||
int error = dx - dyAbs;
|
||
bool first = true;
|
||
while (true) {
|
||
if (includeStart || !first) writePen(x, y);
|
||
if (x == x1 && y == y1) break;
|
||
first = false;
|
||
const int twice = 2 * error;
|
||
if (twice > -dyAbs) { error -= dyAbs; x += stepX; }
|
||
if (twice < dx) { error += dx; y += stepY; }
|
||
}
|
||
};
|
||
auto stampDirectionAware = [&]() {
|
||
writePen(px, py);
|
||
if (motionX || motionY) {
|
||
writePen(px + motionY, py);
|
||
writePen(px, py + motionX);
|
||
}
|
||
};
|
||
auto stampDirectionalEqual = [&]() {
|
||
const bool horizontal = motionX != 0 && motionY == 0;
|
||
const bool vertical = motionY != 0 && motionX == 0;
|
||
if (horizontal) { writePen(px, py - 1); writePen(px, py + 1); }
|
||
else if (vertical) { writePen(px - 1, py); writePen(px + 1, py); }
|
||
else if (motionX == motionY) { writePen(px - 1, py); writePen(px + 1, py); }
|
||
else { writePen(px, py - 1); writePen(px, py + 1); }
|
||
clearInk(px, py);
|
||
if (std::abs(motionX) >= std::abs(motionY)) writePen(px, py + (motionX ? motionX : 1));
|
||
else writePen(px + (motionY ? motionY : 1), py);
|
||
};
|
||
auto randomOffset = [&](bool wide) { return randomRange(wide ? 10 : 5) - (wide ? 5 : 2); };
|
||
auto stampJitter = [&](bool wide) {
|
||
const int ax = std::clamp(previousPx + randomOffset(wide), 0, sppm::kWidth - 1);
|
||
const int ay = std::clamp(previousPy + randomOffset(wide), 0, sppm::kHeight - 1);
|
||
const int bx = std::clamp(px + randomOffset(wide), 0, sppm::kWidth - 1);
|
||
const int by = std::clamp(py + randomOffset(wide), 0, sppm::kHeight - 1);
|
||
drawLine(ax, ay, bx, by, true);
|
||
};
|
||
auto sprayClass = [&]() {
|
||
const int d2 = motionX * motionX + motionY * motionY;
|
||
if (d2 < 4) return 6;
|
||
if (d2 < 8) return 5;
|
||
if (d2 < 12) return 4;
|
||
if (d2 < 24) return 3;
|
||
if (d2 < 48) return 2;
|
||
return 1;
|
||
};
|
||
auto stampSpray = [&](bool heavy) {
|
||
const int cls = sprayClass();
|
||
const int count = cls + (heavy ? 3 : 2);
|
||
const int spread = (7 - cls) + (heavy ? 5 : 2);
|
||
for (int i = 0; i < count; ++i) {
|
||
const int scale = heavy && (i & 1) ? 2 : 1;
|
||
const int ax = std::clamp(previousPx + (randomRange(spread * 2 + 1) - spread) * scale, 0, sppm::kWidth - 1);
|
||
const int ay = std::clamp(previousPy + (randomRange(spread * 2 + 1) - spread) * scale, 0, sppm::kHeight - 1);
|
||
const int bx = std::clamp(px + (randomRange(spread * 2 + 1) - spread) * scale, 0, sppm::kWidth - 1);
|
||
const int by = std::clamp(py + (randomRange(spread * 2 + 1) - spread) * scale, 0, sppm::kHeight - 1);
|
||
drawLine(ax, ay, bx, by, true);
|
||
}
|
||
};
|
||
auto stampAirbrush = [&](bool large) {
|
||
static const std::array<const char*, 5> smallMask{{"..#..", ".###.", "#####", ".###.", "..#.."}};
|
||
static const std::array<const char*, 15> largeMask{{
|
||
"......###......", ".....#####.....", "...#########...", "..###########..", ".#############.",
|
||
"###############", "###############", "###############", "###############", "###############",
|
||
".#############.", "..###########..", "...#########...", ".....#####.....", "......###......"
|
||
}};
|
||
const int width = large ? 15 : 5;
|
||
const int height = large ? 15 : 5;
|
||
const int segmentMagnitude = std::max(std::abs(motionX), std::abs(motionY));
|
||
const int base = large ? 72 : 98;
|
||
const int penalty = std::min(38, std::max(0, segmentMagnitude - 1) * (large ? 2 : 4));
|
||
const int threshold = std::max(24, base - penalty);
|
||
for (int row = 0; row < height; ++row) for (int col = 0; col < width; ++col) {
|
||
const char mark = large ? largeMask[static_cast<std::size_t>(row)][col] : smallMask[static_cast<std::size_t>(row)][col];
|
||
if (mark != '#' || static_cast<int>(random16() & 0xffu) >= threshold) continue;
|
||
writePen(px + col - width / 2, py + row - height / 2);
|
||
}
|
||
};
|
||
switch (penType) {
|
||
case 0: writePen(px, py); break;
|
||
case 1: stampDirectionAware(); break;
|
||
case 2: stampSquare(px, py, 1); break;
|
||
case 3: {
|
||
const int qx = px & ~1, qy = py & ~1;
|
||
if (squiggleAnchorX >= 0 && (squiggleAnchorX != qx || squiggleAnchorY != qy)) {
|
||
const int mx = ((squiggleAnchorX + qx) >> 1) & ~1;
|
||
const int my = ((squiggleAnchorY + qy) >> 1) & ~1;
|
||
writePen(mx, my); writePen(mx + 1, my); writePen(mx, my + 1); writePen(mx + 1, my + 1);
|
||
}
|
||
writePen(qx, qy); writePen(qx + 1, qy); writePen(qx, qy + 1); writePen(qx + 1, qy + 1);
|
||
squiggleAnchorX = qx; squiggleAnchorY = qy;
|
||
break;
|
||
}
|
||
case 4: stampDirectionalEqual(); break;
|
||
case 5: stampAirbrush(false); break;
|
||
case 6: if (motionX || motionY) stampJitter(false); else writePen(px, py); break;
|
||
case 7: if (motionX || motionY) stampSpray(false); else writePen(px, py); break;
|
||
case 8: stampSquare(px, py, 2); break;
|
||
case 9: stampSquare(px, py, 3); break;
|
||
case 10: stampSquare(px, py, 4); break;
|
||
case 11: {
|
||
const int d2 = motionX * motionX + motionY * motionY;
|
||
const int cls = d2 < 4 ? 3 : d2 < 32 ? 2 : 1;
|
||
if (cls == 1) writePen(px, py);
|
||
else if (cls == 2) stampDirectionAware();
|
||
else stampSquare(px, py, 1);
|
||
break;
|
||
}
|
||
case 12: {
|
||
static const std::array<const char*, 7> outer{{"..###..", ".#####.", "#######", "#######", "#######", ".#####.", "..###.."}};
|
||
static const std::array<const char*, 5> inner{{"..#..", ".###.", "#####", ".###.", "..#.."}};
|
||
for (int y = 0; y < 7; ++y) for (int x = 0; x < 7; ++x)
|
||
if (outer[static_cast<std::size_t>(y)][x] == '#') write(px + x - 3, py + y - 3);
|
||
const int holeX = ringPreviousX < 0 ? px : ringPreviousX;
|
||
const int holeY = ringPreviousY < 0 ? py : ringPreviousY;
|
||
for (int y = 0; y < 5; ++y) for (int x = 0; x < 5; ++x)
|
||
if (inner[static_cast<std::size_t>(y)][x] == '#') clearInk(holeX + x - 2, holeY + y - 2);
|
||
ringPreviousX = px; ringPreviousY = py;
|
||
break;
|
||
}
|
||
case 13: stampAirbrush(true); break;
|
||
case 14: if (motionX || motionY) stampJitter(true); else writePen(px, py); break;
|
||
case 15: if (motionX || motionY) stampSpray(true); else writePen(px, py); break;
|
||
default: writePen(px, py); break;
|
||
}
|
||
}
|
||
return changed;
|
||
}
|
||
|
||
void App::strokeAt(int sx, int sy, bool comment) {
|
||
const bool stabilise = !comment && penStabilisationEnabled && activeTool != Tool::Eraser;
|
||
if (stabilise && !stabilisedAfterReplay) {
|
||
if (penStabilisationAfter) {
|
||
if (afterStrokePoints.size() < 50000) afterStrokePoints.emplace_back(sx, sy);
|
||
return;
|
||
}
|
||
const float amount = penStabilisationStrength / 100.0f;
|
||
const float follow = 1.0f - amount * 0.88f;
|
||
if (!realtimeStrokeInitialized) {
|
||
realtimeStrokeX = static_cast<float>(sx);
|
||
realtimeStrokeY = static_cast<float>(sy);
|
||
realtimeStrokeInitialized = true;
|
||
} else {
|
||
realtimeStrokeX += (sx - realtimeStrokeX) * follow;
|
||
realtimeStrokeY += (sy - realtimeStrokeY) * follow;
|
||
}
|
||
sx = static_cast<int>(std::lround(realtimeStrokeX));
|
||
sy = static_cast<int>(std::lround(realtimeStrokeY));
|
||
}
|
||
std::vector<std::uint8_t>* pixels = nullptr;
|
||
if (comment) pixels = &commentPixels;
|
||
else if (docLoaded && frame < doc.frames.size() && layer >= 0 && layer < 4) pixels = &doc.frames[frame].layers[layer];
|
||
if (!pixels) return;
|
||
bool changed = false;
|
||
if (hasLastStroke) {
|
||
const int startX = lastStrokeX, startY = lastStrokeY;
|
||
const int dx = sx - startX, dy = sy - startY;
|
||
const int count = std::max(std::abs(dx), std::abs(dy));
|
||
for (int i = 1; i <= count; ++i) {
|
||
const int x = startX + dx * i / count;
|
||
const int y = startY + dy * i / count;
|
||
changed |= paintPixel(x, y, *pixels);
|
||
lastStrokeX = x;
|
||
lastStrokeY = y;
|
||
}
|
||
} else {
|
||
squiggleAnchorX = squiggleAnchorY = ringPreviousX = ringPreviousY = -1;
|
||
changed = paintPixel(sx, sy, *pixels);
|
||
lastStrokeX = sx;
|
||
lastStrokeY = sy;
|
||
hasLastStroke = true;
|
||
}
|
||
if (changed) {
|
||
if (comment) commentDirty = true;
|
||
else markDirty();
|
||
}
|
||
}
|
||
|
||
void App::finishAfterStroke() {
|
||
if (!penStabilisationEnabled || !penStabilisationAfter || afterStrokePoints.empty() ||
|
||
!docLoaded || frame >= doc.frames.size() || layer < 0 || layer >= 4) {
|
||
afterStrokePoints.clear();
|
||
realtimeStrokeInitialized = false;
|
||
return;
|
||
}
|
||
const std::size_t strokeFrame = frame;
|
||
const int strokeLayer = layer;
|
||
auto& pixels = doc.frames[strokeFrame].layers[static_cast<std::size_t>(strokeLayer)];
|
||
if (!undoStack.empty() && undoStack.back().frame == strokeFrame && undoStack.back().layer == strokeLayer &&
|
||
undoStack.back().pixels.size() == pixels.size()) {
|
||
pixels = undoStack.back().pixels;
|
||
markDirty();
|
||
}
|
||
const auto points = std::move(afterStrokePoints);
|
||
afterStrokePoints.clear();
|
||
const int radius = std::clamp(static_cast<int>(std::lround(penStabilisationStrength * 0.06f)), 0, 6);
|
||
stabilisedAfterReplay = true;
|
||
hasLastStroke = false;
|
||
for (std::size_t i = 0; i < points.size(); ++i) {
|
||
int x = 0, y = 0, count = 0;
|
||
const std::size_t from = i > static_cast<std::size_t>(radius) ? i - static_cast<std::size_t>(radius) : 0;
|
||
const std::size_t to = std::min(points.size() - 1, i + static_cast<std::size_t>(radius));
|
||
for (std::size_t j = from; j <= to; ++j) {
|
||
x += points[j].first;
|
||
y += points[j].second;
|
||
++count;
|
||
}
|
||
strokeAt(x / count, y / count);
|
||
}
|
||
stabilisedAfterReplay = false;
|
||
hasLastStroke = false;
|
||
realtimeStrokeInitialized = false;
|
||
}
|
||
|
||
} // namespace
|