camera.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2013 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   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 TransformType {
            NoneTransform = 0x00,
            TiltTransform = 0x01,
            RotationTransform = 0x02,
            ZoomTransform = 0x04,
            PositionTransform = 0x08,
            ZTransform = 0x10
        };
        typedef uint32_t Transform;

        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;

        double getOriginalZToY() const;

        void setZToY(double zToY);

        double getZToY() const;

        void setZToYEnabled(bool enabled);

        bool isZToYEnabled() const;

        void setCellImageDimensions(uint32_t width, uint32_t height);

        Point getCellImageDimensions();

        Point getCellImageDimensions(Layer* layer);

        double getReferenceScaleX() const { return m_referenceScaleX; }

        double getReferenceScaleY() const { return m_referenceScaleY; }

        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;

        const Rect& getMapViewPort();

        Rect getLayerViewPort(Layer* layer);

        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();

        RenderList& getRenderListRef(Layer* layer);

        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();

        bool isUpdated() { return m_updated; }

        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();

        DoublePoint getLogicalCellDimensions(Layer* layer);

        Point getRealCellDimensions(Layer* layer);

        void renderOverlay();

        void renderStaticLayer(Layer* layer, bool update);

        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;
        double m_zToY;
        bool m_enabledZToY;
        Location m_location;
        ScreenPoint m_cur_origo;
        Rect m_viewport;
        Rect m_mapViewPort;
        bool m_mapViewPortUpdated;
        uint32_t m_screen_cell_width;
        uint32_t m_screen_cell_height;
        double m_referenceScaleX;
        double m_referenceScaleY;
        bool m_enabled;
        Instance* m_attachedto;
        // caches calculated image dimensions for already queried & calculated layers
        std::map<Layer*, Point> m_image_dimensions;
        // contains the geometry changes
        Transform m_transform;

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

        RenderBackend* m_renderbackend;

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

        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