public void DoExit()
{
foreach (string trigger in triggers)
{
TriggerMgr.ToggleTrigger(trigger, false);
}
ResourceMgr.CleanAllGameObjects();
}
public static void Reset()
{
CameraMgr.UseDefaultSkybox();
CameraMgr.Place(Vector3.zero);
CameraMgr.Euler(Vector3.zero);
ResourceMgr.ToggleAllGameObjects(false);
TriggerMgr.ToggleAllTrigger(false);
fsm.Reset();
}
public static void Clean()
{
CameraMgr.UseDefaultSkybox();
CameraMgr.Place(Vector3.zero);
CameraMgr.Euler(Vector3.zero);
ResourceMgr.CleanAllGameObjects();
TriggerMgr.Clean();
fsm.Clean();
images.Clear();
}
public static void Scale(string _uuid, float _x, float _y, float _z, OnErrorDelegate _onError)
{
GameObject go = ResourceMgr.FindGameObject(_uuid);
if (null == go)
{
_onError(string.Format("{0} is not exists !!!", _uuid));
return;
}
go.transform.localScale = new Vector3(_x, _y, _z);
}
// TO DO
public static void SmoothFollow(string _selfUUID, string _targetUUID, float _height, float _heightDamping, float _rotationDamping, OnErrorDelegate _onError)
{
GameObject self = ResourceMgr.FindGameObject(_selfUUID);
if (null == self)
{
_onError(string.Format("{0} is not exists !!!", _selfUUID));
return;
}
GameObject target = ResourceMgr.FindGameObject(_targetUUID);
if (null == target)
{
_onError(string.Format("{0} is not exists !!!", _targetUUID));
return;
}
}
public static void BatchDownloadRes(List <string> _list, OnSuccessFinishDelegate _onFinish)
{
operations.Clear();
List <string> tasks = new List <string>();
foreach (string task in _list)
{
string file = Path.GetFileName(task);
// All files will store in the persistentDataPath
ResourceMgr.UseExternalBundle(file);
if (!File.Exists(resPath + file))
{
tasks.Add(task);
}
}
Log.Info("HttpMgr", "BatchDownload [{0}] tasks", tasks.Count);
if (0 == tasks.Count)
{
_onFinish();
return;
}
int count = 0;
foreach (string task in tasks)
{
string file = Path.GetFileName(task);
Log.Debug("HttpMgr", "Async Get: {0}", task);
Http.Operation operation = http.AsyncGET(task, (_data) =>
{
Log.Debug("HttpMgr", "Get Finish: {0}", task);
System.IO.File.WriteAllBytes(resPath + file, _data);
onFinish(ref count, tasks.Count, _onFinish);
}, (_err) =>
{
Log.Error("HttpMgr", _err);
});
operations.Add(task, operation);
}
}
private static void preloadAssets(List <string> assets, CallBack _onFinish)
{
if (assets.Count <= 0)
{
_onFinish();
return;
}
string assetID = assets[0];
assets.RemoveAt(0);
string package = assetID.Split('@')[0];
string file = assetID.Split('@')[1];
// has '.' is ugc file
if (!file.Contains("."))
{
Log.Trace("SlateMgr", "preload asset package:{0} file:{1}", package, file);
ResourceMgr.PreloadAsset(package, file
, () =>
{
Log.Trace("SlateMgr", "ready preload asset package:{0} file:{1}", package, file);
}
, (_obj) =>
{
Log.Trace("SlateMgr", "finish preload asset package:{0} file:{1}", package, file);
preloadAssets(assets, _onFinish);
}
, (_error) =>
{
Log.Error("SlateMgr", "preload asset package:{0} file:{1} has error:{2}", package, file, _error);
preloadAssets(assets, _onFinish);
});
}
else
{
Log.Trace("SlateMgr", "skip preload ugcfile :{0}", file);
_onFinish();
}
}
public void DoEnter()
{
//preload assets
foreach (Asset asset in assets.Values)
{
// asset has format like as .wav
if (asset.file.Contains("."))
{
byte[] data = UGCMgr.Take(asset.file);
if (null == data)
{
this.LogError("Missing asset, group:{0} package:{1} file:{2} ", asset.group, asset.package, asset.file);
continue;
}
if (asset.group.Equals("skybox"))
{
Material skybox = UGCMgr.BuildSkybox(data);
CameraMgr.ApplySkybox(skybox);
}
}
else
{
Object obj = ResourceMgr.FindFromPreload(asset.package, asset.file);
if (null == obj)
{
this.LogError("Missing asset, group:{0} package:{1} file:{2} ", asset.group, asset.package, asset.file);
continue;
}
if (asset.group.Equals("agent"))
{
GameObject clone = ResourceMgr.CloneGameObject(asset.package, asset.file, asset.guid);
agents.Add(asset.guid);
clone.transform.position = new Vector3(asset.px, asset.py, asset.pz);
clone.transform.rotation = Quaternion.Euler(asset.rx, asset.ry, asset.rz);
clone.transform.localScale = new Vector3(asset.sx, asset.sy, asset.sz);
if (asset.gaze)
{
ReticleHandler handler = clone.AddComponent <ReticleHandler>();
handler.path = asset.slate;
handler.trigger = asset.gazeAlias;
EventTrigger et = clone.AddComponent <EventTrigger>();
EventTrigger.Entry entryEnter = new EventTrigger.Entry();
entryEnter.eventID = EventTriggerType.PointerEnter;
entryEnter.callback.AddListener((data) => { handler.onPointerEnter(); });
et.triggers.Add(entryEnter);
EventTrigger.Entry entryExit = new EventTrigger.Entry();
entryExit.eventID = EventTriggerType.PointerExit;
entryExit.callback.AddListener((data) => { handler.onPointerExit(); });
et.triggers.Add(entryExit);
EventTrigger.Entry entryClick = new EventTrigger.Entry();
entryClick.eventID = EventTriggerType.PointerClick;
entryClick.callback.AddListener((data) => { handler.onPointerClick(); });
et.triggers.Add(entryClick);
Collider collider = clone.GetComponent <Collider>();
if (null != collider)
{
collider.enabled = true;
}
}
}
else if (asset.group.Equals("skybox"))
{
CameraMgr.ApplySkybox(obj as Material);
}
}
}
//hide all triggers
TriggerMgr.ToggleAllTrigger(false);
//show trigger in current slate
foreach (string trigger in triggers)
{
TriggerMgr.ToggleTrigger(trigger, true);
}
// execute startup blocks
foreach (string guid in blocks)
{
Block block = BlockMgr.FindBlock(guid);
if (block.action.Equals("Entry:Startup"))
{
block.Execute();
}
}
}
private static void batchPreloadAsset(List <Dictionary <string, string> > _assets, onBatchPreloadFinishDelegate _onFinish)
{
if (_assets.Count == 0)
{
_onFinish();
return;
}
Dictionary <string, string> asset = _assets[0];
string packageUUID = asset["package"];
string fileUUID = asset["file"];
string imageUUID = asset["image"];
string cloneUUID = asset["uuid"];
string type = asset["type"];
_assets.RemoveAt(0);
if (type.Equals("skybox"))
{
Log.Debug("EditorMgr:importVCB", "preload skybox {0}", fileUUID);
ResourceMgr.PreloadAsset(packageUUID, fileUUID
, () =>
{
Log.Debug("EditorMgr::importVCB", "ready load skybox {0}@{1}", packageUUID, fileUUID);
}
, (_obj) =>
{
Editor.Image image = fsm.FindState(imageUUID) as Editor.Image;
image.skybox = _obj as Material;
Log.Debug("EditorMgr::importVCB", "load skybox {0}@{1} success", packageUUID, fileUUID);
batchPreloadAsset(_assets, _onFinish);
}
, (_err) =>
{
//onNotify(_err);
Log.Error("EditorMgr::importVCB", "load skybox {0}@{1} failed: {2}", packageUUID, fileUUID, _err);
batchPreloadAsset(_assets, _onFinish);
});
}
else if (type.Equals("agent"))
{
float posX = float.Parse(asset["pos.x"]);
float posY = float.Parse(asset["pos.y"]);
float posZ = float.Parse(asset["pos.z"]);
float rotX = float.Parse(asset["rot.x"]);
float rotY = float.Parse(asset["rot.y"]);
float rotZ = float.Parse(asset["rot.z"]);
float scaleX = float.Parse(asset["scale.x"]);
float scaleY = float.Parse(asset["scale.y"]);
float scaleZ = float.Parse(asset["scale.z"]);
Log.Debug("EditorMgr:importVCB", "preload agent {0}", fileUUID);
ResourceMgr.PreloadAsset(packageUUID, fileUUID
, () =>
{
Log.Debug("EditorMgr::importVCB", "ready load agent {0}@{1}", packageUUID, fileUUID);
}
, (_obj) =>
{
Editor.Image image = fsm.FindState(imageUUID) as Editor.Image;
GameObject go = ResourceMgr.CloneGameObject(packageUUID, fileUUID, cloneUUID);
go.SetActive(false);
go.transform.position = new Vector3(posX, posY, posZ);
go.transform.rotation = Quaternion.Euler(rotX, rotY, rotZ);
go.transform.localScale = new Vector3(scaleX, scaleY, scaleZ);
Collider collider = go.GetComponent <Collider>();
if (null != collider)
{
collider.enabled = true;
}
Battlehub.RTEditor.ExposeToEditor script = go.GetComponent <Battlehub.RTEditor.ExposeToEditor>();
if (null == script)
{
script = go.AddComponent <Battlehub.RTEditor.ExposeToEditor>();
//Debug.Log(script);
}
if (!image.objs.Contains(cloneUUID))
{
image.objs.Add(cloneUUID);
}
Log.Debug("EditorMgr::importVCB", "load agent {0}@{1} success", packageUUID, fileUUID);
batchPreloadAsset(_assets, _onFinish);
}
, (_err) =>
{
Log.Error("EditorMgr::importVCB", "load agent {0}@{1} failed: {2}", packageUUID, fileUUID, _err);
batchPreloadAsset(_assets, _onFinish);
});
}
}
private static IEnumerator importVX()
{
string path = System.IO.Path.Combine(VRXX.Platform.GetPersistentDataPath(), "latest.vx");
WWW www = new WWW(path);
yield return(www);
if (null != www.error)
{
Log.Error("EditorMgr::importVX", www.error);
yield break;
}
try
{
//Read json
int jsonSize = VRXX.Convert.ByteToInt(www.bytes, 0);
string json = VRXX.Convert.ByteToString(www.bytes, 4, jsonSize);
Log.Info("EditorMgr::importVX", "parse bean success");
JSONNode root = JSON.Parse(json);
JSONArray slateAry = root["slates"].AsArray;
foreach (JSONNode slateNode in slateAry)
{
string slateUUID = slateNode["guid"].Value;
Log.Trace("EditorMgr:importVX", "new a image {0}", slateUUID);
NewImage(slateUUID);
Editor.Image image = fsm.FindState(slateUUID) as Editor.Image;
JSONArray preloadAry = slateNode["preloads"].AsArray;
foreach (JSONNode node in preloadAry)
{
string group = node["group"].Value;
string package = node["package"].Value;
string file = node["file"].Value;
string guid = node["guid"].Value;
//string id = package + "@" + file;
if (group.Equals("skybox"))
{
ResourceMgr.PreloadAsset(package, file
, () =>
{
//startLoading();
}
, (_obj) =>
{
image.skybox = _obj as Material;
}
, (_err) =>
{
//onNotify(_err);
});
}
}
JSONArray triggerAry = slateNode["triggers"].AsArray;
foreach (JSONNode node in triggerAry)
{
string cloneUUID = node["uuid"].Value;
string alias = node["alias"].Value;
float px = node["px"].AsFloat;
float py = node["py"].AsFloat;
float pz = node["pz"].AsFloat;
float rx = node["rx"].AsFloat;
float ry = node["ry"].AsFloat;
float rz = node["rz"].AsFloat;
}
}
//offset
int count_ugcfile = VRXX.Convert.ByteToInt(www.bytes, 4 + jsonSize);
Log.Info("EditorMgr", "has {0} ugcfiles", count_ugcfile);
int offset = 4 + jsonSize + 4;
for (int i = 0; i < count_ugcfile; ++i)
{
int filenamesize = VRXX.Convert.ByteToInt(www.bytes, offset);
offset += 4;
string filename = VRXX.Convert.ByteToString(www.bytes, offset, filenamesize);
offset += filenamesize;
Log.Info("EditorMgr", "ugcfile is {0}", filename);
int filesize = VRXX.Convert.ByteToInt(www.bytes, offset);
offset += 4;
byte[] bytes = new byte[filesize];
System.Array.Copy(www.bytes, offset, bytes, 0, filesize);
offset += filesize;
UGCMgr.Cache(filename, bytes);
}
}
catch (System.Exception e)
{
Log.Exception("EditorMgr::importVX", e);
}
JSAPI.MessageToJS(JSAPI.MSG.JSEditorOnImportFinish, "", "");
}
