SpriteChecker.hh

Go to the documentation of this file.

#ifndef SPRITECHECKER_HH
#define SPRITECHECKER_HH
 
#include "VDP.hh"
#include "VDPVRAM.hh"
#include "VRAMObserver.hh"
#include "DisplayMode.hh"
#include "narrow.hh"
#include "ranges.hh"
#include "serialize_meta.hh"
#include "unreachable.hh"
#include <array>
#include <cstdint>
#include <span>
 
namespace openmsx {
 
class RenderSettings;
class BooleanSetting;
 
class SpriteChecker final : public VRAMObserver
{
public:
        using SpritePattern = uint32_t;
 
        struct SpriteInfo {
                SpritePattern pattern;
                int16_t x;
                byte colorAttrib;
        };
 
        static constexpr SpritePattern doublePattern(SpritePattern a)
        {
                // bit-pattern "abcd...." gets expanded to "aabbccdd"
                // upper 16 bits (of a 32 bit number) contain the pattern
                // lower 16 bits must be zero
                //                               // abcdefghijklmnop0000000000000000
                a = (a | (a >> 8)) & 0xFF00FF00; // abcdefgh00000000ijklmnop00000000
                a = (a | (a >> 4)) & 0xF0F0F0F0; // abcd0000efgh0000ijkl0000mnop0000
                a = (a | (a >> 2)) & 0xCCCCCCCC; // ab00cd00ef00gh00ij00kl00mn00op00
                a = (a | (a >> 1)) & 0xAAAAAAAA; // a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0
                return a | (a >> 1);             // aabbccddeeffgghhiijjkkllmmnnoopp
        }
 
        SpriteChecker(VDP& vdp, RenderSettings& renderSettings,
                      EmuTime::param time);
 
        void reset(EmuTime::param time);
 
        inline void sync(EmuTime::param time) {
                if (!updateSpritesMethod) {
                        // Optimization: skip vram sync and sprite checks
                        // in sprite mode 0.
                        return;
                }
                // Debug:
                // This method is not re-entrant, so check explicitly that it is not
                // re-entered. This can disappear once the VDP-internal scheduling
                // has become stable.
                #ifdef DEBUG
                static bool syncInProgress = false;
                assert(!syncInProgress);
                syncInProgress = true;
                #endif
                vram.sync(time);
                checkUntil(time);
                #ifdef DEBUG
                syncInProgress = false;
                #endif
        }
 
        inline void resetStatus() {
                // TODO: Used to be 0x5F, but that is contradicted by
                //       TMS9918.pdf. Check on real MSX.
                vdp.setSpriteStatus(vdp.getStatusReg0() & 0x1F);
        }
 
        inline void updateDisplayMode(DisplayMode mode, EmuTime::param time) {
                sync(time);
                setDisplayMode(mode);
 
                // The following is only required when switching from sprite
                // mode0 to some other mode (in other case it has no effect).
                // Because in mode 0, currentLine is not updated.
                currentLine = narrow<int>(frameStartTime.getTicksTill_fast(time)
                                 / VDP::TICKS_PER_LINE);
                // Every line in mode0 has 0 sprites, but none of the lines
                // are ever requested by the renderer, except for the last
                // line, because sprites are checked one line before they
                // are displayed. Though frameStart() already makes sure
                // spriteCount contains zero for all lines.
                //   spriteCount[currentLine - 1] = 0;
        }
 
        inline void updateDisplayEnabled(bool enabled, EmuTime::param time) {
                (void)enabled;
                sync(time);
                // TODO: Speed up sprite checking in display disabled case.
        }
 
        inline void updateSpritesEnabled(bool enabled, EmuTime::param time) {
                (void)enabled;
                sync(time);
                // TODO: Speed up sprite checking in display disabled case.
        }
 
        inline void updateSpriteSizeMag(byte sizeMag, EmuTime::param time) {
                (void)sizeMag;
                sync(time);
                // TODO: Precalc something?
        }
 
