scenegraph.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 TWP_SCENEGRAPH_H
#define TWP_SCENEGRAPH_H

#include "common/array.h"
#include "common/str.h"
#include "math/vector2d.h"
#include "math/matrix4.h"
#include "twp/gfx.h"
#include "twp/rectf.h"
#include "twp/font.h"
#include "twp/spritesheet.h"

#define NUMOBJECTS 8

namespace Twp {

class Motor;

// Represents a node in a scene graph.
class Node {
public:
    Node(const Common::String &name, const Math::Vector2d &scale = Math::Vector2d(1, 1), const Color &color = Color());
    virtual ~Node();

    void setName(const Common::String &name) { _name = name; }
    const Common::String &getName() const { return _name; }

    virtual void setVisible(bool visible) { _visible = visible; }
    bool isVisible() const { return _visible; }

    // Adds new child in current node.
    //
    // Arguments:
    // - `child`: child node to add.
    void addChild(Node *child);
    void removeChild(Node *node);
    void clear();
    // Removes this node from its parent.
    void remove();
    const Common::Array<Node *> &getChildren() const { return _children; }

    Node *getParent() const { return _parent; }
    const Node *getRoot() const;
    // Finds a node in its children and returns its position.
    int find(Node *other);

    // Gets the local position for this node (relative to its parent)
    void setPos(const Math::Vector2d &pos) { _pos = pos; }
    Math::Vector2d getPos() const { return _pos; }

    void setOffset(const Math::Vector2d &offset) { _offset = offset; }
    Math::Vector2d getOffset() const { return _offset; }

    void setShakeOffset(const Math::Vector2d &offset) { _shakeOffset = offset; }
    Math::Vector2d getShakeOffset() const { return _shakeOffset; }

    void setRenderOffset(const Math::Vector2d &offset) { _renderOffset = offset; }
    Math::Vector2d getRenderOffset() const { return _renderOffset; }

    void setScale(const Math::Vector2d &scale) { _scale = scale; }
    virtual Math::Vector2d getScale() const { return _scale; }

    // Gets the absolute position for this node.
    Math::Vector2d getAbsPos() const;

    // Gets the full transformation for this node.
    virtual Math::Matrix4 getTrsf(const Math::Matrix4 &parentTrsf);

    void setColor(const Color &color);
    Color getColor() const { return _color; }
    Color getComputedColor() const { return _computedColor; }

    void setAlpha(float alpha);
    float getAlpha() const { return _color.rgba.a; }

    void setZSort(int zsort) { _zOrder = zsort; }
    virtual int getZSort() const { return _zOrder; }

    void setRotation(float rotation) { _rotation = rotation; }
    float getRotation() const { return _rotation; }

    void setRotationOffset(float rotationOffset) { _rotationOffset = rotationOffset; }
    float getRotationOffset() const { return _rotationOffset; }

    void setAnchor(const Math::Vector2d &anchor);
    void setAnchorNorm(const Math::Vector2d &anchorNorm);
    void setSize(const Math::Vector2d &size);
    Math::Vector2d getSize() const { return _size; }
    virtual Rectf getRect() const;

    void draw(const Math::Matrix4 &parent = Math::Matrix4());

protected:
    virtual void onDrawChildren(const Math::Matrix4 &trsf);
    virtual void onColorUpdated(const Color &c) {}
    virtual void drawCore(const Math::Matrix4 &trsf) {}

private:
    // Gets the location transformation = translation * rotation * scale.
    Math::Matrix4 getLocalTrsf();
    void updateColor();
    void updateColor(const Color &parentColor);
    void updateAlpha();
    void updateAlpha(float parentAlpha);

protected:
    Common::String _name;
    Math::Vector2d _pos;
    int _zOrder = 0;
    Node *_parent = nullptr;
    Common::Array<Node *> _children;
    Math::Vector2d _offset, _shakeOffset, _renderOffset, _anchor, _anchorNorm, _scale, _size;
    Color _color, _computedColor;
    bool _visible = true;
    float _rotation = 0.f;
    float _rotationOffset = 0.f;
};

class ParallaxNode final : public Node {
public:
    ParallaxNode(const Math::Vector2d &parallax, const Common::String &sheet, const Common::StringArray &frames);
    virtual ~ParallaxNode();

    Math::Matrix4 getTrsf(const Math::Matrix4 &parentTrsf) override final;

protected:
    void onDrawChildren(const Math::Matrix4 &trsf) override;
    void drawCore(const Math::Matrix4 &trsf) override final;

private:
    Math::Vector2d _parallax;
    Common::String _sheet;
    Common::StringArray _frames;
};

struct ObjectAnimation;

class Object;
class Anim : public Node {
public:
    Anim(Object *obj);

    void clearFrames();
    void setAnim(const ObjectAnimation *anim, float fps = 0.f, bool loop = false, bool instant = false);
    void update(float elapsed);
    void disable() { _disabled = true; }
    void trigSound();

private:
    virtual void drawCore(const Math::Matrix4 &trsf) override final;

public:
    const ObjectAnimation *_anim = nullptr;
    bool _disabled = false;

private:
    Common::String _sheet;
    Common::Array<Common::String> _frames;
    size_t _frameIndex = 0;
    float _elapsed = 0.f;
    float _frameDuration = 0.f;
    bool _loop = false;
    bool _instant = false;
    Object *_obj = nullptr;
    Common::Array<Common::SharedPtr<Anim> > _anims;
};

class ActorNode final : public Node {
public:
    ActorNode(Common::SharedPtr<Object> obj);

