palette32.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_PALETTE32_H
#define SCI_GRAPHICS_PALETTE32_H

#include "common/ptr.h"

namespace Sci {

#pragma mark HunkPalette

class HunkPalette {
public:
    HunkPalette(const SciSpan<const byte> &rawPalette);

    static void write(SciSpan<byte> &out, const Palette &palette);

    static uint32 calculateHunkPaletteSize(const uint16 numIndexes = 256, const bool sharedUsed = true) {
        const int numPalettes = 1;
        return kHunkPaletteHeaderSize +
            /* slack bytes between hunk header & palette offset table */ 2 +
            /* palette offset table */ 2 * numPalettes +
            /* palette data */ (kEntryHeaderSize + numIndexes * (/* RGB */ 3 + !sharedUsed)) * numPalettes;
    }

    uint32 getVersion() const { return _version; }

    void setVersion(const uint32 version) const;

    const Palette toPalette() const;

private:
    enum {
        kNumPaletteEntriesOffset = 10,

        kHunkPaletteHeaderSize = 13,

        kEntryHeaderSize = 22
    };

    enum {
        kEntryStartColorOffset = 10,

        kEntryNumColorsOffset = 14,

        kEntryUsedOffset = 16,

        kEntrySharedUsedOffset = 17,

        kEntryVersionOffset = 18
    };

    struct EntryHeader {
        uint8 startColor;

        uint16 numColors;

        bool used;

        bool sharedUsed;

        uint32 version;
    };

    mutable uint32 _version;

    uint8 _numPalettes;

    SciSpan<const byte> _data;

    const EntryHeader getEntryHeader() const;

    SciSpan<const byte> getPalPointer() const {
        return _data.subspan(kHunkPaletteHeaderSize + (2 * _numPalettes));
    }
};

#pragma mark -
#pragma mark PalCycler

enum PalCyclerDirection {
    kPalCycleBackward = 0,
    kPalCycleForward  = 1
};

struct PalCycler {
    uint8 fromColor;

    uint16 numColorsToCycle;

    uint8 currentCycle;

    PalCyclerDirection direction;

    uint32 lastUpdateTick;

    int16 delay;

    uint16 numTimesPaused;
};

#pragma mark -
#pragma mark GfxPalette32

class GfxPalette32 {
public:
    GfxPalette32(ResourceManager *resMan);

    void saveLoadWithSerializer(Common::Serializer &s);

    inline const Palette &getNextPalette() const { return _nextPalette; };

    inline const Palette &getCurrentPalette() const { return _currentPalette; };

    inline const uint8 *getHardwarePalette() const { return _hardwarePalette; };

    bool loadPalette(const GuiResourceId resourceId);

    int16 matchColor(const uint8 r, const uint8 g, const uint8 b);

    uint8 getPlatformBlack() const;

    uint8 getPlatformWhite() const;

    void submit(const Palette &palette);
    void submit(const HunkPalette &palette);

    bool updateForFrame();

    void updateFFrame();

    void updateHardware();

private:
    ResourceManager *_resMan;

    uint32 _version;

    bool _needsUpdate;

    uint8 _hardwarePalette[256 * 3];

    Palette _currentPalette;

    Palette _sourcePalette;

    Palette _nextPalette;

    Palette getPaletteFromResource(const GuiResourceId paletteId) const;

    void mergePalette(Palette &to, const Palette &from);

    void applyAll();

#pragma mark -
#pragma mark Varying
public:
    void setVary(const Palette &target, const int16 percent, const int32 ticks, const int16 fromColor, const int16 toColor);

    inline int16 getVaryPercent() const { return ABS(_varyPercent); }

    void setVaryPercent(const int16 percent, const int32 time);

    void setVaryTime(const int32 ticks);

    void setVaryTime(const int16 percent, const int32 ticks);

    void varyOff();

    void varyPause();

    void varyOn();

    void setTarget(const Palette &palette);

    void setStart(const Palette &palette);

    void mergeStart(const Palette &palette);

    void mergeTarget(const Palette &palette);

    void applyVary();

    void kernelPalVarySet(const GuiResourceId paletteId, const int16 percent, const int32 ticks, const int16 fromColor, const int16 toColor);
    void kernelPalVaryMergeTarget(const GuiResourceId paletteId);
    void kernelPalVarySetTarget(const GuiResourceId paletteId);
    void kernelPalVarySetStart(const GuiResourceId paletteId);
    void kernelPalVaryMergeStart(const GuiResourceId paletteId);
    void kernelPalVaryPause(const bool pause);

private:
    Common::ScopedPtr<Palette> _varyStartPalette;

    Common::ScopedPtr<Palette> _varyTargetPalette;

    uint8 _varyFromColor;

    uint8 _varyToColor;

    uint32 _varyLastTick;

    int32 _varyTime;

    int16 _varyDirection;

    int16 _varyPercent;

    int16 _varyTargetPercent;

    uint16 _varyNumTimesPaused;

#pragma mark -
#pragma mark Cycling
public:
    inline const bool *getCycleMap() const { return _cycleMap; }

    void setCycle(const uint8 fromColor, const uint8 toColor, const int16 direction, const int16 delay);

    void doCycle(const uint8 fromColor, const int16 speed);

    void cycleOn(const uint8 fromColor);

    void cyclePause(const uint8 fromColor);

    void cycleAllOn();

    void cycleAllPause();

    void cycleOff(const uint8 fromColor);

    void cycleAllOff();

private:
    enum {
        kNumCyclers = 10
    };

    typedef Common::ScopedPtr<PalCycler> PalCyclerOwner;
    PalCyclerOwner _cyclers[kNumCyclers];

    void updateCycler(PalCycler &cycler, const int16 speed);

    bool _cycleMap[256];

    void clearCycleMap(const uint16 fromColor, const uint16 numColorsToClear);

    void setCycleMap(const uint16 fromColor, const uint16 numColorsToClear);

    PalCycler *getCycler(const uint16 fromColor);

    void applyAllCycles();

    void applyCycles();

#pragma mark -
#pragma mark Fading
public:
    void setFade(const uint16 percent, const uint8 fromColor, const uint16 toColor);

    void fadeOff();

    void applyFade();

private:
    uint16 _fadeTable[256];

#pragma mark -
#pragma mark Gamma correction
public:
    enum {
        numGammaTables = 6
    };

    void setGamma(const int16 level) {
        _gammaLevel = CLIP<int16>(level, 0, numGammaTables) - 1;
        _gammaChanged = true;
    }

private:
    int8 _gammaLevel;

    bool _gammaChanged;
};

} // End of namespace Sci

#endif // SCI_GRAPHICS_PALETTE32_H