fife-parpg: engine/core/view/camera.cpp comparison

comparison engine/core/view/camera.cpp @ 405:cfe2f6db4964

Reverting my last change to camera.cpp. It caused unexpected results with rotated tiles.

author	prock@33b003aa-7bff-0310-803a-e67f0ece8222
date	Fri, 29 Jan 2010 15:55:47 +0000
parents	d98e398d3057
children	f27880d4c08c

comparison

equal deleted inserted replaced

-:0ef7b088b3f8
+:cfe2f6db4964
 namespace FIFE {
 	static Logger _log(LM_CAMERA);
 	Camera::Camera(const std::string& id,
 		Layer *layer,
 		Rect viewport,
 		ExactModelCoordinate emc,
 		RenderBackend* renderbackend,
 		ImagePool* ipool,
 		AnimationPool* apool):
 			m_id(id),
 		if ((m_prev_origo == m_cur_origo) && (m_prev_origo == ScreenPoint(0,0,0))) {
 			m_cur_origo = toScreenCoordinates(ExactModelCoordinate(0,0,0));
 			m_prev_origo = m_cur_origo;
 		}
 		m_location = location;
 		CellGrid* cg = NULL;
 		if (m_location.getLayer()) {
 			cg = m_location.getLayer()->getCellGrid();
 		} else {
 			throw Exception("Location without layer given to Camera::setLocation");
 		}
 		if (!cg) {
 			throw Exception("Camera layer has no cellgrid specified");
 		}
 		updateMatrices();
 		m_cur_origo = toScreenCoordinates(ExactModelCoordinate(0,0,0));
 	}
 	Point Camera::getCellImageDimensions() {
 		return getCellImageDimensions(m_location.getLayer());
 		p.x = static_cast<int>(round(m_reference_scale * dimensions.x));
 		p.y = static_cast<int>(round(m_reference_scale * dimensions.y));
 		m_image_dimensions[layer] = p;
 		return p;
 	}
 	Location Camera::getLocation() const {
 		return m_location;
 	}
 	Location& Camera::getLocationRef() {
 		return m_location;
 	}
 	void Camera::setViewPort(const Rect& viewport) {
 		m_viewport = viewport;
 	}
 	const Rect& Camera::getViewPort() const {
 	}
 	void Camera::setEnabled(bool enabled) {
 		m_enabled = enabled;
 	}
 	bool Camera::isEnabled() {
 		return m_enabled;
 	}
 	void Camera::updateMatrices() {
 	void Camera::calculateZValue(ScreenPoint& screen_coords) {
 		int dy = -(screen_coords.y - toScreenCoordinates(m_location.getMapCoordinates()).y);
 		screen_coords.z = static_cast<int>(tan(m_tilt * (M_PI / 180.0)) * static_cast<double>(dy));
 	}
 	ExactModelCoordinate Camera::toMapCoordinates(ScreenPoint screen_coords, bool z_calculated) {
 		if (!z_calculated) {
 			calculateZValue(screen_coords);
 		}
 		screen_coords.x -= m_viewport.w / 2;
 		FL_DBG(_log, "Updating reference scale");
 		FL_DBG(_log, LMsg("   tilt=") << m_tilt << " rot=" << m_rotation);
 		FL_DBG(_log, LMsg("   m_screen_cell_width=") << m_screen_cell_width);
 	}
 	void Camera::getMatchingInstances(ScreenPoint screen_coords, Layer& layer, std::list<Instance*>& instances) {
 		instances.clear();
 		const std::vector<Instance*>& layer_instances = m_layer_to_instances[&layer];
 		std::vector<Instance*>::const_iterator instance_it = layer_instances.end();
 		while (instance_it != layer_instances.begin()) {
 					instances.push_back(i);
 				}
 			}
 		}
 	}
 	void Camera::getMatchingInstances(Rect screen_rect, Layer& layer, std::list<Instance*>& instances) {
 		instances.clear();
 		const std::vector<Instance*>& layer_instances = m_layer_to_instances[&layer];
 		std::vector<Instance*>::const_iterator instance_it = layer_instances.end();
 		while (instance_it != layer_instances.begin()) {
 				}
 				found_non_transparent_pixel:;
 			}
 		}
 	}
 	void Camera::getMatchingInstances(Location& loc, std::list<Instance*>& instances, bool use_exactcoordinates) {
 		instances.clear();
 		const std::vector<Instance*>& layer_instances = m_layer_to_instances[loc.getLayer()];
 		std::vector<Instance*>::const_iterator instance_it = layer_instances.end();
 		while (instance_it != layer_instances.begin()) {
 		Location loc(m_location);
 		loc.setExactLayerCoordinates( m_attachedto->getLocationRef().getExactLayerCoordinates(m_location.getLayer()) );
 		setLocation(loc);
 		updateMatrices();
 	}
 	void Camera::refresh() {
 		updateMatrices();
 		m_iswarped = true;
 	}
 	void Camera::resetUpdates() {
 		m_iswarped = false;
 		m_prev_origo = m_cur_origo;
 	}
 	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);
 	}
 	RendererBase* Camera::getRenderer(const std::string& name) {
 		return m_renderers[name];
 	}
 	class InstanceDistanceSort {
 	public:
 		Camera* cam;
 		inline bool operator()(const Instance* lhs, const Instance* rhs) {
 			InstanceVisual* liv = lhs->getVisual<InstanceVisual>();
 		}
 	}
 	void Camera::render() {
 		ScreenPoint cammove = m_prev_origo - m_cur_origo;
 		Map* map = m_location.getMap();
 		if (!map) {
 			FL_ERR(_log, "No map for camera found");
 			return;
 		}
 		//if ((!map->isChanged()) && (!m_iswarped) && (cammove == ScreenPoint(0,0,0))) {
 		//	return;
 		//}
 		// update each layer
 		m_renderbackend->pushClipArea(getViewPort());
 		m_layer_to_instances.clear();
 		const std::list<Layer*>& layers = map->getLayers();
 		std::list<Layer*>::const_iterator layer_it = layers.begin();
 		for (;layer_it != layers.end(); ++layer_it) {
 				Instance* instance = *instance_it;
 				InstanceVisual* visual = instance->getVisual<InstanceVisual>();
 				if(!visual->isVisible())
 					continue;
 				InstanceVisualCacheItem& vc = visual->getCacheItem(this);
 				// use cached values if there is no need to do full recalculation
 				ScreenPoint drawpt;
 				int angle = 0;
 				if (m_updated && (!m_iswarped) && (!(instance->getChangeInfo() & (ICHANGE_LOC | ICHANGE_ROTATION | ICHANGE_FACING_LOC))) && (vc.image)) {
 					int pos_estimate_x = vc.screenpoint.x - cammove.x;
 					drawpt.y = pos_estimate_y;
 					drawpt.z = pos_estimate_z;
 					//drawpt.z = toScreenCoordinates( instance->getLocationRef().getMapCoordinates() ).z;
 				} else {
 					drawpt = toScreenCoordinates( instance->getLocationRef().getMapCoordinates() );
-					vc.facing_angle = angle = getAngleBetween(instance->getLocationRef(), instance->getFacingLocation());
+					vc.facing_angle = getAngleBetween(instance->getLocationRef(), instance->getFacingLocation());
-				}
+					angle = vc.facing_angle;
+				}
-				//This is to fix ticket #361.  I would rather not have to put this here.
-				//It should be handled in a more appropriate spot like within Instance::setFacingLocation().
+				angle += instance->getRotation();
-				//It ensures the instances rotation is in sync with it's facing direction.
-				if (angle < 0) {
-					angle = 360+angle;
-				}
-				instance->setRotation(angle);
 				Image* image = NULL;
 				Action* action = instance->getCurrentAction();
 				if (action) {
 					FL_DBG(_log, "Instance has action");
 					}
 				}
 				if (image) {
 					vc.image = image;
 					vc.screenpoint = drawpt;
 					int w = image->getWidth();
 					int h = image->getHeight();
 					drawpt.x -= w / 2;
 					drawpt.x += image->getXShift();
 					drawpt.y -= h / 2;
 					drawpt.y += image->getYShift();
 					Rect r = Rect(drawpt.x, drawpt.y, w, h);
 					vc.dimensions = r;
 					if (m_zoom != 1.0) {
 						// NOTE: Due to image alignment, there is additional additions and substractions on image dimensions
 						//       There's probabaly some better solution for this, but works "good enough" for now.
 						//       In case additions / substractions are removed, gaps appear between tiles.
 						int yo = static_cast<int>(ceil(static_cast<double>(vc.image->getYShift()) * m_zoom)) - vc.image->getYShift();
 						r.x = vc.dimensions.x - static_cast<unsigned int>(ceil(static_cast<double>(r.w - vc.dimensions.w) / 2)) + xo - 1;
 						r.y = vc.dimensions.y - static_cast<unsigned int>(ceil(static_cast<double>(r.h - vc.dimensions.h) / 2)) + yo - 1;
 						vc.dimensions = r;
 					}
 					if (vc.dimensions.intersects(getViewPort())) {
 						instances_to_render.push_back(instance);
 					}
 				}
 			}

Mercurial > fife-parpg

comparison engine/core/view/camera.cpp @ 405:cfe2f6db4964