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 ALCACHOFA_GRAPHICS_H
#define ALCACHOFA_GRAPHICS_H

#include "common/ptr.h"
#include "common/stream.h"
#include "common/serializer.h"
#include "common/rect.h"
#include "common/span.h"
#include "math/vector2d.h"
#include "graphics/managed_surface.h"

#include "alcachofa/camera.h"
#include "alcachofa/common.h"

namespace Alcachofa {

enum class BlendMode {
    AdditiveAlpha, // Normal objects
    Additive,      // "Effect" objects, fades
    Multiply,      // Unused in Movie Adventure
    Alpha,         // Unused in Movie Adventure (used for debugging)
    Tinted         // Used for fonts
};

class Shape;

class ITexture {
public:
    ITexture(Common::Point size);
    virtual ~ITexture() {}

    virtual void update(const Graphics::Surface &surface) = 0;
    inline void update(const Graphics::ManagedSurface &surface) { update(surface.rawSurface()); }

    inline Common::Point size() const { return _size; }

private:
    Common::Point _size;
};

class IRenderer {
public:
    virtual ~IRenderer() {}

    virtual Common::ScopedPtr<ITexture> createTexture(int32 w, int32 h, bool withMipmaps = true) = 0;
    virtual Graphics::PixelFormat getPixelFormat() const = 0;
    virtual bool requiresPoTTextures() const = 0;

    virtual void begin() = 0;
    virtual void setTexture(ITexture *texture) = 0;
    virtual void setBlendMode(BlendMode blendMode) = 0;
    virtual void setLodBias(float lodBias) = 0;
    virtual void setOutput(Graphics::Surface &surface) = 0;
    virtual bool hasOutput() const = 0;
    virtual void quad(
        Math::Vector2d topLeft,
        Math::Vector2d size,
        Color color = kWhite,
        Math::Angle rotation = Math::Angle(),
        Math::Vector2d texMin = Math::Vector2d(0, 0),
        Math::Vector2d texMax = Math::Vector2d(1, 1)) = 0;
    virtual void end() = 0;

    static IRenderer *createOpenGLRenderer(Common::Point resolution);
    static IRenderer *createOpenGLRendererClassic(Common::Point resolution);
    static IRenderer *createOpenGLRendererShaders(Common::Point resolution);
    static IRenderer *createTinyGLRenderer(Common::Point resolution);
};

class IDebugRenderer : public virtual IRenderer {
public:
    virtual void debugPolygon(
        Common::Span<Math::Vector2d> points,
        Color color = kDebugRed
    ) = 0;
    virtual void debugPolyline(
        Common::Span<Math::Vector2d> points,
        Color color = kDebugRed
    ) = 0;

    virtual void debugShape(
        const Shape &shape,
        Color color = kDebugRed
    );

    inline void debugPolyline(Common::Point a, Common::Point b, Color color = kDebugRed) {
        Math::Vector2d points[] = { { (float)a.x, (float)a.y }, { (float)b.x, (float)b.y } };
        debugPolygon({ points, 2 }, color);
    }
};

// as futureoptimization one could actually store these instead of converting to a surface
// this will reduce memory usage and might reduce render times on software renderers
class ImageV1 {
public:
    ImageV1(Common::SeekableReadStream &stream);

    inline Common::Point drawOffset() const { return _drawOffset; }

    void render(Graphics::ManagedSurface &target, Common::Point offset, byte alpha = 255) const;
    Graphics::ManagedSurface *render(byte alpha = 255) const;
    
private:
    struct Segment {
        uint16 _xOffset, _width;
        uint32 _dataOffset;
    };
    struct Line { // indices into _segments
        uint _start, _end;
    };

    Common::Point _drawOffset, _size;
    Common::Array<byte> _pixels;
    Common::Array<byte> _palette;
    Common::Array<Segment> _segments;
    Common::Array<Line> _lines;
};

enum class AnimationFolder {
    Animations,
    Masks,
    Backgrounds
};

struct AnimationFrame {
    Common::Point
        _center, 
        _offset; 
    uint32 _duration;
};

class AnimationBase {
protected:
    AnimationBase(GameFileReference fileRef, AnimationFolder folder = AnimationFolder::Animations);
    ~AnimationBase();

    void load();
    void freeImages();
    void setToEmpty();
    void readV1(Common::SeekableReadStream &stream);
    void readV2(Common::SeekableReadStream &stream);
    void readV3(Common::SeekableReadStream &stream);
    void createIndexMappingV1and2(const Common::Array<byte> &spriteOrder);
    void readFramesV1and2(Common::SeekableReadStream &stream, uint frameCount, uint spriteCount);
    Graphics::ManagedSurface *readImageV3(Common::SeekableReadStream &stream) const;
    Common::Point imageSize(int32 imageI) const;
    inline bool isLoaded() const { return _isLoaded; }

