public static void ShowErrorLoadObject(PrefabObject o, string error)
{
string message = $"Load object {o.Config.i18n.en} error! {error}";
LogManager.GetCurrentClassLogger().Fatal(message);
LauncherErrorManager.Instance.ShowFatal(message, null);
}
/// <summary>
///
/// </summary>
/// <param name="prefabObj"></param>
/// <param name="parent"></param>
/// <returns></returns>
private GameObject InstanceAsset(PrefabObject prefabObj, Transform parent)
{
var go = Object.Instantiate(prefabObj.Asset) as GameObject;
go.name = go.name.Replace("(Clone)", "");
var instanceID = go.GetInstanceID();
var obgInfo = go.AddComponent <ObjInfo>();
if (obgInfo != null)
{
obgInfo.Init();
obgInfo.InstanceId = instanceID;
obgInfo.AssetName = prefabObj.AssetName;
}
prefabObj.GoInstanceIDSet.Add(instanceID);
goInstanceIDList.Add(instanceID, prefabObj);
if (parent != null)
{
go.transform.SetParent(parent, false);
}
return(go);
}
public static void LoadCustomAssetApi(AssetInfo assetInfo, PrefabObject o, ref GameEntity loadCounter, Dictionary <string, Type> typesInDll)
{
string assetName = assetInfo.AssetName;
string assetBundleUri = o.Resources.Bundle;
RequestAsset requestAsset =
new RequestAsset(assetName, assetBundleUri, new object[] { o, assetInfo });
GameEntity counter = loadCounter;
requestAsset.OnFinish += responseAsset =>
{
RequestTexture requestDownLoad = new RequestTexture(Settings.Instance().ApiHost + o.Resources.Icon, 128, 128, TextureFormat.DXT1);
requestDownLoad.OnFinish += responseUri =>
{
ResponseTexture responseTexture = (ResponseTexture)responseUri;
Texture2D texture2D = responseTexture.Texture;
Sprite sprite = Sprite.Create(texture2D, new Rect(0, 0, 128, 128), Vector2.zero);
CreatePrefabEntity(responseAsset, ref counter, o, sprite);
};
requestDownLoad.OnError += s => { CreatePrefabEntity(responseAsset, ref counter, o); };
};
}
private static void CreateSpawnEntity(ObjectDto o, int locationId, int?parentId = null)
{
bool embedded = false;
PrefabObject prefabObject = WorldData.WorldStructure.Objects.GetById(o.ObjectId);
if (prefabObject != null)
{
embedded = prefabObject.Embedded;
}
SpawnInitParams param = new SpawnInitParams
{
IdLocation = locationId,
IdInstance = o.InstanceId,
IdObject = o.ObjectId,
IdServer = 0,
Name = o.InstanceId.ToString(),
ParentId = parentId
};
if (o.Data != null)
{
param.Transforms = o.Data.Transform;
}
Spawner.Instance.SpawnAsset(param);
}
//really hacky way of managing the active focused object. TODO: do better
private void OnPropClicked(SerializedProperty pObject)
{
if (Event.current.button != 1)
{
return;
}
PrefabObject focused = null;
foreach (PrefabObject t in _prefabObjects)
{
//matching based on prefab gameobject reference
bool equal = t.prefab == pObject.FindPropertyRelative("prefab").objectReferenceValue as GameObject;
if (equal)
{
focused = t;
}
t.focused = equal; //sets matching to true, non to false
}
activeObject = focused;
if (previewWindow != null && activeObject != null)
{
previewWindow.activeTexture = activeObject.thumbnail;
}
previewWindow.Repaint();
Repaint(); //because we're changing the state of 'focused' on all the objects, used by the propertyDrawer
}
public static void LoadPrefabObjects(List <PrefabObject> objects)
{
ResetObjectsCounter(objects.Count);
WorldData.ObjectsAreLoaded = false;
for (int i = objects.Count - 1; i >= 0; i--)
{
PrefabObject o = objects[i];
if (o != null)
{
try
{
LoadPrefabObject(o);
}
catch (Exception ex)
{
LauncherErrorManager.Instance.ShowFatal(ErrorHelper.GetErrorDescByCode(TM.Errors.ErrorCode.LoadObjectError) + " " + o.Config.i18n.LocalizedString(),
ex.StackTrace);
}
}
else
{
WorldData.WorldStructure.Objects.RemoveAt(i);
_loadCounter.ReplaceLoadObjectsCounter(i - 1, 0, false);
}
}
}
/// <summary>
/// Adds prefab
/// </summary>
/// <param name="name"></param>
/// <param name="prefab"></param>
/// <returns></returns>
public PrefabsConfig AddPrefab(string name, SpellieSpawnedObject prefab)
{
var obj = PrefabObject.New()
.WithName(name)
.WithObject(prefab);
_prefabs.Add(obj);
return(this);
}
internal void BuildPrefab()
{
PrefabObject = InstantiatePrefabClone("Prefabs/Projectiles/BellBall", "MegaBrassBall");
PrefabObject.transform.localScale *= 4;
ProjectileController ghostPrefab = PrefabObject.GetComponent <ProjectileController>();
ghostPrefab.ghostPrefab = InstantiatePrefabClone("prefabs/projectileghosts/BellBallGhost", "MegaBrassBallGhost");
ghostPrefab.ghostPrefab.transform.localScale *= 4;
}
void Start()
{
camTrans = transform.Find("Main Camera");
screen = DebugScreen.GetInstance();
world = GameObject.Find("World").GetComponent <World>();
promptText = GameObject.Find("Selection prompt").GetComponent <Text>();
//设置Enermy默认模型
enermyModelPrefab = PrefabManager.GetInstance().GetPrefab(PrefabType.Breaker);
InitMonsterModel();
}
public Transform GetPrefab(PrefabObject type)
{
for (int i = 0; i < prefabObjects.Length; i++)
{
if (prefabObjects[i].Type == type)
{
return(prefabObjects[i].Prefab);
}
}
return(null);
}
void CreateAndEnqueuePrefab(int prefabInt)
{
//Instantiate a new object
PrefabObject prefab = Instantiate(prefabObjects[prefabInt]);
//Disable newly instantiated object
prefab.gameObject.SetActive(false);
//Enqueue it to current queue
prefabQueues[prefabInt].MyQueue.Enqueue(prefab);
}
public static void AddPrefabGameObject(int objectId, Object asset, PrefabObject data)
{
if (!Prefabs.ContainsKey(objectId))
{
Prefabs.Add(objectId, (GameObject)asset);
}
if (!PrefabsData.ContainsKey(objectId))
{
PrefabsData.Add(objectId, data);
}
}
public void CreatePrefab()
{
PrefabObject.CreatePrefab(Guid.NewGuid().ToString(),
SessionManager.Instance.GetSceneGameObject(selected.GetKey()),
nameInputField.text,
iconSelector.value,
(ObjectCategory)categorySelector.value);
SessionManager.Instance.sceneObjects.LoadPrefabs();
SessionManager.Instance.mapLoader.ReloadUI();
Close();
}
internal void BuildPrefab()
{
PrefabObject = InstantiatePrefabClone("Prefabs/Projectiles/ImpVoidSpikeProjectile", "IchorSpike");
var projectileDamage = PrefabObject.GetComponent <ProjectileDamage>();
projectileDamage.damageType = RoR2.DamageType.Generic;
ProjectileController ghostPrefab = PrefabObject.GetComponent <ProjectileController>();
ghostPrefab.ghostPrefab = InstantiatePrefabClone("Prefabs/ProjectileGhosts/ImpVoidspikeProjectileGhost", "IchorSpikeGhost");
ghostPrefab.ghostPrefab.GetComponent <Light>().color = new Color(0.98f, 0.71f, 0, 1);
ghostPrefab.ghostPrefab.GetComponentInChildren <MeshRenderer>().material = AssetLoaderAndChecker.MainAssets.LoadAsset <Material>("IchorClaw");
}
public static void CreatePrefabApi(AssetInfo assetInfo, PrefabObject o, ref GameEntity loadCounter)
{
string assetName = assetInfo.AssetName;
string assetBundleUri = o.Resources.Bundle;
RequestAsset requestAsset =
new RequestAsset(assetName, assetBundleUri, new object[] { o, assetInfo });
GameEntity counter = loadCounter;
requestAsset.OnFinish += response => { CreatePrefabEntity(response, ref counter, o); };
//ToDo OnError
}
private bool CheckSelectedObject(ref int objectId)
{
PrefabObject selectedObject = GameStateData.GetPrefabData(ProjectData.SelectedObjectIdToSpawn);
if (selectedObject == null)
{
return(false);
}
objectId = selectedObject.Id;
return(selectedObject.Guid == OnboardingStateMachine.ButtonGuid);
}
void ExtractEnvironmentLightEntity(string xmlstr)
{
try
{
if (xmlstr.Length > 0)
{
TextReader tr = new StringReader(xmlstr);
XDocument xml = XDocument.Load(tr);
string layerguid = GuidUtility.GenID("Main");
foreach (XElement el in xml.Descendants("Entity"))
{
if (el.Attribute("EntityClass") != null)
{
if (el.Attribute("EntityClass").Value == "EnvironmentLight")
{
PrefabObject prObj = new PrefabObject();
prObj.Name = el.Attribute("Name").Value;
if (el.Attribute("Pos") != null)
{
prObj.Pos = el.Attribute("Pos").Value;
}
if (el.Attribute("Rotate") != null)
{
prObj.Rotate = el.Attribute("Rotate").Value;
}
if (el.Attribute("Scale") != null)
{
prObj.Scale = el.Attribute("Scale").Value;
}
prObj.EntityClass = el.Attribute("EntityClass").Value;
prObj.Type = el.Attribute("EntityClass").Value;
prObj.Id = GuidUtility.GenID("dfgdfg453" + prObj.Name + prObj.Pos + prObj.EntityClass);
prObj.Layer = el.Attribute("Layer").Value;
byte[] asciiBytes = Encoding.ASCII.GetBytes(el.Attribute("Layer").Value);
prObj.LayerGUID = layerguid;
prObj.Properties = el.Element("Properties");
prefabObjects.Add(prObj);
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("|{0}|", xmlstr);
Console.WriteLine("Press Enter to continue...");
Console.Read();
//throw;
}
}
public void DespawnPrefabObject(PrefabObject prefabObject, string prefabName)
{
if (!prefabObject.gameObject.activeInHierarchy || prefabObject.gameObject == null)
{
return;
}
for (int i = 0; i < prefabQueues.Count; i++)
{
if (prefabName.Contains(prefabQueues[i].QueueName))
{
prefabObject.gameObject.SetActive(false);
prefabQueues[i].MyQueue.Enqueue(prefabObject);
}
}
}
void ExtractGeomEntity(string xmlstr)
{
TextReader tr = new StringReader(xmlstr);
XDocument xml = XDocument.Load(tr);
XElement elSCOC_Entities = xml.Root;
foreach (XElement elEntity in elSCOC_Entities.Elements("Entity"))
{
SCOC_Entity scocEntity = new SCOC_Entity(elEntity);
PrefabObject prefObj = scocEntity.GetGeomAsPrefabObject(itemsList);
if (prefObj != null)
{
prefabObjects.Add(prefObj);
}
}
}
/// <summary>
/// 用于解绑回调
/// </summary>
public void RemoveCallback(string assetName, PrefabLoadCallback callFun)
{
if (callFun == null)
{
return;
}
PrefabObject prefabObj = null;
if (loadedList.ContainsKey(assetName))
{
prefabObj = loadedList[assetName];
}
if (prefabObj != null)
{
int index = prefabObj.CallbackList.IndexOf(callFun);
if (index >= 0)
{
prefabObj.RefCount--;
prefabObj.CallbackList.RemoveAt(index);
prefabObj.CallParentList.RemoveAt(index);
if (index < prefabObj.LockCallbackCount) // 说明是加载回调过程中解绑回调，需要降低lock个数
{
prefabObj.LockCallbackCount--;
}
}
if (prefabObj.RefCount < 0)
{
string errormsg = string.Format("PrefabLoadMgr Destroy refCount error ! assetName:{0}", prefabObj.AssetName);
Debug.LogError(errormsg);
return;
}
if (prefabObj.RefCount == 0)
{
loadedList.Remove(prefabObj.AssetName);
assetLoadMgr.Unload(prefabObj.Asset);
prefabObj.Asset = null;
}
}
}
void MakePrefabObjects()
{
foreach (Objects obj in objects)
{
foreach (Object_Type1 geomObj in obj.GetObject_Type1())
{
PrefabObject prefabObj = new PrefabObject();
//////////////////////////
//Console.WriteLine(br.BaseStream.Position);
double x = geomObj.pos.x;
double y = geomObj.pos.y;
double z = geomObj.pos.z;
int id = geomObj.id;
Quaternion quat = geomObj.quaternion;
Vector3 scale = geomObj.scale;
prefabObj.Transform34 = geomObj.rotMatrix34;
//quat = ValidateQuaternion(quat);
string objectname = Path.GetFileNameWithoutExtension(geomObj.path);
prefabObj.Name = objectname;
prefabObj.Geometry = geomObj.path;
prefabObj.Pos = (float)x + "," + (float)y + "," + (float)z;
prefabObj.Rotate = quat.W + "," + quat.X + "," + quat.Y + "," + quat.Z;
prefabObj.Scale = scale.X + "," + scale.Y + "," + scale.Z;
//Console.WriteLine(prefabObj.Geometry);
prefabObj.EntityClass = "GeomEntity";
byte[] asciiBytes = Encoding.ASCII.GetBytes(objectname);
prefabObj.Layer = objectname;
//prefabObj.LayerGUID = "3675a837-e15f-dfa0-db3a-"+ bytesToString(asciiBytes);
prefabObj.LayerGUID = GuidUtility.GenLayerID("sdf33" + objectname + prefabObj.Geometry + prefabObj.Pos);
prefabObj.Id = GuidUtility.GenPrefabID("sdf34gffg" + objectname + prefabObj.Geometry + prefabObj.Pos);
//ignore %level% geoms
if (!prefabObj.Geometry.StartsWith("%level%", StringComparison.OrdinalIgnoreCase))
{
prefabObjects.Add(prefabObj);
}
}
}
//foreach (AreaShapes areaShape in areaShapes)
//{
// foreach (PrefabObject prefabObj in areaShape.GetPrefabObjects())
// {
// prefabObjects.Add(prefabObj);
// }
//}
}
private static void LoadPrefabObject(PrefabObject o)
{
string dllCachePath = Path.Combine(Application.dataPath, "/cache/dll/" + o.Config.i18n.en + o.Guid);
Dictionary <string, Type> typesInDll = new Dictionary <string, Type>();
RequestTar request = new RequestTar(o.Resources.Config);
request.OnFinish += response =>
{
string json = ((ResponseTar)response).TextData;
AssetInfo assetInfo = null;
if (!Helper.LoadAssetInfo(json,
ref assetInfo,
ref _loadCounter,
o))
{
return;
}
Helper.LoadResourcesTar(assetInfo, o);
foreach (string dllName in assetInfo.Assembly)
{
string dllPath = o.Resources.DllPath + "/" + dllName;
new RequestTar(dllPath).OnFinish += response1 =>
{
var byteData = ((ResponseTar)response1).ByteData;
LoadAssemby(dllCachePath,
dllName,
ref byteData,
ref typesInDll);
};
}
Helper.LoadCustomAssetTar(assetInfo,
o,
ref _loadCounter,
typesInDll);
};
request.OnError += s => { Helper.ShowErrorLoadObject(o, s); };
}
public static void LoadResourcesApi(AssetInfo assetInfo, PrefabObject o)
{
string assetBundleUri = o.Resources.Bundle;
if (assetInfo.Resources == null)
{
return;
}
foreach (string assetName in assetInfo.Resources)
{
new RequestAsset(assetName, assetBundleUri).OnFinish += response2 =>
{
ResponseAsset responseResource = (ResponseAsset)response2;
ObjectResourses.AddResourse(responseResource.Asset);
};
}
}
private void UpdateSelectIndex(int length, float scrool)
{
if (scrool != 0)
{
if (scrool > 0)
{
selectIndex = (selectIndex + 1) % length;
}
else if (scrool < 0)
{
int complete = length - 1;
selectIndex = (selectIndex + complete) % length;
}
if (editMode == EditMode.MonsterMode)
{
enermyModelPrefab = PrefabManager.GetInstance().GetPrefabByMonsterType((MonsterType)selectIndex);
InitMonsterModel();
}
}
}
private static void CreatePrefabEntity(IResponse response, ref GameEntity counter, PrefabObject o, Sprite icon = null)
{
ResponseAsset responseAsset = (ResponseAsset)response;
Object unityObject = responseAsset.Asset;
PrefabObject serverObject = (PrefabObject)responseAsset.UserData[0];
GameEntity entity = Contexts.sharedInstance.game.CreateEntity();
entity.AddServerObject(serverObject);
GameStateData.AddPrefabGameObject(serverObject.Id, responseAsset.Asset, o);
GameStateData.AddObjectIcon(serverObject.Id, icon);
if (o.Embedded)
{
GameStateData.AddToEmbeddedList(serverObject.Id);
}
AddCastComponent(unityObject, entity);
entity.AddIcon(icon);
counter.loadObjectsCounter.PrefabsLoaded++;
LogManager.GetCurrentClassLogger().Info(o.Config.i18n.en + " is loaded");
}
public static void LoadResourcesTar(AssetInfo assetInfo, PrefabObject o)
{
string assetBundleUri = o.Resources.Bundle;
if (assetInfo.Resources != null)
{
foreach (string resource in assetInfo.Resources)
{
new RequestTar(assetBundleUri).OnFinish += response =>
{
var bundle = ((ResponseTar)response).ByteData;
new RequestLoadAssetFromMemory(resource, bundle).OnFinish += response2 =>
{
ResponseAsset responseResource = (ResponseAsset)response2;
ObjectResourses.AddResourse(responseResource.Asset);
};
};
}
}
}
private void OnDestroy()
{
SceneView.onSceneGUIDelegate -= OnSceneGui;
Camera.onPreCull -= instance.DrawActiveObjectScenePreview;
activeObject = null;
if (!instance)
{
instance = GetWindow <ThumbnailEditorWindow>();
}
Debug.Log("OnDestroy");
EditorPrefs.DeleteKey("ThumbPath");
EditorPrefs.SetString("ThumbData", JsonUtility.ToJson(instance.settings, true));
instance = null;
if (renderCamera != null)
{
DestroyImmediate(renderCamera.gameObject);
}
}
private void RenderPreviews(List <PrefabObject> objects)
{
Camera cam = GetRenderCamera();
ApplyCameraSettings();
var DefaultRenderData = GetCameraTransformTuple(settings.orbitYaw, settings.orbitPitch, settings.orbitDistance, settings.orbitHeight);
(Vector3 pos, Quaternion rot, Vector3 forward, Vector3 target)activeData;
for (var moIndex = 0; moIndex < objects.Count; moIndex++)
{
PrefabObject po = objects[moIndex];
//if it has custom render settings, set them
if (po.hasCustomSettings)
{
activeData = GetCameraTransformTuple(
po.orbitYaw,
po.orbitPitch,
po.orbitDistance,
po.orbitHeight);
}
else
{
activeData = DefaultRenderData;
}
Matrix4x4 mtx = Matrix4x4.TRS(activeData.pos, activeData.rot, Vector3.one).inverse;
RecursiveDrawGameObject(mtx, po.prefab, settings.renderLayer, cam);
var texture = new Texture2D(settings.thumbnailSize, settings.thumbnailSize);
RenderTargetToTexture(cam, ref texture);
po.thumbnail = texture;
objects[moIndex] = po;
}
}
/// <summary>
/// 异步实例化资源
/// </summary>
/// <param name="assetName"></param>
public void LoadAsync(string assetName, PrefabLoadCallback callFun, Transform parent)
{
PrefabObject prefabObj = null;
if (loadedList.ContainsKey(assetName))
{
prefabObj = loadedList[assetName];
prefabObj.CallbackList.Add(callFun);
prefabObj.CallParentList.Add(parent);
prefabObj.RefCount++;
if (prefabObj.Asset != null)
{
loadedAsyncList.Add(prefabObj);
}
return;
}
prefabObj = new PrefabObject()
{
AssetName = assetName, RefCount = 1
};
prefabObj.CallbackList.Add(callFun);
prefabObj.CallParentList.Add(parent);
loadedList.Add(assetName, prefabObj);
assetLoadMgr.LoadAsync(assetName, (string name, Object obj) =>
{
prefabObj.Asset = obj;
prefabObj.LockCallbackCount = prefabObj.CallbackList.Count;
DoInstanceAssetCallback(prefabObj);
}
);
}
private static void CreateSpawnEntity(ObjectDto o, int locationId, int?parentId = null)
{
bool embedded = false;
PrefabObject prefabObject = ProjectData.ProjectStructure.Objects.GetById(o.ObjectId);
if (prefabObject != null)
{
embedded = prefabObject.Embedded;
}
else
{
Debug.LogError("Object is not contains in project structure");
}
SpawnInitParams param = new SpawnInitParams
{
IdLocation = locationId,
IdInstance = o.InstanceId,
IdObject = o.ObjectId,
IdServer = o.Id,
Name = o.Name,
ParentId = parentId,
Embedded = embedded
};
if (o.Data != null)
{
param.Transforms = o.Data.Transform;
param.Joints = o.Data.JointData;
}
Spawner.Instance.SpawnAsset(param);
foreach (ObjectDto dto in o.SceneObjects)
{
CreateSpawnEntity(dto, locationId, o.InstanceId);
}
}
