private EngineNS.GamePlay.Actor.GActor CreateMeshActor(EngineNS.GamePlay.GWorld world, RName scene, RName meshName, Vector3 loc, Vector3 scale)
{
var mesh = CEngine.Instance.MeshManager.CreateMesh(EngineNS.CEngine.Instance.RenderContext, meshName);
var actor = EngineNS.GamePlay.Actor.GActor.NewMeshActor(mesh);
actor.Placement.Location = loc;
actor.Placement.Scale = scale;
this.World.AddActor(actor);
this.World.Scenes[scene].AddActor(actor);
return(actor);
}
public void RefreshFromWorld(EngineNS.GamePlay.GWorld world)
{
mViewDataDic.Clear();
mSceneGraphNodeViewDatas.Clear();
using (var i = world.GetSceneEnumerator())
{
while (i.MoveNext())
{
var nodeV = CreateNodeItem(null, i.Current.Value);
mSceneGraphNodeViewDatas.Add(nodeV);
}
}
TreeList_SceneGraphs.TreeListItemsSource = mSceneGraphNodeViewDatas;
}
protected virtual bool InitWorld()
{
mWorld = new EngineNS.GamePlay.GWorld();
if (false == mWorld.Init())
{
return(false);
}
var scene = new EngineNS.GamePlay.SceneGraph.GSceneGraph();
mWorld.Scenes.Add(RName.GetRName("SnapshorCreator"), scene);
return(true);
}
protected virtual async System.Threading.Tasks.Task <bool> InitWorld(string name)
{
mWorld = new EngineNS.GamePlay.GWorld();
if (false == mWorld.Init())
{
return(false);
}
mWorld.CheckVisibleParam.UsePVS = false;
var scene = await EngineNS.GamePlay.SceneGraph.GSceneGraph.CreateSceneGraph(mWorld, typeof(EngineNS.GamePlay.SceneGraph.GSceneGraph), null);
mWorld.AddScene(RName.GetRName(name), scene);
return(true);
}
public void FinalCleanup()
{
CEngine.Instance.TickManager.RemoveTickInfo(this);
if (mWorld != null)
{
mWorld.Cleanup();
mWorld = null;
}
if (mRP_OffScreen != null)
{
mRP_OffScreen.Cleanup();
mRP_OffScreen = null;
}
if (mCamera != null)
{
mCamera.Cleanup();
mCamera = null;
}
}
public static void MaxZoomMeshShow(float x, float y, float width, float height, Vector3 vMax, Vector3 vMin, EngineNS.Graphics.CGfxCamera Camera, EngineNS.GamePlay.GWorld world, double delta = 2.0)
{
List <Vector3> VecList = new List <Vector3>();
if (vMax.X > 10000)
{
vMax.X = 10000;
}
if (vMax.Y > 10000)
{
vMax.Y = 10000;
}
if (vMax.Z > 10000)
{
vMax.Z = 10000;
}
if (vMin.X < -10000)
{
vMin.X = -10000;
}
if (vMin.Y < -10000)
{
vMin.Y = -10000;
}
if (vMin.Z < -10000)
{
vMin.Z = -10000;
}
VecList.Add(vMin);
VecList.Add(new Vector3(vMax.X, vMin.Y, vMin.Z));
VecList.Add(new Vector3(vMax.X, vMax.Y, vMin.Z));
VecList.Add(new Vector3(vMin.X, vMax.Y, vMin.Z));
VecList.Add(new Vector3(vMin.X, vMax.Y, vMax.Z));
VecList.Add(new Vector3(vMin.X, vMin.Y, vMax.Z));
VecList.Add(new Vector3(vMax.X, vMin.Y, vMax.Z));
VecList.Add(vMax);
var vObjCenter = (vMax - vMin) * 0.5f + vMin;
float fMaxXLength = 0;
float fMaxYLength = 0;
foreach (var vec in VecList)
{
fMaxXLength = System.Math.Max(System.Math.Abs(Vector3.Dot(vec - vObjCenter, Camera.Right)), fMaxXLength);
fMaxYLength = System.Math.Max(System.Math.Abs(Vector3.Dot(vec - vObjCenter, Camera.Right)), fMaxYLength);
}
Vector3 eyePos = Vector3.Zero;
float length = 0;
if (Camera.IsPerspective)
{
float lengthX = (float)(fMaxXLength / System.Math.Tan(Camera.Fov * 0.5));
float lengthY = (float)(fMaxYLength / System.Math.Tan(Camera.Fov * (width / height) * 0.5));
length = (float)(System.Math.Max(lengthX, lengthY) * delta);
eyePos = Camera.Direction * -(float)length + vObjCenter;
}
else
{
var lengthX = (float)(fMaxXLength * 2 * delta);
var lengthY = lengthX * height / width;
Camera.MakeOrtho(lengthX, lengthY, width, height);
var deltaSize = vMax - vMin;
length = System.Math.Max(System.Math.Max(deltaSize.X, deltaSize.Y), deltaSize.Z) + 50.0f;
eyePos = Camera.Direction * -length + vObjCenter;
}
var dir = Camera.Direction;
Camera.LookPosAndDir(eyePos, dir);
}
public async System.Threading.Tasks.Task CollectAssets(RName gameEntry, string platform, bool copyRInfo, string[] sm)
{
var RInfoManager = CMDEngine.CMDEngineInstance.mInfoManager;
World = new EngineNS.GamePlay.GWorld();
World.Init();
MacrossAssets.Add(gameEntry);
await CollectImpl(gameEntry);
{
var engineDesc = new EngineNS.CEngineDesc();
HashSet <object> visitedObjects = new HashSet <object>();
visitedObjects.Add(CMDEngine.Instance);
await CollectRNameFromObject(engineDesc, visitedObjects);
var rn = RName.GetRName("ui/mi_ui_default.instmtl", RName.enRNameType.Engine);
MaterialInstanceAssets.Add(rn);
await CollectImpl(rn);
rn = RName.GetRName("ui/uv_ui_default.uvanim", RName.enRNameType.Engine);
UVAnimAssets.Add(rn);
await CollectImpl(rn);
rn = RName.GetRName("EngineAsset/Texture/default_envmap.txpic");
TextureAssets.Add(rn);
await CollectImpl(rn);
rn = RName.GetRName("Texture/eyeenvmap0.txpic");
TextureAssets.Add(rn);
await CollectImpl(rn);
rn = RName.GetRName("EngineAsset/Texture/default_vignette.txpic");
TextureAssets.Add(rn);
await CollectImpl(rn);
rn = RName.GetRName("ui/mi_ui_defaultfont.instmtl", RName.enRNameType.Engine);
MaterialInstanceAssets.Add(rn);
await CollectImpl(rn);
rn = RName.GetRName("ui/defbutton.txpic", RName.enRNameType.Engine);
TextureAssets.Add(rn);
//rn = RName.GetRName("tutorials/gameplay/dataset/students_table.xls");
//XlsAssets.Add(rn);
await CollectImpl(rn);
}
CookResourceSet(SceneAssets, platform, copyRInfo);
CookResourceSet(MeshAssets, platform, copyRInfo);
CookResourceSet(MeshSourceAssets, platform, copyRInfo);
CookResourceSet(TextureAssets, platform, copyRInfo, null, ResourceCooker.CookTxPic);
CookResourceSet(UVAnimAssets, platform, copyRInfo);
CookResourceSet(NotifyAssets, platform, copyRInfo);
CookResourceSet(SkeletonAssets, platform, copyRInfo);
CookResourceSet(AnimationAssets, platform, copyRInfo);
CookResourceSet(MaterialAssets, platform, copyRInfo, new string[] { ".code", ".link", ".var" });
CookResourceSet(MaterialInstanceAssets, platform, copyRInfo);
CookResourceSet(MacrossAssets, platform, copyRInfo);
CookResourceSet(PrefabAssets, platform, copyRInfo);
CookResourceSet(ClusterAssets, platform, copyRInfo);
CookResourceSet(PhyMtlAssets, platform, copyRInfo);
CookResourceSet(AnimationBlendSpace1DAssets, platform, copyRInfo);
CookResourceSet(AnimationBlendSpaceAssets, platform, copyRInfo);
CookResourceSet(AnimationAdditiveBlendSpace1DAssets, platform, copyRInfo);
CookResourceSet(AnimationAdditiveBlendSpaceAssets, platform, copyRInfo);
CookResourceSet(AnimationClipAssets, platform, copyRInfo);
CookResourceSet(VertexCloudAssets, platform, copyRInfo);
CookResourceSet(UIAssets, platform, copyRInfo);
CookResourceSet(FontAssets, platform, copyRInfo);
CookResourceSet(XlsAssets, platform, copyRInfo, null, ResourceCooker.CookXls);
}
protected virtual async System.Threading.Tasks.Task <bool> InitWorld()
{
mWorld = new EngineNS.GamePlay.GWorld();
if (false == mWorld.Init())
{
return(false);
}
mWorld.CheckVisibleParam.UsePVS = false;
EngineNS.GamePlay.SceneGraph.GSceneGraph scene = null;
var xnd = await EngineNS.IO.XndHolder.LoadXND(mSceneRName.Address + "/scene.map");
if (xnd != null)
{
var type = EngineNS.Rtti.RttiHelper.GetTypeFromSaveString(xnd.Node.GetName());
if (type != null)
{
scene = EngineNS.GamePlay.SceneGraph.GSceneGraph.NewSceneGraphWithoutInit(mWorld, type, new EngineNS.GamePlay.SceneGraph.GSceneGraphDesc());
scene.World = mWorld;
if (await scene.LoadXnd(EngineNS.CEngine.Instance.RenderContext, xnd.Node, mSceneRName) == false)
{
scene = null;
}
else
{
foreach (var actor in mWorld.Actors.Values)
{
actor.PreUse(true);
}
}
}
}
if (scene == null)
{
scene = await EngineNS.GamePlay.SceneGraph.GSceneGraph.CreateSceneGraph(mWorld, typeof(EngineNS.GamePlay.SceneGraph.GSceneGraph), null);
}
mWorld.AddScene(RName.GetRName("SnapshorCreator"), scene);
if (scene.SunActor != null)
{
var sunComp = scene.SunActor.GetComponent <EngineNS.GamePlay.Component.GDirLightComponent>();
if (sunComp != null)
{
sunComp.View = mRP_Snapshot.BaseSceneView;
}
}
//if (SkyName != null && SkyName != RName.EmptyName)
//{
// mSkyBoxActor = await EngineNS.GamePlay.Actor.GActor.NewMeshActorAsync(SkyName);
// mSkyBoxActor.PreUse(true);
// mSkyBoxActor.Placement.Scale = new EngineNS.Vector3(0.1F, 0.1F, 0.1F);
// mWorld.AddEditorActor(mSkyBoxActor);
//}
//if (FloorName != null && FloorName != RName.EmptyName)
//{
// mFloorActor = await EngineNS.GamePlay.Actor.GActor.NewMeshActorAsync(FloorName);
// mFloorActor.PreUse(true);
// mFloorActor.Placement.Scale = new EngineNS.Vector3(10, 0.5f, 10);
// mFloorActor.Placement.Location = new Vector3(0, -0.251f, 0);
// mWorld.AddEditorActor(mFloorActor);
//}
return(true);
}
public static void FocusShow(float x, float y, float width, float height, Vector3 vMax, Vector3 vMin, EngineNS.Graphics.CGfxCamera Camera, EngineNS.GamePlay.GWorld world, double delta = 1.0)
{
List <Vector3> VecList = new List <Vector3>();
if (vMax.X > 10000)
{
vMax.X = 10000;
}
if (vMax.Y > 10000)
{
vMax.Y = 10000;
}
if (vMax.Z > 10000)
{
vMax.Z = 10000;
}
if (vMin.X < -10000)
{
vMin.X = -10000;
}
if (vMin.Y < -10000)
{
vMin.Y = -10000;
}
if (vMin.Z < -10000)
{
vMin.Z = -10000;
}
VecList.Add(vMin);
VecList.Add(new Vector3(vMax.X, vMin.Y, vMin.Z));
VecList.Add(new Vector3(vMax.X, vMax.Y, vMin.Z));
VecList.Add(new Vector3(vMin.X, vMax.Y, vMin.Z));
VecList.Add(new Vector3(vMin.X, vMax.Y, vMax.Z));
VecList.Add(new Vector3(vMin.X, vMin.Y, vMax.Z));
VecList.Add(new Vector3(vMax.X, vMin.Y, vMax.Z));
VecList.Add(vMax);
var vObjCenter = (vMax - vMin) * 0.5f + vMin;
float radius = Vector3.Distance(ref vMax, ref vMin) / 2;
Vector3 eyePos = new Vector3();
if (Camera.IsPerspective)
{
float fovAngle = 0;
if (Camera.Aspect > 1)
{
fovAngle = Camera.FoV * 0.5f;
}
else
{
fovAngle = (float)(Math.Atan(Math.Tan(Camera.FoV * 0.5) * Camera.Aspect));
}
float h = radius / (float)Math.Sin(fovAngle);
eyePos = vObjCenter - Camera.CameraData.Direction * h;
}
else
{
System.Diagnostics.Debug.Assert(false);
}
var dir = Camera.CameraData.Direction;
Camera.LookAtLH(eyePos, vObjCenter, Camera.CameraData.Up);
//Camera.LookPosAndDir(eyePos, dir);
Camera.BeforeFrame();
Camera.SwapBuffer(true);
}
static async System.Threading.Tasks.Task RealMain(CMDEngine cmdEngine, string[] args)
{
await EngineNS.CEngine.Instance.InitSystem(IntPtr.Zero, 0, 0, EngineNS.ERHIType.RHT_VirtualDevice, true);
await EngineNS.CEngine.Instance.OnEngineInited();
CIPlatform.Instance.PlayMode = CIPlatform.enPlayMode.Cook;
switch (args[0].ToLower())
{
case "pack":
{
var src = FindArgument(args, "src=").Substring("src=".Length);
if (src == null)
{
return;
}
var tar = FindArgument(args, "tar=").Substring("tar=".Length);
if (tar == null)
{
return;
}
AssetsPacker.PackAList(src, tar);
var pak = new EngineNS.IO.CPakFile();
pak.LoadPak(tar);
for (UInt32 i = 0; i < pak.AssetNum; i++)
{
var name = pak.GetAssetName(i);
var sz = pak.GetAssetSize(i);
var szip = pak.GetAssetSizeInPak(i);
}
cmdEngine.IsRun = false;
}
break;
case "unpack":
{
}
break;
case "cook":
{
var entry = FindArgument(args, "entry=").Substring("entry=".Length);
var rn = EngineNS.RName.GetRName(entry);
var platformStr = FindArgument(args, "platform=").Substring("platform=".Length);
var platforms = platformStr.Split('+');
var copyRInfo = FindArgument(args, "copyrinfo");
EngineNS.IO.XmlHolder AssetInfos = EngineNS.IO.XmlHolder.NewXMLHolder("AssetsPackage", ""); //For andorid
string[] sm = null;
var smStr = FindArgument(args, "shadermodel=");
if (smStr != null)
{
sm = smStr.Substring("shadermodel=".Length).Split('+');
}
if (FindArgument(args, "genvsproj") != null)
{
CMDEngine.CMDEngineInstance.IsNeedProject = true;
}
var texEncoder = FindArgument(args, "texencoder=");
if (texEncoder != null)
{
ResourceCooker.TexCompressFlags = 0;
var texFormats = texEncoder.Substring("texencoder=".Length).Split('+');
if (FindArgument(texFormats, "PNG") != null)
{
ResourceCooker.TexCompressFlags |= ResourceCooker.ETexCompressMode.PNG;
}
if (FindArgument(texFormats, "ETC2") != null)
{
ResourceCooker.TexCompressFlags |= ResourceCooker.ETexCompressMode.ETC2;
}
if (FindArgument(texFormats, "ASTC") != null)
{
ResourceCooker.TexCompressFlags |= ResourceCooker.ETexCompressMode.ASTC;
}
}
var pakAssets = FindArgument(args, "pak=");
if (pakAssets != null)
{
pakAssets = pakAssets.Substring("pak=".Length);
}
try
{
foreach (var i in platforms)
{
CEngine.Instance.FileManager.CookingPlatform = i;
var cooker = new AssetCooker();
await cooker.CollectAssets(rn, i, copyRInfo != null?true : false, sm);
await CookPlatformShader(args, i, sm, cooker.MaterialAssets);
cooker.DirectCopyFiles(i);
CMDEngine.CMDEngineInstance.SaveAssetinfos(i);
if (pakAssets != null)
{
var listFileName = CEngine.Instance.FileManager.Cooked + CEngine.Instance.FileManager.CookingPlatform + "/tmp_pakassets.alist";
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(listFileName))
{
var files = CEngine.Instance.FileManager.GetFiles(CEngine.Instance.FileManager.CookingRoot, "*.*", System.IO.SearchOption.AllDirectories);
foreach (var j in files)
{
var absName = j.ToLower();
bool error = false;
absName = CEngine.Instance.FileManager.NormalizePath(absName, out error);
if (absName.EndsWith(".rinfo"))
{
continue;
}
if (absName.EndsWith(".cs"))
{
continue;
}
if (absName.EndsWith(".noused"))
{
continue;
}
var NameInPak = absName.Substring(CEngine.Instance.FileManager.CookingRoot.Length);
sw.WriteLine($"{absName} {NameInPak} normal");
}
}
AssetsPacker.PackAList(listFileName, pakAssets);
}
}
}
catch (Exception ex)
{
EngineNS.Profiler.Log.WriteException(ex);
}
finally
{
cmdEngine.IsRun = false;
}
}
break;
case "bake":
{
}
break;
case "localhost":
{
}
break;
case "gen_proj":
{
if (args.Length != 2)
{
return;
}
GenProject.Instance.Command(args);
cmdEngine.IsRun = false;
}
break;
case "fresh_rinfo":
{
var subdir = FindArgument(args, "dir=").Substring("dir=".Length);
var types = FindArgument(args, "type=").Substring("type=".Length);
var resTypes = types.Split('+');
var nouse = cmdEngine.FreshRInfo(subdir, resTypes);
cmdEngine.IsRun = false;
}
break;
case "rname_change":
{
Dictionary <string, string> changeList = new Dictionary <string, string>();
var name = FindArgument(args, "name=");
if (name != null)
{
name = name.Substring("name=".Length);
var seg = name.Split('+');
foreach (var i in seg)
{
var rnPair = i.Split('#');
if (rnPair.Length != 2)
{
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Warning, "RName", $"rename resource arguments error:{i}");
continue;
}
var rn = RName.GetRName(rnPair[0]);
if (CEngine.Instance.FileManager.FileExists(rn.Address))
{
var rnModifier = new RNameModifier();
rnModifier.CollectRefObjects(rn);
await rnModifier.SaveRefObjects(rn, rnPair[1]);
changeList[rnPair[0]] = rnPair[1];
}
else
{
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Warning, "RName", $"rename resource doesn't exist:{i}");
}
}
}
//移动目录
var dir = FindArgument(args, "dir=");
if (dir != null)
{
dir = dir.Replace('&', ' ');
dir = dir.Substring("dir=".Length);
var seg = dir.Split('#');
if (seg.Length != 2)
{
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Warning, "RName", $"rename directory:{dir}");
}
else
{
var src = seg[0].ToLower();
var tar = seg[1].ToLower();
var files = CEngine.Instance.FileManager.GetFiles(EngineNS.CEngine.Instance.FileManager.ProjectContent + src, "*.rinfo", System.IO.SearchOption.AllDirectories);
foreach (var i in files)
{
bool error;
var sf = EngineNS.CEngine.Instance.FileManager.NormalizePath(i, out error);
sf = sf.Substring(EngineNS.CEngine.Instance.FileManager.ProjectContent.Length);
sf = sf.Substring(0, sf.Length - ".rinfo".Length);
var rn = EngineNS.RName.GetRName(sf);
var sf2 = sf.Substring(src.Length);
sf2 = tar + sf2;
if (CEngine.Instance.FileManager.FileExists(rn.Address))
{
var rnModifier = new RNameModifier();
rnModifier.CollectRefObjects(rn);
await rnModifier.SaveRefObjects(rn, sf2);
changeList[sf] = sf2;
}
}
}
}
foreach (var i in changeList)
{
CEngine.Instance.FileManager.RNameRemap[i.Key] = i.Value;
}
var map = FindArgument(args, "savemap=");
if (map != null)
{
map = map.Substring("savemap=".Length);
var seg = map.Split('+');
foreach (var i in seg)
{
var rn = RName.GetRName(i);
EngineNS.GamePlay.GWorld World = new EngineNS.GamePlay.GWorld();
World.Init();
var scene = await EngineNS.GamePlay.GGameInstance.LoadScene(CEngine.Instance.RenderContext, World, rn);
if (scene != null)
{
EngineNS.Vector3 pos = new EngineNS.Vector3(0, -10, 0);
EngineNS.Vector3 lookAt = new EngineNS.Vector3(0, 0, 0);
EngineNS.Vector3 up = new EngineNS.Vector3(0, 1, 0);
{
var xnd = await EngineNS.IO.XndHolder.LoadXND(rn.Address + "/scene.map");
if (xnd != null)
{
var att = xnd.Node.FindAttrib("ED_info");
if (att != null)
{
att.BeginRead();
att.Read(out pos);
att.Read(out lookAt);
att.Read(out up);
att.EndRead();
}
xnd.Dispose();
}
}
await scene.SaveScene(rn, null, (InScene, InXnd) =>
{
var att = InXnd.Node.AddAttrib("ED_info");
att.BeginWrite();
att.Write(pos);
att.Write(lookAt);
att.Write(up);
att.EndWrite();
});
}
}
}
cmdEngine.IsRun = false;
}
break;
default:
break;
}
}
public virtual async System.Threading.Tasks.Task <bool> InitEnvWithScene(UInt32 w, UInt32 h,
[Editor.Editor_RNameType(Editor.Editor_RNameTypeAttribute.Scene)]
RName map, bool startDraw = true)
{
if (w == 0)
{
w = 128;
}
if (h == 0)
{
h = 128;
}
if (map == null)
{
map = RName.EmptyName;
}
mWidth = w;
mHeight = h;
var rc = EngineNS.CEngine.Instance.RenderContext;
mCamera = new EngineNS.Graphics.CGfxCamera();
mCamera.Init(rc, false);
mCamera.PerspectiveFovLH(mCamera.mDefaultFoV, (float)mWidth, (float)mHeight, 0.1f, 1000.0f);
mCamera.BeforeFrame();
//mCamera.SwapBuffer(false);
Vector3 Eye = new Vector3();
Eye.SetValue(0.0f, 50.0f, -30.0f);
Vector3 At = new Vector3();
At.SetValue(0.0f, 0.0f, 0.0f);
Vector3 Up = new Vector3();
Up.SetValue(0.0f, 1.0f, 0.0f);
mCamera.LookAtLH(Eye, At, Up);
mRP_OffScreen = new EngineNS.Graphics.RenderPolicy.CGfxRP_OffScreen();
mRP_OffScreen.OnDrawUI += (CCommandList cmd, Graphics.View.CGfxScreenView view) =>
{
if (UIHost != null)
{
UIHost.Draw(CEngine.Instance.RenderContext, cmd, view);
}
};
await mRP_OffScreen.Init(rc, mWidth, mHeight, mCamera, IntPtr.Zero);
UIHost.Initializer.Id = 1;
UIHost.WindowSize = new SizeF(mWidth, mHeight);
mWorld = new EngineNS.GamePlay.GWorld();
if (false == mWorld.Init())
{
return(false);
}
mWorld.CheckVisibleParam.UsePVS = false;
SceneGraph.GSceneGraph scene = null;
IO.XndHolder xnd = await IO.XndHolder.LoadXND(map.Address + "/scene.map");
if (xnd == null)
{
scene = await GamePlay.SceneGraph.GSceneGraph.CreateSceneGraph(this.World, typeof(GamePlay.SceneGraph.GSceneGraph), new SceneGraph.GSceneGraphDesc());
mWorld.AddScene(map, scene);
}
else
{
var type = Rtti.RttiHelper.GetTypeFromSaveString(xnd.Node.GetName());
if (type == null)
{
return(false);
}
scene = await GamePlay.SceneGraph.GSceneGraph.CreateSceneGraph(this.World, type, null);
if (false == await scene.LoadXnd(rc, xnd.Node, map))
{
return(false);
}
if (scene != null)
{
World.AddScene(map, scene);
mWorld.SetDefaultScene(scene.SceneId);
if (mWorld.DefaultScene.SunActor != null)
{
var sunComp = mWorld.DefaultScene?.SunActor.GetComponent <EngineNS.GamePlay.Component.GDirLightComponent>();
if (sunComp != null)
{
sunComp.View = mRP_OffScreen.BaseSceneView;
}
}
if (scene.McSceneGetter != null && scene.McSceneGetter.Get(false) != null)
{
await scene.McSceneGetter.Get(false).OnSceneLoaded(scene);
scene.McSceneGetter.Get(false).OnRegisterInput();
}
}
}
if (startDraw)
{
this.Start();
}
return(true);
}
private async System.Threading.Tasks.Task <EngineNS.GamePlay.Actor.GActor> CreateMeshActorAsync(EngineNS.GamePlay.GWorld world, RName scene, List <RName> meshesName, Vector3 loc, Vector3 scale)
{
var actor = await EngineNS.GamePlay.Actor.GActor.NewMeshActorAsync(meshesName);
actor.Placement.Location = loc;
actor.Placement.Scale = scale;
this.World.AddActor(actor);
this.World.Scenes[scene].AddActor(actor);
return(actor);
}
private async System.Threading.Tasks.Task <EngineNS.GamePlay.Actor.GActor> CreateMeshActorAsync(EngineNS.GamePlay.GWorld world, RName scene, RName meshName, Vector3 loc, Quaternion rotation, Vector3 scale)
{
var mesh = await CEngine.Instance.MeshManager.CreateMeshAsync(EngineNS.CEngine.Instance.RenderContext, meshName);
var actor = EngineNS.GamePlay.Actor.GActor.NewMeshActor(mesh);
actor.Placement.Location = loc;
actor.Placement.Rotation = rotation;
actor.Placement.Scale = scale;
this.World.AddActor(actor);
this.World.Scenes[scene].AddActor(actor);
return(actor);
}
