/***************************************************************************
 *   Copyright (C) 2005-2019 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          *
 ***************************************************************************/

// Standard C++ library includes

// 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 "model/metamodel/grids/cellgrid.h"
#include "model/metamodel/action.h"
#include "model/metamodel/timeprovider.h"
#include "model/structures/map.h"
#include "model/structures/layer.h"
#include "model/structures/instancetree.h"
#include "model/structures/instance.h"
#include "model/structures/location.h"
#include "util/log/logger.h"
#include "util/math/fife_math.h"
#include "util/math/angles.h"
#include "util/time/timemanager.h"
#include "video/renderbackend.h"
#include "video/image.h"
#include "video/animation.h"
#include "video/imagemanager.h"

#include "camera.h"
#include "layercache.h"
#include "visual.h"


namespace FIFE {
	static Logger _log(LM_CAMERA);

	// to avoid std::bad_alloc errors, we determine the maximum size of batches
	const uint32_t MAX_BATCH_SIZE = 100000;

	class MapObserver : public MapChangeListener {
		Camera* m_camera;

	public:
		MapObserver(Camera* camera) {
			m_camera = camera;
		}
		virtual ~MapObserver() {}

		virtual void onMapChanged(Map* map, std::vector<Layer*>& changedLayers) {
		}

		virtual void onLayerCreate(Map* map, Layer* layer) {
			m_camera->addLayer(layer);
		}

		virtual void onLayerDelete(Map* map, Layer* layer) {
			m_camera->removeLayer(layer);
		}
	};

	Camera::Camera(const std::string& id, Map* map, const Rect& viewport, RenderBackend* renderbackend) :
		m_id(id),
		m_map(map),
		m_viewport(viewport),
		m_renderbackend(renderbackend),
		m_position(ExactModelCoordinate(0, 0, 0)),
		m_matrix(),
		m_inverse_matrix(),
		m_tilt(0),
		m_rotation(0),
		m_zoom(1),
		m_zToY(0),
		m_enabledZToY(false),
		m_location(),
		m_curOrigin(ScreenPoint(0, 0, 0)),
		m_mapViewPort(),
		m_mapViewPortUpdated(false),
		m_screenCellWidth(1),
		m_screenCellHeight(1),
		m_referenceScaleX(1),
		m_referenceScaleY(1),
		m_enabled(true),
		m_attachedTo(NULL),
		m_transform(NoneTransform),
		m_renderers(),
		m_pipeline(),
		m_updated(false),
		m_layerToInstances(),
		m_lighting(false),
		m_light_colors(),
		m_col_overlay(false),
		m_img_overlay(false),
		m_ani_overlay(false) {

		m_map_observer = new MapObserver(this);
		init();
	}

	Camera::~Camera() {
		// Trigger removal of LayerCaches and MapObserver
		if (m_map) {
			m_map->removeChangeListener(m_map_observer);
			const std::list<Layer*>& layers = m_map->getLayers();
			for (std::list<Layer*>::const_iterator i = layers.begin(); i != layers.end(); ++i) {
				removeLayer(*i);
			}
		}

		std::map<std::string, RendererBase*>::iterator r_it = m_renderers.begin();
		for(; r_it != m_renderers.end(); ++r_it) {
			r_it->second->reset();
			delete r_it->second;
		}
		m_renderers.clear();
		delete m_map_observer;
	}

	void Camera::init() {
		m_transform |= PositionTransform;
		updateMatrices();

		m_curOrigin = toScreenCoordinates(m_position);

		// Trigger addition of LayerCaches and MapObserver
		m_map->addChangeListener(m_map_observer);
		const std::list<Layer*>& layers = m_map->getLayers();
		for (std::list<Layer*>::const_iterator i = layers.begin(); i != layers.end(); ++i) {
			addLayer(*i);
		}
	}

	void Camera::setTilt(double tilt) {
		if (!Mathd::Equal(m_tilt, tilt)) {
			m_transform |= TiltTransform;
			m_tilt = tilt;
			updateReferenceScale();
			updateMatrices();
		}
	}

	double Camera::getTilt() const {
		return m_tilt;
	}

	void Camera::setRotation(double rotation) {
		if (!Mathd::Equal(m_rotation, rotation)) {
			m_transform |= RotationTransform;
			m_rotation = rotation;
			updateReferenceScale();
			updateMatrices();
		}
	}

	double Camera::getRotation() const {
		return m_rotation;
	}

	void Camera::setZoom(double zoom) {
		if (!Mathd::Equal(m_zoom, zoom)) {
			m_transform |= ZoomTransform;
			m_zoom = zoom;
			if (m_zoom < 0.001) {
				m_zoom = 0.001;
			}
			updateMatrices();
		}
	}