    static void fullBlend(
        const Graphics::ManagedSurface &source,
        Graphics::ManagedSurface &destination,
        int offsetX,
        int offsetY);

    static constexpr const uint kMaxSpriteIDs = 256;
    static constexpr const uint kMaxSpriteIDsV1 = 8;
    GameFileReference _fileRef;
    AnimationFolder _folder;
    bool _isLoaded = false;
    uint32 _totalDuration = 0;

    int32 _spriteIndexMapping[kMaxSpriteIDs] = { 0 }; 
    Common::Array<int32>
        _spriteOffsets, 
        _spriteBases; 
    Common::Array<bool> _spriteEnabled;
    Common::Array<AnimationFrame> _frames;
    Common::Array<Graphics::ManagedSurface *> _images; 
    Common::Array<Common::Point> _imageOffsets;
};

class Animation : private AnimationBase {
public:
    Animation(GameFileReference fileRef, AnimationFolder folder = AnimationFolder::Animations);

    void load();
    void freeImages();

    using AnimationBase::isLoaded;
    inline uint spriteCount() const { return _spriteBases.size(); }
    inline uint frameCount() const { return _frames.size(); }
    inline uint32 frameDuration(int32 frameI) const { return _frames[frameI]._duration; }
    inline Common::Point frameCenter(int32 frameI) const { return _frames[frameI]._center; }
    inline uint32 totalDuration() const { return _totalDuration; }
    inline uint8 &premultiplyAlpha() { return _premultiplyAlpha; }
    Common::Rect frameBounds(int32 frameI) const;
    Common::Point totalFrameOffset(int32 frameI) const;
    int32 frameAtTime(uint32 time) const;
    int32 imageIndex(int32 frameI, int32 spriteI) const;
    using AnimationBase::imageSize;
    void outputRect2D(int32 frameI, float scale, Math::Vector2d &topLeft, Math::Vector2d &size) const;
    void outputRect3D(int32 frameI, float scale, Math::Vector3d &topLeft, Math::Vector2d &size) const;

    void overrideTexture(const Graphics::ManagedSurface &surface);

    void draw2D(
        int32 frameI,
        Math::Vector2d topLeft,
        float scale,
        BlendMode blendMode,
        Color color);
    void draw3D(
        int32 frameI,
        Math::Vector3d topLeft,
        float scale,
        BlendMode blendMode,
        Color color);
    void drawEffect(
        int32 frameI,
        Math::Vector3d topLeft,
        Math::Vector2d tiling,
        Math::Vector2d texOffset,
        BlendMode blendMode);

private:
    Common::Rect spriteBounds(int32 frameI, int32 spriteI) const;
    Common::Rect maxFrameBounds() const;
    void prerenderFrame(int32 frameI);

    int32_t _renderedFrameI = -1;
    uint8 _premultiplyAlpha = 100, 
        _renderedPremultiplyAlpha = 255;

    Graphics::ManagedSurface _renderedSurface;
    Common::ScopedPtr<ITexture> _renderedTexture;
};

class Font : private AnimationBase {
public:
    Font(GameFileReference fileRef);

    void load();
    void freeImages();
    void drawCharacter(byte ch, Common::Point center, Color color);

    using AnimationBase::isLoaded;
    using AnimationBase::imageSize;
    bool isVisibleChar(byte ch) const;
    Common::Point characterSize(byte ch) const;
    Common::Point spaceSize() const;
    inline uint imageCount() const { return _images.size(); }

private:
    const byte _charToImage, _spaceImageI, _charSpacing;
    Common::Array<Math::Vector2d> _texMins, _texMaxs;
    Common::ScopedPtr<ITexture> _texture;
};

class Graphic {
public:
    Graphic();
    Graphic(Common::SeekableReadStream &stream);
    Graphic(const Graphic &other); // animation reference is taken, so keep other alive
    Graphic(Graphic &&other) = default;
    Graphic &operator=(const Graphic &other);
    Graphic &operator=(Graphic &&other) = default;

    inline Common::Point &topLeft() { return _topLeft; }
    inline int8 &order() { return _order; }
    inline int16 &scale() { return _scale; }
    inline float &depthScale() { return _depthScale; }
    inline Color &color() { return _color; }
    inline int32 &frameI() { return _frameI; }
    inline uint32 &lastTime() { return _lastTime; }
    inline bool isPaused() const { return _isPaused; }
    inline bool hasAnimation() const { return _animation != nullptr; }
    inline Animation &animation() {
        assert(_animation != nullptr && _animation->isLoaded());
        return *_animation;
    }
    inline uint8 &premultiplyAlpha() {
        assert(_animation != nullptr);
        return _animation->premultiplyAlpha();
    }

