Changeset 3098

Timestamp:

12/02/09 13:57:01 (9 months ago)

Author:

phoku

Message:

Still very much work in progress fix on #419.

The Camera.virtualScreenToScreen and screenToVirtualScreen
methods now preserve the z value, but do not use it for
calculation - this fixes them.

LayerCache?.update now calculates the viewport correctly,
however a few issues remain esp. at the borders.

Location:

branches/active/view_performance/engine/core

Files:

• util/math/matrix.h (modified) (2 diffs)
• view/camera.cpp (modified) (3 diffs)
• view/layercache.cpp (modified) (3 diffs)

branches/active/view_performance/engine/core/util/math/matrix.h

@@ -224 +224 @@
                                 return m[ind];
                         }
+                        inline const T& operator[] (int ind) const {
+                                assert(ind > -1 && ind < 16);
+                                return m[ind];
+                        }
 
                         /** Apply the matrix dot product to this matrix
@@ -375 +379 @@
          */
         template<typename T>
-        std::ostream& operator<<(std::ostream& os, Matrix<T>& m) {
+        std::ostream& operator<<(std::ostream& os, const Matrix<T>& m) {
+                
                 return os << "\n|" << m[0] << "," << m[4] << "," << m[8] << ","  << m[12] << "|\n" << \
                                "|" << m[1] << "," << m[5] << "," << m[9] << ","  << m[13] << "|\n" << \

branches/active/view_performance/engine/core/view/camera.cpp

@@ -232 +232 @@
                 m_inverse_matrix = m_matrix.inverse();
 
+                m_vs_matrix.applyTranslate(0,0,0);
                 m_vs_matrix.applyRotate(-m_rotation, 0.0, 0.0, 1.0);
                 m_vs_matrix.applyRotate(-m_tilt, 1.0, 0.0, 0.0);
                 m_vs_inverse_matrix = m_vs_matrix.inverse();
+                FL_WARN(_log, LMsg("matrix: ") << m_matrix << " vs_matrix: " << m_vs_matrix);
         }
 
@@ -267 +269 @@
         
         ScreenPoint Camera::virtualScreenToScreen(const ScreenPoint& p) {
-                Point3D pt = doublePt2intPt( m_matrix * (m_vs_inverse_matrix * intPt2doublePt(p)));
+                Point3D pt = p;
+                pt.z = 0;
+                pt = doublePt2intPt( m_matrix * (m_vs_inverse_matrix * intPt2doublePt(pt)));
                 pt.x += m_viewport.w / 2;
                 pt.y += m_viewport.h / 2;
+                pt.z = p.z;
                 return pt;
         }
@@ -277 +282 @@
                 pt.x -= m_viewport.w / 2;
                 pt.y -= m_viewport.h / 2;
-                return doublePt2intPt( m_vs_matrix * (m_inverse_matrix * intPt2doublePt(pt)));
+                pt.z = 0;
+                DoublePoint3D pt2 = m_inverse_matrix * intPt2doublePt(pt);
+                pt2.z = 0;
+                pt2 = m_vs_matrix * pt2;
+                pt2.z = p.z;
+                return doublePt2intPt(pt2);
         }
 

branches/active/view_performance/engine/core/view/layercache.cpp

@@ -246 +246 @@
                         fullUpdate();
 
-                bool m_updated = true;
                 Point3D cammove = camera_update.getCameraMovement();
                 Point3D screen_delta = m_camera->getOrigin();
@@ -252 +251 @@
 
                 Rect viewport = camera_update.getViewport();
-
+                Rect screen_viewport = viewport;
+                Point3D viewport_a = m_camera->screenToVirtualScreen(Point3D(viewport.x, viewport.y));
+                Point3D viewport_b = m_camera->screenToVirtualScreen(Point3D(viewport.x, viewport.bottom()));
+                Point3D viewport_c = m_camera->screenToVirtualScreen(Point3D(viewport.right(), viewport.y));
+                Point3D viewport_d = m_camera->screenToVirtualScreen(Point3D(viewport.right(), viewport.bottom()));
+                viewport.x = std::min(std::min(viewport_a.x, viewport_b.x),  std::min(viewport_c.x, viewport_d.x));
+                viewport.y = std::min(std::min(viewport_a.y, viewport_b.y),  std::min(viewport_c.y, viewport_d.y));
+                viewport.w = std::max(std::max(viewport_a.x, viewport_b.x),  std::max(viewport_c.x, viewport_d.x)) - viewport.x;
+                viewport.h = std::max(std::max(viewport_a.y, viewport_b.y),  std::max(viewport_c.y, viewport_d.y)) - viewport.y;
+                
+                FL_LOG(_log, LMsg("camera-update viewport") << viewport);
+                
                 std::vector<int> index_list;
                 collect(viewport, index_list);
@@ -280 +290 @@
                         }
 
-                        if(item.cache_item.dimensions.intersects(viewport))
+                        if(item.cache_item.dimensions.intersects(screen_viewport))
                                 m_renderlist.push_back(item);
                 }
-                FL_LOG(_log, LMsg("camera-update ") << " N=" <<m_renderlist.size() << "/" << m_instances.size());
+                FL_LOG(_log, LMsg("camera-update ") << " N=" <<m_renderlist.size() << "/" << m_instances.size() << "/" << index_list.size());
         }