	double Camera::getZoom() const {
		return m_zoom;
	}

	double Camera::getOriginalZToY() const {
		DoubleMatrix matrix;
		matrix.loadScale(m_referenceScaleX, m_referenceScaleY, m_referenceScaleX);
		if (m_location.getLayer()) {
			CellGrid* cg = m_location.getLayer()->getCellGrid();
			if (cg) {
				ExactModelCoordinate pt = m_location.getMapCoordinates();
				matrix.applyTranslate(-pt.x*m_referenceScaleX, -pt.y*m_referenceScaleY, -pt.z*m_referenceScaleX);
			}
		}
		matrix.applyRotate(-m_rotation, 0.0, 0.0, 1.0);
		matrix.applyRotate(-m_tilt, 1.0, 0.0, 0.0);
		return matrix.m9 * -1.0;
	}

	void Camera::setZToY(double zToY) {
		m_enabledZToY = true;
		if (!Mathd::Equal(m_zToY, zToY)) {
			m_transform |= ZTransform;
			m_zToY = zToY;
			updateMatrices();
		}
	}

	double Camera::getZToY() const {
		return m_zToY;
	}

	void Camera::setZToYEnabled(bool enabled) {
		m_enabledZToY = enabled;
	}

	bool Camera::isZToYEnabled() const {
		return m_enabledZToY;
	}

	void Camera::setCellImageDimensions(uint32_t width, uint32_t height) {
		m_screenCellWidth = width;
		m_screenCellHeight = height;
		updateReferenceScale();
		updateMatrices();
		m_transform |= PositionTransform;
	}

	void Camera::setLocation(const Location& location) {
		if (m_location == location) {
			return;
		}

		CellGrid* cell_grid = NULL;
		if (location.getLayer()) {
			cell_grid = location.getLayer()->getCellGrid();
			if (!cell_grid) {
				throw Exception("Location layer without cellgrid given to Camera::setLocation");
			}
		}
		else {
			throw Exception("Location without layer given to Camera::setLocation");
		}

		m_transform |= PositionTransform;
		m_location = location;
		m_position = m_location.getMapCoordinates();
		updateMatrices();
		m_curOrigin = toScreenCoordinates(m_position);
	}

	Point Camera::getCellImageDimensions() {
		return Point(m_screenCellWidth, m_screenCellHeight);
	}

	Point Camera::getCellImageDimensions(Layer* layer) {
		Point p;
		DoublePoint dimensions = getLogicalCellDimensions(layer);
		p.x = static_cast<int32_t>(round(m_referenceScaleX * dimensions.x));
		p.y = static_cast<int32_t>(round(m_referenceScaleY * dimensions.y));
		return p;
	}

	Location Camera::getLocation() {
		if (m_location.getLayer()) {
			m_location.setMapCoordinates(m_position);
			return m_location;
		}
		Location loc = Location();
		if (m_map && m_map->getLayerCount() > 0) {
			loc.setLayer(m_map->getLayers().back());
			loc.setMapCoordinates(m_position);
		}
		return loc;
	}

	void Camera::setViewPort(const Rect& viewport) {
		m_viewport = viewport;
		refresh();
	}

	const Rect& Camera::getViewPort() const {
		return m_viewport;
	}

	const Rect& Camera::getMapViewPort() {
		if (!m_mapViewPortUpdated) {
			ScreenPoint sp1(m_viewport.x, m_viewport.y);
			ScreenPoint sp2(m_viewport.x, m_viewport.y + m_viewport.h);
			ScreenPoint sp3(m_viewport.x + m_viewport.w, m_viewport.y);
			ScreenPoint sp4(m_viewport.x + m_viewport.w, m_viewport.y + m_viewport.h);

			std::vector<ExactModelCoordinate> coords;
			coords.push_back(toMapCoordinates(sp2, false));
			coords.push_back(toMapCoordinates(sp3, false));
			coords.push_back(toMapCoordinates(sp4, false));

			ExactModelCoordinate emc = toMapCoordinates(sp1, false);
			ModelCoordinate min(static_cast<int32_t>(emc.x), static_cast<int32_t>(emc.y));
			ModelCoordinate max(static_cast<int32_t>(emc.x+0.5), static_cast<int32_t>(emc.y+0.5));
			std::vector<ExactModelCoordinate>::iterator it = coords.begin();
			for (; it != coords.end(); ++it) {
				min.x = std::min(min.x, static_cast<int32_t>((*it).x));
				min.y = std::min(min.y, static_cast<int32_t>((*it).y));
				max.x = std::max(max.x, static_cast<int32_t>((*it).x+0.5));
				max.y = std::max(max.y, static_cast<int32_t>((*it).y+0.5));
			}
			// makes the viewport a bit larger
			m_mapViewPort.x = min.x - 1;
			m_mapViewPort.y = min.y - 1;
			m_mapViewPort.w = ABS(max.x - min.x) + 2;
			m_mapViewPort.h = ABS(max.y - min.y) + 2;
			m_mapViewPortUpdated = true;
		}

		return m_mapViewPort;
	}

