renderobject.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/>.
 *
 */

/*
 * This code is based on Broken Sword 2.5 engine
 *
 * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
 *
 * Licensed under GNU GPL v2
 *
 */

/*
    BS_RenderObject
    ---------------
    Dieses ist die Klasse die sämtliche sichtbaren Objekte beschreibt. Alle anderen sichtbaren Objekte müssen von ihr abgeleitet werden.
    Diese Klasse erledigt Aufgaben wie: minimales Neuzeichnen, Renderreihenfolge, Objekthierachie.
    Alle BS_RenderObject Instanzen werden von einem BS_RenderObjectManager in einem Baum verwaltet.

    Autor: Malte Thiesen
*/

#ifndef SWORD25_RENDEROBJECT_H
#define SWORD25_RENDEROBJECT_H

#include "sword25/kernel/common.h"
#include "sword25/kernel/persistable.h"
#include "common/rect.h"
#include "sword25/gfx/graphicengine.h"
#include "sword25/gfx/renderobjectptr.h"

#include "common/list.h"

namespace Sword25 {

class Kernel;
class RenderObjectManager;
class RenderObjectQueue;
class RectangleList;
class Bitmap;
class Animation;
class AnimationTemplate;
class Panel;
class Text;

// Klassendefinition
class RenderObject {
public:
    // Konstanten
    // ----------
    enum TYPES {
        TYPE_ROOT,
        TYPE_STATICBITMAP,
        TYPE_DYNAMICBITMAP,
        TYPE_ANIMATION,
        TYPE_PANEL,
        TYPE_TEXT,
        TYPE_UNKNOWN
    };

    // Add-Methoden
    // ------------

    RenderObjectPtr<Bitmap> addBitmap(const Common::String &fileName);
    RenderObjectPtr<Bitmap> addDynamicBitmap(uint width, uint height);
    RenderObjectPtr<Animation> addAnimation(const Common::String &fileName);
    RenderObjectPtr<Animation> addAnimation(const AnimationTemplate &animationTemplate);
    RenderObjectPtr<Panel> addPanel(int width, int height, uint color = BS_RGB(0, 0, 0));
    RenderObjectPtr<Text> addText(const Common::String &font, const Common::String &text = "");

    // Cast-Methoden
    // -------------
    RenderObjectPtr<Bitmap> toBitmap() {
        if (_type == TYPE_STATICBITMAP || _type == TYPE_DYNAMICBITMAP)
            return RenderObjectPtr<Bitmap>(this->getHandle());
        else
            return RenderObjectPtr<Bitmap>();
    }
    RenderObjectPtr<Animation> toAnimation() {
        if (_type == TYPE_ANIMATION)
            return RenderObjectPtr<Animation>(this->getHandle());
        else
            return RenderObjectPtr<Animation>();
    }
    RenderObjectPtr<Panel> toPanel() {
        if (_type == TYPE_PANEL)
            return RenderObjectPtr<Panel>(this->getHandle());
        else
            return RenderObjectPtr<Panel>();
    }
    RenderObjectPtr<Text> toText() {
        if (_type == TYPE_TEXT)
            return RenderObjectPtr<Text>(this->getHandle());
        else
            return RenderObjectPtr<Text>();
    }

    // Konstruktor / Desktruktor
    // -------------------------
    RenderObject(RenderObjectPtr<RenderObject> pParent, TYPES type, uint handle = 0);
    virtual ~RenderObject();

    // Interface
    // ---------

    void preRender(RenderObjectQueue *renderQueue);

    bool render(RectangleList *updateRects, const Common::Array<int> &updateRectsMinZ);

    bool updateObjectState();
    void deleteAllChildren();

    // Accessor-Methoden
    // -----------------
    virtual void setPos(int x, int y);
    virtual void setX(int x);
    virtual void setY(int y);
    virtual void setZ(int z);
    virtual void setVisible(bool visible);
    virtual int getX() const {
        return _x;
    }
    virtual int getY() const {
        return _y;
    }
    virtual int getAbsoluteX() const {
        return _absoluteX;
    }
    virtual int getAbsoluteY() const {
        return _absoluteY;
    }
    int         getZ() const {
        return _z;
    }

    int getAbsoluteZ() const {
        return _absoluteZ;
    }

