graphics.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 MEDIASTATION_GRAPHICS_H
#define MEDIASTATION_GRAPHICS_H
 
#include "common/rect.h"
#include "common/array.h"
#include "common/stack.h"
#include "graphics/managed_surface.h"
#include "graphics/screen.h"
 
#include "mediastation/clients.h"
#include "mediastation/events.h"
#include "mediastation/mediascript/scriptvalue.h"
 
namespace MediaStation {
 
class MediaStationEngine;
struct DissolvePattern;
class PixMapImage;
 
enum BlitMode {
    kUncompressedBlit = 0x00,
    kRle8Blit = 0x01,
    kClipEnabled = 0x04,
    kUncompressedTransparentBlit = 0x08,
    kPartialDissolve = 0x10,
    kFullDissolve = 0x20,
    // These are variants of Color Cell Compression to compress low framerate
    // "videos" as opposed to just animations. They seem only to be used in
    // the Lamb Chop cutscenes.
    kColorCellCompressionBlit = 0x40,
    kColorCellCompressionTransparentBlit = 0x80
};
 
enum TransitionType {
    kTransitionFadeToBlack = 300,
    kTransitionFadeToPalette = 301,
    kTransitionSetToPalette = 302,
    kTransitionSetToBlack = 303,
    kTransitionFadeToColor = 304,
    kTransitionSetToColor = 305,
    kTransitionSetToPercentOfPalette = 306,
    kTransitionFadeToPaletteObject = 307,
    kTransitionSetToPaletteObject = 308,
    kTransitionSetToPercentOfPaletteObject = 309,
    kTransitionColorShiftCurrentPalette = 310,
    kTransitionScrollLeft = 311,
    kTransitionScrollRight = 312,
    kTransitionScrollUp = 313,
    kTransitionScrollDown = 314,
    kTransitionWipeLeft = 315,
    kTransitionWipeRight = 316,
    kTransitionWipeUp = 317,
    kTransitionWipeDown = 318,
    kTransitionSlideLeft = 319,
    kTransitionSlideRight = 320,
    kTransitionSlideUp = 321,
    kTransitionSlideDown = 322,
    kTransitionSlitLROpen = 323,
    kTransitionSlitLRClose = 324,
    kTransitionSlitUDOpen = 325,
    kTransitionSlitUDClose = 326,
    kTransitionCircleIn = 327,
    kTransitionCircleOut = 328
};
const char *transitionTypeToStr(TransitionType type);
 
enum VideoDisplayManagerSectionType {
    kVideoDisplayManagerUpdateDirty = 0x578,
    kVideoDisplayManagerUpdateAll = 0x579,
    kVideoDisplayManagerEffectTransition = 0x57a,
    kVideoDisplayManagerSetTime = 0x57b,
    kVideoDisplayManagerLoadPalette = 0x5aa,
};
 
class Region {
public:
    void addRect(const Common::Rect &rect);
    bool intersects(const Common::Rect &rect);
    void operator&=(const Common::Rect &rect);
    void operator+=(const Common::Point &point);
 
    Common::Array<Common::Rect> _rects;
    Common::Rect _bounds;
};
 
class Clip {
public:
    Clip() {}
    Clip(const Common::Rect &rect);
 
    void addToRegion(const Region &region);
    void addToRegion(const Common::Rect &rect);
    bool clipIntersectsRect(const Common::Rect &rect);
    void intersectWithRegion(const Common::Rect &rect);
    void makeEmpty();
 
    Region _region;
    Common::Rect _bounds;
};
 
class DisplayContext {
public:
    bool clipIsEmpty();
    void intersectClipWith(const Common::Rect &rect);
    bool rectIsInClip(const Common::Rect &rect);
    void setClipTo(Region region);
    void emptyCurrentClip();
    void deleteClips();
 
    void addClip();
    Clip *currentClip();
    Clip *previousClip();
    void verifyClipSize();
 
    // These are not named as such in the original, but are helper functions
    // for things that likely were macros or something similar in the original.
    void pushOrigin();
    void popOrigin();
 
    Common::Point _origin;
    Graphics::ManagedSurface *_destImage = nullptr;
 
private:
    Common::Stack<Common::Point> _origins;
    Common::Stack<Clip> _clips;
};
 
 
class PrintManager : DisplayContext {
public:
    bool printerIsReady();
    void printScreen();
    void printSpatialObject(SpatialEntity *entity);
    void setSourceSize(Common::Point size);
    void flushToPrinter();
 
