private /*sealed*/ void Init()
        {
            sizeXTiles = desc.SizeXTiles;
            sizeZTiles = desc.SizeZTiles;

            // Center the map on the world origin
            int pageSize      = TerrainManager.Instance.PageSize;
            int centerXMeters = (desc.SizeXPixels * desc.MetersPerSample) / 2;
            int centerZMeters = (desc.SizeZPixels * desc.MetersPerSample) / 2;

            centerXMeters = (centerXMeters / pageSize) * pageSize;
            centerZMeters = (centerZMeters / pageSize) * pageSize;

            xWorldOffsetMeters = centerXMeters;
            zWorldOffsetMeters = centerZMeters;

            tiles = new MosaicTile[sizeXTiles, sizeZTiles];

            for (int tileX = 0; tileX < sizeXTiles; tileX++)
            {
                for (int tileZ = 0; tileZ < sizeZTiles; tileZ++)
                {
                    float      worldTileSizeMM = desc.TileSizeSamples * desc.MetersPerSample * TerrainManager.oneMeter;
                    Vector3    worldLocMM      = new Vector3(tileX * worldTileSizeMM - xWorldOffsetMeters * TerrainManager.oneMeter, 0, tileZ * worldTileSizeMM - zWorldOffsetMeters * TerrainManager.oneMeter);
                    MosaicTile tile            = NewTile(tileX, tileZ, worldLocMM);
                    tile.TileModificationStateChanged += UpdateModifiedState;
                    tile.TileChanged += Tile_OnTileChanged;

                    tiles[tileX, tileZ] = tile;
                }
            }

            TerrainManager.Instance.SettingCameraLocation += CameraLocationPreChange;

            int tileSize = desc.TileSizeSamples;

            tileMask = tileSize - 1;

            tileShift = 0;
            while (tileSize > 1)
            {
                tileSize = tileSize >> 1;
                tileShift++;
            }

            // ensure its a power of 2
            Debug.Assert((1 << tileShift) == desc.TileSizeSamples);
        }
        private void UpdateModifiedState(MosaicTile tile, bool state)
        {
            bool contained = modifiedTiles.Contains(tile);

            //todo: change modifiedTiles to a HashSet when we can use .Net 3.0
            //todo: this would simplify the logic to simply adding or removing based on state
            if (contained && !state)
            {
                modifiedTiles.Remove(tile);
            }
            else if (!contained && state)
            {
                modifiedTiles.Add(tile);
            }

            Modified = modifiedTiles.Count > 0 || desc.Modified;
        }
        private void FireTerrainSplatChanged(MosaicTile tile, int worldXMeters, int worldZMeters, int sizeXMeters, int sizeZMeters)
        {
            if (m_changeNotificationEnabled && TerrainSplatChanged != null)
            {
                TextureMosaicTile textile = tile as TextureMosaicTile;
                if (textile == null)
                {
                    // Refresh all textures within the mosaic
                    // that have dirty texture images
                    RefreshTextures();
                }
                else
                {
                    // Only refresh the given tile
                    textile.RefreshTexture();
                }

                TerrainSplatChanged(this, tile, worldXMeters, worldZMeters, sizeXMeters, sizeZMeters);
            }
        }
        private void Tile_OnTileChanged(MosaicTile tile, int tileXSample, int tileZSample, int sizeXSamples, int sizeZSamples)
        {
            if (MosaicChanged != null)
            {
                // Convert samples coordinates & size to world coordinates & size in meters
                int tileSizeMeters = desc.MetersPerSample * desc.TileSizeSamples;

                // Calculate the upper left corner of the tile in world coordinates
                int worldXMeters = tileXSample * desc.MetersPerSample - xWorldOffsetMeters;
                int worldZMeters = tileZSample * desc.MetersPerSample - zWorldOffsetMeters;

                // Adjust for the tile-specific coordinate
                worldXMeters += tile.tileX * tileSizeMeters;
                worldZMeters += tile.tileZ * tileSizeMeters;

                // Calculate the size of the modified area in meters
                int sizeXMeters = sizeXSamples * desc.MetersPerSample;
                int sizeZMeters = sizeZSamples * desc.MetersPerSample;

                // Generate the notification
                MosaicChanged(this, tile, worldXMeters, worldZMeters, sizeXMeters, sizeZMeters);
            }
        }
