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); } }