    bool _isPortrait = false;
 
    double _leftMargin = -1;
    double _rightMargin = -1;
    double _topMargin = -1;
    double _bottomMargin = -1;
};
 
class DisplayUpdateManager {
public:
    virtual ~DisplayUpdateManager() {}
    virtual void onEvent(const DisplayEvent &event);
 
    void performAutoUpdateAndFlush();
    void performUpdateAll();
    void performUpdateDirty();
 
    void enableAutoUpdate(uint disabledUpdateDepthCounter);
    uint disableAutoUpdate();
    bool needToDisplay();
 
private:
    bool _autoUpdateEnabled = true;
    bool _forceFlush = false;
    uint _disabledScreenAutoUpdateToken = 0;
};
 
class VideoDisplayManager : public ParameterClient {
public:
    VideoDisplayManager(MediaStationEngine *vm);
    ~VideoDisplayManager();
 
    virtual bool attemptToReadFromStream(Chunk &chunk, uint sectionType) override;
 
    void flushToDisplay();
    void updateScreen() { _screen->update(); }
    Graphics::Palette *getRegisteredPalette() { return _registeredPalette; }
    void setRegisteredPalette(Graphics::Palette *palette) { _registeredPalette = palette; }
 
    void imageBlit(
        Common::Point destinationPoint,
        const PixMapImage *image,
        double dissolveFactor,
        DisplayContext *displayContext,
        Graphics::ManagedSurface *destinationImage = nullptr,
        bool useTransBlit = false);
 
    void imageDeltaBlit(
        Common::Point deltaFramePos,
        const Common::Point &keyFrameOffset,
        const PixMapImage *deltaFrame,
        const PixMapImage *keyFrame,
        const double dissolveFactor,
        DisplayContext *displayContext);
 
    Graphics::ManagedSurface decompressRle8Bitmap(
        const PixMapImage *source,
        const Graphics::ManagedSurface *keyFrame = nullptr,
        const Common::Point *keyFrameOffset = nullptr);
 
    const int16 CCC_BLOCK_DIMENSION = 4;
    Graphics::ManagedSurface decompressCccBitmap(const PixMapImage *source);
    Graphics::ManagedSurface decompressCccTransparentBitmap(const PixMapImage *source);
    void decompressCccBlock(
        Graphics::ManagedSurface &dest,
        int16_t blockX,
        int16_t blockY,
        uint8_t backgroundColor,
        uint8_t foregroundColor,
        uint16_t bitMask,
        int16_t blockWidth,
        int16_t blockHeight,
        const uint8_t *transparencyColor = nullptr);
 
    void effectTransition(Common::Array<ScriptValue> &args);
    void setTransitionOnSync(Common::Array<ScriptValue> &args) { _scheduledTransitionOnSync = args; }
    void doTransitionOnSync();
 
    void setGammaValues(double red, double green, double blue);
    void getDefaultGammaValues(double &red, double &green, double &blue);
    void getGammaValues(double &red, double &green, double &blue);
 
    DisplayContext _displayContext;
 
private:
    MediaStationEngine *_vm = nullptr;
    Graphics::Screen *_screen = nullptr;
    Graphics::Palette *_registeredPalette = nullptr;
    Common::Array<ScriptValue> _scheduledTransitionOnSync;
    double _defaultTransitionTime = 0.0;
 
    const double DEFAULT_GAMMA_VALUE = 1.0;
    double _redGamma = 1.0;
    double _greenGamma = 1.0;
    double _blueGamma = 1.0;
 
    void readAndEffectTransition(Chunk &chunk);
    void readAndRegisterPalette(Chunk &chunk);
 
