         var viewPt :Point = _isoView.globalToLocal(new Point(event.stageX, event.stageY));
         _isoView.centerOnPt(new Pt(viewPt.x - _isoView.width / 2 + _isoView.currentX,
             viewPt.y - _isoView.height / 2 + _isoView.currentY), false);
+        refreshBaseBlockScenes();
     }
 
     public function setSceneModel (model :MisoSceneModel) :void

                    }
                }
                baseScene.render();
                _isoView.addScene(baseScene);
            }
        }

        var set :ObjectSet = new ObjectSet();
        _model.getObjects(new Rectangle(-100, -100, 200, 200), set);
        time = getTimer();
        for (ii = 0; ii < set.size(); ii++) {
            var objInfo :ObjectInfo = set.get(ii);
            var objTileId :int = objInfo.tileId;
            var objTileSet :TileSet;

    {
    }

    protected function getBaseBlocks () :Set
    {
        var blocks :Set = Sets.newSetOf(int);

        var size :Point = _isoView.size;
        var topLeft :Point = _isoView.localToIso(new Point(0, 0));
        var topRight :Point = _isoView.localToIso(new Point(size.x, 0));
        var btmLeft :Point = _isoView.localToIso(new Point(0, size.y));
        var btmRight :Point = _isoView.localToIso(new Point(size.x, size.y));

        for (var yy :int = topRight.y - 1; yy <= btmLeft.y + 1; yy++) {
            for (var xx :int = topLeft.x - 1; xx <= btmRight.x + 1; xx++) {

                // Toss out any that aren't actually in our view.
                var blkTop :Point = _isoView.isoToLocal(new Pt(xx, yy, 0));
                var blkRight :Point = _isoView.isoToLocal(new Pt(xx + BLOCK_SIZE, yy, 0));
                var blkLeft :Point = _isoView.isoToLocal(new Pt(xx, yy + BLOCK_SIZE, 0));
                var blkBtm :Point =
                    _isoView.isoToLocal(new Pt(xx + BLOCK_SIZE, yy + BLOCK_SIZE, 0));
                if (blkTop.y < size.y &&
                    blkBtm.y > 0 &&
                    blkLeft.x < size.x &&
                    blkRight.x > 0) {
                    blocks.add(getBlockKey(xx, yy));
                }
            }
        }

        return blocks;
    }

    protected function getBlockKey (x :int, y :int) :int
    {
        return (MathUtil.floorDiv(x, BLOCK_SIZE) << 16 |
            (MathUtil.floorDiv(y, BLOCK_SIZE) & 0xFFFF));
    }

    protected function getBlockX (key :int) :int
    {
        return (key >> 16) * BLOCK_SIZE;
    }

    protected function getBlockY (key :int) :int
    {
        // We really do mean to do this crazy shift left then back right thing to get our sign
        //  back from before we encoded.
        return (((key & 0xFFFF) * BLOCK_SIZE) << 16) >> 16;
    }

    protected function refreshBaseBlockScenes () :void
    {
        var blocks :Set = getBaseBlocks();

        // Take out any scenes no longer in our valid blocks.
        for each (var baseKey :int in _baseScenes.keys()) {
            if (!blocks.contains(baseKey)) {
                // It's not valid anymore, so toss it.
                _isoView.removeScene(_baseScenes.remove(baseKey));
            }
        }

        blocks.forEach(function(blockKey :int) :void {
            if (!_baseScenes.containsKey(blockKey)) {
                // Not already in there, let's create and add it.
                var x :int = getBlockX(blockKey);
                var y :int = getBlockY(blockKey);

                var baseScene :IsoScene = new IsoScene();
                for (var ii :int = x; ii < x + BLOCK_SIZE; ii++) {
                    for (var jj :int = y; jj < y + BLOCK_SIZE; jj++) {
                        var tileId :int = _model.getBaseTileId(ii, jj);
                        if (tileId <= 0) {
                            var defSet :TileSet;
