source/src/vm/vm_template.h

   1 #ifndef __CSP_VM_TEMPLATE_H
   2 #define __CSP_VM_TEMPLATE_H
   3
   4 #include "common.h"
   5
   6 class EMU;
   7 class EVENT;
   8 class DEVICE;
   9 class DLL_PREFIX VM_TEMPLATE {
  10 protected:
  11         EMU* emu;
  12         // devices
  13         EVENT* event;
  14 #if defined(__GIT_REPO_VERSION)
  15         _TCHAR _git_revision[256];
  16 #endif
  17 public:
  18         VM_TEMPLATE(EMU* parent_emu) : emu(parent_emu)
  19         {
  20                 emu = parent_emu;
  21 #if defined(__GIT_REPO_VERSION)
  22                 memset(_git_revision, 0x00, sizeof(_git_revision));
  23 #endif
  24         }
  25         virtual ~VM_TEMPLATE() {} // OK?
  26         // drive virtual machine
  27         virtual void reset() { }
  28         virtual void special_reset() { }
  29         virtual void run() { }
  30         virtual void notify_power_off() { }
  31
  32         virtual double get_frame_rate() { return 59.94; }
  33         virtual void get_screen_resolution(int *w, int *h) {
  34                 if(w != NULL) *w = 0;
  35                 if(h != NULL) *h = 0;
  36         }
  37
  38         // debugger
  39         virtual DEVICE *get_cpu(int num) { return NULL; }
  40         virtual uint32_t get_cpu_pc() { return 0; }
  41         virtual void initialize(void) { }
  42         virtual void update_dipswitch(void) { }
  43
  44         // draw screen
  45         virtual void draw_screen() { }
  46
  47         // multimedia
  48         virtual void movie_sound_callback(uint8_t *buffer, long size) { }
  49         // sound generation
  50         virtual void initialize_sound(int rate, int samples) { }
  51         virtual uint16_t* create_sound(int* extra_frames) { return NULL; }
  52         virtual int get_sound_buffer_ptr() { return 0; }
  53         virtual void set_sound_device_volume(int ch, int decibel_l, int decibel_r) { }
  54
  55         // network
  56         virtual void notify_socket_connected(int ch) { }
  57         virtual void notify_socket_disconnected(int ch) { }
  58         virtual uint8_t* get_socket_send_buffer(int ch, int* size)
  59         {
  60                 if(size != NULL) *size = 0;
  61                 return NULL;
  62         }
  63         virtual void inc_socket_send_buffer_ptr(int ch, int size) { }
  64         virtual uint8_t* get_socket_recv_buffer0(int ch, int* size0, int* size1) {
  65                 if(size0 != NULL) *size0 = 0;
  66                 if(size1 != NULL) *size1 = 0;
  67                 return NULL;
  68         }
  69         virtual uint8_t* get_socket_recv_buffer1(int ch) { return NULL; }
  70         virtual void inc_socket_recv_buffer_ptr(int ch, int size) { }
  71
  72         // notify key
  73         virtual void key_down(int code, bool repeat) { }
  74         virtual void key_up(int code) { }
  75         virtual bool get_caps_locked() { return false; }
  76         virtual bool get_kana_locked() { return false; }
  77         virtual uint32_t get_led_status() { return 0; }
  78
  79
  80         // user interface
  81         virtual void open_floppy_disk(int drv, const _TCHAR *file_path, int bank) { }
  82         virtual void open_quick_disk(int drv, const _TCHAR *file_path) { }
  83         virtual void open_hard_disk(int drv, const _TCHAR *file_path) { }
  84         virtual void open_compact_disc(int drv, const _TCHAR *file_path) { }
  85         virtual void open_laser_disc(int drv, const _TCHAR *file_path) { }
  86         virtual void open_bubble_casette(int drv, const _TCHAR *file_path, int bank) { }
  87         virtual void open_cart(int drv, const _TCHAR *file_path) { }
  88         virtual void play_tape(int drv, const _TCHAR *file_path) { }
  89         virtual void rec_tape(int drv, const _TCHAR *file_path) { }
  90         virtual void load_binary(int drv, const _TCHAR *file_path) { }
  91         virtual void save_binary(int drv, const _TCHAR *file_path) { }
  92
  93         virtual void close_floppy_disk(int drv) { }
  94         virtual void close_quick_disk(int drv) { }
  95         virtual void close_hard_disk(int drv) { }
  96         virtual void close_compact_disc() { }
  97         virtual void close_laser_disc(int drv) { }
  98         virtual void close_bubble_casette(int drv) { }
  99         virtual void close_cart(int drv) { }
 100         virtual void close_tape(int drv) { }
 101
 102         virtual uint32_t is_floppy_disk_accessed() { return 0; }
 103         virtual uint32_t is_quick_disk_accessed() { return 0; }
 104         virtual uint32_t is_hard_disk_accessed() { return 0; }
 105         virtual uint32_t is_compact_disc_accessed() { return 0; }
 106         virtual uint32_t is_laser_disc_accessed() { return 0; }
 107
 108         virtual bool is_floppy_disk_inserted(int drv) { return false; }
 109         virtual bool is_quick_disk_inserted(int drv) { return false; }
 110         virtual bool is_hard_disk_inserted(int drv) { return false; }
 111         virtual bool is_compact_disc_inserted(int drv) { return false; }
 112         virtual bool is_cart_inserted(int drv) { return false; }
 113         virtual bool is_laser_disc_inserted(int drv) { return false; }
 114         virtual bool is_tape_inserted(int drv) { return false; }
 115
 116         virtual void is_floppy_disk_protected(int drv, bool value) { }
 117         virtual bool is_floppy_disk_protected(int drv) { return false; }
 118         virtual void is_bubble_casette_protected(int drv, bool flag) { }
 119         virtual bool is_bubble_casette_protected(int drv) { return false; }
 120
 121         virtual bool is_tape_playing(int drv) { return false; }
 122         virtual bool is_tape_recording(int drv) { return false; }
 123         virtual int get_tape_position(int drv) { return 0; }
 124         virtual const _TCHAR* get_tape_message(int drv) { return (const _TCHAR *) ""; }
 125
 126         virtual void push_play(int drv) { }
 127         virtual void push_stop(int drv) { }
 128         virtual void push_fast_forward(int drv) { }
 129         virtual void push_fast_rewind(int drv) { }
 130         virtual void push_apss_forward(int drv) { }
 131         virtual void push_apss_rewind(int drv) { }
 132
 133         virtual void update_config() { }
 134         virtual bool process_state(FILEIO* state_fio, bool loading) { return true; }
 135
 136         // devices
 137         virtual void set_cpu_clock(DEVICE *cpu, uint32_t clocks) { }
 138         virtual void set_vm_frame_rate(double fps) { }
 139         virtual double get_vm_frame_rate() { return 59.94; }
 140         virtual bool is_frame_skippable() { return false; }
 141         virtual bool is_screen_changed() { return true; }
 142         virtual int max_draw_ranges() { return 0; }
 143         virtual DEVICE* get_device(int id) { return first_device; }
 144         //      misc
 145         virtual const _TCHAR *get_vm_git_version(void) {
 146                 return (const _TCHAR *)_git_revision;
 147         }
 148         virtual int get_key_name_table_size(void) {
 149                 return 0;
 150         }
 151         virtual const _TCHAR *get_phy_key_name_by_scancode(uint32_t scancode) {
 152                 return (const _TCHAR *)NULL;
 153         }
 154         virtual const _TCHAR *get_phy_key_name_by_vk(uint32_t vk) {
 155                 return (const _TCHAR *)NULL;
 156         }
 157         virtual uint32_t get_scancode_by_vk(uint32_t vk) {
 158                 return 0xffffffff;
 159         }
 160         virtual uint32_t get_vk_by_scancode(uint32_t scancode) {
 161                 return 0xffffffff;
 162         }
 163         DEVICE* dummy;
 164         DEVICE* first_device;
 165         DEVICE* last_device;
 166 };
 167
 168 #endif /* __CSP_VM_TEMPLATE_H */