graphics_optimizer.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_GRAPHICS_OPTIMIZER_H
#define YAZE_APP_GFX_GRAPHICS_OPTIMIZER_H
 
#include <string>
#include <unordered_map>
#include <vector>
 
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/util/bpp_format_manager.h"
 
namespace yaze {
namespace gfx {
 
enum class OptimizationStrategy {
  kMemoryOptimized,       
  kPerformanceOptimized,  
  kQualityOptimized,      
  kBalanced               
};
 
struct OptimizationResult {
  bool success;
  std::string message;
  size_t memory_saved;
  float performance_gain;
  float quality_loss;
  std::vector<BppFormat> recommended_formats;
  std::unordered_map<int, BppFormat> sheet_recommendations;
 
  OptimizationResult()
      : success(false),
        memory_saved(0),
        performance_gain(0.0f),
        quality_loss(0.0f) {}
};
 
struct SheetOptimizationData {
  int sheet_id;
  BppFormat current_format;
  BppFormat recommended_format;
  size_t current_size;
  size_t optimized_size;
  float compression_ratio;
  int colors_used;
  bool is_convertible;
  std::string optimization_reason;
 
  SheetOptimizationData()
      : sheet_id(-1),
        current_format(BppFormat::kBpp8),
        recommended_format(BppFormat::kBpp8),
        current_size(0),
        optimized_size(0),
        compression_ratio(1.0f),
        colors_used(0),
        is_convertible(false) {}
};
 
class GraphicsOptimizer {
 public:
  static GraphicsOptimizer& Get();
 
  void Initialize();
 
  OptimizationResult OptimizeSheet(
      const std::vector<uint8_t>& sheet_data, int sheet_id,
      const SnesPalette& palette,
      OptimizationStrategy strategy = OptimizationStrategy::kBalanced);
 
  OptimizationResult OptimizeSheets(
      const std::unordered_map<int, std::vector<uint8_t>>& sheets,
      const std::unordered_map<int, SnesPalette>& palettes,
      OptimizationStrategy strategy = OptimizationStrategy::kBalanced);
 
  SheetOptimizationData AnalyzeSheet(const std::vector<uint8_t>& sheet_data,
                                     int sheet_id, const SnesPalette& palette);
 
  std::unordered_map<int, SheetOptimizationData> GetOptimizationRecommendations(
      const std::unordered_map<int, std::vector<uint8_t>>& sheets,
      const std::unordered_map<int, SnesPalette>& palettes);
 
  OptimizationResult ApplyOptimizations(
      const std::unordered_map<int, SheetOptimizationData>& recommendations,
      std::unordered_map<int, std::vector<uint8_t>>& sheets,
      std::unordered_map<int, SnesPalette>& palettes);
 
  std::unordered_map<std::string, double> GetOptimizationStats() const;
 
  void ClearCache();
 
  void SetOptimizationParameters(float max_quality_loss = 0.1f,
                                 size_t min_memory_savings = 1024,
                                 float performance_threshold = 0.05f);
 
 private:
  GraphicsOptimizer() = default;
  ~GraphicsOptimizer() = default;
 
  // Optimization parameters
  float max_quality_loss_;
  size_t min_memory_savings_;
  float performance_threshold_;
 
  // Statistics tracking
  std::unordered_map<std::string, double> optimization_stats_;
 
  // Cache for optimization results
  std::unordered_map<std::string, SheetOptimizationData> optimization_cache_;
 
  // Helper methods
  BppFormat DetermineOptimalFormat(const std::vector<uint8_t>& data,
                                   const SnesPalette& palette,
                                   OptimizationStrategy strategy);
  float CalculateQualityLoss(BppFormat from_format, BppFormat to_format,
                             const std::vector<uint8_t>& data);
  size_t CalculateMemorySavings(BppFormat from_format, BppFormat to_format,
                                const std::vector<uint8_t>& data);
  float CalculatePerformanceGain(BppFormat from_format, BppFormat to_format);
  bool ShouldOptimize(const SheetOptimizationData& data,
                      OptimizationStrategy strategy);
  std::string GenerateOptimizationReason(const SheetOptimizationData& data);
 
  // Analysis helpers
  int CountUsedColors(const std::vector<uint8_t>& data,
                      const SnesPalette& palette);
  float CalculateColorEfficiency(const std::vector<uint8_t>& data,
                                 const SnesPalette& palette);
  std::vector<int> AnalyzeColorDistribution(const std::vector<uint8_t>& data);
 
  // Cache management
  std::string GenerateCacheKey(const std::vector<uint8_t>& data, int sheet_id);
  void UpdateOptimizationStats(const std::string& operation, double value);
};
 
class GraphicsOptimizationScope {
 public:
  GraphicsOptimizationScope(OptimizationStrategy strategy, int sheet_count);
  ~GraphicsOptimizationScope();
 
  void AddSheet(int sheet_id, size_t original_size, size_t optimized_size);
  void SetResult(const OptimizationResult& result);
 
 private:
  OptimizationStrategy strategy_;
  int sheet_count_;
  std::string operation_name_;
  ScopedTimer timer_;
  OptimizationResult result_;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_GRAPHICS_OPTIMIZER_H