Factoring out a lot of reusable GPU code from gl4/.

src/xenia/gpu/graphics_system.h

@@ -15,8 +15,9 @@
 #include <thread>
 
 #include "xenia/cpu/processor.h"
+#include "xenia/gpu/register_file.h"
+#include "xenia/kernel/xthread.h"
 #include "xenia/memory.h"
-#include "xenia/ui/loop.h"
 #include "xenia/ui/window.h"
 #include "xenia/xbox.h"
 
@@ -27,51 +28,70 @@ class Emulator;
 namespace xe {
 namespace gpu {
 
+class CommandProcessor;
+
 class GraphicsSystem {
  public:
   virtual ~GraphicsSystem();
 
-  static std::unique_ptr<GraphicsSystem> Create(Emulator* emulator);
+  static std::unique_ptr<GraphicsSystem> Create();
   virtual std::unique_ptr<ui::GraphicsContext> CreateContext(
       ui::Window* target_window) = 0;
 
-  Emulator* emulator() const { return emulator_; }
   Memory* memory() const { return memory_; }
   cpu::Processor* processor() const { return processor_; }
+  kernel::KernelState* kernel_state() const { return kernel_state_; }
 
-  virtual X_STATUS Setup(cpu::Processor* processor, ui::Loop* target_loop,
+  virtual X_STATUS Setup(cpu::Processor* processor,
+                         kernel::KernelState* kernel_state,
                          ui::Window* target_window);
   virtual void Shutdown();
 
-  void SetInterruptCallback(uint32_t callback, uint32_t user_data);
-  virtual void InitializeRingBuffer(uint32_t ptr, uint32_t page_count) = 0;
-  virtual void EnableReadPointerWriteBack(uint32_t ptr,
-                                          uint32_t block_size) = 0;
+  RegisterFile* register_file() { return &register_file_; }
+  CommandProcessor* command_processor() const {
+    return command_processor_.get();
+  }
 
+  void InitializeRingBuffer(uint32_t ptr, uint32_t page_count);
+  void EnableReadPointerWriteBack(uint32_t ptr, uint32_t block_size);
+
+  void SetInterruptCallback(uint32_t callback, uint32_t user_data);
   void DispatchInterruptCallback(uint32_t source, uint32_t cpu);
 
-  virtual void RequestFrameTrace() {}
-  virtual void BeginTracing() {}
-  virtual void EndTracing() {}
-  enum class TracePlaybackMode {
-    kUntilEnd,
-    kBreakOnSwap,
-  };
-  virtual void PlayTrace(const uint8_t* trace_data, size_t trace_size,
-                         TracePlaybackMode playback_mode) {}
-  virtual void ClearCaches() {}
+  virtual void ClearCaches();
+
+  void RequestFrameTrace();
+  void BeginTracing();
+  void EndTracing();
 
  protected:
-  explicit GraphicsSystem(Emulator* emulator);
+  GraphicsSystem();
+
+  virtual std::unique_ptr<CommandProcessor> CreateCommandProcessor() = 0;
+
+  static uint32_t ReadRegisterThunk(void* ppc_context, GraphicsSystem* gs,
+                                    uint32_t addr);
+  static void WriteRegisterThunk(void* ppc_context, GraphicsSystem* gs,
+                                 uint32_t addr, uint32_t value);
+  uint32_t ReadRegister(uint32_t addr);
+  void WriteRegister(uint32_t addr, uint32_t value);
+
+  void MarkVblank();
+  virtual void Swap(xe::ui::UIEvent* e) = 0;
 
-  Emulator* emulator_ = nullptr;
   Memory* memory_ = nullptr;
   cpu::Processor* processor_ = nullptr;
-  ui::Loop* target_loop_ = nullptr;
+  kernel::KernelState* kernel_state_ = nullptr;
   ui::Window* target_window_ = nullptr;
 
   uint32_t interrupt_callback_ = 0;
   uint32_t interrupt_callback_data_ = 0;
+
+  std::atomic<bool> vsync_worker_running_;
+  kernel::object_ref<kernel::XHostThread> vsync_worker_thread_;
+
+  RegisterFile register_file_;
+  std::unique_ptr<CommandProcessor> command_processor_;
 };
 
 }  // namespace gpu