VirtualC64.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// This file is part of VirtualC64
//
// Copyright (C) Dirk W. Hoffmann. www.dirkwhoffmann.de
// This FILE is dual-licensed. You are free to choose between:
//
//     - The GNU General Public License v3 (or any later version)
//     - The Mozilla Public License v2
//
// SPDX-License-Identifier: GPL-3.0-or-later OR MPL-2.0
// -----------------------------------------------------------------------------
 
#pragma once
 
#include "VirtualC64Types.h"
#include "Error.h"
#include "MediaFile.h"
#include <filesystem>
 
namespace vc64 {
 
using peddle::Guard;
 
//
// Public API
//
 
class API {
 
public:
 
    class Emulator *emu = nullptr;
 
    API() { }
    API(Emulator *emu) : emu(emu) { }
 
    void suspend();
    void resume();
 
    bool isUserThread() const;
};
 
struct MemoryAPI : API {
 
    class C64Memory *mem = nullptr;
 
    const MemConfig &getConfig() const;
 
    const MemInfo &getInfo() const;
    const MemInfo &getCachedInfo() const;
 
    string memdump(u16 addr, isize num, bool hex, isize pads, MemoryType src) const;
    string txtdump(u16 addr, isize num, MemoryType src) const;
 
    void drawHeatmap(u32 *buffer, isize width, isize height) const;
 
};
 
 
struct CPUAPI : API {
 
    class CPU *cpu = nullptr;
 
    const CPUInfo &getInfo() const;
    const CPUInfo &getCachedInfo() const;
 
    isize loggedInstructions() const;
 
    void clearLog();
 
    void setNumberFormat(peddle::DasmNumberFormat instrFormat, peddle::DasmNumberFormat dataFormat);
 
    isize disassemble(char *dst, const char *fmt, u16 addr) const;
 
    isize disassembleRecorded(char *dst, const char *fmt, isize nr) const;
 
    peddle::Guard *breakpointNr(long nr) const;
 
    Guard *breakpointAt(u32 addr) const;
 
    Guard *watchpointNr(long nr) const;
 
    Guard *watchpointAt(u32 addr) const;
 
};
 
 
struct CIAAPI : API {
 
    class CIA *cia = nullptr;
 
    const CIAConfig &getConfig() const;
 
    const CIAInfo &getInfo() const;
    const CIAInfo &getCachedInfo() const;
 
    CIAStats getStats() const;
 
};
 
 
struct VICIIAPI : API {
 
    class VICII *vicii = nullptr;
 
    const VICIITraits &getTraits() const;
 
    const VICIIConfig &getConfig() const;
 
    const VICIIInfo &getInfo() const;
    const VICIIInfo &getCachedInfo() const;
 
    SpriteInfo getSpriteInfo(isize nr) const;
 
    u32 getColor(isize nr) const;
 
    u32 getColor(isize nr, Palette palette) const;
 
};
 
 
struct SIDAPI : API {
 
    class SIDBridge *sidBridge = nullptr;
 
    SIDInfo getInfo(isize nr) const;
    SIDInfo getCachedInfo(isize nr) const;
 
 
    float draw(u32 *buffer, isize width, isize height,
               float maxAmp, u32 color, isize sid = -1) const;
 
};
 
 
struct AudioPortAPI : API {
 
    class AudioPort *audioPort = nullptr;
 
    AudioPortStats getStats() const;
 
 
 
    isize copyMono(float *buffer, isize n);
 
    isize copyStereo(float *left, float *right, isize n);
 
    isize copyInterleaved(float *buffer, isize n);
 
 
    float draw(u32 *buffer, isize width, isize height,
               float maxAmp, u32 color, isize sid = -1) const;
 
};
 
 
struct VideoPortAPI : API {
 
    class VideoPort *videoPort = nullptr;
 
 
    u32 *getTexture() const;
    u32 *getDmaTexture() const;
 
};
 
 
struct DmaDebuggerAPI : API {
 
    class DmaDebugger *dmaDebugger = nullptr;
 
    const DmaDebuggerConfig &getConfig() const;
 
};
 
 
struct KeyboardAPI : API {
 
    class Keyboard *keyboard = nullptr;
 
    void press(C64Key key, double delay = 0.0) const;
 
    void release(C64Key key, double delay = 0.0) const;
 
    bool isPressed(C64Key key) const;
 
    void autoType(const string &text);
 
    void abortAutoTyping();
 
};
 
 
struct MouseAPI : API {
 
    class Mouse *mouse = nullptr;
 
    bool detectShakeXY(double x, double y);
 
