public virtual async System.Threading.Tasks.Task <bool> InitEnviroment()
{
var rc = EngineNS.CEngine.Instance.RenderContext;
mCamera = new EngineNS.Graphics.CGfxCamera();
mCamera.Init(rc, false);
Vector3 Eye = new Vector3();
Eye.SetValue(0.0f, 0.0f, -3.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);
mCamera.PerspectiveFovLH(mCamera.mDefaultFoV, (float)mWidth, (float)mHeight, 0.1f, 1000.0f);
mCamera.BeforeFrame();
mCamera.SwapBuffer(false);
mRP_Snapshot = new EngineNS.Graphics.RenderPolicy.CGfxRP_Snapshot();
await mRP_Snapshot.Init(rc, mWidth, mHeight, mCamera, IntPtr.Zero);
return(await InitWorld());
}
public void FinalCleanup()
{
mRP_Snapshot.Cleanup();
mRP_Snapshot = null;
mCamera.Cleanup();
mCamera = null;
}
public virtual async System.Threading.Tasks.Task <bool> InitGame(IntPtr WinHandle, UInt32 width, UInt32 height, EngineNS.GamePlay.GGameInstanceDesc desc, EngineNS.Graphics.CGfxCamera camera)
{
var rc = EngineNS.CEngine.Instance.RenderContext;
if (camera == null)
{
camera = new EngineNS.Graphics.CGfxCamera();
camera.Init(rc, false);
}
CEngine.Instance.TickManager.AddTickInfo(this);
await BuildAutoMembers();
WindowHandle = WinHandle;
WindowWidth = width;
WindowHeight = height;
mDesc = desc;
mWorld = new GWorld();
GameCamera = camera;
if (false == mWorld.Init())
{
return(false);
}
var scene = await LoadScene(rc, desc.SceneName, true);
if (scene == null)
{
return(false);
}
mWorld.AddScene(desc.SceneName, scene);
mWorld.SetDefaultScene(scene.SceneId);
foreach (var i in AutoMembers)
{
await i.Key.OnGameInit(i.Value, width, height);
}
Vector3 Eye = new Vector3();
Eye.SetValue(0.0f, 1.0f, -3.0f);
Vector3 At = new Vector3();
At.SetValue(0.0f, 1.0f, 0.0f);
Vector3 Up = new Vector3();
Up.SetValue(0.0f, 1.0f, 0.0f);
camera.LookAtLH(Eye, At, Up);
camera.PerspectiveFovLH(camera.mDefaultFoV, (float)width, (float)height, 0.1f, 1000.0f);
var mRP_GameMobile = new EngineNS.Graphics.RenderPolicy.CGfxRP_GameMobile();
await mRP_GameMobile.Init(rc, width, height, camera, WinHandle);
this.SetGameRenderPolicy(mRP_GameMobile);
return(true);
}
public override void CommitVisual(CRenderContext rc, EngineNS.Graphics.CGfxCamera camera)
{
base.CommitVisual(rc, camera);
if (mMeshComponent != null)
{
mMeshComponent?.CommitVisual(rc, camera);
}
}
public override void CommitVisual(CCommandList cmd, EngineNS.Graphics.CGfxCamera camera, GamePlay.SceneGraph.CheckVisibleParam param)
{
base.CommitVisual(cmd, camera, param);
if (mMeshComponent != null)
{
mMeshComponent?.CommitVisual(cmd, camera, param);
}
}
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 async System.Threading.Tasks.Task SaveToFile(string strFileName)
{
var rc = CEngine.Instance.RenderContext;
EngineNS.Graphics.CGfxCamera Camera = new EngineNS.Graphics.CGfxCamera();
Vector3 Eye = new Vector3();
Eye.SetValue(0.0f, 3.0f, -6.0f);
Vector3 At = new Vector3();
At.SetValue(0.0f, 1.0f, 0.0f);
Vector3 Up = new Vector3();
Up.SetValue(0.0f, 1.0f, 0.0f);
Camera.LookAtLH(Eye, At, Up);
Camera.SetViewPort(rc, EditorViewPort);
Camera.PerspectiveFovLH(MathHelper.V_PI / 4,
(float)EditorViewPort.ViewPort.Width,
(float)EditorViewPort.ViewPort.Height, 0.01f, 100.0f);
CalculateCamera(Camera, 2.0);
CMRTClearColor[] clrColors = new CMRTClearColor[]
{
new CMRTClearColor(0, 0xFF000000),
};
Camera.DisplayView.ClearMRT(clrColors, true, 1.0F, true, 0);
Camera.DisplayView.ClearPasses(EngineNS.Graphics.EDrawChannel.DCN_Base);
this.World?.Tick();
this.World?.CheckVisible(rc, Camera);
RPolicy.TickLogic(Camera.DisplayView);
RPolicy.TickSync();
RPolicy.TickRender(null);
Camera.DisplayView.RenderTargets[0].Texture2D.Save2File(rc, strFileName, EIMAGE_FILE_FORMAT.PNG);
}
public void CalculateCamera(EngineNS.Graphics.CGfxCamera Camera, double delta)
{
Vector3 vMax = Vector3.UnitXYZ * float.MinValue;
Vector3 vMin = Vector3.UnitXYZ * float.MaxValue;
foreach (var actor in mWorld.Actors)
{
Vector3 tempMax = Vector3.Zero, tempMin = Vector3.Zero;
BoundingBox aabb = new BoundingBox();
actor.Value.GetAABB(ref aabb);
tempMin = aabb.Minimum;
tempMax = aabb.Maximum;
vMax.X = System.Math.Max(vMax.X, tempMax.X);
vMax.Y = System.Math.Max(vMax.Y, tempMax.Y);
vMax.Z = System.Math.Max(vMax.Z, tempMax.Z);
vMin.X = System.Math.Min(vMin.X, tempMin.X);
vMin.Y = System.Math.Min(vMin.Y, tempMin.Y);
vMin.Z = System.Math.Min(vMin.Z, tempMin.Z);
}
MaxZoomMeshShow(0, 0, mWidth, mHeight, vMax, vMin, Camera, mWorld, delta);
}
public void CalculateCamera(EngineNS.Graphics.CGfxCamera Camera, double delta)
{
if (FocusActor == null)
{
return;
}
Vector3 vMax = Vector3.UnitXYZ * float.MinValue;
Vector3 vMin = Vector3.UnitXYZ * float.MaxValue;
Vector3 tempMax = Vector3.Zero, tempMin = Vector3.Zero;
BoundingBox aabb = new BoundingBox();
FocusActor.GetAABB(ref aabb);
tempMin = aabb.Minimum;
tempMax = aabb.Maximum;
vMax.X = System.Math.Max(vMax.X, tempMax.X);
vMax.Y = System.Math.Max(vMax.Y, tempMax.Y);
vMax.Z = System.Math.Max(vMax.Z, tempMax.Z);
vMin.X = System.Math.Min(vMin.X, tempMin.X);
vMin.Y = System.Math.Min(vMin.Y, tempMin.Y);
vMin.Z = System.Math.Min(vMin.Z, tempMin.Z);
FocusShow(0, 0, mWidth, mHeight, vMax, vMin, Camera, mWorld, delta);
}
public virtual async System.Threading.Tasks.Task <bool> InitEnviroment(UInt32 w, UInt32 h, string name)
{
mWidth = w;
mHeight = h;
var rc = EngineNS.CEngine.Instance.RenderContext;
mCamera = new EngineNS.Graphics.CGfxCamera();
mCamera.Init(rc, false);
Vector3 Eye = new Vector3();
Eye.SetValue(0.0f, 0.0f, -3.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);
mCamera.PerspectiveFovLH(mCamera.mDefaultFoV, (float)mWidth, (float)mHeight, 0.1f, 1000.0f);
mCamera.BeforeFrame();
mCamera.SwapBuffer(false);
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);
return(await InitWorld(name));
}
public static void CaptureWithPoint(EngineNS.Vector3 point,
EngineNS.Matrix worldMatrix,
EngineNS.Graphics.CGfxCamera camera,
EngineNS.CRenderContext rc,
EngineNS.Vector3 camDir,
EngineNS.Vector3 camUp,
UInt32 actorsCount,
EngineNS.Graphics.RenderPolicy.CGfxRP_SceneCapture rp,
UInt32 textureIdx,
ref EngineNS.Support.CBlobObject dataBlob,
ref EngineNS.Support.CBlobObject picBlob)
{
var lookat = point + camDir;
lookat = EngineNS.Vector3.TransformCoordinate(lookat, worldMatrix);
point = EngineNS.Vector3.TransformCoordinate(point, worldMatrix);
camUp = EngineNS.Vector3.TransformNormal(camUp, worldMatrix);
camera.LookAtLH(point, lookat, camUp);
camera.BeforeFrame();
//world.Tick();
//world.SlowDrawAll(rc, camera);
var maxId = actorsCount;
rp.TickLogic(null, rc);
camera.SwapBuffer(true);
rp.TickRender(null);
//camera.ClearAllRenderLayerData();
// debug
#pragma warning disable 0162
if (false)
{
var texRGB = rp.CaptureSV.FrameBuffer.GetSRV_RenderTarget(1);
texRGB.Save2File(rc, "e:/testCapture.bmp", EngineNS.EIMAGE_FILE_FORMAT.BMP);
}
#pragma warning restore 0162
if (rp.UseCapture)
{
var blob = new EngineNS.Support.CBlobObject();
blob.PushData(rp.TexData0.Data, rp.TexData0.Size);
dataBlob = blob;
if (rp.CaptureRGBData)
{
blob = new EngineNS.Support.CBlobObject();
blob.PushData(rp.TexData1.Data, rp.TexData1.Size);
picBlob = blob;
}
//await EngineNS.CEngine.Instance.EventPoster.Post(() =>
//{
// rp.CaptureSV.mFrameBuffer.GetSRV_RenderTarget(0).Save2File($"D:\\{camIdx}.png", (int)mWidth, (int)mHeight, (int)(mWidth * 4), rp.TexData0.ToBytes(), EngineNS.EIMAGE_FILE_FORMAT.PNG);
// rp.CaptureSV.mFrameBuffer.GetSRV_RenderTarget(1).Save2File($"D:\\{camIdx}_ref.png", (int)mWidth, (int)mHeight, (int)(mWidth * 4), rp.TexData1.ToBytes(), EngineNS.EIMAGE_FILE_FORMAT.PNG);
// return true;
//}, EngineNS.Thread.Async.EAsyncTarget.AsyncEditor);
}
var cmd = EngineNS.CEngine.Instance.RenderContext.ImmCommandList;
var actirIdTexture = rp.GetActoridTexture();
cmd.CSSetShaderResource(textureIdx, actirIdTexture);
uint texSize = 512;
cmd.CSDispatch(texSize / 8, texSize / 8, 1);
}
public async System.Threading.Tasks.Task <bool> StartGame(Type gameInstanceType, IntPtr WinHandle, UInt32 width, UInt32 height, EngineNS.GamePlay.GGameInstanceDesc desc, EngineNS.Graphics.CGfxCamera camera, RName startScript)
{
#if PWindow
//Bricks.RemoteServices.RPCExecManager.Insance.SaveCode();
#endif
McGame = CEngine.Instance.MacrossDataManager.NewObjectGetter <GamePlay.McGameInstance>(startScript);
TickableNum = CEngine.Instance.TickManager.GetTickableNum();
if (mGameInstance != null && mGameInstance.GameState != GamePlay.GGameInstance.enGameState.Stopped)
{
return(false);
}
var savedLogic = CEngine.Instance.ThreadLogic.LimitTime;
var savedRender = CEngine.Instance.ThreadRHI.LimitTime;
CEngine.Instance.ThreadLogic.LimitTime = long.MaxValue;
CEngine.Instance.ThreadRHI.LimitTime = long.MaxValue;
mGameInstance = System.Activator.CreateInstance(gameInstanceType) as GamePlay.GGameInstance;
mGameInstance.GameState = GamePlay.GGameInstance.enGameState.initializing;
try
{
if (false == await mGameInstance.InitGame(WinHandle, width, height, desc, camera))
{
CEngine.Instance.ThreadLogic.LimitTime = savedLogic;
CEngine.Instance.ThreadRHI.LimitTime = savedRender;
return(false);
}
}
catch (Exception ex)
{
Profiler.Log.WriteException(ex);
}
foreach (var i in AutoMembers)
{
await i.Key.OnGameStart(i.Value);
}
OnGameStarted();
CEngine.Instance.ThreadLogic.LimitTime = savedLogic;
CEngine.Instance.ThreadRHI.LimitTime = savedRender;
var smp = Thread.ASyncSemaphore.CreateSemaphore(1);
EngineNS.CEngine.Instance.EventPoster.RunOn(async() =>
{
var mcGame = McGame.Get();
if (mcGame != null)
{
Profiler.Log.WriteLine(Profiler.ELogTag.Info, "Macross", "Macross begin mcGame.OnGameStart");
try
{
await mcGame.OnGameStart(mGameInstance);
}
catch (Exception ex)
{
Profiler.Log.WriteException(ex);
}
Profiler.Log.WriteLine(Profiler.ELogTag.Info, "Macross", "Macross end mcGame.OnGameStart");
}
smp.Release();
return(true);
}, Thread.Async.EAsyncTarget.Logic);
await smp.Await();
mGameInstance.GameState = GamePlay.GGameInstance.enGameState.Initialized;
await mGameInstance.OnGameInited();
return(true);
}
public static void CaptureGeoBox(EngineNS.Bricks.HollowMaker.Agent.GeoBox geoBox,
EngineNS.Bricks.HollowMaker.GeomScene.AgentBoxs agentData,
EngineNS.Graphics.CGfxCamera camera,
EngineNS.CRenderContext rc,
UInt32 numElem,
EngineNS.Graphics.RenderPolicy.CGfxRP_SceneCapture rp,
EngineNS.CCommandList cmd,
UInt32 cbIndex,
EngineNS.CConstantBuffer cbuffer,
EngineNS.CGpuBuffer buffer_visible,
EngineNS.CShaderDesc csMain_visible,
EngineNS.CComputeShader cs_visible,
EngineNS.CUnorderedAccessView uav_visible,
EngineNS.CGpuBuffer buffer_setBit,
EngineNS.CShaderDesc csMain_setBit,
EngineNS.CComputeShader cs_setBit,
EngineNS.CUnorderedAccessView uav_setBit,
EngineNS.CComputeShader cs_Clear,
List <EngineNS.Support.BitSet> savedBitsets,
UInt32 textureIdx,
Action <int, EngineNS.Support.CBlobObject, EngineNS.Support.CBlobObject> actionAfterCapturePerDir)
{
var cornerPos = geoBox.Box.GetCorners();
//for(int posIdx = 0; posIdx < cornerPos.Length; posIdx++)
//{
// await CaptureSceneWithPoint(cornerPos[posIdx], world, camera, rc, camDirs, camUps, dataBlobs, picBlobs);
//}
cmd.SetComputeShader(cs_visible);
UInt32[] pUAVInitialCounts = new UInt32[1] {
1,
};
cmd.CSSetUnorderedAccessView(0, uav_visible, pUAVInitialCounts);
//await CaptureSceneWithPoint(geoBox.Box.GetCenter(), agentData.Mat , camera, rc, camDirs, camUps, numElem/*, dataBlobs, picBlobs*/);
for (int camIdx = 0; camIdx < 6; camIdx++)
{
EngineNS.Support.CBlobObject idBlob = null;
EngineNS.Support.CBlobObject picBlob = null;
EditorCommon.PVSAssist.CaptureWithPoint(geoBox.Box.GetCenter(), agentData.Mat, camera, rc, camDirs[camIdx], camUps[camIdx], numElem, rp, textureIdx, ref idBlob, ref picBlob);
actionAfterCapturePerDir?.Invoke(camIdx, idBlob, picBlob);
}
// gbuffer0
var blob = new EngineNS.Support.CBlobObject();
buffer_visible.GetBufferData(rc, blob);
var idArray = blob.ToUInts();
// fill uav1, clear uav0
cmd.SetComputeShader(cs_setBit);
UInt32[] pUAVInitialCounts1 = new UInt32[1] {
1,
};
cmd.CSSetUnorderedAccessView(0, uav_visible, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(1, uav_setBit, pUAVInitialCounts);
var cbDesc = new EngineNS.CConstantBufferDesc();
if (csMain_setBit.GetCBufferDesc(cbIndex, ref cbDesc))
{
if (cbDesc.Type == EngineNS.ECBufferRhiType.SIT_CBUFFER)
{
cmd.CSSetConstantBuffer(cbDesc.CSBindPoint, cbuffer);
}
}
cmd.CSDispatch(numElem, 1, 1);
var blob0 = new EngineNS.Support.CBlobObject();
buffer_visible.GetBufferData(rc, blob0);
var visArray = blob0.ToUInts();
// gbuffer1
var blob1 = new EngineNS.Support.CBlobObject();
buffer_setBit.GetBufferData(rc, blob1);
var idArray1 = blob1.ToBytes();
var bitSet = new EngineNS.Support.BitSet();
var bitSet1 = new EngineNS.Support.BitSet();
bitSet.Init(numElem * 2, idArray1);
bitSet1.Init(numElem);
for (UInt32 e = 0; e < numElem; e++)
{
var bit1 = bitSet.IsBit(e * 2 + 0);
var bit2 = bitSet.IsBit(e * 2 + 1);
bitSet1.SetBit(e, bit1 || bit2);
}
savedBitsets.Add(bitSet1);
cmd.SetComputeShader(cs_Clear);
cmd.CSSetUnorderedAccessView(0, uav_visible, pUAVInitialCounts);
cmd.CSSetUnorderedAccessView(1, uav_setBit, pUAVInitialCounts);
cmd.CSDispatch(numElem / 16 + 1, 1, 1);
}
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);
}
public override async System.Threading.Tasks.Task <bool> InitGame(IntPtr WinHandle, UInt32 width, UInt32 height, EngineNS.GamePlay.GGameInstanceDesc desc, EngineNS.Graphics.CGfxCamera camera)
{
#if PWindow
EngineNS.Bricks.RemoteServices.RPCExecuter.Instance.SaveCode();
#elif PAndroid
AccessGameRes.CheckAndCreateFirstAssetList();
#endif
return(await base.InitGame(WinHandle, width, height, desc, camera));
}
/*EngineNS.Graphics.CGfxCamera mCamera;
* async Task Test_Init()
* {
* var rc = EngineNS.CEngine.Instance.RenderContext;
* mCamera = new EngineNS.Graphics.CGfxCamera();
* mCamera.Init(rc, false);
* mCamera.PerspectiveFovLH((float)(System.Math.PI * 0.6f), mWidth, mHeight);
* mSceneCaptureRP = new EngineNS.Graphics.RenderPolicy.CGfxRP_SceneCapture();
* await mSceneCaptureRP.Init(rc, mWidth, mHeight, mCamera, IntPtr.Zero);
* }
*
* void Test_TickLogic(EditorCommon.ViewPort.ViewPortControl vp)
* {
* }
* private void Test_TickRender(EditorCommon.ViewPort.ViewPortControl vp)
* {
* if (mCamera == null)
* return;
* var rc = EngineNS.CEngine.Instance.RenderContext;
* EngineNS.Vector3[] camDirs = { EngineNS.Vector3.UnitX, -EngineNS.Vector3.UnitZ, -EngineNS.Vector3.UnitX, EngineNS.Vector3.UnitZ, EngineNS.Vector3.UnitY, -EngineNS.Vector3.UnitY };
* EngineNS.Vector3[] camUps = { EngineNS.Vector3.UnitY, EngineNS.Vector3.UnitY, EngineNS.Vector3.UnitY, EngineNS.Vector3.UnitY, EngineNS.Vector3.UnitZ, -EngineNS.Vector3.UnitZ };
* rc.BindCurrentSwapChain(vp.RPolicy.mSwapChain);
* for (int camIdx = 0; camIdx < 6; camIdx++)
* {
* var dir = camDirs[camIdx];
* var pos = new EngineNS.Vector3(0, 1, 0);
* var up = camUps[camIdx];
* var lookat = pos + dir;
* mCamera.LookAtLH(pos, lookat, up);
* mCamera.BeforeFrame();
*
* vp.World.CheckVisible(rc, mCamera);
* vp.World.Tick();
*
* mSceneCaptureRP.TickLogic(null, rc);
* mCamera.SwapBuffer(true);
*
* mSceneCaptureRP.TickRender(null);
* mCamera.ClearAllRenderLayerData();
* }
* //rc.Present(0, 0);
*
* }
* private void Test_TickSync(EditorCommon.ViewPort.ViewPortControl vp)
* {
*
* }*/
async Task BuildSceneCaptures(EngineNS.GamePlay.SceneGraph.GSceneGraph processScene, List <EngineNS.GamePlay.Actor.GActor> drawActors)
{
if (processScene.SceneFilename == EngineNS.RName.EmptyName)
{
EditorCommon.MessageBox.Show("没有找到当前场景的保存路径！");
return;
}
var rc = EngineNS.CEngine.Instance.RenderContext;
var camera = new EngineNS.Graphics.CGfxCamera();
camera.Init(rc, false);
camera.PerspectiveFovLH((float)(System.Math.PI * 0.6f), mWidth, mHeight);
mSceneCaptureRP = new EngineNS.Graphics.RenderPolicy.CGfxRP_SceneCapture();
await mSceneCaptureRP.Init(rc, mWidth, mHeight, camera, IntPtr.Zero);
mSceneCaptureRP.CaptureRGBData = false;
// Compute shader
//////const string CSVersion = "cs_5_0";
//////var macros = new EngineNS.CShaderDefinitions();
//////var shaderFile = EngineNS.RName.GetRName("Shaders/Compute/extractID.compute").Address;
//////var csMain0 = rc.CompileHLSLFromFile(shaderFile, "CSMain", CSVersion, macros);
//////var csMain1 = rc.CompileHLSLFromFile(shaderFile, "CSMain1", CSVersion, macros);
//////var cs = rc.CreateComputeShader(csMain0);
//////var cs1 = rc.CreateComputeShader(csMain1);
uint numElem = (UInt32)drawActors.Count;
//// debug
//numElem = 255 * 255 * 2;
//////var bfDesc = new EngineNS.CGpuBufferDesc();
//////bfDesc.ToDefault();
//////bfDesc.ByteWidth = 4 * numElem;
//////bfDesc.StructureByteStride = 4;
//////var buffer = rc.CreateGpuBuffer(bfDesc, IntPtr.Zero);
//////var uavDesc = new EngineNS.CUnorderedAccessViewDesc();
//////uavDesc.ToDefault();
//////uavDesc.Buffer.NumElements = numElem;
//////var uav = rc.CreateUnorderedAccessView(buffer, uavDesc);
//////// 一个uint保存16个actorID的权重
//////var numElemUAV1 = numElem / 16 + 1;
//////bfDesc.ByteWidth = 4* numElemUAV1;
//////bfDesc.StructureByteStride = 4;
//////var buffer1 = rc.CreateGpuBuffer(bfDesc, IntPtr.Zero);
//////uavDesc.Buffer.NumElements = numElemUAV1;
//////var uav1 = rc.CreateUnorderedAccessView(buffer1, uavDesc);
//////var cbIndex = csMain1.FindCBufferDesc("CaptureEnv");
//////EngineNS.CConstantBuffer cbuffer = null;
//////if((int)cbIndex!=-1)
//////{
////// cbuffer = rc.CreateConstantBuffer(csMain1, cbIndex);
////// var varIdx = cbuffer.FindVar("rateWeight");
////// cbuffer.SetValue(varIdx, new EngineNS.Quaternion(1, 1, 10000, 100000), 0);
////// cbuffer.FlushContent2(rc);
//////}
//////var texIdx = csMain0.FindSRVDesc("SrcTexture");
var cmd = rc.ImmCommandList;
UInt32 cbIndex;
EngineNS.CConstantBuffer cbuffer;
EngineNS.CGpuBuffer buffer_visible;
EngineNS.CShaderDesc csMain_visible;
EngineNS.CComputeShader cs_visible;
EngineNS.CUnorderedAccessView uav_visible;
EngineNS.CGpuBuffer buffer_setBit;
EngineNS.CShaderDesc csMain_setBit;
EngineNS.CComputeShader cs_setBit;
EngineNS.CUnorderedAccessView uav_setBit;
EngineNS.CShaderDesc csMain_Clear;
EngineNS.CComputeShader cs_clear;
UInt32 textureIdx;
EditorCommon.PVSAssist.ComputeShaderInit(numElem, out cbIndex, out cbuffer, out buffer_visible, out csMain_visible, out cs_visible, out uav_visible, out buffer_setBit,
out csMain_setBit, out cs_setBit, out uav_setBit,
out csMain_Clear, out cs_clear,
out textureIdx);
var checkVisibleParam = new EngineNS.GamePlay.SceneGraph.CheckVisibleParam();
foreach (var actor in drawActors)
{
actor.OnCheckVisible(rc.ImmCommandList, processScene, camera, checkVisibleParam);
}
//mSceneCaptureRP.TickLogic(null, rc);
int VoxelMemSize = ((int)numElem / 8 + 1) + 4;
// 读取geoScene
var t1 = EngineNS.Support.Time.HighPrecision_GetTickCount();
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Info, "Editor", "Begin Capture Scene VIS");
var geoScene = await EngineNS.Bricks.HollowMaker.GeomScene.CreateGeomScene(processScene.SceneFilename.Address + "/geoscene.dat");
EditorCommon.Controls.Debugger.PVSDebugger.GeoScene = geoScene;
for (int j = 0; j < geoScene.AgentDatas.Count; j++)
{
var capDataDir = processScene.SceneFilename.Address + "/capturedata/" + j + "/";
if (!EngineNS.CEngine.Instance.FileManager.DirectoryExists(capDataDir))
{
EngineNS.CEngine.Instance.FileManager.CreateDirectory(capDataDir);
}
List <EngineNS.Support.BitSet> savedBitsets = new List <EngineNS.Support.BitSet>();
var agentData = geoScene.AgentDatas[j];
var memSize = VoxelMemSize * agentData.AgentData.Count;
for (int i = 0; i < agentData.AgentData.Count; i++)
{
var geoBox = geoScene.AgentDatas[j].AgentData[i];
EditorCommon.PVSAssist.CaptureGeoBox(geoBox, agentData, camera, rc, numElem, mSceneCaptureRP, cmd, cbIndex, cbuffer, buffer_visible, csMain_visible, cs_visible, uav_visible, buffer_setBit, csMain_setBit, cs_setBit, uav_setBit, cs_clear, savedBitsets, textureIdx, null);
}
var saveXnd = EngineNS.IO.XndHolder.NewXNDHolder();
var voxelAtt = saveXnd.Node.AddAttrib("voxelData");
voxelAtt.BeginWrite();
voxelAtt.Write(agentData.BVSize);
voxelAtt.Write(agentData.Mat);
voxelAtt.Write(agentData.AgentData.Count);
for (int i = 0; i < agentData.AgentData.Count; i++)
{
var geoBox = agentData.AgentData[i];
var pvsVoxel = new EngineNS.Bricks.HollowMaker.PVSVoxel();
pvsVoxel.Shape = geoBox.Box;
pvsVoxel.X = geoBox.X;
pvsVoxel.Y = geoBox.Y;
pvsVoxel.Z = geoBox.Z;
pvsVoxel.Bits = savedBitsets[i];
pvsVoxel.LinkedVoxels = new List <int>(geoBox.Neighbors);
var str = pvsVoxel.Bits.ToBase64String();
pvsVoxel.BitsHash = (UInt32)(str.GetHashCode());
voxelAtt.WriteMetaObject(pvsVoxel);
}
voxelAtt.EndWrite();
EngineNS.IO.XndHolder.SaveXND(capDataDir + "vis.data", saveXnd);
System.GC.Collect();
}
var t2 = EngineNS.Support.Time.HighPrecision_GetTickCount();
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Info, "Editor", $"End Capture Scene VIS,Time = {(t2-t1)/1000000}");
mSceneCaptureRP.Cleanup();
}
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 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);
}
