instancerenderer.h

/***************************************************************************
 *   Copyright (C) 2005-2008 by the FIFE team                              *
 *   http://www.fifengine.de                                               *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_INSTANCERENDERER_H
#define FIFE_INSTANCERENDERER_H

// Standard C++ library includes
#include <string>
#include <list>

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "view/rendererbase.h"
#include "util/time/timer.h"

namespace FIFE {
    class Location;
    class RenderBackend;
    class InstanceDeleteListener;

    class InstanceRenderer: public RendererBase {
    public:
        InstanceRenderer(RenderBackend* renderbackend, int32_t position);

        InstanceRenderer(const InstanceRenderer& old);

        RendererBase* clone();

        virtual ~InstanceRenderer();
        void render(Camera* cam, Layer* layer, RenderList& instances);
        std::string getName() { return "InstanceRenderer"; }

        void addOutlined(Instance* instance, int32_t r, int32_t g, int32_t b, int32_t width, int32_t threshold = 1);

        void addColored(Instance* instance, int32_t r, int32_t g, int32_t b);

        void addTransparentArea(Instance* instance, const std::list<std::string> &groups, uint32_t w, uint32_t h, uint8_t trans, bool front = true);

        void removeOutlined(Instance* instance);

        void removeColored(Instance* instance);

        void removeTransparentArea(Instance* instance);

        void removeAllOutlines();

        void removeAllColored();

        void removeAllTransparentAreas();

        void addIgnoreLight(const std::list<std::string> &groups);

        void removeIgnoreLight(const std::list<std::string> &groups);

        void removeAllIgnoreLight();

        static InstanceRenderer* getInstance(IRendererContainer* cnt);

        RenderBackend* getRenderBackend() const {return m_renderbackend;}

        void reset();

        void setRemoveInterval(uint32_t interval);
        
        uint32_t getRemoveInterval() const;
        
        void addToCheck(const ImagePtr& image);

        void check();

        void removeInstance(Instance* instance);

        bool needColorBinding() { return m_need_bind_coloring; }

    private:
        bool m_area_layer;
        uint32_t m_interval;
        bool m_timer_enabled;
        std::list<std::string> m_unlit_groups;
        bool m_need_sorting;
        bool m_need_bind_coloring;

        enum InstanceRendererEffect {
            NOTHING = 0x00,
            OUTLINE = 0x01,
            COLOR = 0x02,
            AREA = 0x04
        };
        typedef uint8_t Effect;

        // contains per-instance information for outline drawing
        class OutlineInfo {
        public:
            uint8_t r;
            uint8_t g;
            uint8_t b;
            int32_t width;
            int32_t threshold;
            bool dirty;
            ImagePtr outline;
            Image* curimg;
            InstanceRenderer* renderer;
            OutlineInfo(InstanceRenderer* r);
            ~OutlineInfo();
        };
        // contains per-instance information for overlay drawing
        class ColoringInfo {
        public:
            uint8_t r;
            uint8_t g;
            uint8_t b;
            bool dirty;
            ImagePtr overlay;
            Image* curimg;
            InstanceRenderer* renderer;
            ColoringInfo(InstanceRenderer* r);
            ~ColoringInfo();
        };
        class AreaInfo {
        public:
            Instance* instance;
            std::list<std::string> groups;
            uint32_t w;
            uint32_t h;
            uint8_t trans;
            bool front;
            double z;
            AreaInfo();
            ~AreaInfo();
        };
        typedef std::map<Instance*, OutlineInfo> InstanceToOutlines_t;
        typedef std::map<Instance*, ColoringInfo> InstanceToColoring_t;
        typedef std::map<Instance*, AreaInfo> InstanceToAreas_t;

        InstanceToOutlines_t m_instance_outlines;
        InstanceToColoring_t m_instance_colorings;
        InstanceToAreas_t m_instance_areas;

        // struct to hold the ImagePtr with a timestamp
        typedef struct {
            ImagePtr image;
            uint32_t timestamp;
        } s_image_entry;
        typedef std::list<s_image_entry> ImagesToCheck_t;
        // old effect images
        ImagesToCheck_t m_check_images;
        // timer
        Timer m_timer;
        
        // InstanceDeleteListener to automatically remove Instance effect (outline, coloring, ...)
        InstanceDeleteListener* m_delete_listener;
        typedef std::map<Instance*, Effect> InstanceToEffects_t;
        InstanceToEffects_t m_assigned_instances;

        Image* bindOutline(OutlineInfo& info, RenderItem& vc, Camera* cam);
        Image* bindColoring(ColoringInfo& info, RenderItem& vc, Camera* cam);

        void renderUnsorted(Camera* cam, Layer* layer, RenderList& instances);
        void renderAlreadySorted(Camera* cam, Layer* layer, RenderList& instances);

        void removeFromCheck(const ImagePtr& image);
        bool isValidImage(const ImagePtr& image);
    };
}

#endif