VDPCmdEngine.hh

Go to the documentation of this file.

#ifndef VDPCMDENGINE_HH
#define VDPCMDENGINE_HH

#include "VDP.hh"
#include "DisplayMode.hh"
#include "Observer.hh"
#include "serialize_meta.hh"
#include "openmsx.hh"
#include "noncopyable.hh"
#include "likely.hh"
#include <memory>

namespace openmsx {

class VDPVRAM;
class CommandController;
class RenderSettings;
class Setting;
class BooleanSetting;
class TclCallback;


class VDPCmd {
public:
        virtual ~VDPCmd() {}

        virtual void start(EmuTime::param time, VDPCmdEngine& engine) = 0;

        virtual void execute(EmuTime::param limit, VDPCmdEngine& engine) = 0;
};


class VDPCmdEngine : private Observer<Setting>, private noncopyable
{
public:
        VDPCmdEngine(VDP& vdp, RenderSettings& renderSettings_,
                     CommandController& commandController);
        virtual ~VDPCmdEngine();

        void reset(EmuTime::param time);

        inline void sync(EmuTime::param time) {
                if (!currentCommand) return;
                currentCommand->execute(time, *this);
                if (currentCommand && unlikely(vdp.cpuAccessScheduled())) {
                        // If there's a CPU access scheduled, then the next
                        // slot will be used by the CPU. So we take a later
                        // slot.
                        nextAccessSlot(1); // skip one slot
                        assert(this->time > time);
                }
        }

        inline byte getStatus(EmuTime::param time) {
                if (time >= statusChangeTime) {
                        sync(time);
                }
                return status;
        }

        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 (!currentCommand) status &= 0x7F;
                transfer = true;
        }

        inline unsigned getBorderX(EmuTime::param time) {
                sync(time);
                return ASX;
        }

        void setCmdReg(byte index, byte value, EmuTime::param time);

        byte peekCmdReg(byte index);

        void updateDisplayMode(DisplayMode mode, EmuTime::param time);

        template<typename Archive>
        void serialize(Archive& ar, unsigned version);

private:
        template <template <typename Mode> class Command>
        void createHEngines(unsigned cmd);
        void deleteHEngines(unsigned cmd);

        template <template <typename Mode, typename LogOp> class Command>
        void createLEngines(unsigned cmd, VDPCmd* dummy);
        void deleteLEngines(unsigned cmd);

        virtual void update(const Setting& setting);

        void executeCommand(EmuTime::param time);

        inline void nextAccessSlot(int delta) {
                time = vdp.getAccessSlot(time, delta);
        }
        inline AccessSlotCalculator getSlotCalculator() const {
                return vdp.getAccessSlotCalculator(time);
        }
        inline void nextAccessSlot(AccessSlotCalculator& calculator, int delta) {
#ifdef DEBUG
                EmuTime old = time;
                nextAccessSlot(delta);
                EmuTime verify = time;
                time = old;
#endif
                time += calculator.getNext(delta);
#ifdef DEBUG
                assert(time == verify);
#endif
        }

        void commandDone(EmuTime::param time);

        void reportVdpCommand();


        VDP& vdp;
        VDPVRAM& vram;

        RenderSettings& renderSettings;

        const std::unique_ptr<BooleanSetting> cmdTraceSetting;
        const std::unique_ptr<TclCallback> cmdInProgressCallback;

        VDPCmd* commands[256][4];
        VDPCmd* currentCommand;

        EmuTime time;

        EmuTime statusChangeTime;

        int phase;

        int scrMode;

        unsigned SX, SY, DX, DY, NX, NY; // registers that can be set by CPU
        unsigned ASX, ADX, ANX; // Temporary registers used in the VDP commands
                                // Register ASX can be read (via status register 8/9)
        byte COL, ARG, CMD;

        byte tmpSrc;
        byte tmpDst;

        byte status;

        bool transfer;

        const bool hasExtendedVRAM;

        //bool brokenTiming; // not used anymore ATM
        //                   // TODO remove completely or try to restore?

        friend struct AbortCmd;
        friend struct PointBaseCmd;
        friend struct PsetBaseCmd;
        friend struct SrchBaseCmd;
        friend struct LineBaseCmd;
        friend class BlockCmd;
        template<typename> friend struct PointCmd;
        template<typename> friend struct SrchCmd;
        template<typename> friend struct LmcmCmd;
        template<typename> friend struct HmmvCmd;
        template<typename> friend struct HmmmCmd;
        template<typename> friend struct YmmmCmd;
        template<typename> friend struct HmmcCmd;
        template<typename> friend struct LmmvBaseCmd;
        template<typename> friend struct LmmmBaseCmd;
        template<typename> friend struct LmmcBaseCmd;
        template<typename, typename> friend struct PsetCmd;
        template<typename, typename> friend struct LineCmd;
        template<typename, typename> friend struct LmmvCmd;
        template<typename, typename> friend struct LmmmCmd;
        template<typename, typename> friend struct LmmcCmd;
};
SERIALIZE_CLASS_VERSION(VDPCmdEngine, 3);

} // namespace openmsx

#endif