	Rect Camera::getLayerViewPort(Layer* layer) {
		Rect mapView = getMapViewPort();
		Location loc(layer);
		ExactModelCoordinate emc(mapView.x, mapView.y);
		loc.setMapCoordinates(emc);
		emc.x = mapView.x+mapView.w;
		emc.y = mapView.y+mapView.h;
		mapView.x = loc.getLayerCoordinates().x;
		mapView.y = loc.getLayerCoordinates().y;
		loc.setMapCoordinates(emc);
		mapView.w = ABS(loc.getLayerCoordinates().x - mapView.x);
		mapView.h = ABS(loc.getLayerCoordinates().y - mapView.y);

		return mapView;
	}

	void Camera::setEnabled(bool enabled) {
		m_enabled = enabled;
	}

	bool Camera::isEnabled() {
		return m_enabled;
	}

	void Camera::setPosition(const ExactModelCoordinate& position) {
		if (Mathd::Equal(m_position.x, position.x) && Mathd::Equal(m_position.y, position.y)) {
			return;
		}
		m_transform |= PositionTransform;
		m_position = position;
		updateMatrices();
		m_curOrigin = toScreenCoordinates(m_position);
	}

	ExactModelCoordinate Camera::getPosition() const {
		return m_position;
	}

	Point3D Camera::getOrigin() const {
		return m_curOrigin;
	}

	void Camera::updateMatrices() {
		m_matrix.loadScale(m_referenceScaleX, m_referenceScaleY, m_referenceScaleX);
		m_vs_matrix.loadScale(m_referenceScaleX, m_referenceScaleY, m_referenceScaleX);

		m_matrix.applyTranslate(-m_position.x*m_referenceScaleX, -m_position.y*m_referenceScaleY, -m_position.z*m_referenceScaleX);

		m_matrix.applyRotate(-m_rotation, 0.0, 0.0, 1.0);
		m_matrix.applyRotate(-m_tilt, 1.0, 0.0, 0.0);
		if (m_enabledZToY) {
			m_matrix.m9 = -m_zToY; // z -> y height in pixels
		}
		double scale = m_zoom;
		m_matrix.applyScale(scale, scale, scale);
		m_matrix.applyTranslate(+m_viewport.x+m_viewport.w/2, +m_viewport.y+m_viewport.h/2, 0);
		m_inverse_matrix = m_matrix.inverse();

		m_vs_matrix.applyRotate(-m_rotation, 0.0, 0.0, 1.0);
		m_vs_matrix.applyRotate(-m_tilt, 1.0, 0.0, 0.0);
		if (m_enabledZToY) {
			m_vs_matrix.m9 = -m_zToY; // z -> y height in pixels
		}
		m_vs_inverse_matrix = m_vs_matrix.inverse();

		// calculate the screen<->virtual screen transformation
		// this explicitly ignores the z-value.
		m_vscreen_2_screen = m_matrix;
		// NOTE: mult4by4 is an in-place modification.
		m_vscreen_2_screen.mult4by4(m_vs_inverse_matrix);
		// set the z transformation to unity
		const int32_t N=4;
		for(int32_t i=0; i!=N; ++i) {
			  m_vscreen_2_screen[2*N + i] = 0;
			  m_vscreen_2_screen[i*N + 2] = 0;
		}
		m_vscreen_2_screen[2*N + 2] = 1;
		m_screen_2_vscreen = m_vscreen_2_screen.inverse();

		m_mapViewPortUpdated = false;
		// FL_WARN(_log, LMsg("matrix: ") << m_matrix << " 1: " << m_matrix.inverse().mult4by4(m_matrix));
// 		FL_WARN(_log, LMsg("vs2s matrix: ") << m_vscreen_2_screen << " s2vs matrix: " << m_screen_2_vscreen);
	}

	void Camera::calculateZValue(DoublePoint3D& screen_coords) {
		int32_t dy = -(screen_coords.y - toScreenCoordinates(m_position).y);
		screen_coords.z = Mathd::Tan(m_tilt * (Mathd::pi() / 180.0)) * static_cast<double>(dy);
	}

	ExactModelCoordinate Camera::toMapCoordinates(ScreenPoint screen_coords, bool z_calculated) {
		DoublePoint3D double_screen_coords = intPt2doublePt(screen_coords);
		if (!z_calculated) {
			calculateZValue(double_screen_coords);
		}
		return m_inverse_matrix * double_screen_coords;
	}

