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