Changeset 4002


Ignore:
Timestamp:
07/17/12 14:34:42 (2 years ago)
Author:
helios2000
Message:
  • Added getMapViewPort() and getLayerViewPort() functions to camera class. These functions return the position and size of the camera in map or layer coordinates. CellRenderer? make use of it to speed up rendering, especially when many cells exist in the cache. ref[t:647]
Location:
trunk/engine/core
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/engine/core/model/structures/cellcache.cpp

    r3992 r4002  
    849849                                if (c) { 
    850850                                        cells.push_back(c); 
    851                                 } else { 
    852                                         return cells; 
    853851                                } 
    854852                        } 
  • trunk/engine/core/view/camera.cpp

    r3992 r4002  
    8888                        m_cur_origo(ScreenPoint(0,0,0)), 
    8989                        m_viewport(), 
     90                        m_mapViewPort(), 
     91                        m_mapViewPortUpdated(false), 
    9092                        m_screen_cell_width(1), 
    9193                        m_screen_cell_height(1), 
     
    261263        } 
    262264 
     265        const Rect& Camera::getMapViewPort() { 
     266                if (!m_mapViewPortUpdated) { 
     267                        ScreenPoint sp1(m_viewport.x, m_viewport.y); 
     268                        ScreenPoint sp2(m_viewport.x, m_viewport.y + m_viewport.h); 
     269                        ScreenPoint sp3(m_viewport.x + m_viewport.w, m_viewport.y); 
     270                        ScreenPoint sp4(m_viewport.x + m_viewport.w, m_viewport.y + m_viewport.h); 
     271 
     272                        std::vector<ExactModelCoordinate> coords; 
     273                        coords.push_back(toMapCoordinates(sp2, false)); 
     274                        coords.push_back(toMapCoordinates(sp3, false)); 
     275                        coords.push_back(toMapCoordinates(sp4, false)); 
     276                 
     277                        ExactModelCoordinate emc = toMapCoordinates(sp1, false); 
     278                        ModelCoordinate min(static_cast<int32_t>(emc.x), static_cast<int32_t>(emc.y)); 
     279                        ModelCoordinate max(static_cast<int32_t>(emc.x+0.5), static_cast<int32_t>(emc.y+0.5)); 
     280                        std::vector<ExactModelCoordinate>::iterator it = coords.begin(); 
     281                        for (; it != coords.end(); ++it) { 
     282                                min.x = std::min(min.x, static_cast<int32_t>((*it).x)); 
     283                                min.y = std::min(min.y, static_cast<int32_t>((*it).y)); 
     284                                max.x = std::max(max.x, static_cast<int32_t>((*it).x+0.5)); 
     285                                max.y = std::max(max.y, static_cast<int32_t>((*it).y+0.5)); 
     286                        } 
     287                        // makes the viewport a bit larger 
     288                        m_mapViewPort.x = min.x - 1; 
     289                        m_mapViewPort.y = min.y - 1; 
     290                        m_mapViewPort.w = ABS(max.x - min.x) + 2; 
     291                        m_mapViewPort.h = ABS(max.y - min.y) + 2; 
     292                        m_mapViewPortUpdated = true; 
     293                } 
     294 
     295                return m_mapViewPort; 
     296        } 
     297 
     298        Rect Camera::getLayerViewPort(Layer* layer) { 
     299                Rect mapView = getMapViewPort(); 
     300                Location loc(layer); 
     301                ExactModelCoordinate emc(mapView.x, mapView.y); 
     302                loc.setMapCoordinates(emc); 
     303                emc.x = mapView.x+mapView.w; 
     304                emc.y = mapView.y+mapView.h; 
     305                mapView.x = loc.getLayerCoordinates().x; 
     306                mapView.y = loc.getLayerCoordinates().y; 
     307                loc.setMapCoordinates(emc); 
     308                mapView.w = ABS(loc.getLayerCoordinates().x - mapView.x); 
     309                mapView.h = ABS(loc.getLayerCoordinates().y - mapView.y); 
     310 
     311                return mapView; 
     312        } 
     313 
    263314        void Camera::setEnabled(bool enabled) { 
    264315                m_enabled = enabled; 
     
    309360                m_screen_2_vscreen = m_vscreen_2_screen.inverse(); 
    310361                m_iswarped = true; 
     362                m_mapViewPortUpdated = false; 
    311363                // FL_WARN(_log, LMsg("matrix: ") << m_matrix << " 1: " << m_matrix.inverse().mult4by4(m_matrix)); 
    312364//              FL_WARN(_log, LMsg("vs2s matrix: ") << m_vscreen_2_screen << " s2vs matrix: " << m_screen_2_vscreen); 
  • trunk/engine/core/view/camera.h

    r3992 r4002  
    191191                void setViewPort(const Rect& viewport); 
    192192 
    193                 /** Gets the viewport for camera 
     193                /** Gets the viewport for camera in pixel coordinates 
    194194                 * @return camera viewport 
    195195                 */ 
    196196                const Rect& getViewPort() const; 
     197 
     198                /** Gets the viewport for camera in map coordinates 
     199                 * @return camera viewport 
     200                 */ 
     201                const Rect& getMapViewPort(); 
     202 
     203                /** Gets the viewport for camera in layer coordinates 
     204                 * @param layer A pointer to the layer whose geometry is used for the conversion 
     205                 * @return camera viewport 
     206                 */ 
     207                Rect getLayerViewPort(Layer* layer); 
    197208 
    198209                /** Transforms given point from screen coordinates to map coordinates 
     
    408419                ScreenPoint m_cur_origo; 
    409420                Rect m_viewport; 
     421                Rect m_mapViewPort; 
     422                bool m_mapViewPortUpdated; 
    410423                bool m_view_updated; 
    411424                uint32_t m_screen_cell_width; 
  • trunk/engine/core/view/camera.i

    r3827 r4002  
    5252                void setViewPort(const Rect& viewport); 
    5353                const Rect& getViewPort() const; 
     54                const Rect& getMapViewPort(); 
     55                Rect getLayerViewPort(Layer* layer); 
    5456                void setCellImageDimensions(uint32_t width, uint32_t height); 
    5557                Point getCellImageDimensions(); 
  • trunk/engine/core/view/renderers/cellrenderer.cpp

    r3992 r4002  
    117117                const bool zoomed = !Mathd::Equal(1.0, cam->getZoom()); 
    118118 
    119                 // make viewport 25% larger 
    120                 Rect cv = cam->getViewPort(); 
    121                 int32_t cvx2 = round((cv.x+cv.w) * 1.25); 
    122                 int32_t cvy2 = round((cv.y+cv.h) * 1.25); 
    123                 cv.x -= round((cv.x+cv.w) * 0.125); 
    124                 cv.y -= round((cv.y+cv.h) * 0.125); 
    125                 cv.w = cvx2; 
    126                 cv.h = cvy2; 
    127  
    128                 const std::vector<std::vector<Cell*> >& cells = cache->getCells(); 
    129                 std::vector<std::vector<Cell*> >::const_iterator it = cells.begin(); 
    130                 for (; it != cells.end(); ++it) { 
    131                         std::vector<Cell*>::const_iterator cit = (*it).begin(); 
    132                         for (; cit != (*it).end(); ++cit) { 
    133                                 ScreenPoint sp = cam->toScreenCoordinates(cg->toMapCoordinates(FIFE::intPt2doublePt((*cit)->getLayerCoordinates()))); 
    134                                 // if it's not in cameras view then continue 
    135                                 if (sp.x < cv.x || sp.x > cv.x + cv.w || 
    136                                         sp.y < cv.y || sp.y > cv.y + cv.h) { 
    137                                         continue; 
    138                                 } 
     119                Rect layerView = cam->getLayerViewPort(layer); 
     120                std::vector<Cell*> cells = cache->getCellsInRect(layerView); 
     121                std::vector<Cell*>::iterator cit = cells.begin(); 
     122                for (; cit != cells.end(); ++cit) { 
     123                        if (m_blockingEnabled) { 
     124                                if ((*cit)->getCellType() != CTYPE_NO_BLOCKER) { 
     125                                        std::vector<ExactModelCoordinate> vertices; 
     126                                        cg->getVertices(vertices, (*cit)->getLayerCoordinates()); 
     127                                        std::vector<ExactModelCoordinate>::const_iterator it = vertices.begin(); 
     128                                        int32_t halfind = vertices.size() / 2; 
     129                                        ScreenPoint firstpt = cam->toScreenCoordinates(cg->toMapCoordinates(*it)); 
     130                                        Point pt1(firstpt.x, firstpt.y); 
     131                                        Point pt2; 
     132                                        ++it; 
     133                                        for (; it != vertices.end(); it++) { 
     134                                                ScreenPoint pts = cam->toScreenCoordinates(cg->toMapCoordinates(*it)); 
     135                                                pt2.x = pts.x; 
     136                                                pt2.y = pts.y; 
     137                                                m_renderbackend->drawLine(pt1, pt2, m_blockerColor.r, m_blockerColor.g, m_blockerColor.b); 
     138                                                pt1 = pt2; 
     139                                        } 
     140                                        m_renderbackend->drawLine(pt2, Point(firstpt.x, firstpt.y), m_blockerColor.r, m_blockerColor.g, m_blockerColor.b); 
     141                                        ScreenPoint spt1 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[0])); 
     142                                        Point pt3(spt1.x, spt1.y); 
     143                                        ScreenPoint spt2 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[halfind])); 
     144                                        Point pt4(spt2.x, spt2.y); 
     145                                        m_renderbackend->drawLine(pt3, pt4, m_blockerColor.r, m_blockerColor.g, m_blockerColor.b); 
     146                                } 
     147                        } 
    139148                                 
    140                                 if (m_blockingEnabled) { 
    141                                         if ((*cit)->getCellType() != CTYPE_NO_BLOCKER) { 
    142                                                 std::vector<ExactModelCoordinate> vertices; 
    143                                                 cg->getVertices(vertices, (*cit)->getLayerCoordinates()); 
    144                                                 std::vector<ExactModelCoordinate>::const_iterator it = vertices.begin(); 
    145                                                 int32_t halfind = vertices.size() / 2; 
    146                                                 ScreenPoint firstpt = cam->toScreenCoordinates(cg->toMapCoordinates(*it)); 
    147                                                 Point pt1(firstpt.x, firstpt.y); 
    148                                                 Point pt2; 
    149                                                 ++it; 
    150                                                 for (; it != vertices.end(); it++) { 
    151                                                         ScreenPoint pts = cam->toScreenCoordinates(cg->toMapCoordinates(*it)); 
    152                                                         pt2.x = pts.x; 
    153                                                         pt2.y = pts.y; 
    154                                                         m_renderbackend->drawLine(pt1, pt2, m_blockerColor.r, m_blockerColor.g, m_blockerColor.b); 
    155                                                         pt1 = pt2; 
    156                                                 } 
    157                                                 m_renderbackend->drawLine(pt2, Point(firstpt.x, firstpt.y), m_blockerColor.r, m_blockerColor.g, m_blockerColor.b); 
    158                                                 ScreenPoint spt1 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[0])); 
    159                                                 Point pt3(spt1.x, spt1.y); 
    160                                                 ScreenPoint spt2 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[halfind])); 
    161                                                 Point pt4(spt2.x, spt2.y); 
    162                                                 m_renderbackend->drawLine(pt3, pt4, m_blockerColor.r, m_blockerColor.g, m_blockerColor.b); 
    163                                         } 
    164                                 } 
    165                                  
    166                                 if (render_costs) { 
    167                                         bool match = false; 
    168                                         double cost; 
    169                                         std::set<std::string>::iterator cost_it = m_visualCosts.begin(); 
    170                                         for (; cost_it != m_visualCosts.end(); ++cost_it) { 
    171                                                 std::vector<std::string> cell_costs = cache->getCellCosts(*cit); 
    172                                                 std::vector<std::string>::iterator cc_it = cell_costs.begin(); 
    173                                                 for (; cc_it != cell_costs.end(); ++cc_it) { 
    174                                                         if (*cc_it == *cost_it) { 
    175                                                                 match = true; 
    176                                                                 cost = cache->getCost(*cost_it); 
    177                                                                 break; 
    178                                                         } 
    179                                                 } 
    180                                                 if (match) { 
     149                        if (render_costs) { 
     150                                bool match = false; 
     151                                double cost; 
     152                                std::set<std::string>::iterator cost_it = m_visualCosts.begin(); 
     153                                for (; cost_it != m_visualCosts.end(); ++cost_it) { 
     154                                        std::vector<std::string> cell_costs = cache->getCellCosts(*cit); 
     155                                        std::vector<std::string>::iterator cc_it = cell_costs.begin(); 
     156                                        for (; cc_it != cell_costs.end(); ++cc_it) { 
     157                                                if (*cc_it == *cost_it) { 
     158                                                        match = true; 
     159                                                        cost = cache->getCost(*cost_it); 
    181160                                                        break; 
    182161                                                } 
    183162                                        } 
    184163                                        if (match) { 
    185                                                 Location loc(layer); 
    186                                                 loc.setLayerCoordinates((*cit)->getLayerCoordinates()); 
    187                                                 ScreenPoint drawpt = cam->toScreenCoordinates(loc.getMapCoordinates()); 
    188  
    189                                                 std::stringstream stream; 
    190                                                 stream << cost; 
    191                                                 Image* img = m_font->getAsImage(stream.str()); 
    192  
    193                                                 Rect r; 
    194                                                 if (zoomed) { 
    195                                                         double zoom = cam->getZoom(); 
    196                                                         r.x = drawpt.x - (img->getWidth()/2) * zoom; 
    197                                                         r.y = drawpt.y - (img->getHeight()/2) * zoom; 
    198                                                         r.w = img->getWidth() * zoom; 
    199                                                         r.h = img->getHeight() * zoom; 
    200                                                         img->render(r); 
    201                                                 } else { 
    202                                                         r.x = drawpt.x - img->getWidth()/2; 
    203                                                         r.y = drawpt.y - img->getHeight()/2; 
    204                                                         r.w = img->getWidth(); 
    205                                                         r.h = img->getHeight(); 
    206                                                         img->render(r); 
    207                                                 } 
    208                                         } 
    209                                 } 
    210  
    211                                 if (fow_update) { 
    212                                         CellVisualEffect cve = (*cit)->getFoWType(); 
    213                                         if (cve == CELLV_CONCEALED) { 
    214                                                 if (m_concealImage.get()) { 
    215                                                         addConcealImageToMap(cam, Point(sp.x, sp.y), m_concealImage); 
    216                                                 } 
    217                                         } else if (cve == CELLV_MASKED) { 
    218                                                 if (m_maskImage.get()) { 
    219                                                         addMaskImageToMap(cam, Point(sp.x, sp.y), m_maskImage); 
    220                                                 } 
    221                                         } 
    222                                 } 
    223                         } 
    224                 } 
     164                                                break; 
     165                                        } 
     166                                } 
     167                                if (match) { 
     168                                        Location loc(layer); 
     169                                        loc.setLayerCoordinates((*cit)->getLayerCoordinates()); 
     170                                        ScreenPoint drawpt = cam->toScreenCoordinates(loc.getMapCoordinates()); 
     171 
     172                                        std::stringstream stream; 
     173                                        stream << cost; 
     174                                        Image* img = m_font->getAsImage(stream.str()); 
     175                                         
     176                                        Rect r; 
     177                                        if (zoomed) { 
     178                                                double zoom = cam->getZoom(); 
     179                                                r.x = drawpt.x - (img->getWidth()/2) * zoom; 
     180                                                r.y = drawpt.y - (img->getHeight()/2) * zoom; 
     181                                                r.w = img->getWidth() * zoom; 
     182                                                r.h = img->getHeight() * zoom; 
     183                                                img->render(r); 
     184                                        } else { 
     185                                                r.x = drawpt.x - img->getWidth()/2; 
     186                                                r.y = drawpt.y - img->getHeight()/2; 
     187                                                r.w = img->getWidth(); 
     188                                                r.h = img->getHeight(); 
     189                                                img->render(r); 
     190                                        } 
     191                                } 
     192                        } 
     193 
     194                        if (fow_update) { 
     195                                ScreenPoint sp = cam->toScreenCoordinates(cg->toMapCoordinates( 
     196                                        FIFE::intPt2doublePt((*cit)->getLayerCoordinates()))); 
     197                                CellVisualEffect cve = (*cit)->getFoWType(); 
     198                                if (cve == CELLV_CONCEALED) { 
     199                                        if (m_concealImage.get()) { 
     200                                                addConcealImageToMap(cam, Point(sp.x, sp.y), m_concealImage); 
     201                                        } 
     202                                } else if (cve == CELLV_MASKED) { 
     203                                        if (m_maskImage.get()) { 
     204                                                addMaskImageToMap(cam, Point(sp.x, sp.y), m_maskImage); 
     205                                        } 
     206                                } 
     207                        } 
     208                } 
     209 
    225210                if (m_pathVisualEnabled && !m_visualPaths.empty()) { 
    226211                        std::vector<Instance*>::iterator it = m_visualPaths.begin(); 
Note: See TracChangeset for help on using the changeset viewer.