	ScreenPoint Camera::toScreenCoordinates(const ExactModelCoordinate& elevation_coords) {
		ScreenPoint pt = doublePt2intPt(m_matrix * elevation_coords);
		return pt;
	}

	DoublePoint3D Camera::toVirtualScreenCoordinates(const ExactModelCoordinate& elevation_coords) {
		DoublePoint3D pt = (m_vs_matrix * elevation_coords);
		return pt;
	}

	ScreenPoint Camera::virtualScreenToScreen(const DoublePoint3D& p) {
		return doublePt2intPt(m_vscreen_2_screen * p);
	}

	DoublePoint3D Camera::screenToVirtualScreen(const ScreenPoint& p) {
		return m_screen_2_vscreen * intPt2doublePt(p);
	}

	DoublePoint Camera::getLogicalCellDimensions(Layer* layer) {
		assert(layer);
		CellGrid* cg = layer->getCellGrid();
		assert(cg);

		ModelCoordinate cell(0,0);
		std::vector<ExactModelCoordinate> vertices;
		cg->getVertices(vertices, cell);

		DoubleMatrix mtx;
		mtx.loadRotate(m_rotation, 0.0, 0.0, 1.0);
		mtx.applyRotate(m_tilt, 1.0, 0.0, 0.0);

		double x1 = 0;
		double x2 = 0;
		double y1 = 0;
		double y2 = 0;

		for (uint32_t i = 0; i < vertices.size(); i++) {
			vertices[i] = cg->toMapCoordinates(vertices[i]);
			vertices[i] = mtx * vertices[i];
			if (i == 0) {
				x1 = x2 = vertices[0].x;
				y1 = y2 = vertices[0].y;
			} else {
				x1 = std::min(vertices[i].x, x1);
				x2 = std::max(vertices[i].x, x2);
				y1 = std::min(vertices[i].y, y1);
				y2 = std::max(vertices[i].y, y2);
			}
		}
		return DoublePoint( x2 - x1, y2 - y1 );
	}

	DoublePoint Camera::getLogicalCellDimensions() {
		std::vector<ExactModelCoordinate> vertices;
		vertices.push_back(ExactModelCoordinate(-0.5, -0.5));
		vertices.push_back(ExactModelCoordinate(0.5, -0.5));
		vertices.push_back(ExactModelCoordinate(0.5, 0.5));
		vertices.push_back(ExactModelCoordinate(-0.5, 0.5));

		DoubleMatrix mtx;
		mtx.loadRotate(m_rotation, 0.0, 0.0, 1.0);
		mtx.applyRotate(m_tilt, 1.0, 0.0, 0.0);

		double x1 = 0;
		double x2 = 0;
		double y1 = 0;
		double y2 = 0;

		for (uint32_t i = 0; i < vertices.size(); i++) {
			vertices[i] = mtx * vertices[i];
			if (i == 0) {
				x1 = x2 = vertices[0].x;
				y1 = y2 = vertices[0].y;
			}
			else {
				x1 = std::min(vertices[i].x, x1);
				x2 = std::max(vertices[i].x, x2);
				y1 = std::min(vertices[i].y, y1);
				y2 = std::max(vertices[i].y, y2);
			}
		}
		return DoublePoint(x2 - x1, y2 - y1);
	}

	void Camera::updateReferenceScale() {
		DoublePoint dim = getLogicalCellDimensions();
		m_referenceScaleX = static_cast<double>(m_screenCellWidth) / dim.x;
		m_referenceScaleY = static_cast<double>(m_screenCellHeight) / dim.y;

		FL_DBG(_log, "Updating reference scale");
		FL_DBG(_log, LMsg("   tilt=") << m_tilt << " rot=" << m_rotation);
		FL_DBG(_log, LMsg("   m_screenCellWidth=") << m_screenCellWidth);
		FL_DBG(_log, LMsg("   m_screenCellHeight=") << m_screenCellHeight);
		FL_DBG(_log, LMsg("   m_referenceScaleX=") << m_referenceScaleX);
		FL_DBG(_log, LMsg("   m_referenceScaleY=") << m_referenceScaleY);
	}

	RenderList& Camera::getRenderListRef(Layer* layer) {
		return m_layerToInstances[layer];
	}

