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 "serialize_meta.hh"
#include "unreachable.hh"

namespace openmsx {

class RenderSettings;
class BooleanSetting;

class SpriteChecker: public VRAMObserver
{
public:
        typedef unsigned SpritePattern;

        struct SpriteInfo {
                SpritePattern pattern;
                short int x;
                byte colorAttrib;
        };

        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 = 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 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 = frameStartTime.getTicksTill_fast(time)
                               / VDP::TICKS_PER_LINE;
                if (currentLine < limit) {
                        // Call the right update method for the current display mode.
                        (this->*updateSpritesMethod)(limit);
                }
        }

        inline int getCollisionX(EmuTime::param time) {
                sync(time);
                return collisionX;
        }

        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;
                for (int i = 0; i < 313; i++) spriteCount[i] = 0;
                // TODO: Reset anything else? Does the real VDP?
        }

        inline void frameEnd(EmuTime::param time) {
                sync(time);
        }

        inline int getSprites(int line, const SpriteInfo*& visibleSprites) 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 0;

                visibleSprites = spriteBuffer[line];
                return spriteCount[line];
        }

        // VRAMObserver implementation:

        void updateVRAM(unsigned /*offset*/, EmuTime::param time) {
                checkUntil(time);
        }

        void updateWindow(bool /*enabled*/, EmuTime::param time) {
                sync(time);
        }

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

private:
        inline void setDisplayMode(DisplayMode mode) {
                switch (mode.getSpriteMode()) {
                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);

        inline SpritePattern calculatePatternNP(unsigned patternNr, unsigned y);
        inline SpritePattern calculatePatternPlanar(unsigned patternNr, unsigned y);

        inline void checkSprites1(int minLine, int maxLine);

        inline void checkSprites2(int minLine, int maxLine);

        typedef void (SpriteChecker::*UpdateSpritesMethod)(int limit);
        UpdateSpritesMethod updateSpritesMethod;

        VDP& vdp;

        VDPVRAM& vram;

        BooleanSetting& limitSpritesSetting;

        Clock<VDP::TICKS_PER_SECOND> frameStartTime;

        int currentLine;

        int collisionX;

        int collisionY;

        SpriteInfo spriteBuffer[313][32 + 1]; // +1 for sentinel

        int spriteCount[313];

        bool planar;
};
SERIALIZE_CLASS_VERSION(SpriteChecker, 2);

} // namespace openmsx

#endif