    void loadResources();
    void freeResources();
    void update();
    void start(bool looping);
    void pause();
    void reset();
    void setAnimation(const GameFileReference &fileRef, AnimationFolder folder);
    void setAnimation(Animation *animation); 
    void syncGame(Common::Serializer &serializer);

private:
    friend class AnimationDrawRequest;
    friend class SpecialEffectDrawRequest;
    Common::ScopedPtr<Animation> _ownedAnimation;
    Animation *_animation = nullptr;
    Common::Point _topLeft;
    int16 _scale = kBaseScale;
    int8 _order = 0;
    Color _color = kWhite;

    bool _isPaused = true,
        _isLooping = true;
    uint32 _lastTime = 0; 
    int32 _frameI = -1;
    float _depthScale = 1.0f;
};

class IDrawRequest {
public:
    IDrawRequest(int8 order);
    virtual ~IDrawRequest() {}

    inline int8 order() const { return _order; }
    virtual void draw() = 0;

private:
    const int8 _order;
};

class AnimationDrawRequest : public IDrawRequest {
public:
    AnimationDrawRequest(
        Graphic &graphic,
        bool is3D,
        BlendMode blendMode,
        float lodBias = 0.0f);
    AnimationDrawRequest(
        Animation *animation,
        int32 frameI,
        Math::Vector2d center,
        int8 order
    );

    void draw() override;

private:
    bool _is3D;
    Animation *_animation;
    int32 _frameI;
    Math::Vector3d _topLeft;
    float _scale;
    Color _color;
    BlendMode _blendMode;
    float _lodBias;
};

class SpecialEffectDrawRequest : public IDrawRequest {
public:
    SpecialEffectDrawRequest(
        Graphic &graphic,
        Common::Point topLeft,
        Common::Point bottomRight,
        Math::Vector2d texOffset,
        BlendMode blendMode);

    void draw() override;

private:
    Animation *_animation;
    int32 _frameI;
    Math::Vector3d _topLeft;
    Math::Vector2d
        _size,
        _texOffset;
    BlendMode _blendMode;
};

class TextDrawRequest : public IDrawRequest {
public:
    TextDrawRequest(
        Font &font,
        const char *text,
        Common::Point pos,
        int maxWidth,
        bool centered,
        Color color,
        int8 order);

    inline Common::Point size() const { return { (int16)_width, (int16)_height }; }
    void draw() override;

private:
    static constexpr uint kMaxLines = 12;
    using TextLine = Common::Span<const byte>; 

    Font &_font;
    int _posY = 0, _height = 0, _width = 0;
    Color _color;
    Common::Span<TextLine> _lines;
    Common::Span<int> _posX;
    TextLine _allLines[kMaxLines];
    int _allPosX[kMaxLines] = { 0 };
};

enum class FadeType {
    ToBlack,
    ToWhite
    // Originally there was a CrossFade, but it is unused for now and thus not implemented
};

enum class PermanentFadeAction {
    Nothing,
    SetFaded,
    UnsetFaded
};

class FadeDrawRequest : public IDrawRequest {
public:
    FadeDrawRequest(FadeType type, float value, int8 order);

    void draw() override;

private:
    FadeType _type;
    float _value;
};

Task *fade(Process &process, FadeType fadeType,
    float from, float to,
    int32 duration, EasingType easingType,
    int8 order,
    PermanentFadeAction permanentFadeAction = PermanentFadeAction::Nothing);

class BorderDrawRequest : public IDrawRequest {
public:
    BorderDrawRequest(Common::Rect rect, Color color);

    void draw() override;

private:
    Common::Rect _rect;
    Color _color;
};

class BumpAllocator {
public:
    BumpAllocator(size_t pageSize);
    ~BumpAllocator();

    template<typename T, typename... Args>
    inline T *allocate(Args&&... args) {
        return new(allocateRaw(sizeof(T), alignof(T))) T(Common::forward<Args>(args)...);
    }
    void *allocateRaw(size_t size, size_t align);
    void deallocateAll();

private:
    void allocatePage();

    const size_t _pageSize;
    size_t _pageI = 0, _used = 0;
    Common::Array<void *> _pages;
};

class DrawQueue {
public:
    DrawQueue(IRenderer *renderer);

    template<typename T, typename... Args>
    inline void add(Args&&... args) {
        addRequest(_allocator.allocate<T>(Common::forward<Args>(args)...));
    }
    inline BumpAllocator &allocator() { return _allocator; }

    void clear();
    void setLodBias(int8 orderFrom, int8 orderTo, float newLodBias);
    void draw();

private:
    void addRequest(IDrawRequest *drawRequest);

    static constexpr const uint kMaxDrawRequestsPerOrder = 50;
    IRenderer *const _renderer;
    BumpAllocator _allocator;
    IDrawRequest *_requestsPerOrder[kOrderCount][kMaxDrawRequestsPerOrder] = { { 0 } };
    uint8 _requestsPerOrderCount[kOrderCount] = { 0 };
    float _lodBiasPerOrder[kOrderCount] = { 0 };
};

}

#endif // ALCACHOFA_GRAPHICS_H