	void Camera::getMatchingInstances(ScreenPoint screen_coords, Layer& layer, std::list<Instance*>& instances, uint8_t alpha) {
		instances.clear();
		bool zoomed = !Mathd::Equal(m_zoom, 1.0);
		bool special_alpha = alpha != 0;

		const RenderList& layer_instances = m_layerToInstances[&layer];
		RenderList::const_iterator instance_it = layer_instances.end();
		while (instance_it != layer_instances.begin()) {
			--instance_it;
			Instance* i = (*instance_it)->instance;
			const RenderItem& vc = **instance_it;
			if ((vc.dimensions.contains(Point(screen_coords.x, screen_coords.y)))) {
				if(vc.image->isSharedImage()) {
					vc.image->forceLoadInternal();
				}
				uint8_t r, g, b, a = 0;
				int32_t x = screen_coords.x - vc.dimensions.x;
				int32_t y = screen_coords.y - vc.dimensions.y;
				if (zoomed) {
					double fx = static_cast<double>(x);
					double fy = static_cast<double>(y);
					double fow = static_cast<double>(vc.image->getWidth());
					double foh = static_cast<double>(vc.image->getHeight());
					double fsw = static_cast<double>(vc.dimensions.w);
					double fsh = static_cast<double>(vc.dimensions.h);
					x = static_cast<int32_t>(round(fx / fsw * fow));
					y = static_cast<int32_t>(round(fy / fsh * foh));
				}
				if (vc.getAnimationOverlay()) {
					std::vector<ImagePtr>* ao = vc.getAnimationOverlay();
					std::vector<ImagePtr>::iterator it = ao->begin();
					for (; it != ao->end(); ++it) {
						if ((*it)->isSharedImage()) {
							(*it)->forceLoadInternal();
						}
						(*it)->getPixelRGBA(x, y, &r, &g, &b, &a);
						// instance is hit with mouse if not totally transparent
						if (a == 0 || (special_alpha && a < alpha)) {
							continue;
						}
						instances.push_back(i);
						break;
					}
				} else {
					vc.image->getPixelRGBA(x, y, &r, &g, &b, &a);
					// instance is hit with mouse if not totally transparent
					if (a == 0 || (special_alpha && a < alpha)) {
						continue;
					}
					instances.push_back(i);
				}
			}
		}
	}

	void Camera::getMatchingInstances(Rect screen_rect, Layer& layer, std::list<Instance*>& instances, uint8_t alpha) {
		instances.clear();
		bool zoomed = !Mathd::Equal(m_zoom, 1.0);
		bool special_alpha = alpha != 0;

		const RenderList& layer_instances = m_layerToInstances[&layer];
		RenderList::const_iterator instance_it = layer_instances.end();
		while (instance_it != layer_instances.begin()) {
			--instance_it;
			Instance* i = (*instance_it)->instance;;
			const RenderItem& vc = **instance_it;
			if ((vc.dimensions.intersects(screen_rect))) {
				if(vc.image->isSharedImage()) {
					vc.image->forceLoadInternal();
				}
				uint8_t r, g, b, a = 0;
				int32_t intersection_left = std::max(screen_rect.x, vc.dimensions.x);
				int32_t intersection_right = std::min(screen_rect.right(), vc.dimensions.right());
				int32_t intersection_top = std::max(screen_rect.y, vc.dimensions.y);
				int32_t intersection_bottom = std::min(screen_rect.bottom(), vc.dimensions.bottom());

				for(int32_t xx = intersection_left; xx < intersection_right; xx++) {
					for(int32_t yy = intersection_top; yy < intersection_bottom; yy++) {
						int32_t x = xx - vc.dimensions.x;
						int32_t y = yy - vc.dimensions.y;
						if (zoomed) {
							double fx = static_cast<double>(x);
							double fy = static_cast<double>(y);
							double fow = static_cast<double>(vc.image->getWidth());
							double foh = static_cast<double>(vc.image->getHeight());
							double fsw = static_cast<double>(vc.dimensions.w);
							double fsh = static_cast<double>(vc.dimensions.h);
							x = static_cast<int32_t>(round(fx / fsw * fow));
							y = static_cast<int32_t>(round(fy / fsh * foh));
						}
						if (vc.getAnimationOverlay()) {
							std::vector<ImagePtr>* ao = vc.getAnimationOverlay();
							std::vector<ImagePtr>::iterator it = ao->begin();
							for (; it != ao->end(); ++it) {
								if ((*it)->isSharedImage()) {
									(*it)->forceLoadInternal();
								}
								(*it)->getPixelRGBA(x, y, &r, &g, &b, &a);
								// instance is hit with mouse if not totally transparent
								if (a == 0 || (special_alpha && a < alpha)) {
									continue;
								}
								instances.push_back(i);
								goto found_non_transparent_pixel;
							}
						} else {
							vc.image->getPixelRGBA(x, y, &r, &g, &b, &a);
							// instance is hit with mouse if not totally transparent
							if (a == 0 || (special_alpha && a < alpha)) {
								continue;
							}
							instances.push_back(i);
							goto found_non_transparent_pixel;
						}
					}
				}
				found_non_transparent_pixel:;
			}
		}
	}

