public bool LoadSkeletonAction(CRenderContext rc, RName name, bool firstLoad)
{
using (var xnd = IO.XndHolder.SyncLoadXND(name.Address))
{
if (xnd == null)
{
return(false);
}
if (false == SDK_GfxSkeletonAction_LoadXnd(CoreObject, rc.CoreObject, name.Name, xnd.Node.CoreObject, firstLoad))
{
return(false);
}
var num = SDK_GfxSkeletonAction_GetBoneNumber(CoreObject);
mAnimNodes = new CGfxBoneAnim[num];
for (UInt32 i = 0; i < num; i++)
{
var ptr = SDK_GfxSkeletonAction_GetBoneAnum(CoreObject, i);
if (ptr.Pointer == IntPtr.Zero)
{
continue;
}
mAnimNodes[i] = new CGfxBoneAnim(ptr);
}
return(true);
}
}
public static IO.Serializer.Serializer CreateObjectFromXML([EngineNS.Editor.Editor_RNameType(EngineNS.Editor.Editor_RNameTypeAttribute.Describe)] RName file)
{
using (var xml = LoadXML(file.Address))
{
if (xml == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "IO", $"LoadXML failed {file}");
return(null);
}
var type = Rtti.RttiHelper.GetTypeFromSaveString(xml.RootNode.Name);
if (type == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "IO", $"LoadObjectFromXML failed Type = {xml.RootNode.Name}");
return(null);
}
var obj = System.Activator.CreateInstance(type) as IO.Serializer.Serializer;
if (obj == null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Error, "IO", $"LoadObjectFromXML CreateInstance failed Type = {xml.RootNode.Name}");
return(null);
}
obj.ReadObjectXML(xml.RootNode);
return(obj);
}
}
public void AddScene(RName name, SceneGraph.GSceneGraph sg)
{
lock (Scenes)
{
Scenes.Add(name, sg);
}
}
public CPhyMaterial LoadMaterial(RName name)
{
CPhyMaterial result;
if (Materials.TryGetValue(name, out result))
{
return(result);
}
using (IO.XndHolder xnd = IO.XndHolder.SyncLoadXND(name.Address))
{
if (xnd == null)
{
return(null);
}
var attr = xnd.Node.FindAttrib("Params");
if (attr == null)
{
return(null);
}
result = CPhyMaterial.LoadXnd(this, attr);
Materials.Add(name, result);
return(result);
}
}
private static bool CookXlsImpl(RName rn, string targetPath, bool copyRInfo, bool isandroid)
{
var dataSet = new EngineNS.Bricks.DataProvider.GDataSet();
var resInfo = CMDEngine.CMDEngineInstance.mInfoManager.CreateResourceInfo("Xls") as ExcelViewEditor.ExcelResourceInfo;
if (resInfo == null)
{
return(false);
}
resInfo.Load(rn.Address + ".rinfo");
if (resInfo.MacrossName == null)
{
return(false);
}
Type objType = EngineNS.Macross.MacrossFactory.Instance.GetMacrossType(resInfo.MacrossName);
bool result = dataSet.LoadExcel(objType, rn);
if (result)
{
dataSet.Save2Xnd(targetPath + ".dateset");
if (isandroid)
{
CMDEngine.CMDEngineInstance.AddAssetInfos(targetPath + ".dateset");
}
}
if (copyRInfo)
{
CEngine.Instance.FileManager.CopyFile(rn.Address, targetPath, true);
}
return(true);
}
public bool LoadXnd(RName name)
{
using (var xnd = IO.XndHolder.SyncLoadXND(name.Address))
{
if (xnd == null)
{
return(false);
}
var attr = xnd.Node.FindAttrib("Excel");
if (attr == null)
{
return(false);
}
mDataRows = new List <T>();
attr.BeginRead();
int count = 0;
attr.Read(out count);
for (int i = 0; i < count; i++)
{
var obj = attr.ReadMetaObject() as T;
mDataRows.Add(obj);
}
attr.EndRead();
return(true);
}
}
public override bool LoadDataSet(
[EngineNS.Editor.Editor_RNameMExcelType(typeof(XlslObject))]
RName name,
bool reg2Manager)
{
return(base.LoadDataSet(name, reg2Manager));
}
private void ProcFiles(List <string> files, RName rn)
{
foreach (var i in files)
{
bool error;
var sf = EngineNS.CEngine.Instance.FileManager.NormalizePath(i, out error);
sf = sf.Substring(RootPath.Length);
sf = sf.Substring(0, sf.Length - ".rinfo".Length);
var rn1 = EngineNS.RName.GetRName(sf, CurRNameType);
var rinfo = _CreateObjectFromXML(i);
if (rinfo != null)
{
foreach (var j in rinfo.ReferenceRNameList)
{
if (rn == j)
{
var hashSet = GetHashSet(rinfo.ResourceType);
if (hashSet != null)
{
if (hashSet.Contains(rn1) == false)
{
hashSet.Add(rn1);
break;
}
}
}
}
}
}
}
public void Remove(RName name)
{
if (Prefabs.ContainsKey(name))
{
Prefabs.Remove(name);;
}
}
public override async Task <bool> SetInitializer(CRenderContext rc, GActor host, GComponentInitializer v)
{
if (await base.SetInitializer(rc, host, v) == false)
{
return(false);
}
mMeshComponent = new GamePlay.Component.GMeshComponent();
var meshCompInit = new GamePlay.Component.GMeshComponent.GMeshComponentInitializer();
meshCompInit.SpecialName = "VisualMesh";
meshCompInit.MeshName = RName.GetRName("editor/icon/icon_3D/mesh/play_start.gms", RName.enRNameType.Game);
await mMeshComponent.SetInitializer(rc, Host, meshCompInit);
//var mat = host.Placement.WorldMatrix;
//mMeshComponent.OnUpdateDrawMatrix(ref mat);
Initializer = v as AgentGeomBoxComponentInitializer;
if (Initializer != null)
{
AgentGridSize = Initializer.AgentGridSize;
StartPos = Initializer.StartPos;
}
else
{
Initializer = new AgentGeomBoxComponentInitializer();
}
return(true);
}
public bool RemoveUVAnimFromDic(RName name)
{
lock (UVAnims)
{
return(UVAnims.Remove(name));
}
}
public override bool CheckIfNeedImport()
{
mAnimAbsFilePath = RName.EditorOnly_GetRNameFromAbsFile(AssetImportOption.AbsSavePath + "/" + AssetImportOption.Name + CEngineDesc.AnimationClipExtension);
var operationResult = AssetImportMessageType.AMT_UnKnown;
if (EngineNS.CEngine.Instance.FileManager.FileExists(mAnimAbsFilePath.Address))
{
var userDesire = _OnCreaterAssetImportMessageDumping(this, AssetImportMessageType.AMT_FileExist, 0, "FileExist", ImportPercent);
operationResult = FileOperation(userDesire, mAnimAbsFilePath);
}
if (operationResult == AssetImportMessageType.AMT_IgnoreFile)
{
ImportPercent = 1.0f;
_OnCreaterAssetImportMessageDumping(this, AssetImportMessageType.AMT_Import, 0, "Skip", ImportPercent);
return(false);
}
if (operationResult == AssetImportMessageType.AMT_RenameFile)
{
var validName = GetValidFileName(AssetImportOption.AbsSavePath, AssetImportOption.Name, CEngineDesc.AnimationClipExtension);
mAnimAbsFilePath = RName.EditorOnly_GetRNameFromAbsFile(validName);
return(true);
}
if (operationResult == AssetImportMessageType.AMT_DeleteOriginFile)
{
return(true);
}
return(true);
}
private async System.Threading.Tasks.Task CollectImpl(RName name)
{
var ext = CEngine.Instance.FileManager.GetFileExtension(name.Address);
var resTypeName = GetResourceTypeName(ext);
if (resTypeName == "Scene")
{
var scene = await EngineNS.GamePlay.GGameInstance.LoadScene(CEngine.Instance.RenderContext, World, name);
if (scene != null)
{
foreach (var i in scene.Actors.Values)
{
await AnalysisActor(i);
}
}
}
else if (resTypeName == "Prefab")
{
var prefabActor = await EngineNS.GamePlay.Actor.GActor.NewPrefabActorAsync(name);
if (prefabActor != null)
{
await AnalysisActor(prefabActor);
}
}
else
{
var RInfoManager = CMDEngine.CMDEngineInstance.mInfoManager;
var resInfo = RInfoManager.CreateResourceInfo(resTypeName);
if (resInfo != null)
{
var rinfoAddress = name.Address + ".rinfo";
resInfo.Load(rinfoAddress);
foreach (var i in resInfo.ReferenceRNameList)
{
ext = CEngine.Instance.FileManager.GetFileExtension(i.Address);
resTypeName = GetResourceTypeName(ext);
var hashSet = GetHashSet(resTypeName);
if (hashSet != null)
{
if (hashSet.Contains(i) == false)
{
hashSet.Add(i);
await CollectImpl(i);
}
}
else
{
System.Diagnostics.Debug.Assert(false);
}
}
}
else
{
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Warning, "Cook", $"ResourceTypeName({resTypeName}) create failed");
}
}
}
public static async System.Threading.Tasks.Task <GamePlay.Actor.GActor> CreateParticleActor2(
[Editor.Editor_RNameType(Editor.Editor_RNameTypeAttribute.Mesh)] RName gmsName,
[Editor.Editor_RNameMacrossType(typeof(EngineNS.Bricks.Particle.McParticleEffector))] RName macross,
bool IdentityDrawTransform)
{
var rc = CEngine.Instance.RenderContext;
// ParticleActor
var actor = new GamePlay.Actor.GActor();
actor.ActorId = Guid.NewGuid();
var placement = new GamePlay.Component.GPlacementComponent();
actor.Placement = placement;
var particleComp = new Bricks.Particle.GParticleComponent();
var particleInit = new Bricks.Particle.GParticleComponent.GParticleComponentInitializer();
particleInit.MeshName = gmsName;
particleInit.MacrossName = macross;
await particleComp.SetInitializer(rc, actor, actor, particleInit);
particleComp.IsIdentityDrawTransform = true;
actor.AddComponent(particleComp);
return(actor);
}
public async System.Threading.Tasks.Task <ResourceInfo> CreateEmptyResource(string Absfolder, string rootFolder, EditorCommon.Resources.IResourceCreateData createData)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
var data = createData as MaterialInstanceResourceCreateData;
var result = new MaterialInstanceResourceInfo();
var reName = EngineNS.CEngine.Instance.FileManager._GetRelativePathFromAbsPath(Absfolder.TrimEnd('/') + "/" + data.ResourceName, rootFolder) + EngineNS.CEngineDesc.MaterialInstanceExtension;
result.ResourceName = RName.GetRName(reName, data.RNameType);
result.ParentMaterialRName = data.ParentMaterial;
result.ReferenceRNameList.Add(data.ParentMaterial);
var mtl = await EngineNS.CEngine.Instance.MaterialManager.GetMaterialAsync(EngineNS.CEngine.Instance.RenderContext, data.ParentMaterial);
var mtlInst = EngineNS.CEngine.Instance.MaterialInstanceManager.NewMaterialInstance(
EngineNS.CEngine.Instance.RenderContext,
mtl, result.ResourceName);
if (mtlInst == null)
{
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Error, "Editor", $"MaterialInstance create error");
}
foreach (var i in mtl.ParamList)
{
mtlInst.SetParam(i);
}
mtlInst.SaveMaterialInstance();
return(result);
}
protected override async System.Threading.Tasks.Task <GActor> CreateObject(RName name)
{
var rc = CEngine.Instance.RenderContext;
GActor actor = await CEngine.Instance.PrefabManager.GetPrefab(rc, name, true);
return(actor);
}
public bool LoadExcel(Type objType, RName name)
{
bool result = false;
LoadDataSetFromExcel(objType, name, ref result);
return(result);
}
public async System.Threading.Tasks.Task <ResourceInfo> CreateEmptyResource(string Absfolder, string rootFolder, EditorCommon.Resources.IResourceCreateData createData)
{
await EngineNS.Thread.AsyncDummyClass.DummyFunc();
var result = new MeshResourceInfo();
var mcd = createData as MeshCreateData;
if (EngineNS.CEngine.Instance.FileManager.GetFileExtension(mcd.ResourceName) != EngineNS.CEngineDesc.MeshExtension)
{
mcd.ResourceName = mcd.ResourceName + EngineNS.CEngineDesc.MeshExtension;
}
var reName = EngineNS.CEngine.Instance.FileManager._GetRelativePathFromAbsPath(Absfolder + "/" + mcd.ResourceName, rootFolder);
result.ResourceName = RName.GetRName(reName, mcd.RNameType);
var vmsInfo = await EditorCommon.Resources.ResourceInfoManager.Instance.CreateResourceInfoFromFile(mcd.GeomMesh.Address + ".rinfo", null) as MeshSourceResourceInfo;
result.SkeletonAsset = vmsInfo.SkeletonAsset;
RName meshPrimitives = mcd.GeomMesh;
//var shadingEnv = CEngine.Instance.ShadingEnvManager.GetGfxShadingEnv(mcd.ShadingEnv);
var mCurMesh = EngineNS.CEngine.Instance.MeshManager.NewMesh(
EngineNS.CEngine.Instance.RenderContext,
result.ResourceName, meshPrimitives /*, shadingEnv*/);
var mtl = EngineNS.CEngine.Instance.MaterialInstanceManager.DefaultMaterialInstance;
for (UInt32 i = 0; i < mCurMesh.MtlMeshArray.Length; i++)
{
await mCurMesh.SetMaterialInstanceAsync(EngineNS.CEngine.Instance.RenderContext, i, mtl, null);
}
mCurMesh.SaveMesh();
return(result);
}
public virtual bool LoadDataSet(
[Editor.Editor_RNameType(Editor.Editor_RNameTypeAttribute.Excel)]
//[EngineNS.Editor.Editor_RNameMExcelType(typeof(T))]：期待以后C#能这么写
RName name,
bool reg2Manager)
{
#if !PWindow
if (LoadXnd(RName.GetRName(name.Name + ".dateset")))
{
return(true);
}
#else
bool result = false;
LoadDataSetFromExcel(name, ref result);
if (result)
{
if (reg2Manager)
{
CEngine.Instance.GameInstance?.DataSetManager?.RegDataSet(typeof(T), this);
}
//Save2Xnd(RName.GetRName(name.Name + ".dateset"));
return(true);
}
else
{
if (LoadXnd(RName.GetRName(name.Name + ".dateset")))
{
return(true);
}
}
#endif
return(false);
}
public void SaveClusteredMesh(RName name)
{
var xnd = IO.XndHolder.NewXNDHolder();
IO.XndNode node = xnd.Node;
var attr = node.AddAttrib("Vertices");
attr.BeginWrite();
attr.Write(MeshVertices.Count);
for (int i = 0; i < MeshVertices.Count; i++)
{
attr.Write(MeshVertices[i]);
}
attr.EndWrite();
attr = node.AddAttrib("ClusterDatas");
attr.BeginWrite();
attr.Write(ClusterDatas.Count);
for (int i = 0; i < ClusterDatas.Count; i++)
{
attr.Write(ClusterDatas[i]);
}
attr.EndWrite();
attr = node.AddAttrib("IndexBuffer");
attr.BeginWrite();
attr.Write(IndexBuffer.Count);
for (int i = 0; i < IndexBuffer.Count; i++)
{
attr.Write(IndexBuffer[i]);
}
attr.EndWrite();
IO.XndHolder.SaveXND(name.Address, xnd);
}
internal Protocol([NotNull] string name, [NotNull] ISerializers serializers, [NotNull] IIdentities identities, [NotNull] IScheduler scheduler,
[NotNull] IWire wire, Lifetime lifetime, SerializationCtx?serializationCtx = null, [CanBeNull] ProtocolContexts parentContexts = null, params RdContextBase[] initialContexts)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Location = new RName(name);
Serializers = serializers ?? throw new ArgumentNullException(nameof(serializers));
Identities = identities ?? throw new ArgumentNullException(nameof(identities));
Scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
Wire = wire ?? throw new ArgumentNullException(nameof(wire));
SerializationContext = serializationCtx ?? new SerializationCtx(this, new Dictionary <string, IInternRoot <object> >()
{
{ ProtocolInternScopeStringId, CreateProtocolInternRoot(lifetime) }
});
Contexts = parentContexts ?? new ProtocolContexts(SerializationContext);
wire.Contexts = Contexts;
if (serializationCtx == null)
{
SerializationContext.InternRoots[ProtocolInternScopeStringId].Bind(lifetime, this, ProtocolInternRootRdId);
}
foreach (var rdContextBase in initialContexts)
{
rdContextBase.RegisterOn(Contexts);
}
if (parentContexts == null)
{
BindContexts(lifetime);
}
OutOfSyncModels = new ViewableSet <RdExtBase>();
}
public static BlendTree_AnimationClip CreateSync(RName name)
{
var bs = new BlendTree_AnimationClip();
bs.Clip = Animation.AnimNode.AnimationClip.CreateSync(name);
return(bs);
}
public object CreateMacrossObject(RName name, out MacrossDesc desc)
{
desc = GetDesc(name);
//string dllName = "";
//switch(EngineNS.CIPlatform.Instance.PlatformType)
//{
// case EPlatformType.PLATFORM_WIN:
// dllName = "MacrossScript.dll";
// break;
// case EPlatformType.PLATFORM_DROID:
// dllName = "MacrossScript.Android.dll";
// break;
// default:
// throw new InvalidOperationException();
//}
var assembly = EngineNS.Rtti.RttiHelper.GetAnalyseAssembly(CIPlatform.Instance.CSType, "Game");
var ret = CreateMacrossObject(name, assembly);
if (desc == null)
{
SetVersion(name, GetVersion(name));
desc = GetDesc(name);
}
return(ret);
}
public async System.Threading.Tasks.Task <CGfxVertexCloud> GetVertexCloud(RName name)
{
CGfxVertexCloud vc;
if (VertexClouds.TryGetValue(name, out vc))
{
return(vc);
}
vc = new CGfxVertexCloud();
var xnd = await IO.XndHolder.LoadXND(name.Address);
if (xnd == null)
{
return(null);
}
if (false == await vc.LoadXnd(xnd.Node))
{
return(null);
}
CGfxVertexCloud prev;
if (VertexClouds.TryGetValue(name, out prev))
{
return(prev);
}
VertexClouds.Add(name, vc);
return(vc);
}
public async System.Threading.Tasks.Task <GamePlay.Actor.GActor> CreateTitanActor(
[Editor.Editor_RNameType(Editor.Editor_RNameTypeAttribute.Mesh)]
RName mesh,
Vector3 lookOffset, float radius, float height,
[Editor.Editor_RNameType(Editor.Editor_RNameTypeAttribute.PhyMaterial)]
RName phyMtl)
{
var titanActor = await EngineNS.GamePlay.Actor.GActor.NewMeshActorAsync(mesh);
titanActor.SpecialName = "TitanActor";
this.World.AddActor(titanActor);
this.World.DefaultScene.AddActor(titanActor);
var tpcComp = new EngineNS.GamePlay.Camera.ThirdPersonCameraComponent();
titanActor.AddComponent(tpcComp);
tpcComp.SetCamera(this.GameCamera, 4.0f, lookOffset);
var physxCtr = new EngineNS.Bricks.PhysicsCore.GPhyControllerComponent();
var phyCtrInit = new EngineNS.Bricks.PhysicsCore.GPhyControllerComponent.GPhyControllerComponentInitializer();
phyCtrInit.IsBox = false;
phyCtrInit.CapsuleRadius = radius;
phyCtrInit.CapsuleHeight = height;
phyCtrInit.MaterialName = phyMtl;
await physxCtr.SetInitializer(CEngine.Instance.RenderContext, titanActor, titanActor, phyCtrInit);
titanActor.AddComponent(physxCtr);
ControlActor = titanActor;
return(titanActor);
}
public CGfxMeshPrimitives RefreshMeshPrimitives(CRenderContext rc, RName name)
{
if (name.IsExtension(CEngineDesc.MeshSourceExtension) == false)
{
return(null);
}
lock (MeshPrimitives)
{
CGfxMeshPrimitives mesh;
if (false == MeshPrimitives.TryGetValue(name, out mesh))
{
mesh = new CGfxMeshPrimitives();
if (mesh.LoadMesh(rc, name, true) == false)
{
return(null);
}
MeshPrimitives.Add(name, mesh);
}
else
{
using (var xnd = IO.XndHolder.SyncLoadXND(name.Address))
{
mesh.RefreshResource(rc, name.Name, xnd.Node);
}
}
return(mesh.CloneMeshPrimitives());
}
}
public static BlendTree_BlendSpace2D CreateSync(RName name)
{
var bs = new BlendTree_BlendSpace2D();
bs.BlendSpace = Animation.AnimNode.BlendSpace2D.CreateSync(name);
return(bs);
}
public void SaveVertexCloud(RName name)
{
var xnd = IO.XndHolder.NewXNDHolder();
this.Save2Xnd(xnd.Node);
IO.XndHolder.SaveXND(name.Address, xnd);
}
public void RemoveScene(RName name)
{
lock (Scenes)
{
Scenes.Remove(name);
}
}
public void RemoveSkeletonAction(RName name)
{
if (SkeletonActions.ContainsKey(name))
{
SkeletonActions.Remove(name);
}
}
