32 #include "model/metamodel/grids/cellgrid.h"
33 #include "model/metamodel/action.h"
34 #include "model/structures/layer.h"
35 #include "model/structures/instance.h"
36 #include "model/structures/location.h"
37 #include "util/base/exception.h"
38 #include "util/log/logger.h"
39 #include "util/math/fife_math.h"
40 #include "util/math/angles.h"
41 #include "video/renderbackend.h"
42 #include "video/image.h"
43 #include "video/imagepool.h"
44 #include "video/animation.h"
45 #include "video/animationpool.h"
48 #include "layercache.h"
53 static Logger _log(LM_CAMERA);
55 class CacheLayerChangeListener :
public LayerChangeListener {
57 CacheLayerChangeListener(LayerCache* cache)
61 virtual ~CacheLayerChangeListener() {};
63 virtual void onLayerChanged(Layer* layer, std::vector<Instance*>& instances)
65 for(std::vector<Instance*>::iterator i = instances.begin();
66 i != instances.end(); ++i) {
67 m_cache->updateInstance(*i);
71 virtual void onInstanceCreate(Layer* layer, Instance* instance)
73 m_cache->addInstance(instance);
76 virtual void onInstanceDelete(Layer* layer, Instance* instance)
78 m_cache->removeInstance(instance);
84 LayerCache::LayerCache(Camera* camera, ImagePool* image_pool, AnimationPool* animation_pool) {
86 m_image_pool = image_pool;
87 m_animation_pool = animation_pool;
92 LayerCache::~LayerCache() {
93 m_layer->removeChangeListener(m_layer_observer);
94 delete m_layer_observer;
98 void LayerCache::setLayer(Layer* layer) {
100 m_layer_observer =
new CacheLayerChangeListener(
this);
101 layer->addChangeListener(m_layer_observer);
105 void LayerCache::reset() {
108 m_tree =
new CacheTree;
109 const std::vector<Instance*>& instances = m_layer->getInstances();
110 for(std::vector<Instance*>::const_iterator i = instances.begin();
111 i != instances.end(); ++i) {
116 void LayerCache::addInstance(Instance* instance) {
117 if(m_instance_map.find(instance)!=m_instance_map.end()) {
118 throw new Duplicate(instance->getId());
123 item.instance = instance;
124 m_instances.push_back(item);
125 m_instance_map[instance] = m_instances.size() - 1;
128 entry.instance_index = m_instances.size() - 1;
129 entry.entry_index = m_entries.size();
130 m_entries.push_back(entry);
131 updateEntry(m_entries.back());
134 void LayerCache::removeInstance(Instance* instance) {
141 if(m_instance_map.find(instance) == m_instance_map.end()) {
142 throw new NotFound(instance->getId());
144 Entry& item = m_entries[m_instance_map[instance]];
145 assert(item.instance_index == m_instance_map[instance]);
148 item.node->data().erase(item.entry_index);
150 item.instance_index = unsigned(-1);
151 m_instance_map.erase(instance);
154 void LayerCache::updateInstance(Instance* instance) {
155 Entry& entry = m_entries[m_instance_map[instance]];
159 void LayerCache::updateEntry(LayerCache::Entry& item) {
160 if(item.instance_index ==
unsigned(-1)) {
164 item.node->data().erase(item.entry_index);
166 RenderItem& render_item = m_instances[item.instance_index];
167 Instance* instance = render_item.instance;
169 DoublePoint3D screen_position = m_camera->toVirtualScreenCoordinates(instance->getLocationRef().getMapCoordinates());
171 render_item.facing_angle =
getAngleBetween(instance->getLocationRef(), instance->getFacingLocation());
172 int angle = m_camera->getRotation() + render_item.facing_angle + instance->getRotation();
175 Action* action = instance->getCurrentAction();
183 int image_id = render_item.getStaticImageIndexByAngle(angle, instance);
185 action = instance->getObject()->getDefaultAction();
187 image = &m_image_pool->getImage(image_id);
190 item.force_update = bool(action);
193 int animation_id = action->getVisual<ActionVisual>()->getAnimationIndexByAngle(render_item.facing_angle + m_camera->getRotation());
194 Animation& animation = m_animation_pool->getAnimation(animation_id);
195 unsigned animation_time = instance->getActionRuntime() % animation.getDuration();
196 image = animation.getFrameByTimestamp(animation_time);
198 int facing_angle = render_item.facing_angle;
199 if (facing_angle < 0){
202 instance->setRotation(facing_angle);
206 w = image->getWidth();
207 h = image->getHeight();
208 xshift = image->getXShift();
209 yshift = image->getYShift();
212 screen_position.x -= w / 2;
213 screen_position.x += xshift;
214 screen_position.y -= h / 2;
215 screen_position.y += yshift;
217 render_item.image = image;
218 render_item.screenpoint = screen_position;
220 render_item.bbox.x = screen_position.x;
221 render_item.bbox.y = screen_position.y;
222 render_item.bbox.w = w;
223 render_item.bbox.h = h;
225 render_item.dimensions.x = screen_position.x;
226 render_item.dimensions.y = screen_position.y;
227 render_item.dimensions.w = w;
228 render_item.dimensions.h = h;
230 CacheTree::Node* node = m_tree->find_container(render_item.bbox);
232 node->data().insert(item.entry_index);
235 class CacheTreeCollector {
236 std::vector<int>& m_indices;
239 CacheTreeCollector(std::vector<int>& indices,
const Rect& _viewport)
240 : m_indices(indices), m_viewport(_viewport) {
242 bool visit(LayerCache::CacheTree::Node* node,
int d = -1);
245 bool CacheTreeCollector::visit(LayerCache::CacheTree::Node* node,
int d) {
246 if(!m_viewport.intersects(Rect(node->x(), node->y(),node->size(),node->size())))
248 std::set<int>& list = node->data();
249 for(std::set<int>::iterator i = list.begin(); i!=list.end();++i) {
250 m_indices.push_back(*i);
255 void LayerCache::collect(
const Rect& viewport, std::vector<int>& index_list) {
256 CacheTree::Node * node = m_tree->find_container(viewport);
257 CacheTreeCollector collector(index_list, viewport);
258 node->apply_visitor(collector);
259 node = node->parent();
261 collector.visit(node);
262 node = node->parent();
266 void LayerCache::fullUpdate() {
267 for(
unsigned i=0; i!=m_entries.size(); ++i)
268 updateEntry(m_entries[i]);
271 class InstanceDistanceSort {
273 inline bool operator()(RenderItem*
const & lhs, RenderItem*
const & rhs) {
274 if (lhs->screenpoint.z == rhs->screenpoint.z) {
275 InstanceVisual* liv = lhs->instance->getVisual<InstanceVisual>();
276 InstanceVisual* riv = rhs->instance->getVisual<InstanceVisual>();
277 return liv->getStackPosition() < riv->getStackPosition();
279 return lhs->screenpoint.z < rhs->screenpoint.z;
283 void LayerCache::update(Camera::Transform transform, RenderList& renderlist) {
284 const double OVERDRAW = 2.5;
286 if(!m_layer->areInstancesVisible()) {
287 FL_DBG(_log,
"Layer instances hidden");
290 bool isWarped = transform == Camera::WarpedTransform;
294 Rect viewport = m_camera->getViewPort();
295 Rect screen_viewport = viewport;
296 float zoom = m_camera->getZoom();
297 DoublePoint3D viewport_a = m_camera->screenToVirtualScreen(Point3D(viewport.x, viewport.y));
298 DoublePoint3D viewport_b = m_camera->screenToVirtualScreen(Point3D(viewport.right(), viewport.bottom()));
299 viewport.x = std::min(viewport_a.x, viewport_b.x);
300 viewport.y = std::min(viewport_a.y, viewport_b.y);
301 viewport.w = std::max(viewport_a.x, viewport_b.x) - viewport.x;
302 viewport.h = std::max(viewport_a.y, viewport_b.y) - viewport.y;
303 unsigned char layer_trans = m_layer->getLayerTransparency();
306 std::vector<int> index_list;
307 collect(viewport, index_list);
308 for(
unsigned i=0; i!=index_list.size();++i) {
309 Entry& entry = m_entries[index_list[i]];
315 if(entry.force_update)
318 RenderItem& item = m_instances[entry.instance_index];
319 InstanceVisual* visual = item.instance->getVisual<InstanceVisual>();
320 bool visible = visual->isVisible();
321 unsigned char instance_trans = visual->getTransparency();
322 if(!item.image || !visible || (instance_trans == 255 && layer_trans == 0)
323 || (instance_trans == 0 && layer_trans == 255)) {
327 if(layer_trans != 0) {
328 if(instance_trans != 0) {
329 short calc_trans = layer_trans - instance_trans;
330 if(calc_trans >= 0) {
331 instance_trans = calc_trans;
336 instance_trans = layer_trans;
340 Point3D screen_point = m_camera->virtualScreenToScreen(item.screenpoint);
347 item.dimensions.x = screen_point.x;
348 item.dimensions.y = screen_point.y;
349 item.dimensions.w = item.bbox.w;
350 item.dimensions.h = item.bbox.h;
352 item.transparency = 255 - instance_trans;
358 item.dimensions.w = unsigned(
double(item.bbox.w) * zoom + OVERDRAW);
359 item.dimensions.h = unsigned(
double(item.bbox.h) * zoom + OVERDRAW);
362 if(item.dimensions.intersects(screen_viewport))
363 renderlist.push_back(&item);
366 InstanceDistanceSort ids;
367 std::stable_sort(renderlist.begin(), renderlist.end(), ids);