Beispiel #5
0
 protected void On_TerrainSplatChanged(ITerrainMaterialConfig cfg, MosaicTile tile, int worldXMeters, int worldZMeters, int sizeXMeters, int sizeZMeters)
 {
     dirty = true;
 }
 private void Mosaic_OnMosaicChanged(Mosaic mosaic, MosaicTile tile, int worldXMeters, int worldZMeters, int sizeXMeters, int sizeZMeters)
 {
     FireTerrainSplatChanged(tile, worldXMeters, worldZMeters, sizeXMeters, sizeZMeters);
 }
        private void UpdateModifiedState(MosaicTile tile, bool state)
        {
            bool contained = modifiedTiles.Contains(tile);

            //todo: change modifiedTiles to a HashSet when we can use .Net 3.0
            //todo: this would simplify the logic to simply adding or removing based on state
            if (contained && !state)
            {
                modifiedTiles.Remove(tile);
            }
            else if (!contained && state)
            {
                modifiedTiles.Add(tile);
            }

            Modified = modifiedTiles.Count > 0 || desc.Modified;
        }
        private void Tile_OnTileChanged(MosaicTile tile, int tileXSample, int tileZSample, int sizeXSamples, int sizeZSamples)
        {
            if (MosaicChanged != null)
            {
                // Convert samples coordinates & size to world coordinates & size in meters
                int tileSizeMeters = desc.MetersPerSample * desc.TileSizeSamples;

                // Calculate the upper left corner of the tile in world coordinates
                int worldXMeters = tileXSample * desc.MetersPerSample - xWorldOffsetMeters;
                int worldZMeters = tileZSample * desc.MetersPerSample - zWorldOffsetMeters;

                // Adjust for the tile-specific coordinate
                worldXMeters += tile.tileX * tileSizeMeters;
                worldZMeters += tile.tileZ * tileSizeMeters;

                // Calculate the size of the modified area in meters
                int sizeXMeters = sizeXSamples * desc.MetersPerSample;
                int sizeZMeters = sizeZSamples * desc.MetersPerSample;

                // Generate the notification
                MosaicChanged(this, tile, worldXMeters, worldZMeters, sizeXMeters, sizeZMeters);
            }
        }
        private void FireTerrainSplatChanged(MosaicTile tile, int worldXMeters, int worldZMeters, int sizeXMeters, int sizeZMeters)
        {
            if (m_changeNotificationEnabled && TerrainSplatChanged != null)
            {
                TextureMosaicTile textile = tile as TextureMosaicTile;
                if (textile == null)
                {
                    // Refresh all textures within the mosaic
                    // that have dirty texture images
                    RefreshTextures();
                }
                else
                {
                    // Only refresh the given tile
                    textile.RefreshTexture();
                }

                TerrainSplatChanged(this, tile, worldXMeters, worldZMeters, sizeXMeters, sizeZMeters);
            }
        }
 private void Mosaic_OnMosaicChanged(Mosaic mosaic, MosaicTile tile, int worldXMeters, int worldZMeters, int sizeXMeters, int sizeZMeters)
 {
     FireTerrainSplatChanged(tile, worldXMeters, worldZMeters, sizeXMeters, sizeZMeters);
 }
 protected void On_TerrainSplatChanged(ITerrainMaterialConfig cfg, MosaicTile tile, int worldXMeters, int worldZMeters, int sizeXMeters, int sizeZMeters)
 {
     dirty = true;
 }