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/animation.h"
44 #include "video/imagemanager.h"
47 #include "layercache.h"
52 static Logger _log(LM_CAMERA);
54 class CacheLayerChangeListener :
public LayerChangeListener {
56 CacheLayerChangeListener(LayerCache* cache) {
59 virtual ~CacheLayerChangeListener() {};
61 virtual void onLayerChanged(Layer* layer, std::vector<Instance*>& instances) {
62 for(std::vector<Instance*>::iterator i = instances.begin();
63 i != instances.end(); ++i) {
64 m_cache->updateInstance(*i);
68 virtual void onInstanceCreate(Layer* layer, Instance* instance) {
69 m_cache->addInstance(instance);
72 virtual void onInstanceDelete(Layer* layer, Instance* instance) {
73 m_cache->removeInstance(instance);
79 LayerCache::LayerCache(Camera* camera) {
84 m_need_sorting =
true;
86 if(RenderBackend::instance()->getName() ==
"OpenGLe") {
87 m_need_sorting =
false;
91 LayerCache::~LayerCache() {
92 m_layer->removeChangeListener(m_layer_observer);
93 delete m_layer_observer;
97 void LayerCache::setLayer(Layer* layer) {
99 m_layer_observer =
new CacheLayerChangeListener(
this);
100 layer->addChangeListener(m_layer_observer);
104 void LayerCache::reset() {
107 m_tree =
new CacheTree;
108 const std::vector<Instance*>& instances = m_layer->getInstances();
109 for(std::vector<Instance*>::const_iterator i = instances.begin();
110 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());
135 void LayerCache::removeInstance(Instance* instance) {
142 if(m_instance_map.find(instance) == m_instance_map.end()) {
143 throw new NotFound(instance->getId());
145 Entry& item = m_entries[m_instance_map[instance]];
146 assert(item.instance_index == m_instance_map[instance]);
149 item.node->data().erase(item.entry_index);
152 item.instance_index = -1;
153 m_instance_map.erase(instance);
157 void LayerCache::updateInstance(Instance* instance) {
158 Entry& entry = m_entries[m_instance_map[instance]];
162 void LayerCache::updateEntry(LayerCache::Entry& item) {
163 if(item.instance_index == -1) {
167 RenderItem& render_item = m_instances[item.instance_index];
168 Instance* instance = render_item.instance;
170 ExactModelCoordinate map_coords = instance->getLocationRef().getMapCoordinates();
171 DoublePoint3D screen_position = m_camera->toVirtualScreenCoordinates(map_coords);
172 render_item.instance_z = instance->getLocationRef().getExactLayerCoordinates().z;
174 render_item.facing_angle =
getAngleBetween(instance->getLocationRef(), instance->getFacingLocation());
175 int32_t angle =
static_cast<int32_t
>(m_camera->getRotation()) +
176 render_item.facing_angle + instance->getRotation();
179 Action* action = instance->getCurrentAction();
185 int32_t image_id = render_item.getStaticImageIndexByAngle(angle, instance);
187 if (!instance->getObject()->isStatic()) {
188 action = instance->getObject()->getDefaultAction();
191 image = ImageManager::instance()->get(image_id);
194 item.force_update = (action != 0);
197 AnimationPtr animation = action->getVisual<ActionVisual>()->getAnimationByAngle(
198 render_item.facing_angle + static_cast<int32_t>(m_camera->getRotation()));
199 unsigned animation_time = instance->getActionRuntime() % animation->getDuration();
201 image = animation->getFrameByTimestamp(animation_time);
203 int32_t action_frame = animation->getActionFrame();
204 if (action_frame != -1) {
205 if (render_item.image != image) {
206 if (action_frame == animation->getFrameIndex(animation_time)) {
207 instance->callOnActionFrame(action, action_frame);
212 int32_t facing_angle = render_item.facing_angle;
213 if (facing_angle < 0){
216 instance->setRotation(facing_angle);
221 w = image->getWidth();
222 h = image->getHeight();
224 screen_position.x -= w / 2;
225 screen_position.x += image->getXShift();
226 screen_position.y -= h / 2;
227 screen_position.y += image->getYShift();
230 render_item.image = image;
231 if (render_item.screenpoint == screen_position) {
235 render_item.screenpoint = screen_position;
237 render_item.bbox.x =
static_cast<int32_t
>(screen_position.x);
238 render_item.bbox.y =
static_cast<int32_t
>(screen_position.y);
239 render_item.bbox.w = w;
240 render_item.bbox.h = h;
242 render_item.dimensions = render_item.bbox;
244 CacheTree::Node* node = m_tree->find_container(render_item.bbox);
247 item.node->data().erase(item.entry_index);
250 node->data().insert(item.entry_index);
254 class CacheTreeCollector {
255 std::vector<int32_t>& m_indices;
258 CacheTreeCollector(std::vector<int32_t>& indices,
const Rect& _viewport)
259 : m_indices(indices), m_viewport(_viewport) {
261 bool visit(LayerCache::CacheTree::Node* node, int32_t d = -1);
264 bool CacheTreeCollector::visit(LayerCache::CacheTree::Node* node, int32_t d) {
265 if(!m_viewport.intersects(Rect(node->x(), node->y(),node->size(),node->size()))) {
268 std::set<int32_t>& list = node->data();
269 for(std::set<int32_t>::iterator i = list.begin(); i!=list.end();++i) {
270 m_indices.push_back(*i);
275 void LayerCache::collect(
const Rect& viewport, std::vector<int32_t>& index_list) {
276 CacheTree::Node * node = m_tree->find_container(viewport);
277 CacheTreeCollector collector(index_list, viewport);
278 node->apply_visitor(collector);
279 node = node->parent();
281 collector.visit(node);
282 node = node->parent();
286 void LayerCache::fullUpdate() {
287 for(
unsigned i=0; i!=m_entries.size(); ++i) {
288 updateEntry(m_entries[i]);
292 class InstanceDistanceSort {
294 inline bool operator()(RenderItem*
const & lhs, RenderItem*
const & rhs) {
295 if (lhs->screenpoint.z == rhs->screenpoint.z) {
296 InstanceVisual* liv = lhs->instance->getVisual<InstanceVisual>();
297 InstanceVisual* riv = rhs->instance->getVisual<InstanceVisual>();
298 return liv->getStackPosition() < riv->getStackPosition();
300 return lhs->screenpoint.z < rhs->screenpoint.z;
304 void LayerCache::update(Camera::Transform transform, RenderList& renderlist) {
305 const double OVERDRAW = 2.5;
307 m_needupdate =
false;
308 if(!m_layer->areInstancesVisible()) {
309 FL_DBG(_log,
"Layer instances hidden");
312 bool isWarped = transform == Camera::WarpedTransform;
317 Rect viewport = m_camera->getViewPort();
318 Rect screen_viewport = viewport;
319 double zoom = m_camera->getZoom();
320 DoublePoint3D viewport_a = m_camera->screenToVirtualScreen(Point3D(viewport.x, viewport.y));
321 DoublePoint3D viewport_b = m_camera->screenToVirtualScreen(Point3D(viewport.right(), viewport.bottom()));
322 viewport.x =
static_cast<int32_t
>(std::min(viewport_a.x, viewport_b.x));
323 viewport.y =
static_cast<int32_t
>(std::min(viewport_a.y, viewport_b.y));
324 viewport.w =
static_cast<int32_t
>(std::max(viewport_a.x, viewport_b.x) - viewport.x);
325 viewport.h =
static_cast<int32_t
>(std::max(viewport_a.y, viewport_b.y) - viewport.y);
326 uint8_t layer_trans = m_layer->getLayerTransparency();
328 double zmin = 0.0, zmax = 0.0;
331 std::vector<int32_t> index_list;
332 collect(viewport, index_list);
333 for(
unsigned i=0; i!=index_list.size();++i) {
334 Entry& entry = m_entries[index_list[i]];
340 if(entry.force_update || !isWarped) {
344 RenderItem& item = m_instances[entry.instance_index];
345 InstanceVisual* visual = item.instance->getVisual<InstanceVisual>();
346 bool visible = (visual->isVisible() != 0);
347 uint8_t instance_trans = visual->getTransparency();
348 if(!item.image || !visible || (instance_trans == 255 && layer_trans == 0)
349 || (instance_trans == 0 && layer_trans == 255)) {
353 if(layer_trans != 0) {
354 if(instance_trans != 0) {
355 uint8_t calc_trans = layer_trans - instance_trans;
356 if(calc_trans >= 0) {
357 instance_trans = calc_trans;
362 instance_trans = layer_trans;
366 Point3D screen_point = m_camera->virtualScreenToScreen(item.screenpoint);
373 item.dimensions.x = screen_point.x;
374 item.dimensions.y = screen_point.y;
375 item.dimensions.w = item.bbox.w;
376 item.dimensions.h = item.bbox.h;
378 item.transparency = 255 - instance_trans;
384 item.dimensions.w = unsigned(
double(item.bbox.w) * zoom + OVERDRAW);
385 item.dimensions.h = unsigned(
double(item.bbox.h) * zoom + OVERDRAW);
388 if (!m_need_sorting) {
389 zmin = std::min(zmin, item.screenpoint.z);
390 zmax = std::max(zmax, item.screenpoint.z);
393 if(item.dimensions.intersects(screen_viewport)) {
394 renderlist.push_back(&item);
398 if (m_need_sorting) {
399 InstanceDistanceSort ids;
400 std::stable_sort(renderlist.begin(), renderlist.end(), ids);
411 double det = zmin - zmax;
412 if (fabs(det) > FLT_EPSILON) {
413 double det_a = -10.0 - 10.0;
414 double det_b = 10.0 * zmin - (-10.0) * zmax;
415 double a =
static_cast<float>(det_a / det);
416 double b =
static_cast<float>(det_b / det);
417 float estimate = sqrtf(static_cast<float>(renderlist.size()));
418 float stack_delta = fabs(-10.0f - 10.0f) / estimate * 0.1f;
420 RenderList::iterator it = renderlist.begin();
421 for ( ; it != renderlist.end(); ++it) {
422 double& z = (*it)->screenpoint.z;
424 InstanceVisual* vis = (*it)->instance->getVisual<InstanceVisual>();
425 z += vis->getStackPosition() * stack_delta;
int32_t getAngleBetween(const Location &loc1, const Location &loc2)