src/core/dummygraphics.cpp

   1 #include "core/window.hpp"
   2
   3 #include <cstdlib>
   4 #include <iostream>
   5
   6 namespace
   7 {
   8         uint64_t next_message_to_print = 0;
   9         bool is_dummy = true;
  10
  11         void dummy_init() throw()
  12         {
  13                 platform::pausing_allowed = false;
  14         }
  15
  16         void dummy_quit() throw()
  17         {
  18         }
  19
  20         void dummy_notify_message() throw()
  21         {
  22                 //Read without lock becase we run in the same thread.
  23                 while(platform::msgbuf.get_msg_first() + platform::msgbuf.get_msg_count() > next_message_to_print) {
  24                         if(platform::msgbuf.get_msg_first() > next_message_to_print)
  25                                 next_message_to_print = platform::msgbuf.get_msg_first();
  26                         else
  27                                 std::cout << platform::msgbuf.get_message(next_message_to_print++) << std::endl;
  28                 }
  29         }
  30
  31         void dummy_notify_status() throw()
  32         {
  33         }
  34
  35         void dummy_notify_screen() throw()
  36         {
  37         }
  38
  39         void dummy_error_message(const std::string& text) throw()
  40         {
  41                 std::cerr << "Error message: " << text << std::endl;
  42         }
  43
  44         void dummy_fatal_error() throw()
  45         {
  46                 std::cerr << "Exiting on fatal error." << std::endl;
  47         }
  48
  49         void dummy_action_updated()
  50         {
  51         }
  52
  53         void dummy_request_rom(rom_request& req)
  54         {
  55                 throw std::runtime_error("Headless build does not support ROM requests");
  56         }
  57
  58         const char* dummy_name() { return "Dummy graphics plugin"; }
  59
  60         struct _graphics_driver driver = {
  61                 .init = dummy_init,
  62                 .quit = dummy_quit,
  63                 .notify_message = dummy_notify_message,
  64                 .notify_status = dummy_notify_status,
  65                 .notify_screen = dummy_notify_screen,
  66                 .error_message = dummy_error_message,
  67                 .fatal_error = dummy_fatal_error,
  68                 .name = dummy_name,
  69                 .action_updated = dummy_action_updated,
  70                 .request_rom = dummy_request_rom
  71         };
  72
  73 }
  74
  75 graphics_driver::graphics_driver(_graphics_driver drv)
  76 {
  77         driver = drv;
  78         is_dummy = false;
  79 }
  80
  81 bool graphics_driver_is_dummy()
  82 {
  83         return is_dummy;
  84 }
  85
  86 void graphics_driver_init() throw()
  87 {
  88         driver.init();
  89 }
  90
  91 void graphics_driver_quit() throw()
  92 {
  93         driver.quit();
  94 }
  95
  96 void graphics_driver_notify_message() throw()
  97 {
  98         driver.notify_message();
  99 }
 100
 101 void graphics_driver_notify_status() throw()
 102 {
 103         driver.notify_status();
 104 }
 105
 106 void graphics_driver_notify_screen() throw()
 107 {
 108         driver.notify_screen();
 109 }
 110
 111 void graphics_driver_error_message(const std::string& text) throw()
 112 {
 113         driver.error_message(text);
 114 }
 115
 116 void graphics_driver_fatal_error() throw()
 117 {
 118         driver.fatal_error();
 119 }
 120
 121 const char* graphics_driver_name()
 122 {
 123         return driver.name();
 124 }
 125
 126 void graphics_driver_action_updated()
 127 {
 128         driver.action_updated();
 129 }
 130
 131 void graphics_driver_request_rom(rom_request& req)
 132 {
 133         driver.request_rom(req);
 134 }