	void Camera::getMatchingInstances(Location& loc, std::list<Instance*>& instances, bool use_exactcoordinates) {
		instances.clear();
		Layer* layer = loc.getLayer();
		if(!layer) {
			return;
		}

		const RenderList& layer_instances = m_layerToInstances[layer];
		RenderList::const_iterator instance_it = layer_instances.end();
		while (instance_it != layer_instances.begin()) {
			--instance_it;
			Instance* i = (*instance_it)->instance;
			if (use_exactcoordinates) {
				if (i->getLocationRef().getExactLayerCoordinatesRef() == loc.getExactLayerCoordinatesRef()) {
					instances.push_back(i);
				}
			} else {
				if (i->getLocationRef().getLayerCoordinates() == loc.getLayerCoordinates()) {
					instances.push_back(i);
				}
			}
		}
	}

	void Camera::attach(Instance *instance) {
		if (instance && instance != m_attachedTo) {
			m_attachedTo = instance;
		}
	}

	void Camera::detach() {
		m_attachedTo = NULL;
	}

	void Camera::update() {
		if (!m_attachedTo) {
			return;
		}
		ExactModelCoordinate pos = m_attachedTo->getLocationRef().getMapCoordinates();
		if (Mathd::Equal(m_position.x, pos.x) && Mathd::Equal(m_position.y, pos.y)) {
			return;
		}
		m_transform |= PositionTransform;
		m_position = pos;
		updateMatrices();
		m_curOrigin = toScreenCoordinates(m_position);
	}

	void Camera::refresh() {
		updateMatrices();
		m_transform |= RotationTransform;
		m_curOrigin = toScreenCoordinates(m_position);
	}

	void Camera::resetUpdates() {
		if (m_transform == NoneTransform) {
			m_updated = false;
		} else {
			m_updated = true;
		}
		m_transform = NoneTransform;
	}

	bool pipelineSort(const RendererBase* lhs, const RendererBase* rhs) {
		return (lhs->getPipelinePosition() < rhs->getPipelinePosition());
	}

	void Camera::addRenderer(RendererBase* renderer) {
		renderer->setRendererListener(this);
		m_renderers[renderer->getName()] = renderer;
		if (renderer->isEnabled()) {
			m_pipeline.push_back(renderer);
		}
		m_pipeline.sort(pipelineSort);
	}

	void Camera::onRendererPipelinePositionChanged(RendererBase* renderer) {
		m_pipeline.sort(pipelineSort);
	}

	void Camera::onRendererEnabledChanged(RendererBase* renderer) {
		assert(m_renderers[renderer->getName()]);
		if (renderer->isEnabled()) {
			FL_LOG(_log, LMsg("Enabling renderer ") << renderer->getName());
			m_pipeline.push_back(renderer);
			m_pipeline.sort(pipelineSort);
		} else {
			m_pipeline.remove(renderer);
		}
	}

	RendererBase* Camera::getRenderer(const std::string& name) {
		return m_renderers[name];
	}

	void Camera::resetRenderers() {
		std::map<std::string, RendererBase*>::iterator r_it = m_renderers.begin();
		for (; r_it != m_renderers.end(); ++r_it) {
			r_it->second->reset();
		}
	}

	void Camera::addLayer(Layer* layer) {
		m_cache[layer] = new LayerCache(this);
		m_cache[layer]->setLayer(layer);
		m_layerToInstances[layer] = RenderList();
		refresh();
	}

	void Camera::removeLayer(Layer* layer) {
		delete m_cache[layer];
		m_cache.erase(layer);
		m_layerToInstances.erase(layer);
		if (m_location.getLayer() == layer) {
			m_location.reset();
		}
		refresh();
	}

	void Camera::setLightingColor(float red, float green, float blue) {
		m_lighting = true;
		m_light_colors.clear();
		m_light_colors.push_back(red);
		m_light_colors.push_back(green);
		m_light_colors.push_back(blue);
	}

	std::vector<float> Camera::getLightingColor() {
		if(m_light_colors.empty()) {
			for(int32_t colors = 0; colors != 3; ++colors) {
				m_light_colors.push_back(1.0f);
			}
		}
		return m_light_colors;
	}

	void Camera::resetLightingColor() {
		m_lighting = false;
		m_renderbackend->resetLighting();
	}

	void Camera::setOverlayColor(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) {
		m_col_overlay = true;
		m_overlay_color.r = red;
		m_overlay_color.g = green;
		m_overlay_color.b = blue;
		m_overlay_color.a = alpha;
	}

