camera.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_VIEW_CAMERA_H
#define FIFE_VIEW_CAMERA_H

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

// 3rd party library includes
#include <SDL.h>

// 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 "model/structures/location.h"
#include "util/structures/rect.h"
#include "util/math/matrix.h"
#include "video/animation.h"

#include "rendererbase.h"

namespace FIFE {

    typedef Point3D ScreenPoint;
    class Layer;
    class Instance;
    class RenderBackend;
    class LayerCache;
    class MapObserver;
    typedef std::map<Layer*, RenderList > t_layer_to_instances;

    class Camera: public IRendererListener, public IRendererContainer {
    public:
        enum Transform {
            NormalTransform = 0,
            WarpedTransform = 1
        };

        Camera(const std::string& id,
            Layer* layer,
            const Rect& viewport,
            RenderBackend* renderbackend);

        virtual ~Camera();

        const std::string& getId() const { return m_id; }

        void setId(const std::string& id) { m_id = id; }

        void setTilt(double tilt);

        double getTilt() const;

        void setRotation(double rotation);

        double getRotation() const;

        void setZoom(double zoom);

        double getZoom() const;

        void setCellImageDimensions(uint32_t width, uint32_t height);

        Point getCellImageDimensions();

        Point getCellImageDimensions(Layer* layer);

        double getReferenceScale() const { return m_reference_scale; }

        Point3D getZOffset(Layer* layer);

        void setLocation(const Location& location);

        Location getLocation() const;

        Point3D getOrigin() const;

        Location& getLocationRef();

        void attach(Instance *instance);

        void detach();

        Instance* getAttached() const { return m_attachedto; }

        void setViewPort(const Rect& viewport);

        const Rect& getViewPort() const;

        ExactModelCoordinate toMapCoordinates(ScreenPoint screen_coords, bool z_calculated=true);

        ScreenPoint toScreenCoordinates(const ExactModelCoordinate& map_coords);

        DoublePoint3D toVirtualScreenCoordinates(const ExactModelCoordinate& map_coords);

        ScreenPoint virtualScreenToScreen(const DoublePoint3D& p);
        DoublePoint3D screenToVirtualScreen(const ScreenPoint& p);

        void setEnabled(bool enabled);

        bool isEnabled();

        void getMatchingInstances(ScreenPoint screen_coords, Layer& layer, std::list<Instance*>& instances, uint8_t alpha = 0);

        void getMatchingInstances(Rect screen_rect, Layer& layer, std::list<Instance*>& instances, uint8_t alpha = 0);

        void getMatchingInstances(Location& loc, std::list<Instance*>& instances, bool use_exactcoordinates=false);

        void update();

        void refresh();

        void resetUpdates();

        void addRenderer(RendererBase* renderer);

        RendererBase* getRenderer(const std::string& name);

        void resetRenderers();

        void calculateZValue(ScreenPoint& screen_coords);

        void onRendererPipelinePositionChanged(RendererBase* renderer);

        void onRendererEnabledChanged(RendererBase* renderer);

        void setLightingColor(float red, float green, float blue);

        void resetLightingColor();

        std::vector<float> getLightingColor();

        void setOverlayColor(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);

        std::vector<uint8_t> getOverlayColor();

        void resetOverlayColor();

        void setOverlayImage(int32_t id, bool fill = false);

        int32_t getOverlayImage();

        void resetOverlayImage();

        void setOverlayAnimation(AnimationPtr anim, bool fill = false);

        AnimationPtr getOverlayAnimation();

        void resetOverlayAnimation();

        void render();

    private:
        friend class MapObserver;
        void addLayer(Layer* layer);
        void removeLayer(Layer* layer);
        void updateMap(Map* map);
        std::string m_id;


        void updateMatrices();

        void updateReferenceScale();

        void updateRenderLists();

        void cacheUpdate(Layer* layer);

        DoublePoint getLogicalCellDimensions(Layer* layer);

        Point getRealCellDimensions(Layer* layer);

        void renderOverlay();

        DoubleMatrix m_matrix;
        DoubleMatrix m_inverse_matrix;

        DoubleMatrix m_vs_matrix;
        DoubleMatrix m_vs_inverse_matrix;
        DoubleMatrix m_vscreen_2_screen;
        DoubleMatrix m_screen_2_vscreen;

        double m_tilt;
        double m_rotation;
        double m_zoom;
        Location m_location;
        ScreenPoint m_cur_origo;
        Rect m_viewport;
        bool m_view_updated;
        uint32_t m_screen_cell_width;
        uint32_t m_screen_cell_height;
        double m_reference_scale;
        bool m_enabled;
        Instance* m_attachedto;
        // caches calculated image dimensions for already queried & calculated layers
        std::map<Layer*, Point> m_image_dimensions;
        bool m_iswarped; // true, if the geometry had changed

        // list of renderers managed by the view
        std::map<std::string, RendererBase*> m_renderers;
        std::list<RendererBase*> m_pipeline;
        bool m_updated; // false, if view has not been updated

        RenderBackend* m_renderbackend;

        // caches layer -> instances structure between renders e.g. to fast query of mouse picking order
        t_layer_to_instances m_layer_to_instances;

        std::map<Layer*,LayerCache*> m_cache;
        MapObserver* m_map_observer;
        Map* m_map;

        // is lighting enable
        bool m_lighting;
        // caches the light color for the camera
        std::vector<float> m_light_colors;

        // overlay stuff
        bool m_col_overlay;
        bool m_img_overlay;
        bool m_ani_overlay;
        SDL_Color m_overlay_color;
        int32_t m_img_id;
        AnimationPtr m_ani_ptr;
        bool m_img_fill;
        bool m_ani_fill;
        uint32_t m_start_time;
    };
}
#endif