animation.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 ANIMATION_H
#define ANIMATION_H
 
#include "common/ptr.h"
#include "common/rect.h"
#include "common/scummsys.h"
#include "common/str.h"
 
namespace Common {
class SeekableReadStream;
}
namespace Graphics {
struct Surface;
class ManagedSurface;
} // namespace Graphics
namespace Video {
class FlicDecoder;
}
 
namespace AGDS {
 
class AGDSEngine;
class Object;
 
class Animation {
    using FlicPtr = Common::ScopedPtr<Video::FlicDecoder>;
    using ManagedSurfacePtr = Common::ScopedPtr<Graphics::ManagedSurface>;
 
    AGDSEngine *_engine;
    Common::String _name;
    FlicPtr _flic;
    ManagedSurfacePtr _frame;
    ManagedSurfacePtr _scaledFrame;
    int _frames;
    Common::Point _position;
    Common::String _process;
    Common::String _phaseVar;
    bool _loop;
    int _cycles;
    bool _phaseVarControlled;
    int _phase;
    bool _paused;
    int _speed;
    int _z;
    int _rotation;
    int _delay;
    int _random;
    float _scale;
    bool _onScreen;
    uint _visibleHeight;
    uint _visibleCenter;
 
public:
    Animation(AGDSEngine *engine, const Common::String &name);
    ~Animation();
 
    bool hasFrame() const {
        return _frame != nullptr;
    }
 
    int frames() const {
        return _frames;
    }
    bool ended() const {
        return _phase >= _frames;
    }
 
    const Common::Point &position() const {
        return _position;
    }
 
    void position(Common::Point position) {
        _position = position;
    }
 
    const Common::String &phaseVar() const {
        return _phaseVar;
    }
 
    void phaseVar(const Common::String &phaseVar) {
        _phaseVar = phaseVar;
    }
 
    const Common::String &process() const {
        return _process;
    }
 
    void process(const Common::String &process) {
        _process = process;
    }
 
    void loop(bool loop) {
        _loop = loop;
    }
 
    void cycles(int cycles) {
        _cycles = cycles;
    }
 
    void delay(int delay) {
        _delay = delay;
    }
 
    void setRandom(int value) { // can't declare random() because of stupid macro
        _random = value;
    }
 
    void phaseVarControlled(bool controlled) {
        _phaseVarControlled = controlled;
        _onScreen = !controlled;
    }
 
    bool paused() const {
        return _paused;
    }
 
    void pause() {
        _paused = true;
    }
 
    void resume() {
        _paused = false;
    }
 
    void rewind();
 
    void speed(int speed) {
        _speed = speed;
    }
 
    void z(int z) {
        _z = z;
    }
 
    int z() const {
        return _z;
    }
 
    void rotate(int rotation) {
        if (_rotation == rotation)
            return;
 
        _rotation = rotation;
        rescaleCurrentFrame();
    }
 
    void scale(float scale);
    float scale() const {
        return _scale;
    }
 
    int phase() const {
        return _phase;
    }
 
    void onScreen(bool onScreen);
 
    bool load(Common::SeekableReadStream *stream, const Common::String &fname);
    void paint(Graphics::Surface &backbuffer, Common::Point dst, Graphics::ManagedSurface *mask = nullptr, int maskAlpha = 0) const;
    uint width() const;
    uint height() const;
    uint visibleHeight() const {
        return _visibleHeight;
    }
    uint visibleCenter() const {
        return _visibleCenter;
    }
    bool tick();
 
    void decodeNextFrame();
 
private:
    void rescaleCurrentFrame();
    void freeFrame();
    void freeScaledFrame();
};
 
} // End of namespace AGDS
 
#endif /* AGDS_ANIMATION_H */