remap32.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCI_GRAPHICS_REMAP32_H
#define SCI_GRAPHICS_REMAP32_H

#include "common/algorithm.h"
#include "common/array.h"
#include "common/scummsys.h"
#include "sci/graphics/helpers.h"

namespace Sci {
class GfxPalette32;

enum RemapType {
    kRemapNone = 0,
    kRemapByRange = 1,
    kRemapByPercent = 2,
    kRemapToGray = 3,
    kRemapToPercentGray = 4
};

#pragma mark -
#pragma mark SingleRemap

class SingleRemap {
public:
    SingleRemap() : _type(kRemapNone) {}

    RemapType _type;

    uint8 _from;

    uint8 _to;

    int16 _delta;

    int16 _percent;

    uint8 _gray;

    uint8 _remapColors[237];

    void reset();

    bool update();

private:
    int16 _lastPercent;

    uint8 _lastGray;

    Color _originalColors[237];

    bool _originalColorsChanged[237];

    Color _idealColors[237];

    bool _idealColorsChanged[237];

    int _matchDistances[237];

    bool updateRange();

    bool updateBrightness();

    bool updateSaturation();

    bool updateSaturationAndBrightness();

    bool apply();

    int colorDistance(const Color &a, const Color &b) const;

    int16 matchColor(const Color &color, const int minimumDistance, int &outDistance, const bool *const blockedIndexes) const;
};

#pragma mark -
#pragma mark GfxRemap32

class GfxRemap32 : public Common::Serializable {
public:
    GfxRemap32();

    void saveLoadWithSerializer(Common::Serializer &s) override;

    inline uint8 getRemapCount() const { return _numActiveRemaps; }
    inline uint8 getStartColor() const { return _remapStartColor; }
    inline uint8 getEndColor() const { return _remapEndColor; }
    inline uint8 getBlockedRangeStart() const { return _blockedRangeStart; }
    inline int16 getBlockedRangeCount() const { return _blockedRangeCount; }

    void remapOff(const uint8 color);

    void remapAllOff();

    void remapByRange(const uint8 color, const int16 from, const int16 to, const int16 delta);

    void remapByPercent(const uint8 color, const int16 percent);

    void remapToGray(const uint8 color, const int8 gray);

    void remapToPercentGray(const uint8 color, const int16 gray, const int16 percent);

    void blockRange(const uint8 from, const int16 count);

    inline bool remapEnabled(uint8 color) const {
        const uint8 index = _remapEndColor - color;
        // At least KQ7 DOS uses remap colors that are outside the valid remap
        // range; in these cases, just treat those pixels as skip pixels (which
        // is how they would be treated in SSCI)
        if (index >= _remaps.size()) {
            return false;
        }
        return (_remaps[index]._type != kRemapNone);
    }

    inline uint8 remapColor(const uint8 sourceColor, const uint8 targetColor) const {
        const uint8 index = _remapEndColor - sourceColor;
        assert(index < _remaps.size());
        const SingleRemap &singleRemap = _remaps[index];
        assert(singleRemap._type != kRemapNone);
        // SSCI never really properly handled attempts to draw to a target with
        // pixels above the remap color maximum. In RAMA, the cursor views have
        // a remap color outlining the cursor, and so get drawn into a target
        // surface filled with a skip color of 255. In SSCI, this causes the
        // remapped color to be read from some statically allocated, never
        // written memory and so always ends up being 0 (black).
        if (targetColor >= _remapStartColor) {
            return 0;
        }
        return singleRemap._remapColors[targetColor];
    }

    bool remapAllTables(const bool paletteUpdated);

private:
    typedef Common::Array<SingleRemap> SingleRemapsList;

    uint8 _remapStartColor;

    uint8 _remapEndColor;

    uint8 _numActiveRemaps;

    SingleRemapsList _remaps;

    bool _needsUpdate;

    uint8 _blockedRangeStart;

    int16 _blockedRangeCount;
};

} // End of namespace Sci

#endif // SCI_GRAPHICS_REMAP32_H