	std::vector<uint8_t> Camera::getOverlayColor() {
		std::vector<uint8_t> colors;
		if (m_col_overlay) {
			colors.push_back(m_overlay_color.r);
			colors.push_back(m_overlay_color.g);
			colors.push_back(m_overlay_color.b);
			colors.push_back(m_overlay_color.a);
		} else {
			for(uint8_t cc = 0; cc != 4; ++cc) {
				colors.push_back(255);
			}
		}
		return colors;
	}

	void Camera::resetOverlayColor() {
		m_col_overlay = false;
	}

	void Camera::setOverlayImage(int32_t id, bool fill) {
		m_img_overlay = true;
		m_img_id = id;
		m_img_fill = fill;
	}

	int32_t Camera::getOverlayImage() {
		int32_t id = -1;
		if (m_img_overlay) {
			id = m_img_id;
		}
		return id;
	}

	void Camera::resetOverlayImage() {
		m_img_overlay = false;
		m_img_id = -1;
	}

	void Camera::setOverlayAnimation(AnimationPtr anim, bool fill) {
		m_ani_overlay = true;
		m_ani_ptr = anim;
		m_ani_fill = fill;
		m_start_time = 0;
	}

	AnimationPtr Camera::getOverlayAnimation() {
		return m_ani_ptr;
	}

	void Camera::resetOverlayAnimation() {
		m_ani_overlay = false;
		m_ani_ptr.reset();
	}

	void Camera::renderOverlay() {
		if (!m_col_overlay && !m_img_overlay && !m_ani_overlay) {
			return;
		}
		uint16_t width = m_viewport.w;
		uint16_t height = m_viewport.h;
		Point pm = Point(m_viewport.x + width/2, m_viewport.y + height/2);
		Rect r;

		// color overlay
		if (m_col_overlay) {
			Point p = Point(m_viewport.x, m_viewport.y);
			m_renderbackend->fillRectangle(p, width, height, m_overlay_color.r, m_overlay_color.g, m_overlay_color.b, m_overlay_color.a);
		}
		// image overlay
		if (m_img_overlay) {
			ImagePtr resptr = ImageManager::instance()->get(m_img_id);
			Image* img = resptr.get();
			if (img) {
				if (m_img_fill) {
					r.w = width;
					r.h = height;
				} else {
					r.w = img->getWidth();
					r.h = img->getHeight();
				}
				r.x = pm.x-r.w/2;
				r.y = pm.y-r.h/2;
				img->render(r);
			}
		}
		// animation overlay
		if (m_ani_overlay) {
			assert(m_ani_ptr != 0);

			if (m_start_time == 0) {
				m_start_time = TimeManager::instance()->getTime();
			}
			uint32_t animtime = scaleTime(1.0, TimeManager::instance()->getTime() - m_start_time) % m_ani_ptr->getDuration();
			ImagePtr img = m_ani_ptr->getFrameByTimestamp(animtime);
			if (img) {
				if (m_ani_fill) {
					r.w = width;
					r.h = height;
				} else {
					r.w = img->getWidth();
					r.h = img->getHeight();
				}
				r.x = pm.x-r.w/2;
				r.y = pm.y-r.h/2;
				img->render(r);
			}
		}
	}

	void Camera::renderStaticLayer(Layer* layer, bool update) {
		// ToDo: Remove this function from the camera class to something like engine pre-render.
		// ToDo: Check if partial rendering of only updated RenderItems to existing FBO is possible/faster in our case.
		// ToDo: Add and fix support for SDL backend, for SDL it works only on the lowest layer(alpha/transparent bug).
		LayerCache* cache = m_cache[layer];
		ImagePtr cacheImage = cache->getCacheImage();
		if (!cacheImage.get()) {
			// the cacheImage name will be, camera id + _virtual_layer_image_ + layer id
			cacheImage = ImageManager::instance()->loadBlank(m_id+"_virtual_layer_image_"+layer->getId(), m_viewport.w, m_viewport.h);
			cache->setCacheImage(cacheImage);
			update = true;
		}
		if (update) {
			// for the case that the viewport size is not the same as the screen size,
			// we have to change the values for OpenGL backend
			Rect rec(0, m_renderbackend->getHeight()-m_viewport.h, m_viewport.w, m_viewport.h);
			if (m_renderbackend->getName() == "SDL") {
				rec = m_viewport;
			}
			m_renderbackend->attachRenderTarget(cacheImage, true);
			// here we use the new viewport size
			m_renderbackend->pushClipArea(rec, false);
			// render stuff to texture
			RenderList& instancesToRender = m_layerToInstances[layer];
			// split the RenderList into smaller parts
			if (instancesToRender.size() > MAX_BATCH_SIZE) {
				uint8_t batches = ceil(instancesToRender.size() / static_cast<float>(MAX_BATCH_SIZE));
				uint32_t residual = instancesToRender.size() % MAX_BATCH_SIZE;
				for (uint8_t i = 0; i < batches; ++i) {
					uint32_t start = i*MAX_BATCH_SIZE;
					uint32_t end = start + ((i+1 == batches) ? residual : MAX_BATCH_SIZE);
					RenderList tempList(instancesToRender.begin() + start, instancesToRender.begin() + end);
					std::list<RendererBase*>::iterator r_it = m_pipeline.begin();
					for (; r_it != m_pipeline.end(); ++r_it) {
						if ((*r_it)->isActivedLayer(layer)) {
							(*r_it)->render(this, layer, tempList);
							m_renderbackend->renderVertexArrays();
						}
					}
				}
			} else {
				std::list<RendererBase*>::iterator r_it = m_pipeline.begin();
				for (; r_it != m_pipeline.end(); ++r_it) {
					if ((*r_it)->isActivedLayer(layer)) {
						(*r_it)->render(this, layer, instancesToRender);
						m_renderbackend->renderVertexArrays();
					}
				}
			}
			m_renderbackend->detachRenderTarget();
			m_renderbackend->popClipArea();
		}
	}