    int getZSort() const override final;
    Math::Vector2d getScale() const override final;

private:
    Common::SharedPtr<Object> _object;
};

class TextNode final : public Node {
public:
    TextNode();
    virtual ~TextNode() final;

    void setText(const Text &text);
    void updateBounds();
    virtual Rectf getRect() const override final;

private:
    virtual void onColorUpdated(const Color &color) override final;
    virtual void drawCore(const Math::Matrix4 &trsf) override final;

private:
    Text _text;
};

class Scene final : public Node {
public:
    Scene();
    virtual ~Scene() final;
};

enum class CursorShape {
    Normal,
    Front,
    Back,
    Left,
    Right,
    Pause
};

enum InputStateFlag {
    II_FLAGS_UI_INPUT_ON = 1,
    II_FLAGS_UI_INPUT_OFF = 2,
    II_FLAGS_UI_VERBS_ON = 4,
    II_FLAGS_UI_VERBS_OFF = 8,
    II_FLAGS_UI_HUDOBJECTS_ON = 0x10,
    II_FLAGS_UI_HUDOBJECTS_OFF = 0x20,
    II_FLAGS_UI_CURSOR_ON = 0x40,
    II_FLAGS_UI_CURSOR_OFF = 0x80
};

class InputState final : public Node {
public:
    InputState();
    virtual ~InputState() final;

    InputStateFlag getState() const;
    void setState(InputStateFlag state);

    void setInputHUD(bool value) { _inputHUD = value; }
    bool getInputHUD() const { return _inputHUD; }

    void setInputActive(bool value) { _inputActive = value; }
    bool getInputActive() const { return _inputActive; }

    void setShowCursor(bool value) { _showCursor = value; }
    bool getShowCursor() const { return _showCursor; }

    void setInputVerbsActive(bool value) { _inputVerbsActive = value; }
    bool getInputVerbsActive() const { return _inputVerbsActive; }

    void setHotspot(bool value) { _hotspot = value; }
    bool getHotspot() const { return _hotspot; }

    void setCursorShape(CursorShape shape);

private:
    virtual void drawCore(const Math::Matrix4 &trsf) override final;
    Common::String getCursorName() const;

public:
    bool _inputHUD = false;
    bool _inputActive = false;
    bool _showCursor = false;
    bool _inputVerbsActive = false;
    CursorShape _cursorShape = CursorShape::Normal;
    bool _hotspot = false;
};

class OverlayNode final : public Node {
public:
    OverlayNode();

    void setOverlayColor(const Color &color) { _ovlColor = color; }
    Color getOverlayColor() const { return _ovlColor; }

private:
    virtual void drawCore(const Math::Matrix4 &trsf) override final;

private:
    Color _ovlColor;
};

class Inventory : public Node {
public:
    Inventory();
    void update(float elapsed, Common::SharedPtr<Object> actor = nullptr, const Color &backColor = Color(0, 0, 0), const Color &verbNormal = Color(0, 0, 0));

    bool isOver() const { return _over; }
    Common::SharedPtr<Object> getObject() const { return _obj; }
    Math::Vector2d getPos(Common::SharedPtr<Object> inv) const;
    Math::Vector2d getPos(int index) const;
    int getOverIndex() const;

    void setVisible(bool visible) override;

private:
    virtual void drawCore(const Math::Matrix4 &trsf) override final;
    void drawArrows(const Math::Matrix4 &trsf);
    void drawBack(const Math::Matrix4 &trsf);
    void drawItems(const Math::Matrix4 &trsf);
    void drawSprite(const SpriteSheetFrame &sf, Texture *texture, const Color &color, const Math::Matrix4 &trsf);

public:
    bool _active = false;

private:
    Common::SharedPtr<Object> _actor;
    Color _backColor, _verbNormal;
    bool _down = false;
    Common::SharedPtr<Object> _obj;
    Common::Rect _itemRects[NUMOBJECTS];
    Common::ScopedPtr<Motor> _shake[NUMOBJECTS];
    bool _inventoryOver[NUMOBJECTS];
    Math::Vector2d _shakeOffset[NUMOBJECTS];
    float _shakeTime[NUMOBJECTS];
    Common::Rect _arrowUpRect;
    Common::Rect _arrowDnRect;
    float _jiggleTime = 0.f;
    float _fadeTime = 0.f;
    bool _fadeIn = false;
    bool _over = false;
};

class SentenceNode : public Node {
public:
    SentenceNode();
    virtual ~SentenceNode();

    void setText(const Common::String &text);

private:
    void drawCore(const Math::Matrix4 &trsf) override final;

private:
    Common::String _text;
};

class SpriteNode : public Node {
public:
    SpriteNode();
    virtual ~SpriteNode();

    void setSprite(const Common::String &sheet, const Common::String &frame);

private:
    void drawCore(const Math::Matrix4 &trsf) override final;

private:
    Common::String _sheet;
    Common::String _frame;
};

class NoOverrideNode : public Node {
public:
    NoOverrideNode();
    virtual ~NoOverrideNode();

    void reset();
    bool update(float elapsed);

private:
    SpriteNode _icon;
    float _elapsed = 0.f;
};

class HotspotMarkerNode : public Node {
public:
    HotspotMarkerNode();
    virtual ~HotspotMarkerNode();

private:
    void drawSprite(const SpriteSheetFrame &sf, Texture *texture, const Color &color, const Math::Matrix4 &trsf);
    void drawCore(const Math::Matrix4 &trsf) override final;
};

} // End of namespace Twp

#endif