VDPCmdEngine.hh

Go to the documentation of this file.

#ifndef VDPCMDENGINE_HH
#define VDPCMDENGINE_HH
 
#include "VDP.hh"
#include "VDPAccessSlots.hh"
 
#include "BooleanSetting.hh"
#include "Probe.hh"
#include "TclCallback.hh"
#include "openmsx.hh"
#include "serialize_meta.hh"
 
namespace openmsx {
 
class VDPVRAM;
class DisplayMode;
class CommandController;
 
 
class VDPCmdEngine
{
public:
        // bits in ARG register
        static constexpr byte MXD = 0x20;
        static constexpr byte MXS = 0x10;
        static constexpr byte DIY = 0x08;
        static constexpr byte DIX = 0x04;
        static constexpr byte EQ  = 0x02;
        static constexpr byte MAJ = 0x01;
 
public:
        VDPCmdEngine(VDP& vdp, CommandController& commandController);
 
        void reset(EmuTime::param time);
 
        inline void sync(EmuTime::param time) {
                if (CMD) sync2(time);
        }
        void sync2(EmuTime::param time);
 
        void stealAccessSlot(EmuTime::param time) {
                if (CMD && engineTime <= time) {
                        // take the next available slot
                        engineTime = getNextAccessSlot(time, VDPAccessSlots::Delta::D1);
                        assert(engineTime > time);
                }
        }
 
        [[nodiscard]] inline byte getStatus(EmuTime::param time) {
                if (time >= statusChangeTime) {
                        sync(time);
                }
                return status;
        }
 
        [[nodiscard]] inline byte readColor(EmuTime::param time) {
                sync(time);
                return COL;
        }
        inline void resetColor() {
                // Note: Real VDP always resets TR, but for such a short time
                //       that the MSX won't notice it.
                // TODO: What happens on non-transfer commands?
                if (!CMD) status &= 0x7F;
                transfer = true;
        }
 
        [[nodiscard]] inline unsigned getBorderX(EmuTime::param time) {
                sync(time);
                return ASX;
        }
 
        void setCmdReg(byte index, byte value, EmuTime::param time);
 
        [[nodiscard]] byte peekCmdReg(byte index) const;
 
        void updateDisplayMode(DisplayMode mode, bool cmdBit, EmuTime::param time);
 
        // For debugging only
        bool commandInProgress(EmuTime::param time) {
                sync(time);
                return status & 1;
        }
        auto getLastCommand() const {
                return std::tuple{
                        lastSX, lastSY, lastDX, lastDY, lastNX, lastNY,
                        lastCOL, lastARG, lastCMD};
        }
        auto getInprogressPosition() const {
                return (status & 1) ? std::tuple{int(ASX), int(SY), int(ADX), int(DY)}
                                    : std::tuple{-1, -1, -1, -1};
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        void executeCommand(EmuTime::param time);
 
        void setStatusChangeTime(EmuTime::param t);
        void calcFinishTime(unsigned NX, unsigned NY, unsigned ticksPerPixel);
 
                                void startAbrt(EmuTime::param time);
                                void startPoint(EmuTime::param time);
                                void startPset(EmuTime::param time);
                                void startSrch(EmuTime::param time);
                                void startLine(EmuTime::param time);
        template<typename Mode> void startLmmv(EmuTime::param time);
        template<typename Mode> void startLmmm(EmuTime::param time);
        template<typename Mode> void startLmcm(EmuTime::param time);
        template<typename Mode> void startLmmc(EmuTime::param time);
        template<typename Mode> void startHmmv(EmuTime::param time);
        template<typename Mode> void startHmmm(EmuTime::param time);
        template<typename Mode> void startYmmm(EmuTime::param time);
        template<typename Mode> void startHmmc(EmuTime::param time);
 
        template<typename Mode>                 void executePoint(EmuTime::param limit);
        template<typename Mode, typename LogOp> void executePset(EmuTime::param limit);
        template<typename Mode>                 void executeSrch(EmuTime::param limit);
        template<typename Mode, typename LogOp> void executeLine(EmuTime::param limit);
        template<typename Mode, typename LogOp> void executeLmmv(EmuTime::param limit);
        template<typename Mode, typename LogOp> void executeLmmm(EmuTime::param limit);
        template<typename Mode>                 void executeLmcm(EmuTime::param limit);
        template<typename Mode, typename LogOp> void executeLmmc(EmuTime::param limit);
        template<typename Mode>                 void executeHmmv(EmuTime::param limit);
        template<typename Mode>                 void executeHmmm(EmuTime::param limit);
        template<typename Mode>                 void executeYmmm(EmuTime::param limit);
        template<typename Mode>                 void executeHmmc(EmuTime::param limit);
 
        // Advance to the next access slot at or past the given time.
        inline EmuTime getNextAccessSlot(EmuTime::param time) const {
                return vdp.getAccessSlot(time, VDPAccessSlots::Delta::D0);
        }
        inline void nextAccessSlot(EmuTime::param time) {
                engineTime = getNextAccessSlot(time);
        }
        // Advance to the next access slot that is at least 'delta' cycles past
        // the current one.
        inline EmuTime getNextAccessSlot(EmuTime::param time, VDPAccessSlots::Delta delta) const {
                return vdp.getAccessSlot(time, delta);
        }
        inline void nextAccessSlot(VDPAccessSlots::Delta delta) {
                engineTime = getNextAccessSlot(engineTime, delta);
        }
        inline VDPAccessSlots::Calculator getSlotCalculator(
                        EmuTime::param limit) const {
                return vdp.getAccessSlotCalculator(engineTime, limit);
        }
 
        void commandDone(EmuTime::param time);
 
        void reportVdpCommand() const;
 
private:
        VDP& vdp;
        VDPVRAM& vram;
 
        BooleanSetting cmdTraceSetting;
        TclCallback cmdInProgressCallback;
 
        Probe<bool> executingProbe;
 
        EmuTime engineTime{EmuTime::zero()};
 
        EmuTime statusChangeTime{EmuTime::infinity()};
 
        int phase{0};
 
        int scrMode{-1};
 
        unsigned SX{0}, SY{0}, DX{0}, DY{0}, NX{0}, NY{0}; // registers that can be set by CPU
        unsigned ASX{0}, ADX{0}, ANX{0}; // Temporary registers used in the VDP commands
                                         // Register ASX can be read (via status register 8/9)
        byte COL{0}, ARG{0}, CMD{0};
 
        int lastSX{0}, lastSY{0}, lastDX{0}, lastDY{0}, lastNX{0}, lastNY{0};
        byte lastCOL{0}, lastARG{0}, lastCMD{0};
 
        byte tmpSrc{0};
        byte tmpDst{0};
 
        byte status{0};
 
        bool transfer{false};
 
        const bool hasExtendedVRAM;
};
SERIALIZE_CLASS_VERSION(VDPCmdEngine, 4);
 
} // namespace openmsx
 
#endif