    // Blitting methods.
    // blitRectsClip encompasses the functionality of both opaqueBlitRectsClip
    // and transparentBlitRectsClip in the disasm.
    void blitRectsClip(
        Graphics::ManagedSurface *dest,
        const Common::Point &destLocation,
        const PixMapImage *source,
        const Common::Array<Common::Rect> &dirtyRegion,
        bool useTransBlit = false);
    void rleBlitRectsClip(
        Graphics::ManagedSurface *dest,
        const Common::Point &destLocation,
        const PixMapImage *source,
        const Common::Array<Common::Rect> &dirtyRegion);
    void cccBlitRectsClip(
        Graphics::ManagedSurface *dest,
        const Common::Point &destLocation,
        const PixMapImage *source,
        const Common::Array<Common::Rect> &dirtyRegion);
    void cccTransparentBlitRectsClip(
        Graphics::ManagedSurface *dest,
        const Common::Point &destLocation,
        const PixMapImage *source,
        const Common::Array<Common::Rect> &dirtyRegion);
    void dissolveBlitRectsClip(
        Graphics::ManagedSurface *dest,
        const Common::Point &destPos,
        const PixMapImage *source,
        const Common::Array<Common::Rect> &dirtyRegion,
        const uint dissolveFactor);
    void dissolveBlit1Rect(
        Graphics::ManagedSurface *dest,
        const Common::Rect &areaToRedraw,
        const Common::Point &originOnScreen,
        const PixMapImage *source,
        const Common::Rect &dirtyRegion,
        const DissolvePattern &pattern);
    void fullDeltaRleBlitRectsClip(
        Graphics::ManagedSurface *destinationImage,
        const Common::Point &deltaFramePos,
        const Common::Point &keyFrameOffset,
        const PixMapImage *deltaFrame,
        const PixMapImage *keyFrame,
        const Common::Array<Common::Rect> &dirtyRegion);
    void deltaRleBlitRectsClip(
        Graphics::ManagedSurface *destinationImage,
        const Common::Point &deltaFramePos,
        const PixMapImage *deltaFrame,
        const PixMapImage *keyFrame,
        const Common::Array<Common::Rect> &dirtyRegion);
    void deltaRleBlit1Rect(
        Graphics::ManagedSurface *destinationImage,
        const Common::Point &destinationPoint,
        const PixMapImage *sourceImage,
        const PixMapImage *deltaImage,
        const Common::Rect &dirtyRect);
 
    // Transition methods.
    const double DEFAULT_FADE_TRANSITION_TIME_IN_SECONDS = 0.5;
    const byte DEFAULT_PALETTE_TRANSITION_START_INDEX = 0x01;
    const byte DEFAULT_PALETTE_TRANSITION_COLOR_COUNT = 0xFE;
    void fadeToBlack(Common::Array<ScriptValue> &args);
    void fadeToRegisteredPalette(Common::Array<ScriptValue> &args);
    void setToRegisteredPalette(Common::Array<ScriptValue> &args);
    void setToBlack(Common::Array<ScriptValue> &args);
    void fadeToColor(Common::Array<ScriptValue> &args);
    void setToColor(Common::Array<ScriptValue> &args);
    void setToPercentOfPalette(Common::Array<ScriptValue> &args);
    void fadeToPaletteObject(Common::Array<ScriptValue> &args);
    void setToPaletteObject(Common::Array<ScriptValue> &args);
    void setToPercentOfPaletteObject(Common::Array<ScriptValue> &args);
    void colorShiftCurrentPalette(Common::Array<ScriptValue> &args);
    void circleOut(Common::Array<ScriptValue> &args);
 
    void _setPalette(Graphics::Palette &palette, uint startIndex, uint colorCount);
    void _setPaletteToColor(Graphics::Palette &targetPalette, byte r, byte g, byte b);
    uint _limitColorRange(uint &startIndex, uint &colorCount);
    byte _interpolateColorComponent(byte source, byte target, double progress);
 
    void _fadeToColor(byte r, byte g, byte b, double fadeTime, uint startIndex, uint colorCount);
    void _setToColor(byte r, byte g, byte b, uint startIndex, uint colorCount);
    void _setPercentToColor(double percent, byte r, byte g, byte b, uint startIndex, uint colorCount);
 
    void _fadeToPalette(double fadeTime, Graphics::Palette &targetPalette, uint startIndex, uint colorCount);
    void _setToPercentPalette(double percent, Graphics::Palette &currentPalette, Graphics::Palette &targetPalette,
        uint startIndex, uint colorCount);
    void _fadeToRegisteredPalette(double fadeTime, uint startIndex, uint colorCount);
    void _setToRegisteredPalette(uint startIndex, uint colorCount);
    void _colorShiftCurrentPalette(uint startIndex, uint shiftAmount, uint colorCount);
    void _fadeToPaletteObject(uint paletteId, double fadeTime, uint startIndex, uint colorCount);
    void _setToPaletteObject(uint paletteId, uint startIndex, uint colorCount);
    void _setPercentToPaletteObject(double percent, uint paletteId, uint startIndex, uint colorCount);
};
 
} // End of namespace MediaStation
 
#endif