    bool detectShakeDxDy(double dx, double dy);
};
 
 
struct JoystickAPI : API {
 
    class Joystick *joystick = nullptr;
 
    const JoystickInfo &getInfo() const;
    const JoystickInfo &getCachedInfo() const;
};
 
 
struct PaddleAPI : API {
 
    class Paddle *paddle = nullptr;
 
    const PaddleInfo &getInfo() const;
    const PaddleInfo &getCachedInfo() const;
};
 
 
struct DatasetteAPI : API {
 
    class Datasette *datasette = nullptr;
 
    const DatasetteInfo &getInfo() const;
    const DatasetteInfo &getCachedInfo() const;
 
    void insertTape(MediaFile &file);
 
    void ejectTape();
 
};
 
 
struct ControlPortAPI : API {
 
    class ControlPort *controlPort = nullptr;
 
    JoystickAPI joystick;
 
    MouseAPI mouse;
 
    PaddleAPI paddle;
};
 
 
struct RecorderAPI : API {
 
    class Recorder *recorder = nullptr;
 
    const RecorderConfig &getConfig() const;
 
    const RecorderInfo &getInfo() const;
    const RecorderInfo &getCachedInfo() const;
 
    const fs::path getExecPath() const;
 
    void setExecPath(const std::filesystem::path &path);
 
    void startRecording(isize x1, isize y1, isize x2, isize y2);
 
    void stopRecording();
 
    bool exportAs(const std::filesystem::path &path);
 
};
 
 
struct ExpansionPortAPI : API {
 
    class ExpansionPort *expansionPort = nullptr;
 
 
    CartridgeTraits getCartridgeTraits() const;
 
    const CartridgeInfo &getInfo() const;
    const CartridgeInfo &getCachedInfo() const;
 
    CartridgeRomInfo getRomInfo(isize nr) const;
 
 
    void attachCartridge(const std::filesystem::path &path, bool reset = true);
 
    void attachCartridge(const MediaFile &c, bool reset = true);
 
    // void attachCartridge(Cartridge *c);
 
    void attachReu(isize capacity);
 
    void attachGeoRam(isize capacity);
 
    void attachIsepicCartridge();
 
    void detachCartridge();
 
 
};
 
 
//
// Serial port (IEC bus)
//
 
struct SerialPortAPI : API {
 
    class SerialPort *serialPort = nullptr;
 
};
 
 
//
// Disk
//
 
struct DiskAPI : API {
 
    class Drive *drive = nullptr;
 
    class Disk *get();
};
 
 
//
// Drive
//
 
struct DriveAPI : API {
 
    class Drive *drive = nullptr;
 
    DiskAPI disk;
 
    const DriveConfig &getConfig() const;
 
    const DriveInfo &getInfo() const;
    const DriveInfo &getCachedInfo() const;
 
    void insertBlankDisk(DOSType fstype, string name);
 
    void insertMedia(MediaFile &file, bool wp);
 
    void insertFileSystem(const class FileSystem &fs, bool wp);
 
    void ejectDisk();
};
 
 
struct RetroShellAPI : API {
 
    class RetroShell *retroShell = nullptr;
 
 
    const char *text();
 
    isize cursorRel();
 
 
    void press(RetroShellKey key, bool shift = false);
 
    void press(char c);
 
    void press(const string &s);
 
 
    void setStream(std::ostream &os);
 
 
    void execScript(std::stringstream &ss);
    void execScript(const std::ifstream &fs);
    void execScript(const string &contents);
    void execScript(const MediaFile &file);
 
};
 
struct DefaultsAPI : API {
 
    class Defaults *defaults = nullptr;
 
    DefaultsAPI(Defaults *defaults) : defaults(defaults) { }
    
 
public:
 
    void load(const std::filesystem::path &path);
 
    void load(std::ifstream &stream);
 
    void load(std::stringstream &stream);
 
    void save(const std::filesystem::path &path);
 
    void save(std::ofstream &stream);
 
    void save(std::stringstream &stream);
 
 
 
public:
 
    string getString(const string &key) const;
 
    i64 getInt(const string &key) const;
 
    i64 get(Option option) const;
 
    i64 get(Option option, isize nr) const;
 
    string getFallbackRaw(const string &key) const;
 
    i64 getFallback(const string &key) const;
 
    i64 getFallback(Option option) const;
 
    i64 getFallback(Option option, isize nr = 0) const;
 
 
 
    void set(const string &key, const string &value);
 
    void set(Option opt, const string &value, std::vector<isize> objids = { 0 });
 
