bpp_format_ui.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_BPP_FORMAT_UI_H
#define YAZE_APP_GUI_BPP_FORMAT_UI_H
 
#include <string>
#include <vector>
#include <functional>
 
#include "app/gfx/bpp_format_manager.h"
#include "app/gfx/bitmap.h"
#include "app/gfx/snes_palette.h"
 
namespace yaze {
namespace gui {
 
class BppFormatUI {
 public:
  explicit BppFormatUI(const std::string& id);
  
  bool RenderFormatSelector(gfx::Bitmap* bitmap, const gfx::SnesPalette& palette,
                           std::function<void(gfx::BppFormat)> on_format_changed);
  
  void RenderAnalysisPanel(const gfx::Bitmap& bitmap, const gfx::SnesPalette& palette);
  
  void RenderConversionPreview(const gfx::Bitmap& bitmap, gfx::BppFormat target_format,
                              const gfx::SnesPalette& palette);
  
  void RenderSheetAnalysis(const std::vector<uint8_t>& sheet_data, int sheet_id,
                          const gfx::SnesPalette& palette);
  
  gfx::BppFormat GetSelectedFormat() const { return selected_format_; }
  
  void SetSelectedFormat(gfx::BppFormat format) { selected_format_ = format; }
  
  bool IsConversionAvailable(gfx::BppFormat from_format, gfx::BppFormat to_format) const;
  
  int GetConversionEfficiency(gfx::BppFormat from_format, gfx::BppFormat to_format) const;
 
 private:
  std::string id_;
  gfx::BppFormat selected_format_;
  gfx::BppFormat preview_format_;
  bool show_analysis_;
  bool show_preview_;
  bool show_sheet_analysis_;
  
  // Analysis cache
  std::unordered_map<int, gfx::GraphicsSheetAnalysis> cached_analysis_;
  
  // UI state
  bool format_changed_;
  std::string last_analysis_sheet_;
  
  // Helper methods
  void RenderFormatInfo(const gfx::BppFormatInfo& info);
  void RenderColorUsageChart(const std::vector<int>& color_usage);
  void RenderConversionHistory(const std::string& history);
  std::string GetFormatDescription(gfx::BppFormat format) const;
  ImVec4 GetFormatColor(gfx::BppFormat format) const;
  void UpdateAnalysisCache(int sheet_id, const gfx::GraphicsSheetAnalysis& analysis);
};
 
class BppConversionDialog {
 public:
  explicit BppConversionDialog(const std::string& id);
  
  void Show(const gfx::Bitmap& bitmap, const gfx::SnesPalette& palette,
           std::function<void(gfx::BppFormat, bool)> on_convert);
  
  bool Render();
  
  bool IsOpen() const { return is_open_; }
  
  void Close() { is_open_ = false; }
 
 private:
  std::string id_;
  bool is_open_;
  gfx::Bitmap source_bitmap_;
  gfx::SnesPalette source_palette_;
  gfx::BppFormat target_format_;
  bool preserve_palette_;
  std::function<void(gfx::BppFormat, bool)> convert_callback_;
  
  // Preview data
  std::vector<uint8_t> preview_data_;
  gfx::Bitmap preview_bitmap_;
  bool preview_valid_;
  
  // UI state
  bool show_preview_;
  float preview_scale_;
  
  // Helper methods
  void UpdatePreview();
  void RenderFormatSelector();
  void RenderPreview();
  void RenderOptions();
  void RenderButtons();
};
 
class BppComparisonTool {
 public:
  explicit BppComparisonTool(const std::string& id);
  
  void SetSource(const gfx::Bitmap& bitmap, const gfx::SnesPalette& palette);
  
  void Render();
  
  bool IsOpen() const { return is_open_; }
  
  void Open() { is_open_ = true; }
  
  void Close() { is_open_ = false; }
 
 private:
  std::string id_;
  bool is_open_;
  
  // Source data
  gfx::Bitmap source_bitmap_;
  gfx::SnesPalette source_palette_;
  bool has_source_;
  
  // Comparison data
  std::unordered_map<gfx::BppFormat, gfx::Bitmap> comparison_bitmaps_;
  std::unordered_map<gfx::BppFormat, gfx::SnesPalette> comparison_palettes_;
  std::unordered_map<gfx::BppFormat, bool> comparison_valid_;
  
  // UI state
  float comparison_scale_;
  bool show_metrics_;
  gfx::BppFormat selected_comparison_;
  
  // Helper methods
  void GenerateComparisons();
  void RenderComparisonGrid();
  void RenderMetrics();
  void RenderFormatSelector();
  std::string CalculateMetrics(gfx::BppFormat format) const;
};
 
}  // namespace gui
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_BPP_FORMAT_UI_H