public TileDetails(TileConfig tc) : this()
{
_tileConfig = tc;
IsEdit = true;
PopulateControls();
}
public void wordt_de_juiste_tegel_gevonden()
{
var config = new TileConfig
{
Naam = nameof(wordt_de_juiste_tegel_gevonden),
LinksBoven = new Coordinaat(116000, 580000),
TegelBreedte = 1000,
TegelHoogte = 1000,
Url = "{X_Links},{Y_Boven},{X_Rechts},{Y_Onder},{Rij},{Kolom}",
};
var tiles = config.GetTilesForRectangle(new[] { new Coordinaat(config.LinksBoven.X + 1, config.LinksBoven.Y - 1), new Coordinaat(config.LinksBoven.X + 2, config.LinksBoven.Y - 2) });
PAssert.That(() => tiles.Count() == 1);
var tile = tiles.Single();
PAssert.That(() => tile.TopLeft.X == config.LinksBoven.X);
PAssert.That(() => tile.TopLeft.Y == config.LinksBoven.Y);
PAssert.That(() => tile.BottomRight.X == config.LinksBoven.X + config.TegelBreedte);
PAssert.That(() => tile.BottomRight.Y == config.LinksBoven.Y - config.TegelHoogte);
PAssert.That(() => tile.Rij == 1);
PAssert.That(() => tile.Kolom == 1);
PAssert.That(() => tile.FormattedUrl() == "116000,580000,117000,579000,1,1");
}
public void CreateTilesFromConfiguration(TileConfig tileConfig, UnityObject prefab)
{
Vector2 coordinate = tileConfig.coordinate;
TileType type = tileConfig.type;
State state = tileConfig.state;
int tileCoordinateX = (int)coordinate.x;
int tileCoordinateY = (int)coordinate.y;
BaseTile tile = null;
switch (type)
{
case TileType.Water:
tile = waterTilePrefab;
break;
case TileType.Asphalt:
tile = asphaltTilePrefab;
break;
case TileType.Grass:
tile = grassTilePrefab;
break;
}
InstantiateSavedTile(tileCoordinateX, tileCoordinateY, tile);
InstantiateSavedUnityObject(tileCoordinateX, tileCoordinateY, prefab);
SetState(tileCoordinateX, tileCoordinateY, state);
}
/// <summary>
/// Initialize the generation context: settings, logger,
/// tiles configuration and tile generator.
/// </summary>
private void Init()
{
// Load settings
try {
_settings = Settings.LoadOrDefault(Settings.SETTINGS_PATH);
_logger = new Logger(_settings.LogFilePath);
} catch (Exception ex) {
_msg.InvalidSettings(ex);
Environment.Exit(11);
return;
}
// Initialize the logger
_msg.Logger = _logger;
try {
_logger.Init();
} catch (Exception ex) {
_msg.InvalidLogFile(ex);
Environment.Exit(12);
return;
}
_logger.Success("Loaded settings");
// Load tiles configuration
try {
_tilesConfig = TileConfig.Load(_settings.TilesConfigPath);
} catch (Exception ex) {
_msg.InvalidTilesConfig(ex);
Environment.Exit(13);
}
_logger.Success("Loaded tiles configuration");
// Initialize the tile generator
_generator = new TileGenerator(_settings, _logger);
_logger.Success("Initialized tiles generator");
}
public EditorTiles(string stage_directory, string palleteDir = null)
{
Image = new GIF(Path.Combine(stage_directory, "16x16Tiles.gif"), palleteDir);
//ImageTransparent = new GIF(SetImageOpacity(Image.ToBitmap(), (float)0.1));
//IDImage = new GIF(Environment.CurrentDirectory + "\\Resources\\Tile Overlays\\" + "16x16Tiles_ID.gif");
//EditorImage = new GIF(Environment.CurrentDirectory + "\\Resources\\Tile Overlays\\" + "16x16Tiles_Edit.gif");
if (File.Exists(Path.Combine(stage_directory, "TileConfig.bin")))
{
Config = new TileConfig(Path.Combine(stage_directory, "TileConfig.bin"));
Bitmap SheetA = new Bitmap(16, 16 * 1024);
Bitmap SheetB = new Bitmap(16, 16 * 1024);
using (Graphics g = Graphics.FromImage(SheetA))
{
for (int i = 0; i < 1024; i++)
{
g.DrawImage(Config.CollisionPath1[i].DrawCMask(System.Drawing.Color.FromArgb(0, 0, 0, 0), System.Drawing.Color.White), new Point(0, 16 * i));
}
}
using (Graphics g = Graphics.FromImage(SheetB))
{
for (int i = 0; i < 1024; i++)
{
g.DrawImage(Config.CollisionPath2[i].DrawCMask(System.Drawing.Color.FromArgb(0, 0, 0, 0), System.Drawing.Color.White), new Point(0, 16 * i));
}
}
CollisionMaskA = new GIF(SheetA);
CollisionMaskB = new GIF(SheetB);
}
}
private static void AchtergrondCommand_(TileConfig tileConfig)
{
try
{
var location = AutocadUtils.GetRectangle();
if (location == null)
{
return;
}
var tileNames = tileConfig.GetTileByLocation(location).ToArray();
if (!tileNames.Any())
{
Application.ShowAlertDialog(GeenAchtergrondGevonden);
}
foreach (var tileName in tileNames)
{
var num = (short)Application.GetSystemVariable("FILEDIA");
Application.DocumentManager.CurrentDocument.SendStringToExecute("_FILEDIA " + 0 + " ", true, false,
false);
var str = $"_MAPIINSERT \"{tileName}\" N ";
Application.DocumentManager.CurrentDocument.SendStringToExecute(str, false, true, true);
Application.DocumentManager.CurrentDocument.SendStringToExecute("_FILEDIA " + num + " ", true, false,
false);
}
}
catch (Exception ex)
{
Utilities.HandleError(ex);
}
}
public Key(DataSource dataSource, TileConfig config)
{
DataSourceId = dataSource.DataSourceId;
ZoomLevel = config.ZoomLevel;
TileX = config.TileX;
TileY = config.TileY;
}
private void radButtonDelete_Click(object sender, EventArgs e)
{
List <TileConfig> lTileConfig = _lTileConfig != null ? _lTileConfig : new List <TileConfig>();
if (this.radGridViewTileConfig.CurrentRow is GridViewDataRowInfo)
{
TileConfig targetTileConfig = (TileConfig)radGridViewTileConfig.CurrentRow.DataBoundItem;
if (lTileConfig.Count(x => x.TileconfigID == targetTileConfig.ID) > 0)
{
System.Diagnostics.Debug.WriteLine("Cannot delete ID: {0}, since sub tiles exist", targetTileConfig.ID);
this.ShowAlertBox("Options", "Sub tiles exist under parent tile, cannot delete parent tile!");
}
else
{
System.Diagnostics.Debug.WriteLine("Delete ID: {0}", targetTileConfig.ID);
DialogResult dr = RadMessageBox.Show(this, "Are you sure delete the tile? This operation cannot be undone!", "Delete Tile", MessageBoxButtons.YesNo, RadMessageIcon.Question);
if (dr == DialogResult.Yes)
{
SetCurrentSelectionIndex();
NetworkFunction.DeleteTileConfig(targetTileConfig);
}
}
}
}
private void SetAllTileConfigFromServer(TileConfig tileConfig)
{
string dataFolder = Utility.GetGameSelectorDataFolder();
Utility.MakeSureFolderExist(dataFolder + @"Images");
_internalTileConfig = null;
if (PopulateImageFolder(tileConfig.MainScreenTiles, dataFolder))
{
_internalTileConfig = tileConfig;
if (_internalClientRunningMode != null && (_internalClientRunningMode.RunningMode == Enums.ClientRunningMode.TIMING_ON || _internalClientRunningMode.RunningMode == Enums.ClientRunningMode.NO_TIMING_ON))
{
Tile playTile = _internalTileConfig.MainScreenTiles.Where(x => x.TileID == _internalClientRunningMode.CurrentRunningTileID.ToString()).FirstOrDefault();
if (playTile != null)
{
_internalCurrentPlayingTile = playTile;
}
}
_isRequestingTileWithImage = false;
Debug.WriteLine("========IMAGE GOOD");
}
else
{
// some image not exist / not match
_isRequestingTileWithImage = true;
Debug.WriteLine("========IMAGE NOT GOOD");
}
}
private static void AchtergrondCommand(TileConfig tileConfig)
{
using (var tr = Application.DocumentManager.CurrentDocument.TransactionManager.StartTransaction()) {
var i = new GeomapImage();
tr.GetObject(Application.DocumentManager.CurrentDocument.Database.CurrentSpaceId, OpenMode.ForWrite);
var ri = RasterImageDef.GetImageDictionary(Application.DocumentManager.MdiActiveDocument.Database);
}
}
public NeighborData(TileConfig leftNeighborConfig, TileConfig rightNeighborConfig, int leftRotation, int rightRotation, bool horizontal = true)
{
LeftNeighborConfig = leftNeighborConfig;
RightNeighborConfig = rightNeighborConfig;
LeftRotation = leftRotation;
RightRotation = rightRotation;
Horizontal = horizontal;
}
public void GenerateMap()
{
TileConfig[,] tileConfigs = new TileConfig[, ] {
{ land, mountain, land },
{ land, mountain, land },
{ mountain, mountain, land }
};
MeshMap.GenerateMap(transform, tileConfigs);
}
private void buttonTileConfigDown_Click(object sender, EventArgs e)
{
if (this.radGridViewTileConfig.CurrentRow is GridViewDataRowInfo)
{
TileConfig targetTileConfig = (TileConfig)radGridViewTileConfig.CurrentRow.DataBoundItem;
SetCurrentSelectionIndex();
NetworkFunction.ReOrderDownTileConfig(targetTileConfig);
}
}
public static void GetTileConfig(int tileConfigSetID)
{
TileConfig tc = new TileConfig()
{
TileConfigSetID = tileConfigSetID
};
VRCommandServer cmd = new VRCommandServer(Enums.ControlMessage.GET_TILE_CONFIG, tc);
SendCommandToServer(cmd);
}
public StageTiles(string stage_directory, string palleteDir = null)
{
Image = new GIF(Path.Combine(stage_directory, "16x16Tiles.gif"), palleteDir);
ImageTransparent = new GIF(SetImageOpacity(Image.ToBitmap(), (float)0.1));
IDImage = new GIF(Environment.CurrentDirectory + "\\Resources\\Tile Overlays\\" + "16x16Tiles_ID.gif");
EditorImage = new GIF(Environment.CurrentDirectory + "\\Resources\\Tile Overlays\\" + "16x16Tiles_Edit.gif");
if (File.Exists(Path.Combine(stage_directory, "TileConfig.bin")))
{
Config = new TileConfig(Path.Combine(stage_directory, "TileConfig.bin"));
}
}
/// <summary>
/// Generate tiles for an application and update the shortcut.
/// </summary>
/// <param name="tileConfig">Tile generation configuration</param>
/// <param name="app">Application shortcut and executable information</param>
/// <param name="sizes">Tiles dimensions</param>
/// <param name="overwrite">Overwrite existing tiles</param>
public static void GenerateTileSet(TileConfig tileConfig, AppShortcut app, TileSetSizes sizes, bool overwrite = false)
{
// Prepare assets directory and make some verifications
string appPath = Path.GetDirectoryName(app.ExecutablePath);
string assetsPath = Path.Combine(appPath, AssetsConstants.AssetsFolderName);
string xml = Path.Combine(appPath, Path.GetFileNameWithoutExtension(app.ExecutablePath)
+ AssetsConstants.VisualElementsManifestXmlFileExtension);
string mediumTilePath = Path.Combine(assetsPath, AssetsConstants.MediumTileFileName);
string smallTilePath = Path.Combine(assetsPath, AssetsConstants.SmallTileFileName);
if (File.Exists(xml) && Directory.Exists(assetsPath) && !File.Exists(mediumTilePath) && !File.Exists(smallTilePath))
{
// Assets (not generated by Tile) already exist in the application directory
throw new Exception("Application already have built-in custom assets");
}
else if (!overwrite && File.Exists(xml))
{
// Custom assets (generated by Tile) already exist
throw new Exception("Custom assets already exist, delete them or set the override flag to true");
}
// else: create the assets directory
Directory.CreateDirectory(assetsPath);
// Generate the XML file (background color, logo paths, foreground color, and XML filename)
File.WriteAllText(xml, GenerateXMLVisualElements(
tileConfig.BackgroundColorAsObj, tileConfig.ForegroundTextAsEnum, tileConfig.ShowNameOnMediumTile));
// Tile generation
Image mediumTile, smallTile;
if (tileConfig.GenerationModeAsEnum == TileGenerationMode.Custom)
{
mediumTile = GenerateTile(sizes.Medium.TileSize, tileConfig.BackgroundColorAsObj,
tileConfig.IconPath, sizes.Medium.TileSize);
smallTile = GenerateTile(sizes.Small.TileSize, tileConfig.BackgroundColorAsObj,
tileConfig.IconPath, sizes.Small.TileSize);
}
else
{
int shift = (int)(ADJUSTED_ICON_Y_SHIFT * sizes.Medium.TileSize.Height);
mediumTile = GenerateTile(sizes.Medium.TileSize, tileConfig.BackgroundColorAsObj,
tileConfig.IconPath, sizes.Medium.IconSize.Scale(tileConfig.IconScale.MediumTile),
tileConfig.GenerationModeAsEnum == TileGenerationMode.Adjusted ? shift : 0);
smallTile = GenerateTile(sizes.Small.TileSize, tileConfig.BackgroundColorAsObj,
tileConfig.IconPath, sizes.Small.IconSize.Scale(tileConfig.IconScale.SmallTile));
}
// Save tiles in assets directory
mediumTile.Save(mediumTilePath, ImageFormat.Png);
smallTile.Save(smallTilePath, ImageFormat.Png);
// Set shortcut last write time to now (to update tile)
File.SetLastWriteTime(app.ShortcutPath, DateTime.Now);
}
private void radGridViewTileConfig_DoubleClick(object sender, EventArgs e)
{
if (this.radGridViewTileConfig.CurrentRow is GridViewDataRowInfo)
{
TileConfig targetTileConfig = (TileConfig)radGridViewTileConfig.CurrentRow.DataBoundItem;
SetCurrentSelectionIndex();
TileDetails td = new TileDetails(targetTileConfig);
td.ShowDialog();
}
}
private void buttonSendTileConfig_Click(object sender, EventArgs e)
{
List <Connection> currentConnections = NetworkComms.GetExistingConnection();
TileConfig tc = BuildMockTileData();
foreach (Connection conn in currentConnections)
{
VRCommand cmd = new VRCommand(tc);
SendCommandToClientSpecific(conn, cmd);
}
}
/// <summary>
/// Reload the tiles configuration file.
/// </summary>
/// <param name="sender">Event sender</param>
/// <param name="e">Event arguments</param>
private void ReloadTilesConfigurationFile(object sender, RoutedEventArgs e)
{
try {
_tilesConfig = TileConfig.Load(_settings.TilesConfigPath);
_apps = null;
_viewModel.SelectedApps = null;
_viewModel.IsReady = false;
_msg.LoadedTilesConfigFile();
LookupApplications();
} catch (Exception ex) {
_msg.InvalidTilesConfig(ex);
}
}
public List <Feature> Fetch(TileConfig config, DataSource dataSource)
{
//Don't cache high levels
if (config.ZoomLevel < _minLevelToCache)
{
return(dataSource.Fetch(config.PaddedEnvelope));
}
var key = new Key(dataSource, config);
return(_lurchTable.GetOrAdd(key, delegate
{
return dataSource.Fetch(config.PaddedEnvelope);
}));
}
/// <summary>
/// Copy the embedded tiles configuration file next to the application executable
/// to allow the user to customize tile generation.
/// </summary>
/// <param name="sender">Event sender</param>
/// <param name="e">Event arguments</param>
private void ExposeTilesConfigurationFile(object sender, RoutedEventArgs e)
{
string path = _settings.TilesConfigPath;
if (File.Exists(path) && !_msg.OverwriteTilesConfigFile())
{
return;
} // else
try {
TileConfig.ExportEmbeddedConfiguration(path);
_msg.ExposedTilesConfigFile(path);
} catch (Exception ex) {
_msg.FailedExposingTilesConfigFile(ex);
}
}
public void buiten_het_raster_geen_tegel_boven()
{
var config = new TileConfig
{
Naam = nameof(buiten_het_raster_geen_tegel_links),
LinksBoven = new Coordinaat(116000, 580000),
TegelBreedte = 1000,
TegelHoogte = 1000,
Url = "{X_Links},{Y_Boven},{X_Rechts},{Y_Onder},{Rij},{Kolom}",
};
var tiles = config.GetTilesForRectangle(new[] { new Coordinaat(config.LinksBoven.X, config.LinksBoven.Y - 1), new Coordinaat(config.LinksBoven.X + 1, config.LinksBoven.Y - 2) });
PAssert.That(() => tiles.Count() == 0);
}
private void SetClientUITileConfig()
{
if (_internalTileConfig != null)
{
TileConfig tmpTileConfig = _internalTileConfig;
if (_internalClientRunningMode != null && _internalClientRunningMode.CustomerAge > 0)
{
tmpTileConfig.MainScreenTiles.RemoveAll(x => x.AgeRequire > _internalClientRunningMode.CustomerAge);
}
VRCommand cmd = new VRCommand(tmpTileConfig);
SendCommandToUIClient(cmd);
}
}
public bool CanPlaceLabel(TileConfig tile, LabelDetails label)
{
var qt = _quadtrees[tile.ZoomLevel];
lock (qt)
{
var potentials = qt.Query(label.Outline.EnvelopeInternal);
foreach (var x in potentials)
{
//If we collide with ourself, we can be placed
if (x.Outline.Intersects(label.Outline))
{
return(x.UniqueId == label.UniqueId);
}
}
qt.Insert(label.Outline.EnvelopeInternal, label);
}
return(true);
}
/// <summary>
/// Load configuration, initialize and run the program.
/// </summary>
/// <param name="args">Command line arguments</param>
/// <returns>Exit code</returns>
private int Run(string[] args = null)
{
var settings = Settings.LoadOrDefault(Settings.SETTINGS_PATH);
_logger = new Logger(settings.LogFilePath);
_logger.Init();
_logger.Success("Loaded settings");
var tilesConfig = TileConfig.Load(settings.TilesConfigPath);
_logger.Success("Loaded tiles configuration");
var generator = new TileGenerator(settings, _logger);
_logger.Success("Initialized tiles generator");
var apps = generator.LookupApps(tilesConfig);
if (apps.Count == 0)
{
_logger.Warning("No applications to process, check the shortcuts locations");
return(1);
}
else
{
_logger.Success($"Found {apps.Count} applications to process");
if (args.Length > 0)
{
apps = apps.Keep(args); // Only process given apps
}
var processedApps = generator.GenerateTiles(tilesConfig, apps);
if (processedApps.Count > 0)
{
_logger.Success($"Processed {processedApps.Count}/{apps.Count} application(s) ({string.Join(", ", processedApps)})");
}
else
{
_logger.Info("No tiles were generated");
}
}
return(0);
}
public async Task <TileConfig> UpdateAsync(TileConfig item)
{
var TileConfig = _context.TileConfig.Where(q => q.CharacterTileId == item.CharacterTileId).FirstOrDefault();
if (TileConfig == null)
{
return(TileConfig);
}
TileConfig.Col = item.Col;
TileConfig.Row = item.Row;
TileConfig.SizeX = item.SizeX;
TileConfig.SizeY = item.SizeY;
try
{
await _repo.Update(TileConfig);
}
catch (Exception ex)
{
throw ex;
}
return(TileConfig);
}
// incomming vr command
private void HandleIncomingCommand(PacketHeader packetHeader, Connection connection, VRCommand vrCommand)
{
switch (vrCommand.ControlMessage)
{
case Enums.ControlMessage.PLAY_LOG:
infoText = connection.ToString() + " Play Log: '" + vrCommand.PlayLog.TileID.ToString() + "', '" + vrCommand.PlayLog.SignalType.ToString() + "'";
break;
case Enums.ControlMessage.LOAD_CONFIG:
TileConfig tc = BuildMockTileData();
VRCommand cmd = new VRCommand(tc);
SendCommandToClientSpecific(connection, cmd);
break;
case Enums.ControlMessage.STATUS:
infoText = connection.ToString() + " Client Status: '" + vrCommand.ClientStatus.ClientIP + "'";
break;
case Enums.ControlMessage.CLIENT_UI_READY:
EndNow();
//Task.Delay(1000).ContinueWith(t => EndNow());
infoText = connection.ToString() + " Client UI Ready.";
break;
default:
break;
}
}
private void radButtonAddSubTile_Click(object sender, EventArgs e)
{
int parentTileConfigID = 0;
int lastOrder = 0;
List <TileConfig> lTileConfig = _lTileConfig != null ? _lTileConfig : new List <TileConfig>();
if (this.radGridViewTileConfig.CurrentRow is GridViewDataRowInfo)
{
TileConfig targetTileConfig = (TileConfig)radGridViewTileConfig.CurrentRow.DataBoundItem;
if (targetTileConfig.TileconfigID == 0)
{
parentTileConfigID = targetTileConfig.ID; // selected tile will be the parent
}
else
{
parentTileConfigID = targetTileConfig.TileconfigID; // set the parent tile
}
}
foreach (TileConfig tc in lTileConfig)
{
if (tc.TileconfigID == parentTileConfigID && tc.Order > lastOrder)
{
lastOrder = tc.Order;
}
}
System.Diagnostics.Debug.WriteLine("parentTileConfigID: {0} lastOrder: {1}", parentTileConfigID, lastOrder);
SetCurrentSelectionIndex();
TileDetails td = new TileDetails(parentTileConfigID, lastOrder + 1, (int)comboBoxTileConfig.SelectedItem.Value);
td.ShowDialog();
}
/// <summary>
/// Create button for each tile based at tiles configs library.
/// </summary>
/// <param name="tileConfigsLibrary">Tiles configs library.</param>
private void CreateTileButtonsGui(TileConfigsLibrary tileConfigsLibrary)
{
EditorGUILayout.BeginVertical(_innerContainerGuiStyle);
//Display the title
EditorGUILayout.LabelField("Tile Configs:", EditorStyles.boldLabel);
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal(EditorStyles.helpBox);
foreach (var tileConfig in tileConfigsLibrary.tileConfigsList)
{
if (GUILayout.Button($"{tileConfig.tileMaterialConfig.tileMaterialType}", GUILayout.Width(64), GUILayout.Height(40)))
{
Debug.Log($"Current tile material: {tileConfig.tileMaterialConfig.tileMaterialType}");
_currentTileConfig = tileConfig;
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
public void HandleEntry(FileInfo sourceFile, Entry entry, List <Model3D> modelCollection, DataTreeObject dataTreeParent = null, Transform3D globalTransform = null)
{
TileEntry tile = (TileEntry)entry;
//Transform3D trs = new Transform3D();
//tile.getTransform(tile.getConfig(scene.getConfigManager()), trs);
SetupCosmeticInformation(tile, dataTreeParent);
// TODO: Some config references have SK data that I need. I need to do a hybrid of my shallow implementation on
// top of the bootstrapper that loads the actual filtered game data so that I can grab everything.
TileConfig[] tileCfgs = ConfigReferenceBootstrapper.ConfigReferences["tile"].OfType <TileConfig>().ToArray();
TileConfig tileCfg = tileCfgs.GetEntryByName(tile.tile.getName());
if (tileCfg == null)
{
XanLogger.WriteLine($"Unable to find data for tile [{tile.tile.getName()}]!");
return;
}
// First things first: Tiles are offset and in the wrong position. Fix it.
SKAnimatorToolsProxy.IncrementEnd();
TileConfig.Original originalImpl;
do
{
if (tileCfg == null)
{
XanLogger.WriteLine("ALERT: A tile was null!", color: System.Drawing.Color.Red);
return;
}
if (tileCfg.getConfigManager() != null)
{
originalImpl = tileCfg.getOriginal(tileCfg.getConfigManager());
break;
}
else
{
if (tileCfg.implementation is TileConfig.Original original)
{
originalImpl = original;
break;
}
else if (tileCfg.implementation is TileConfig.Derived derived)
{
tileCfg = tileCfgs.GetEntryByName(derived.tile.getName());
}
else
{
originalImpl = null;
break;
}
}
} while (true);
//tile.GetExportTransform(originalImpl, out Transform3D transform);
// All transforms are relative to the center of the object. the origin of the actual models is in their lower-back-left bounds.
// I need to add a flag to tell the exporter to move the geometry based on bounds center.
Transform3D transform = new Transform3D();
tile.getTransform(originalImpl, transform);
//transform.getTranslation().addLocal(new Vector3f(0, tile.elevation / 2, 0));
string relativeModelPath = originalImpl.model.getName();
XanLogger.WriteLine("Grabbing tile [" + tile.tile.getName() + "] at " + relativeModelPath, XanLogger.DEBUG);
ConfigReferenceUtil.HandleConfigReference(sourceFile, originalImpl.model, modelCollection, dataTreeParent, globalTransform.compose(transform));
SKAnimatorToolsProxy.IncrementProgress();
}