    void set(Option opt, i64 value, std::vector<isize> objids = { 0 });
 
    void setFallback(const string &key, const string &value);
 
    void setFallback(Option opt, const string &value, std::vector<isize> objids = { 0 });
 
    void setFallback(Option opt, i64 value, std::vector<isize> objids = { 0 });
 
 
 
    void remove();
 
    void remove(const string &key) throws;
 
    void remove(Option option) throws;
 
    void remove(Option option, isize nr) throws;
 
    void remove(Option option, std::vector <isize> nrs) throws;
 
};
 
 
struct C64API : public API {
 
    class C64 *c64 = nullptr;
 
 
    const C64Info &getInfo() const;
    const C64Info &getCachedInfo() const;
 
    EventSlotInfo getSlotInfo(isize nr) const;
 
    RomTraits getRomTraits(RomType type) const;
 
 
    void hardReset();
 
    void softReset();
 
 
    InspectionTarget getInspectionTarget() const;
 
    void setInspectionTarget(InspectionTarget target);
 
    void removeInspectionTarget();
 
 
 
    MediaFile *takeSnapshot();
 
    void loadSnapshot(const MediaFile &snapshot);
 
 
 
    void loadRom(const fs::path &path);
 
    void loadRom(const MediaFile &file);
 
    void deleteRom(RomType type);
 
    void saveRom(RomType rom, const std::filesystem::path &path);
 
 
 
    void flash(const MediaFile &file);
 
    void flash(const MediaFile &file, isize item);
 
    void flash(const FileSystem &fs, isize item);
};
 
 
class VirtualC64 : API {
 
    //
    // Static methods
    //
 
public:
 
    static string version();
 
    static string build();
 
 
    //
    // Initializing
    //
 
public:
 
    VirtualC64();
    ~VirtualC64();
 
 
    const EmulatorConfig &getConfig() const;
 
    const EmulatorInfo &getInfo() const;
    const EmulatorInfo &getCachedInfo() const;
 
    const EmulatorStats &getStats() const;
 
 
    bool isPoweredOn();
 
    bool isPoweredOff();
 
    bool isPaused();
 
    bool isRunning();
 
    bool isSuspended();
 
    bool isHalted();
 
    bool isWarping();
 
    bool isTracking();
 
    void isReady();
 
 
 
    void powerOn();
 
    void powerOff();
 
    void run();
 
    void pause();
 
    void halt();
 
    void suspend();
 
    void resume();
 
    void warpOn(isize source = 0);
 
    void warpOff(isize source = 0);
 
    void trackOn(isize source = 0);
 
    void trackOff(isize source = 0);
 
 
 
    void stepInto();
 
    void stepOver();
 
 
 
    void wakeUp();
 
 
 
    void launch(const void *listener, Callback *func);
 
    i64 get(Option option) const;
 
    i64 get(Option option, long id) const;
 
    void set(C64Model model);
 
    void set(Option opt, i64 value) throws;
 
    void set(Option opt, i64 value, long id);
 
 
    void exportConfig(const std::filesystem::path &path) const;
    void exportConfig(std::ostream& stream) const;
 
 
 
    void put(const Cmd &cmd);
    void put(CmdType type, i64 payload = 0, i64 payload2 = 0) { put(Cmd(type, payload, payload2)); }
    void put(CmdType type, ConfigCmd payload)  { put(Cmd(type, payload)); }
    void put(CmdType type, KeyCmd payload)  { put(Cmd(type, payload)); }
    void put(CmdType type, CoordCmd payload)  { put(Cmd(type, payload)); }
    void put(CmdType type, GamePadCmd payload)  { put(Cmd(type, payload)); }
    void put(CmdType type, TapeCmd payload)  { put(Cmd(type, payload)); }
    void put(CmdType type, AlarmCmd payload)  { put(Cmd(type, payload)); }
 
 
    static DefaultsAPI defaults;
    C64API c64;
    MemoryAPI mem;
    CPUAPI cpu;
    CIAAPI cia1, cia2;
    VICIIAPI vicii;
    SIDAPI sid;
    AudioPortAPI audioPort;
    VideoPortAPI videoPort;
    DmaDebuggerAPI dmaDebugger;
    KeyboardAPI keyboard;
    DatasetteAPI datasette;
    ControlPortAPI controlPort1, controlPort2;
    RecorderAPI recorder;
    ExpansionPortAPI expansionPort;
    SerialPortAPI serialPort;
    DriveAPI drive8, drive9;
    RetroShellAPI retroShell;
};
 
}