364 lines
14 KiB
C++
364 lines
14 KiB
C++
#include <ftxui/component/component.hpp>
|
|
#include <ftxui/dom/elements.hpp>
|
|
#include <ftxui/component/screen_interactive.hpp>
|
|
#include <ftxui/screen/screen.hpp>
|
|
#include <iostream>
|
|
#include <filesystem>
|
|
|
|
#include "bella_sdk/bella_engine.h" // Core rendering engine
|
|
#include "bella_sdk/bella_scene.h" // Scene management
|
|
#include "dl_core/dl_logging.h" // Logging utilities
|
|
#include <thread> // For std::this_thread (C++ standard library)
|
|
#include <chrono> // For timing operations (C++ standard library)
|
|
|
|
std::string directory_path = ".";
|
|
int selected_index = -1; // Global variable to hold the selected index
|
|
dl::String currentRender;
|
|
|
|
void CleanTrailingSlash(std::string& path) {
|
|
// Only strip if it's longer than a root path (e.g., "/" or "C:\")
|
|
#if defined(_WIN32)
|
|
if (path.size() > 3 && (path.back() == '/' || path.back() == '\\')) path.pop_back();
|
|
#else
|
|
if (path.size() > 1 && path.back() == '/') path.pop_back();
|
|
#endif
|
|
}
|
|
|
|
std::string FormatSize(uintmax_t size) {
|
|
if (size == 0) return "0 B";
|
|
const char* units[] = { "B", "KB", "MB", "GB", "TB" };
|
|
int i = 0;
|
|
double d_size = static_cast<double>(size);
|
|
while (d_size >= 1024 && i < 4) {
|
|
d_size /= 1024;
|
|
i++;
|
|
}
|
|
std::stringstream ss;
|
|
ss << std::fixed << std::setprecision(1) << d_size << " " << units[i];
|
|
return ss.str();
|
|
}
|
|
|
|
/*
|
|
* MyEngineObserver Class
|
|
* This class receives callbacks from the Bella rendering engine to track rendering progress.
|
|
* It implements the EngineObserver interface and provides methods to:
|
|
* - Handle render start/stop events
|
|
* - Track rendering progress
|
|
* - Handle error conditions
|
|
* - Store and retrieve the current progress state
|
|
*/
|
|
struct MyEngineObserver : public dl::bella_sdk::EngineObserver
|
|
{
|
|
public:
|
|
// Called when a rendering pass starts
|
|
void onStarted(dl::String pass) override
|
|
{
|
|
std::cout << "Started pass " << pass.buf() << std::endl;
|
|
dl::logInfo("Started pass %s", pass.buf());
|
|
}
|
|
|
|
// Called to update the current status of rendering
|
|
//void onStatus(String pass, String status) override
|
|
//{
|
|
// logInfo("%s [%s]", status.buf(), pass.buf());
|
|
//}
|
|
|
|
// Called to update rendering progress (percentage, time remaining, etc)
|
|
void onProgress(dl::String pass, dl::bella_sdk::Progress progress) override
|
|
{
|
|
std::cout << progress.toString().buf() << std::endl;
|
|
setString(new std::string(progress.toString().buf()));
|
|
dl::logInfo("%s [%s]", progress.toString().buf(), pass.buf());
|
|
}
|
|
|
|
//void onImage(String pass, Image image) override
|
|
//{
|
|
// logInfo("We got an image %d x %d.", (int)image.width(), (int)image.height());
|
|
//}
|
|
|
|
// Called when an error occurs during rendering
|
|
void onError(dl::String pass, dl::String msg) override
|
|
{
|
|
dl::logError("%s [%s]", msg.buf(), pass.buf());
|
|
}
|
|
|
|
// Called when a rendering pass completes
|
|
void onStopped(dl::String pass) override
|
|
{
|
|
dl::logInfo("Stopped %s", pass.buf());
|
|
std::atomic_bool active_render = false;
|
|
}
|
|
|
|
// Returns the current progress as a string
|
|
std::string getProgress() const {
|
|
std::string* currentProgress = progressPtr.load();
|
|
if (currentProgress) {
|
|
return *currentProgress;
|
|
}
|
|
else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
// Cleanup resources in destructor
|
|
~MyEngineObserver() {
|
|
setString(nullptr);
|
|
}
|
|
private:
|
|
// Thread-safe pointer to current progress string
|
|
std::atomic<std::string*> progressPtr{ nullptr };
|
|
|
|
// Helper function to safely update the progress string
|
|
void setString(std::string* newStatus) {
|
|
std::string* oldStatus = progressPtr.exchange(newStatus);
|
|
delete oldStatus; // Clean up old string if it exists
|
|
}
|
|
};
|
|
|
|
// Note: You must pass the ScreenInteractive object to trigger a redraw.
|
|
void ReloadDirectory(ftxui::ScreenInteractive& screen, const std::filesystem::path& new_path, std::vector<std::string>& entries, std::vector<std::string>& clean_names) {
|
|
if (!std::filesystem::exists(new_path) || !std::filesystem::is_directory(new_path)) return;
|
|
|
|
entries.clear();
|
|
clean_names.clear();
|
|
|
|
//std::string directory_path = new_path.string(); // Replace with your directory path //windows
|
|
// Check if the path is a valid directory
|
|
if (!std::filesystem::exists(new_path) || !std::filesystem::is_directory(new_path)) {
|
|
// Handle error case (optional: display a warning in the TUI)
|
|
std::cerr << "Error: Not a directory or path does not exist." << std::endl;
|
|
std::cerr << "Path not a directory: " + new_path.string();
|
|
return;
|
|
}
|
|
|
|
// 2. Read the new directory entries
|
|
int i = 1;
|
|
|
|
clean_names.clear();
|
|
entries.clear();
|
|
entries.push_back("0. .. (go up one level)"); // Option to go up one level
|
|
clean_names.push_back("..");
|
|
if (std::filesystem::is_directory(new_path)) {
|
|
// Append slash to directories for clarity
|
|
for (const auto& entry : std::filesystem::directory_iterator(new_path)) {
|
|
|
|
if (std::filesystem::is_directory(entry.path()) || std::filesystem::is_regular_file(entry.path())) {
|
|
|
|
std::string name = entry.path().filename().string();
|
|
if (!name.empty() && name[0] == '.') // Works in C++11, C++14, and C++17
|
|
continue; // Skip hidden files and directories
|
|
if (std::filesystem::is_directory(entry.path())) {
|
|
name += "/"; // Append slash to directories for clarity
|
|
}
|
|
if (std::filesystem::is_regular_file(entry.path()) && i == selected_index) {
|
|
// Optionally, append file size
|
|
auto size = std::filesystem::file_size(entry.path());
|
|
name += " (" + FormatSize(size) + ")";
|
|
}
|
|
entries.push_back(std::to_string(i) + ". " + name);
|
|
clean_names.push_back(name);
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Replace this line in renderImage():
|
|
// engine.render();
|
|
|
|
|
|
void renderSynchronous(dl::bella_sdk::Engine& engine, MyEngineObserver& engineObserver, std::string selected_name) {
|
|
dl::String belPath = dl::String(directory_path.c_str()) + "\\";
|
|
engine.loadScene(belPath + dl::String(selected_name.c_str()));
|
|
|
|
if (!engine.scene().read(dl::String(selected_name.c_str()))) return;
|
|
|
|
dl::bella_sdk::Node bPass = engine.scene().beautyPass();
|
|
|
|
// Create the mandatory output node type
|
|
dl::bella_sdk::Node pathNode = engine.scene().createNode("outputImagePath");
|
|
pathNode["dir"] = dl::String(directory_path.c_str());
|
|
pathNode["name"] = "render_result";
|
|
pathNode["ext"] = ".png";
|
|
|
|
// Link the node to the beauty pass
|
|
bPass["overridePath"] = pathNode;
|
|
bPass["timeLimit"] = 30.0f;
|
|
|
|
// This call will now "freeze" the UI until finished
|
|
engine.start();
|
|
|
|
// Explicitly wait until the engine is done to ensure the file is written
|
|
while (engine.rendering()) {
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
}
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
// Define a variable to hold the final selection index
|
|
int final_selected_index = -1; // Use -1 to indicate no selection was made
|
|
std::vector<std::string> entries;
|
|
std::vector<std::string> clean_names; // New vector for logic
|
|
|
|
std::string current_path = std::filesystem::current_path().string();
|
|
std::filesystem::path start_path = std::filesystem::current_path();
|
|
|
|
if (argc > 1)
|
|
{
|
|
// Convert relative input (like "../../..") into a full absolute path
|
|
start_path = std::filesystem::absolute(argv[1]);
|
|
|
|
// Convert to string
|
|
start_path = start_path.lexically_normal();
|
|
std::string path_str = start_path.string();
|
|
// Manually remove trailing slash if it exists and isn't the root directory
|
|
if (path_str.size() > 1 && (path_str.back() == '/' || path_str.back() == '\\')) {
|
|
path_str.pop_back();
|
|
}
|
|
|
|
current_path = path_str;
|
|
|
|
}
|
|
|
|
directory_path = current_path; // Update global
|
|
|
|
// Check if the directory exists
|
|
if (!std::filesystem::exists(directory_path) || !std::filesystem::is_directory(directory_path)) {
|
|
std::cerr << "Error: Directory '" << directory_path << "' not found or is not a directory." << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
ftxui::ScreenInteractive screen = ftxui::ScreenInteractive::TerminalOutput();
|
|
ReloadDirectory(screen, start_path, entries, clean_names);
|
|
int selected = 0;
|
|
auto menu = ftxui::Menu(&entries,&selected);
|
|
|
|
std::string input_buffer = ""; // Stores digits as the user types them
|
|
|
|
// --- The key part: Applying CatchEvent() ---
|
|
auto menu_with_event_handler = menu | ftxui::CatchEvent([&](ftxui::Event event) {
|
|
// 1. Handle Digit Input (0-9)
|
|
if (event.is_character()) {
|
|
char c = event.character()[0];
|
|
if (std::isdigit(c)) {
|
|
input_buffer += c; // Add the digit to our "typing" buffer
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 2. Handle Backspace (to correct typing errors)
|
|
if (event == ftxui::Event::Backspace && !input_buffer.empty()) {
|
|
input_buffer.pop_back();
|
|
return true;
|
|
}
|
|
|
|
// Handle the 'Enter' key press
|
|
if (event == ftxui::Event::Return) {
|
|
if (!input_buffer.empty()) {
|
|
try
|
|
{
|
|
// Convert buffer to integer and check bounds
|
|
int requested_index = std::stoi(input_buffer);// -1;
|
|
if (requested_index >= 0 && requested_index < (int)clean_names.size()) {
|
|
selected = requested_index; // Move the highlight to the typed index
|
|
}
|
|
} catch (...) {}
|
|
input_buffer.clear(); // Clear buffer after use
|
|
}
|
|
std::string selected_name;
|
|
std::filesystem::path new_path;
|
|
|
|
if (clean_names.size() > 0)
|
|
selected_name = clean_names[selected];
|
|
// Construct the new path
|
|
if (selected_name == "..") {
|
|
new_path = std::filesystem::path(current_path).parent_path();
|
|
}
|
|
else {
|
|
new_path = std::filesystem::path(current_path) / selected_name;
|
|
}
|
|
|
|
new_path = std::filesystem::absolute(new_path).lexically_normal();
|
|
|
|
new_path.make_preferred();
|
|
CleanTrailingSlash(current_path);
|
|
// std::string normalized = std::filesystem::path(current_path).generic_string();
|
|
directory_path = current_path; // Update global variable
|
|
if (std::filesystem::is_regular_file(new_path))
|
|
{
|
|
selected_index = selected; // Update global selected index
|
|
final_selected_index = selected; // Store the final selection index
|
|
if (selected_name.substr(selected_name.length() - 3) == "bsz") {
|
|
dl::bella_sdk::Engine engine; // The renderer itself
|
|
|
|
MyEngineObserver engineObserver;
|
|
engine.subscribe(&engineObserver);
|
|
renderSynchronous(engine, engineObserver, selected_name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
current_path = new_path.string();
|
|
}
|
|
// Call the function to switch and reload
|
|
ReloadDirectory(screen, current_path, entries, clean_names);
|
|
selected = 0; // Reset selection to the first item
|
|
|
|
return true; // Event handled
|
|
}
|
|
|
|
// Handle the 'q' key press to quit anytime
|
|
if (event == ftxui::Event::Character('q')) {
|
|
screen.Exit();
|
|
return true; // Event handled
|
|
}
|
|
|
|
// If the event is not one we want to catch, return false
|
|
// so the Menu can handle it (like arrow keys)
|
|
return false;
|
|
});
|
|
|
|
// Create a renderer that defines the layout of your application
|
|
ftxui::Component main_renderer = ftxui::Renderer(menu_with_event_handler, [&] {
|
|
return ftxui::vbox({
|
|
|
|
// Header showing the current directory
|
|
ftxui::hbox({
|
|
ftxui::text(" Current Directory: ") | ftxui::bold,
|
|
ftxui::text(current_path) | ftxui::color(ftxui::Color::Cyan),
|
|
}),
|
|
ftxui::separator(),
|
|
|
|
// The menu itself, wrapped in a frame to allow scrolling if the list is long
|
|
menu_with_event_handler->Render() | ftxui::vscroll_indicator | ftxui::frame,
|
|
|
|
ftxui::filler(), // Pushes the footer to the bottom
|
|
ftxui::separator(),
|
|
|
|
ftxui::hbox({
|
|
ftxui::text("Enter folder #: "),
|
|
ftxui::text(input_buffer),
|
|
}),
|
|
|
|
// Footer with instructions
|
|
ftxui::hbox({
|
|
ftxui::text(" [Enter] Open [q] Quit "),
|
|
ftxui::filler(),
|
|
ftxui::text(" Items: " + std::to_string(clean_names.size())) | ftxui::dim,
|
|
}),
|
|
}) | ftxui::border; // Adds a border around the whole app
|
|
});
|
|
|
|
screen.Loop(main_renderer);
|
|
// This will print to your terminal AFTER you press 'q' to quit
|
|
std::cout << "Final Path on Exit: " << current_path << std::endl;
|
|
// ----------------------------------------------------
|
|
// --- OUTPUT AFTER THE LOOP HAS CLEANLY EXITED ---
|
|
// ----------------------------------------------------
|
|
std::cout<< "directory path: " << directory_path << std::endl;
|
|
if (final_selected_index >= 0 && final_selected_index < entries.size()) {
|
|
std::cout << "Selected Entry: " << entries[final_selected_index] << std::endl;
|
|
} else {
|
|
std::cout << "Selection cancelled or no valid entry selected." << std::endl;
|
|
}
|
|
|
|
} |