    int         getWidth() const {
        return _width;
    }
    int         getHeight() const {
        return _height;
    }
    bool        isVisible() const {
        return _visible;
    }
    TYPES       getType() const {
        return _type;
    }
    bool        getInitSuccess() const {
        return _initSuccess;
    }
    const Common::Rect  &getBbox() const {
        return _bbox;
    }
    void forceRefresh() {
        _refreshForced = true;
    }
    uint32 getHandle() const {
        return _handle;
    }

    // Get the RenderObjects current version
    int getVersion() const {
        return _version;
    }

    bool isSolid() const {
        return _isSolid;
    }

    // Persistenz-Methoden
    // -------------------
    virtual bool persist(OutputPersistenceBlock &writer);
    virtual bool unpersist(InputPersistenceBlock &reader);
    // TODO: Evtl. protected
    bool persistChildren(OutputPersistenceBlock &writer);
    bool unpersistChildren(InputPersistenceBlock &reader);
    // TODO: Evtl. private
    RenderObjectPtr<RenderObject> recreatePersistedRenderObject(InputPersistenceBlock &reader);

protected:
    // Typen
    // -----
    typedef Common::List<RenderObjectPtr<RenderObject> >          RENDEROBJECT_LIST;
    typedef Common::List<RenderObjectPtr<RenderObject> >::iterator    RENDEROBJECT_ITER;

    int32       _x;            
    int32       _y;            
    int32       _z;            
    int32       _absoluteX;    
    int32       _absoluteY;    
    int32       _absoluteZ;
    int32       _width;        
    int32       _height;       
    bool        _visible;      
    bool        _childChanged; 
    TYPES       _type;         
    bool        _initSuccess;  
    Common::Rect _bbox;         

    // Kopien der Variablen, die für die Errechnung des Dirty-Rects und zur Bestimmung der Objektveränderung notwendig sind
    Common::Rect     _oldBbox;
    int32       _oldX;
    int32       _oldY;
    int32       _oldZ;
    bool        _oldVisible;

    static int _nextGlobalVersion;

    int32 _version;

    // This should be set to true if the RenderObject is NOT alpha-blended to optimize drawing
    bool _isSolid;

    RenderObjectManager *_managerPtr;

    // Render-Methode
    // --------------
    virtual bool doRender(RectangleList *updateRects) = 0; // { return true; }

    // RenderObject-Baum Variablen
    // ---------------------------
    // Der Baum legt die hierachische Ordnung der BS_RenderObjects fest.
    // Alle Eigenschaften wie X, Y, Z und Visible eines BS_RenderObjects sind relativ zu denen seines Vaters.
    // Außerdem sind die Objekte von links nach rechts in ihrer Renderreihenfolge sortiert.
    // Das primäre Sortierkriterium ist hierbei der Z-Wert und das sekundäre der Y-Wert (von oben nach unten).
    // Beispiel:
    //                  Screen
    //                 /  |   \.
    //               /    |     \.
    //             /      |       \.
    //           /        |         \.
    //     Background Interface   Maus
    //      /   \      /  |   \.
    //    /      \    /   |    \.
    // George   Tür Icn1 Icn2 Icn3
    //
    // Wenn jetzt das Interface mit SetVisible() ausgeblendet würde, verschwinden auch die Icons, die sich im Interface
    // befinden.
    // Wenn der Hintergrund bewegt wird (Scrolling), bewegen sich auch die darauf befindlichen Gegenstände und Personen.

    RenderObjectPtr<RenderObject> _parentPtr;
    RENDEROBJECT_LIST           _children;

    RenderObjectManager *getManager() const {
        return _managerPtr;
    }
    bool addObject(RenderObjectPtr<RenderObject> pObject);

private:
    bool _refreshForced;

    uint32 _handle;

    bool detatchChildren(RenderObjectPtr<RenderObject> pObject);
    void updateBoxes();
    Common::Rect calcBoundingBox() const;
    Common::Rect calcDirtyRect() const;
    void calcAbsolutePos(int32 &x, int32 &y, int32 &z) const;
    int32 calcAbsoluteX() const;
    int32 calcAbsoluteY() const;

    int32 calcAbsoluteZ() const;

    void sortRenderObjects();
    void validateObject();
    void updateAbsolutePos();
    void signalChildChange() {
        _childChanged = true;
    }
    bool getObjectIntersection(RenderObjectPtr<RenderObject> pObject, Common::Rect &result);
    static bool greater(const RenderObjectPtr<RenderObject> lhs, const RenderObjectPtr<RenderObject> rhs);
};

} // End of namespace Sword25

#endif