        inline void updateTransparency(bool tp, EmuTime::param time) {
                (void)tp;
                sync(time);
        }
 
        inline void updateVerticalScroll(int scroll, EmuTime::param time) {
                (void)scroll;
                sync(time);
                // TODO: Precalc something?
        }
 
        inline void checkUntil(EmuTime::param time) {
                // TODO:
                // Currently the sprite checking is done atomically at the end of
                // the display line. In reality, sprite checking is probably done
                // during most of the line. Run tests on real MSX to make a more
                // accurate model of sprite checking.
                int limit = narrow<int>(frameStartTime.getTicksTill_fast(time)
                               / VDP::TICKS_PER_LINE);
                if (currentLine < limit) {
                        // Call the right update method for the current display mode.
                        (this->*updateSpritesMethod)(limit);
                }
        }
 
        [[nodiscard]] inline int getCollisionX(EmuTime::param time) {
                sync(time);
                return collisionX;
        }
 
        [[nodiscard]] inline int getCollisionY(EmuTime::param time) {
                sync(time);
                return collisionY;
        }
 
        inline void resetCollision() {
                collisionX = collisionY = 0;
        }
 
        inline void frameStart(EmuTime::param time) {
                frameStartTime.reset(time);
                currentLine = 0;
                ranges::fill(spriteCount, 0);
                // TODO: Reset anything else? Does the real VDP?
        }
 
        inline void frameEnd(EmuTime::param time) {
                sync(time);
        }
 
        [[nodiscard]] inline std::span<const SpriteInfo> getSprites(int line) const {
                // Compensate for the fact sprites are checked one line earlier
                // than they are displayed.
                line--;
 
                // TODO: Is there ever a sprite on absolute line 0?
                //       Maybe there is, but it is never displayed.
                if (line < 0) return {};
 
                return subspan(spriteBuffer[line], 0, spriteCount[line]);
        }
 
        // VRAMObserver implementation:
 
        void updateVRAM(unsigned /*offset*/, EmuTime::param time) override {
                checkUntil(time);
        }
 
        void updateWindow(bool /*enabled*/, EmuTime::param time) override {
                sync(time);
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        inline void setDisplayMode(DisplayMode mode) {
                switch (mode.getSpriteMode(vdp.isMSX1VDP())) {
                case 0:
                        updateSpritesMethod = nullptr;
                        break;
                case 1:
                        updateSpritesMethod = &SpriteChecker::updateSprites1;
                        break;
                case 2:
                        updateSpritesMethod = &SpriteChecker::updateSprites2;
                        planar = mode.isPlanar();
                        // An alternative is to have a planar and non-planar
                        // updateSprites2 method.
                        break;
                default:
                        UNREACHABLE;
                }
        }
 
        void updateSprites1(int limit);
 
        void updateSprites2(int limit);
 
        [[nodiscard]] inline SpritePattern calculatePatternNP(unsigned patternNr, unsigned y) const;
        [[nodiscard]] inline SpritePattern calculatePatternPlanar(unsigned patternNr, unsigned y) const;
 
        inline void checkSprites1(int minLine, int maxLine);
 
        inline void checkSprites2(int minLine, int maxLine);
 
private:
        using UpdateSpritesMethod = void (SpriteChecker::*)(int limit);
        UpdateSpritesMethod updateSpritesMethod;
 
        VDP& vdp;
 
        VDPVRAM& vram;
 
        BooleanSetting& limitSpritesSetting;
 
        Clock<VDP::TICKS_PER_SECOND> frameStartTime;
 
        int currentLine;
 
        int collisionX;
 
        int collisionY;
 
        std::array<std::array<SpriteInfo, 32 + 1>, 313> spriteBuffer; // +1 for sentinel
 
        std::array<uint8_t, 313> spriteCount;
 
        bool planar;
};
SERIALIZE_CLASS_VERSION(SpriteChecker, 2);
 
} // namespace openmsx
 
#endif