public virtual void UnloadTile(MapTreeNode node, Action <bool> callback)
{
Destroy(node.Tile.gameObject);
node.Tile = null;
callback?.Invoke(true);
}
/// <summary>
/// Fetch the asset bundle containing the tile from the web or from
/// disk, depending on the url.
/// </summary>
protected IEnumerator LoadBundleRoutine(MapTreeNode node)
{
if (AssetBundleCache.ContainsKey(node.Key))
{
yield break;
}
if (node.Data == null)
{
yield break;
}
var url = GetAbsoluteUrl(node.Data.BundleFile);
using (var request = UnityWebRequestAssetBundle.GetAssetBundle(url, 0, 0))
{
yield return(request.SendWebRequest());
if (request.isNetworkError || request.isHttpError)
{
Debug.LogError($"Failed to send web request to URL: {url}");
Debug.LogError(request.error);
}
else
{
var bundle = DownloadHandlerAssetBundle.GetContent(request);
AssetBundleCache[node.Key] = bundle;
}
}
}
/// <summary>
/// Load texture from the loaded asset bundle and assign the material
/// to the tile.
/// </summary>
protected override IEnumerator LoadTextureRoutine(MapTreeNode node)
{
if (!AssetBundleCache.ContainsKey(node.Key))
{
node.Tile.TextureLoaded = true;
yield break;
}
var bundle = AssetBundleCache[node.Key];
var request = bundle.LoadAssetAsync <Texture2D>(node.Data.TextureFile);
yield return(request);
while (!node.Tile.MeshLoaded)
{
yield return(null);
}
var g = node.Tile.GetComponentInChildren <MeshFilter>().gameObject;
var renderer = g.AddComponent <MeshRenderer>();
renderer.material = TileMat;
renderer.material.mainTexture = (Texture2D)request.asset;
node.Tile.TextureLoaded = true;
}
private void btnRemoveUnusedDatasets_Click(object sender, EventArgs e)
{
MapTreeNode root = (MapTreeNode)tvDatasets.Nodes[0];
List <DatasetTreeNode> remove = new List <DatasetTreeNode>();
foreach (DatasetTreeNode dsNode in root.Nodes)
{
if (dsNode.LayerCount == 0)
{
remove.Add(dsNode);
}
}
foreach (DatasetTreeNode r in remove)
{
_map.RemoveDataset(r.Dataset);
r.Remove();
}
//tvDatasets_AfterSelect(tvDatasets, null);
//btnRemoveUnusedDatasets.Enabled = false;
InitUI();
}
/// <summary>
/// Load mesh from the loaded asset bundle and instantiate the mesh
/// GameObject.
/// </summary>
protected override IEnumerator LoadMeshRoutine(MapTreeNode node)
{
if (!AssetBundleCache.ContainsKey(node.Key))
{
node.Tile.MeshLoaded = true;
yield break;
}
var g = new GameObject("mesh");
g.transform.SetParent(node.Tile.transform);
g.transform.localPosition = node.AnchorOffset;
g.transform.localRotation = node.WorldRotation;
var filter = g.AddComponent <MeshFilter>();
var collider = g.AddComponent <MeshCollider>();
var bundle = AssetBundleCache[node.Key];
var request = bundle.LoadAssetAsync <Mesh>(node.Data.MeshFile);
yield return(request);
filter.sharedMesh = (Mesh)request.asset;
collider.sharedMesh = filter.sharedMesh;
node.Tile.MeshLoaded = true;
}
public FormMapDatasets(IMap map)
{
InitializeComponent();
_map = map;
MapTreeNode root = new MapTreeNode()
{
Map = _map
};
int i = 0;
IDataset dataset = null;
while ((dataset = _map[i++]) != null)
{
int count = (from l in _map.MapElements where l.DatasetID == (i - 1) select l).Count();
root.Nodes.Add(new DatasetTreeNode()
{
Dataset = dataset, LayerCount = count
});
if (btnRemoveUnusedDatasets.Enabled == false)
{
btnRemoveUnusedDatasets.Enabled = count == 0;
}
}
tvDatasets.Nodes.Add(root);
root.Expand();
}
public override void UnloadTile(MapTreeNode node, Action <bool> callback)
{
var task = new TileWorkItem {
Node = node, Callback = callback
};
UnloadTasks.Enqueue(task);
}
public MapTreeNodeStr(MapTreeNode mapTreeNode, MapTreeStr mapTreeStr)
{
Tree = mapTreeStr;
MapID = new OutputStructSentence("マップID", mapTreeNode.MapID.ToString());
MapName = new OutputStructSentence("マップ名", SetMapName(mapTreeNode.MapID));
IsExpanded = new OutputStructSentence("子ノード群が展開されているか", mapTreeNode.IsExpanded.ToString());
ParentNode = mapTreeNode?.ParentNode;
}
protected void CreateTile(MapTreeNode node)
{
var g = new GameObject(node.Key);
g.transform.SetParent(transform);
g.transform.position = node.WorldPosition;
g.transform.rotation = Quaternion.identity;
node.Tile = g.AddComponent <MapTile>();
node.Tile.Node = node;
}
private void UnloadBundle(MapTreeNode node)
{
if (!AssetBundleCache.ContainsKey(node.Key))
{
return;
}
var bundle = AssetBundleCache[node.Key];
AssetBundleCache.Remove(node.Key);
bundle.Unload(true);
}
async void ReadMapTreeTest()
{
pathText.text = Application.streamingAssetsPath;
string path = Application.streamingAssetsPath + "/Project/Data/BasicData/MapTree.dat";
var reader = new MapTreeDataFileReader();
MapTreeData data = await reader.ReadFileAsync(path);
for (int i = 0; i < data.TreeNodeList.Count; i++)
{
MapTreeNode node = data.TreeNodeList[i];
}
//infoText.text = mapData.MapSizeWidth.ToString();
}
protected override IEnumerator LoadMeshRoutine(MapTreeNode node)
{
var g = GameObject.CreatePrimitive(PrimitiveType.Cube);
g.transform.SetParent(node.Tile.transform);
g.transform.position = node.WorldPosition + 0.5f * new Vector3((float)node.Size, 0, (float)node.Size);
g.transform.localRotation = Quaternion.identity;
g.transform.localScale = new Vector3((float)node.Size, 1, (float)node.Size);
yield return(new WaitForSeconds(1));
node.Tile.MeshLoaded = true;
}
protected override IEnumerator LoadTextureRoutine(MapTreeNode node)
{
while (!node.Tile.MeshLoaded)
{
yield return(null);
}
var r = node.Tile.GetComponentInChildren <Renderer>();
r.material = TileMat;
r.material.color = Color.Lerp(Color.white, Color.red, node.Level * 0.3f);
yield return(new WaitForSeconds(1));
node.Tile.TextureLoaded = true;
}
protected IEnumerator SetupMapTree()
{
// create base level nodes
foreach (var tiledata in Metadata.Tiles.Where(x => x.Level == 0))
{
var node = new MapTreeNode(null, tiledata);
BaseLevelNodes.Add(node);
}
var time = DateTime.Now;
// expand base level nodes into separate trees
var q = new Queue <MapTreeNode>(BaseLevelNodes);
while (q.Count > 0)
{
var node = q.Dequeue();
NodeIndex[node.Key] = node;
InitNode(node);
if (node.Level >= Metadata.MaxLevel)
{
continue;
}
// expand node into its children
for (int row = 0; row < 2; ++row)
{
for (int col = 0; col < 2; ++col)
{
var child = new MapTreeNode(node, node.Level + 1, node.X * 2 + col, node.Y * 2 + row);
node.AddChild(child);
q.Enqueue(child);
}
}
if ((DateTime.Now - time).TotalSeconds > 1f / 60)
{
yield return(null);
time = DateTime.Now;
}
}
}
protected void InitNode(MapTreeNode node)
{
if (node.Data == null)
{
node.Data = Metadata.FindTile(node.Level, node.X, node.Y);
}
node.Size = Metadata.BaseTileSize / (1 << node.Level);
node.Origin = Metadata.Position + new Double2(node.Size * node.X, node.Size * node.Y);
var tileoffset = new Vector3((float)(node.Size * node.X), 0, (float)(node.Size * node.Y));
var anchoroffset = new Vector3((float)Metadata.AnchorOffset.X, 0, (float)Metadata.AnchorOffset.Y);
node.WorldPosition = tileoffset;
node.WorldRotation = Quaternion.Euler(Metadata.Rotation);
node.AnchorOffset = anchoroffset - tileoffset;
node.MinDistance = (node.Level == Metadata.MaxLevel) ? 0 : node.Size * Math.Sqrt(2);
node.TileLoader = Loader;
}
private void InitUI()
{
tvDatasets.Nodes.Clear();
MapTreeNode root = new MapTreeNode()
{
Map = _map
};
int i = 0;
IDataset dataset = null;
while ((dataset = _map[i++]) != null)
{
int count = (from l in _map.MapElements where l.DatasetID == (i - 1) select l).Count();
var datasetNode = new DatasetTreeNode()
{
Dataset = dataset, LayerCount = count
};
root.Nodes.Add(datasetNode);
if (btnRemoveUnusedDatasets.Enabled == false)
{
btnRemoveUnusedDatasets.Enabled = count == 0;
}
if (count > 0)
{
foreach (var layer in _map.MapElements.Where(l => l.DatasetID == i - 1))
{
datasetNode.Nodes.Add(new LayerTreeNode(layer));
}
}
}
tvDatasets.Nodes.Add(root);
root.Expand();
}
protected virtual IEnumerator LoadTileRoutine(MapTreeNode node, Action <bool> callback)
{
CreateTile(node);
var tasks = new List <Coroutine>
{
StartCoroutine(LoadMeshRoutine(node)),
StartCoroutine(LoadTextureRoutine(node))
};
foreach (var task in tasks)
{
yield return(task);
}
while (!node.Tile.MeshLoaded || !node.Tile.TextureLoaded)
{
yield return(null);
}
callback?.Invoke(true);
}
protected abstract IEnumerator LoadTextureRoutine(MapTreeNode node);
protected abstract IEnumerator LoadMeshRoutine(MapTreeNode node);
public virtual void LoadTile(MapTreeNode node, Action <bool> callback)
{
StartCoroutine(LoadTileRoutine(node, callback));
}
