public override async System.Threading.Tasks.Task <bool> SetInitializer(CRenderContext rc, EngineNS.GamePlay.Actor.GActor host, GComponentInitializer v)
{
if (!await base.SetInitializer(rc, host, v))
{
return(false);
}
if (mLineMeshComponent == null)
{
await InitGraphLines();
}
if (mLineMeshComponent != null)
{
mLineMeshComponent.Host = host;
Host.PlacementChange -= PlacementChange;
Host.PlacementChange += PlacementChange;
var mat = host.Placement.WorldMatrix;
mLineMeshComponent.OnUpdateDrawMatrix(ref mat);
}
Initializer = v as NavLinkProxyComponentInitializer;
Radius = Initializer.Radius;
Direction = Initializer.Direction;
return(true);
}
public Form1()
{
InitializeComponent();
Ball = new CObject3D("Ball.ini");
Stairs[0] = new CObject3D("Floor.ini");
for (int i = 1; i < NUM_STAIRS; i++)
{
Stairs[i] = new CObject3D(Stairs[0]);
}
Spirals[0] = new CObject3D("Spiral.ini");
for (int i = 1; i < NUM_SPIRALS; i++)
{
Spirals[i] = new CObject3D(Spirals[0]);
}
Diamond = new CObject3D("Diamond.ini");
RenderContext = new CRenderContext(ClientSize.Width, ClientSize.Height);
FormCanvas = CreateGraphics();
RenderContext.SetViewerPosition(0, -80, 500);
Initialize();
timer1.Enabled = true;
}
//private NavLinkProxyComponentInitializer Initializer;
public override async System.Threading.Tasks.Task <bool> SetInitializer(CRenderContext rc, GamePlay.IEntity host, GamePlay.Component.IComponentContainer hostContainer, GComponentInitializer v)
{
if (!await base.SetInitializer(rc, host, hostContainer, v))
{
return(false);
}
if (mLineMeshComponent == null)
{
await InitGraphLines();
}
if (mLineMeshComponent != null)
{
mLineMeshComponent.Entity = host;
Host.PlacementChange -= PlacementChange;
Host.PlacementChange += PlacementChange;
var mat = this.Host.Placement.WorldMatrix;
mLineMeshComponent.OnUpdateDrawMatrix(ref mat);
}
var initializer = v as NavLinkProxyComponentInitializer;
Radius = initializer.Radius;
Direction = initializer.Direction;
Initializer = initializer;
return(true);
}
public bool Init(CRenderContext RHICtx, CGfxMesh SceneMesh, UInt32 index, CGfxMaterialInstance mtl_inst, CGfxShadingEnv[] EnvShaderArray, bool preUseEffect)
{
if (EnvShaderArray == null)
{
EnvShaderArray = CEngine.Instance.PrebuildPassData.DefaultShadingEnvs;
}
MtlInst = mtl_inst;
mRootSceneMesh = SceneMesh;
mAtomIndex = index;
CGfxEffect[] effects = new CGfxEffect[EnvShaderArray.Length];
for (int ppi = 0; ppi < (int)PrebuildPassIndex.PPI_Num; ppi++)
{
if (EnvShaderArray[ppi] == null)
{
continue;
}
var effect = GetEffectAsync(RHICtx, SceneMesh, true, EnvShaderArray[ppi].EnvCode);
effects[ppi] = effect;
}
return(InitByEffects(RHICtx, SceneMesh, index, mtl_inst, effects, EnvShaderArray, preUseEffect));
}
public void ReCreateCBuffer(CRenderContext rc, CGfxEffect effect, bool FlushVars)
{
if (effect.CacheData.PerInstanceId != UInt32.MaxValue)
{
bool recreateCB = false;
if (mCBuffer != null)
{
var desc = new CConstantBufferDesc();
effect.ShaderProgram.GetCBufferDesc(effect.CacheData.PerInstanceId, ref desc);
if (mCBuffer.Size != desc.Size)
{
recreateCB = true;
}
else
{
recreateCB = !mCBuffer.IsSameVars(effect.ShaderProgram, effect.CacheData.PerInstanceId);
}
}
else
{
recreateCB = true;
}
if (recreateCB)
{
mCBuffer = rc.CreateConstantBuffer(effect.ShaderProgram, effect.CacheData.PerInstanceId);
MtlInst.SetCBufferVars(CBuffer);
}
else if (FlushVars)
{
MtlInst.SetCBufferVars(CBuffer);
}
}
}
public bool Init(CRenderContext rc, bool autoFlush)
{
mSceneRenderLayer = new CGfxRenderLayer[(int)ERenderLayer.RL_Num];
for (int i = 0; i < mSceneRenderLayer.Length; i++)
{
mSceneRenderLayer[i] = new CGfxRenderLayer();
}
var shaderProgram = CEngine.Instance.EffectManager.DefaultEffect.ShaderProgram;
CEngine.Instance.EffectManager.DefaultEffect.PreUse((succsessed) =>
{
var cbIndex = CEngine.Instance.EffectManager.DefaultEffect.CacheData.CBID_Camera;
mCBuffer = rc.CreateConstantBuffer(shaderProgram, cbIndex);
if (mCBuffer == null)
{
#if DEBUG
System.Diagnostics.Debug.Assert(false);
#endif
}
//mCBuffer.AutoFlush = autoFlush;
SDK_GfxCamera_BindConstBuffer(CoreObject, mCBuffer.CoreObject);
});
return(true);
}
public CShaderSamplers GetSamplerBinder_PickedEditor(CRenderContext RHICtx, CShaderProgram shader)
{
if (shader == null)
{
return(null);
}
if (mSamplerBinder_PickedEditor == null)
{
mSamplerBinder_PickedEditor = new CShaderSamplers();
using (var it = MtlInst.Material.GetSamplerStateDescs().GetEnumerator())
{
while (it.MoveNext())
{
var name = it.Current.Key;
var samplerDesc = it.Current.Value;
CSamplerBindInfo info = new CSamplerBindInfo();
if (shader.FindSamplerBindInfoByShaderName(MtlInst, name, ref info))
{
CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, samplerDesc);
mSamplerBinder_PickedEditor.PSBindSampler(info.PSBindPoint, SamplerState);
}
else
{
var defaultSamplerDesc = new CSamplerStateDesc();
defaultSamplerDesc.SetDefault();
CSamplerState SamplerState = CEngine.Instance.SamplerStateManager.GetSamplerState(RHICtx, defaultSamplerDesc);
mSamplerBinder_PickedEditor.PSBindSampler(info.PSBindPoint, SamplerState);
}
}
}
}
return(mSamplerBinder_PickedEditor);
}
internal void UnsafeReInit(CRenderContext rc, NativePointer self)
{
Core_Release();
mCoreObject = self;
Core_AddRef();
for (UInt32 i = 0; i < MdfNumber; i++)
{
var mdfPtr = SDK_GfxMdfQueue_GetModifier(CoreObject, i);
var mdfName = CGfxModifier.SDK_GfxModifier_GetName(mdfPtr);
var mdfType = Rtti.RttiHelper.GetTypeFromSaveString(mdfName);
//这里好像最好不要克隆，因为我们希望这种调用是CGfxMeshPrimitives加载的时候用，他就是表征vms，
//而不是自己独立一份的数据
//var mdfPtr = CGfxModifier.SDK_GfxModifier_CloneModifier(mdfPtr, rc.CoreObject);
if (mdfPtr.GetPointer() == IntPtr.Zero)
{
continue;
}
var modifier = System.Activator.CreateInstance(mdfType, new object[] { mdfPtr }) as CGfxModifier;
if (modifier == null)
{
continue;
}
AddModifier(modifier);
}
UpdateHash64();
}
public async System.Threading.Tasks.Task <bool> Init(CRenderContext rc, CSwapChain SwapChain,
View.CGfxScreenViewDesc ViewInfo, CGfxShadingEnv ShadingEnv, RName MtlInst, string debugName)
{
mCmdList = new CCommandList[2];
EngineNS.CCommandListDesc CmdListDesc = new EngineNS.CCommandListDesc();
mCmdList[0] = rc.CreateCommandList(CmdListDesc);
mCmdList[1] = rc.CreateCommandList(CmdListDesc);
mCmdList[0].DebugName = debugName;
mCmdList[1].DebugName = debugName;
var ScreenAlignedTriangle = CEngine.Instance.MeshPrimitivesManager.GetMeshPrimitives(rc, CEngineDesc.ScreenAlignedTriangleName, true);
mScreenAlignedTriangle = CEngine.Instance.MeshManager.CreateMesh(rc, ScreenAlignedTriangle);
var mtl = await CEngine.Instance.MaterialInstanceManager.GetMaterialInstanceAsync(rc, MtlInst);
mScreenAlignedTriangle.SetMaterialInstance(rc, 0,
mtl,
CEngine.Instance.PrebuildPassData.DefaultShadingEnvs);
//await mScreenAlignedTriangle.AwaitEffects();
mShadingEnv = ShadingEnv;
mScreenView = new View.CGfxScreenView();
return(await mScreenView.Init(rc, SwapChain, ViewInfo, ShadingEnv, mtl, mScreenAlignedTriangle));
}
public async System.Threading.Tasks.Task <bool> Init(CRenderContext rc)
{
if (CEngine.Instance.MaterialManager.DefaultMaterial == null ||
CEngine.Instance.ShadingEnvManager.DefaultShadingEnv == null)
{
return(false);
}
var desc = CGfxEffectDesc.CreateDesc(CEngine.Instance.MaterialManager.DefaultMaterial,
new Mesh.CGfxMdfQueue(),
CEngine.Instance.ShadingEnvManager.DefaultShadingEnv.EnvCode);
mDefaultEffect = GetEffect(rc, desc);
await mDefaultEffect.AwaitLoad();
if (mDefaultEffect.CacheData.CBID_View == UInt32.MaxValue)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Fatal, "Shader", $"DefaultEffect({desc.EnvShaderPatch.ShaderName}) CBID_View is invalid");
return(false);
}
if (mDefaultEffect.CacheData.CBID_Camera == UInt32.MaxValue)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Fatal, "Shader", $"DefaultEffect({desc.EnvShaderPatch.ShaderName}) CBID_Camera is invalid");
return(false);
}
return(true);
}
public override void TickLogic(CGfxSceneView view, CRenderContext RHICtx)
{
if (mCaptureSV == null)
{
return;
}
var rc = EngineNS.CEngine.Instance.RenderContext;
if (rc == null)
{
return;
}
mCaptureSV.CookSpecRenderLayerDataToPass(rc, ERenderLayer.RL_Opaque, Camera, mCaptureSE, PrebuildPassIndex.PPI_SceneCapture);
mCaptureSV.CookSpecRenderLayerDataToPass(rc, ERenderLayer.RL_CustomOpaque, Camera, mCaptureSE, PrebuildPassIndex.PPI_SceneCapture);
mCaptureSV.CookSpecRenderLayerDataToPass(rc, ERenderLayer.RL_CustomTranslucent, Camera, mCaptureSE, PrebuildPassIndex.PPI_SceneCapture);
mCaptureSV.CookSpecRenderLayerDataToPass(rc, ERenderLayer.RL_Translucent, Camera, mCaptureSE, PrebuildPassIndex.PPI_SceneCapture);
mCaptureSV.CookSpecRenderLayerDataToPass(rc, ERenderLayer.RL_Gizmos, Camera, mCaptureSE, PrebuildPassIndex.PPI_SceneCapture);
mCommandList_Final.BeginCommand();
mCommandList_Final.BeginRenderPass(mRenderPassDesc_SceneCapture, mCaptureSV.FrameBuffer);
mCaptureSV.PushSpecRenderLayerDataToRHI(mCommandList_Final, ERenderLayer.RL_Opaque);
mCaptureSV.PushSpecRenderLayerDataToRHI(mCommandList_Final, ERenderLayer.RL_CustomOpaque);
mCaptureSV.PushSpecRenderLayerDataToRHI(mCommandList_Final, ERenderLayer.RL_CustomTranslucent);
mCaptureSV.PushSpecRenderLayerDataToRHI(mCommandList_Final, ERenderLayer.RL_Translucent);
mCaptureSV.PushSpecRenderLayerDataToRHI(mCommandList_Final, ERenderLayer.RL_Gizmos);
mCommandList_Final.BuildRenderPass(int.MaxValue, false, true);
mCommandList_Final.EndRenderPass();
mCommandList_Final.EndCommand();
}
public CGfxEffect GetEffect(CRenderContext rc, CGfxEffectDesc desc)
{
lock (Effects)
{
CGfxEffect result;
var saved = desc.String;
var hash = desc.GetHash64();
if (Effects.TryGetValue(hash, out result) == true)
{
if (hash != result.Desc.GetHash64())
{
Effects.Remove(hash);
hash = result.Desc.GetHash64();
Effects[hash] = result;
//System.Diagnostics.Debug.Assert(false);
}
return(result);
}
else
{
result = new CGfxEffect(desc);
result.PreUse();
Effects.Add(desc.GetHash64(), result);
return(result);
}
}
}
public async System.Threading.Tasks.Task ResetDebugBox(CRenderContext rc, EngineNS.GamePlay.Actor.GActor actor, EngineNS.Bricks.Particle.CGfxParticleSystem sys)
{
BoundingBox.Merge(ref Host.LocalBoundingBox, ref sys.AABB.Box, out Host.LocalBoundingBox);
OnUpdateDrawMatrix(ref Host.Placement.mDrawTransform);
await CreateBoundBox(rc, Host, sys);
}
private Cluster.ClusteredMesh GetClusteredMesh(CRenderContext rc, RName clusterName, out uint indexOffset)
{
KeyValuePair <uint, Cluster.ClusteredMesh> result;
if (mClusteredMeshs.TryGetValue(clusterName, out result))
{
indexOffset = result.Key;
return(result.Value);
}
else
{
uint vertexOffset = (uint)mAllVertices.Count;
Cluster.ClusteredMesh clusterMesh = CEngine.Instance.ClusteredMeshManager.GetResource(rc, clusterName, true);
mAllVertices.AddRange(clusterMesh.MeshVertices);
indexOffset = (uint)mAllIndices.Count;
for (int i = 0; i < clusterMesh.IndexBuffer.Count; i++)
{
uint index = vertexOffset + clusterMesh.IndexBuffer[i];
mAllIndices.Add(index);
}
result = new KeyValuePair <uint, Cluster.ClusteredMesh>(indexOffset, clusterMesh);
mClusteredMeshs.Add(clusterName, result);
return(result.Value);
}
}
public override async System.Threading.Tasks.Task <bool> SetInitializer(CRenderContext rc, IEntity host, IComponentContainer hostContainer, GComponentInitializer v)
{
await base.SetInitializer(rc, host, hostContainer, v);
DirLightInitializer = v as GDirLightComponentInitializer;
return(true);
}
public bool ChangeFace(CRenderContext rc, Graphics.Mesh.CGfxMeshCooker.EBoxFace face, float delta)
{
switch (face)
{
case Graphics.Mesh.CGfxMeshCooker.EBoxFace.Left:
return(ChangeLeftFace(rc, delta));
case Graphics.Mesh.CGfxMeshCooker.EBoxFace.Right:
return(ChangeRightFace(rc, delta));
case Graphics.Mesh.CGfxMeshCooker.EBoxFace.Back:
return(ChangeBackFace(rc, delta));
case Graphics.Mesh.CGfxMeshCooker.EBoxFace.Front:
return(ChangeFrontFace(rc, delta));
case Graphics.Mesh.CGfxMeshCooker.EBoxFace.Top:
return(ChangeTopFace(rc, delta));
case Graphics.Mesh.CGfxMeshCooker.EBoxFace.Bottom:
return(ChangeBottomFace(rc, delta));
default:
return(false);
}
}
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 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 override void OnResize(CRenderContext RHICtx, CSwapChain SwapChain, UInt32 width, UInt32 height)
{
Camera.PerspectiveFovLH(Camera.mDefaultFoV, (float)width, (float)height);
mCopyPostprocessPass.mScreenView.OnResize(RHICtx, SwapChain, width, height);
BaseSceneView.OnResize(RHICtx, null, width, height);
//post effect;
mMobileAO.OnResize(RHICtx, width, height, BaseSceneView);
mBloomMobile.OnResize(RHICtx, width, height, BaseSceneView);
mSunShaftMobile.OnResize(RHICtx, width, height);
mCopySE.mBaseSceneView = BaseSceneView.FrameBuffer.GetSRV_RenderTarget(0);
if (CEngine.EnableBloom == true)
{
mCopySE.mBloomTex = mBloomMobile.mUSView8.FrameBuffer.GetSRV_RenderTarget(0);
}
else
{
mCopySE.mBloomTex = BaseSceneView.FrameBuffer.GetSRV_RenderTarget(0);
}
mCopySE.mSunShaftTex = mSunShaftMobile.mView_Blur.FrameBuffer.GetSRV_RenderTarget(0);
mCopySE.mSRV_MobileAo = mMobileAO.mView_AoMask.FrameBuffer.GetSRV_RenderTarget(0);
var ViewportSizeAndRcp = new Vector4(width, height, 1.0f / width, 1.0f / height);
mCopyPostprocessPass.mScreenView.ViewportSizeAndRcp = ViewportSizeAndRcp;
}
public void TickRender(CRenderContext RHICtx)
{
if (RHICtx == null)
{
System.Diagnostics.Debug.Assert(false);
return;
}
if (CEngine.EnableMobileAo == true)
{
var CmdList = mCLDB_AoMask[1];
CmdList.Commit(RHICtx);
CmdList = mCLDB_BlurH[1];
CmdList.Commit(RHICtx);
CmdList = mCLDB_BlurV[1];
CmdList.Commit(RHICtx);
}
else
{
var CmdList = mCLDB_BlurV[1];
CmdList.Commit(RHICtx);
}
}
public void UpdatePerMtlMeshCBufferForShadow(CRenderContext RHICtx, CGfxCamera camera)
{
var refPrebuildPass = GetFirstValidPass();
if (refPrebuildPass == null || refPrebuildPass.Effect == null)
{
return;
}
var cbIndex = refPrebuildPass.Effect.CacheData.PerInstanceId;// effect.ShaderProgram.FindCBuffer("cbPerInstance");
if ((int)cbIndex >= 0)
{
//else
//{
// //this code below is for what????????
// var cbDesc = new CConstantBufferDesc();
// if (refPrebuildPass.Effect.ShaderProgram.GetCBufferDesc(cbIndex, ref cbDesc))
// {
// if (mCBuffer.Size != cbDesc.Size)
// {
// Profiler.Log.WriteLine(Profiler.ELogTag.Warning, "Material", $"{refPrebuildPass.Effect.Desc.MtlShaderPatch.Name} CBuffer size is invalid, recreate it");
// mCBuffer?.Cleanup();
// mCBuffer = RHICtx.CreateConstantBuffer(refPrebuildPass.Effect.ShaderProgram, cbIndex);
// MeshVarVersion = UInt32.MaxValue;
// }
// }
//}
PassData2ConstBufferPerTickForShadow(camera);
//MtlInst.SetCBufferVars(mCBuffer);
}
}
public void OnResize(CRenderContext RHICtx, UInt32 width, UInt32 height, CGfxSceneView BaseSceneView)
{
if (RHICtx == null || mView_AoMask == null || mView_BlurH == null /*|| mView_BlurV == null*/)
{
System.Diagnostics.Debug.Assert(false);
return;
}
UInt32 Width = Math.Max(width, 64);
UInt32 Height = Math.Max(height, 64);
UInt32 Width4 = Width / mRTCut;
UInt32 Height4 = Height / mRTCut;
mView_AoMask.OnResize(RHICtx, null, Width4, Height4);
mView_BlurH.OnResize(RHICtx, null, Width4, Height4);
//mView_BlurV.OnResize(RHICtx, null, Width4, Height4);
//mSE_AoMask.mBaseSceneView = BaseSceneView.mFrameBuffer.GetSRV_RenderTarget(0);
mSE_BlurH.mSRV_AoMask = mView_AoMask.FrameBuffer.GetSRV_RenderTarget(0);
//mSE_BlurV.mSRV_Src = mView_BlurH.FrameBuffer.GetSRV_RenderTarget(0);
mViewportSizeAndRcp = new Vector4(Width4, Height4, 1.0f / Width4, 1.0f / Height4);
mView_AoMask.ViewportSizeAndRcp = mViewportSizeAndRcp;
mView_BlurH.ViewportSizeAndRcp = mViewportSizeAndRcp;
//mView_BlurV.ViewportSizeAndRcp = ViewportSizeAndRcp;
}
public CGfxEffect TryGetEffect(CRenderContext RHICtx, CGfxMesh mesh, bool tryLoad, GfxEnvShaderCode ShaderEnv)
{
var result = CGfxEffectDesc.CreateDesc(MtlInst.Material, mesh.MdfQueue, ShaderEnv);//, mShaderDefinition);
var hash64 = result.GetHash64();
return(CEngine.Instance.EffectManager.TryGetEffect(ref hash64));
}
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 void RefreshAllPassEffect(CRenderContext rc)
{
for (EngineNS.PrebuildPassIndex i = 0; i < EngineNS.PrebuildPassIndex.PPI_Num; i++)
{
RefreshPassEffect(rc, i);
}
}
public void TickRender(CRenderContext RHICtx)
{
for (UInt32 CmdIdx = 0; CmdIdx < mCsmNum; CmdIdx++)
{
mCmdListDB_Shadow[CmdIdx, 1].Commit(RHICtx);
}
}
public override async Task <bool> SetInitializer(CRenderContext rc, GamePlay.IEntity host, GamePlay.Component.IComponentContainer hostContainer, GComponentInitializer v)
{
if (await base.SetInitializer(rc, host, hostContainer, v) == false)
{
return(false);
}
mMeshComponent = new GamePlay.Component.GMeshComponent();
var meshCompInit = new GamePlay.Component.GMeshComponent.GMeshComponentInitializer();
meshCompInit.SpecialName = "VisualMesh";
meshCompInit.MeshName = CEngineDesc.PlayerStartMesh;
await mMeshComponent.SetInitializer(rc, Host, Host, meshCompInit);
//var mat = host.Placement.WorldMatrix;
//mMeshComponent.OnUpdateDrawMatrix(ref mat);
AgentGeomBoxInitializer = v as AgentGeomBoxComponentInitializer;
if (AgentGeomBoxInitializer != null)
{
AgentGridSize = AgentGeomBoxInitializer.AgentGridSize;
StartPos = AgentGeomBoxInitializer.StartPos;
}
else
{
AgentGeomBoxInitializer = new AgentGeomBoxComponentInitializer();
}
return(true);
}
public async override System.Threading.Tasks.Task <GActor> Clone(CRenderContext rc)
{
var result = new GPrefab();
//var result = new GCloneActor();
var init = Initializer.CloneObject() as GActorInitializer;
init.ActorId = Guid.NewGuid();
result.SetInitializer(init);
if (CenterData != null)
{
Rtti.MetaClass.CopyData(CenterData, result.CenterData);
}
for (int i = 0; i < Components.Count; ++i)
{
var comp = await Components[i]?.CloneComponent(rc, result, result);
result.AddComponent(comp);
}
for (int i = 0; i < Children.Count; ++i)
{
var actor = await Children[i].Clone(rc);
actor.SetParent(result);
actor.OnActorLoaded();
}
result.OnActorLoaded();
result.OnPlacementChanged(result.Placement);
result.WaitContext.Result = result;
result.WaitContext.SetFinished(WaitContext.IsFinished);
return(result);
}
public override Graphics.Mesh.CGfxModifier CloneModifier(CRenderContext rc)
{
var result = new CGfxParticleModifier();
result.Name = Name;
return(result);
}
public override void CommitVisual(CRenderContext rc, Graphics.CGfxCamera camera)
{
if (EngineNS.CIPlatform.Instance.PlayMode == CIPlatform.enPlayMode.Editor)
{
mLineMeshComponent?.CommitVisual(rc, camera);
}
}