	void Camera::updateRenderLists() {
		if (!m_map) {
			FL_ERR(_log, "No map for camera found");
			return;
		}

		const std::list<Layer*>& layers = m_map->getLayers();
		std::list<Layer*>::const_iterator layer_it = layers.begin();
		for (;layer_it != layers.end(); ++layer_it) {
			LayerCache* cache = m_cache[*layer_it];
			if(!cache) {
				addLayer(*layer_it);
				cache = m_cache[*layer_it];
				FL_ERR(_log, LMsg("Layer Cache miss! (This shouldn't happen!)") << (*layer_it)->getId());
			}
			RenderList& instancesToRender = m_layerToInstances[*layer_it];
			if ((*layer_it)->isStatic() && m_transform == NoneTransform) {
				continue;
			}
			cache->update(m_transform, instancesToRender);
		}
		resetUpdates();
	}

	void Camera::render() {
		updateRenderLists();

		if (!m_map) {
			return;
		}

		uint32_t lm = m_renderbackend->getLightingModel();
		if (lm != 0) {
			m_renderbackend->resetStencilBuffer(0);
			if (m_lighting) {
				m_renderbackend->setLighting(m_light_colors[0], m_light_colors[1], m_light_colors[2]);
			}
		}

		const std::list<Layer*>& layers = m_map->getLayers();
		std::list<Layer*>::const_iterator layer_it = layers.begin();
		for ( ; layer_it != layers.end(); ++layer_it) {
			// layer with static flag will rendered as one texture
			if ((*layer_it)->isStatic()) {
				renderStaticLayer(*layer_it, m_updated);
				continue;
			}
		}

		m_renderbackend->pushClipArea(getViewPort());

		layer_it = layers.begin();
		for ( ; layer_it != layers.end(); ++layer_it) {
			// layer with static flag will rendered as one texture
			if ((*layer_it)->isStatic()) {
				m_cache[*layer_it]->getCacheImage()->render(m_viewport);
				m_renderbackend->renderVertexArrays();
				continue;
			}
			RenderList& instancesToRender = m_layerToInstances[*layer_it];
			// split the RenderList into smaller parts
			if (instancesToRender.size() > MAX_BATCH_SIZE) {
				uint8_t batches = ceil(instancesToRender.size() / static_cast<float>(MAX_BATCH_SIZE));
				uint32_t residual = instancesToRender.size() % MAX_BATCH_SIZE;
				for (uint8_t i = 0; i < batches; ++i) {
					uint32_t start = i*MAX_BATCH_SIZE;
					uint32_t end = start + ((i+1 == batches) ? residual : MAX_BATCH_SIZE);
					RenderList tempList(instancesToRender.begin() + start, instancesToRender.begin() + end);
					std::list<RendererBase*>::iterator r_it = m_pipeline.begin();
					for (; r_it != m_pipeline.end(); ++r_it) {
						if ((*r_it)->isActivedLayer(*layer_it)) {
							(*r_it)->render(this, *layer_it, tempList);
							m_renderbackend->renderVertexArrays();
						}
					}
				}
			} else {
				std::list<RendererBase*>::iterator r_it = m_pipeline.begin();
				for (; r_it != m_pipeline.end(); ++r_it) {
					if ((*r_it)->isActivedLayer(*layer_it)) {
						(*r_it)->render(this, *layer_it, instancesToRender);
						m_renderbackend->renderVertexArrays();
					}
				}
			}
		}

		renderOverlay();
		m_renderbackend->renderVertexArrays();
		if (m_lighting && lm != 0) {
			m_renderbackend->resetLighting();
		}
		m_renderbackend->popClipArea();
	}
}
