public void ShowLoadingProgress(EngineNS.GamePlay.SceneGraph.GSceneGraph scene)
{
mProgressScene = scene;
ProgressBar_Loading.Visibility = Visibility.Visible;
ProgressBar_Loading.Value = 0;
EnableTick = true;
}
public ModuleTreeViewItem(EngineNS.GamePlay.SceneGraph.GSceneGraph scene)
{
mHostScene = scene;
if (scene != null)
{
BindingOperations.SetBinding(this, NameProperty, new Binding("Name")
{
Source = scene
});
TypeName = $"({scene.GetType().FullName})";
}
}
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);
}
void InitModulesTreeView(EngineNS.GamePlay.SceneGraph.GSceneGraph scene)
{
mModules.Clear();
mCurrentScene = scene;
if (mCurrentScene == null)
{
return;
}
var item = new ModuleTreeViewItem(scene);
mModules.Add(item);
foreach (var module in scene.Modules.Values)
{
var moduleItem = new ModuleTreeViewItem(module);
item.ChildList.Add(moduleItem);
}
}
public static void GetBuildActors(EngineNS.GamePlay.SceneGraph.GSceneGraph sc,
List <EngineNS.GamePlay.Actor.GActor> allActors,
List <EngineNS.GamePlay.Actor.GActor> pvsActors,
List <EngineNS.GamePlay.Actor.GActor> unPVSActors,
List <EngineNS.GamePlay.Component.ISceneGraphComponent> buildItems)
{
using (var i = sc.Actors.GetEnumerator())
{
while (i.MoveNext())
{
EngineNS.GamePlay.Actor.GActor actor = i.Current.Value;
// 不包含平行光
if (actor.GetComponent(typeof(EngineNS.GamePlay.Component.GDirLightComponent)) != null)
{
continue;
}
// 不包含带有SceneGraphComponent的Actor
var comp = actor.GetComponent(typeof(EngineNS.GamePlay.Component.ISceneGraphComponent)) as EngineNS.GamePlay.Component.ISceneGraphComponent;
if (comp != null)
{
buildItems.Add(comp);
continue;
}
allActors.Add(actor);
if (actor.Initializer.InPVS)
{
pvsActors.Add(actor);
}
else
{
unPVSActors.Add(actor);
}
sc.DefaultSceneNode.RemoveActor(actor);
}
}
}
private async Task BuildPVS(EngineNS.GamePlay.SceneGraph.GSceneGraph scene, List <EngineNS.GamePlay.SceneGraph.GPvsSet> pvsSets)
{
pvsSets.Clear();
var rootDir = scene.SceneFilename.Address + "/capturedata/";
if (EngineNS.CEngine.Instance.FileManager.DirectoryExists(rootDir))
{
var dirs = EngineNS.CEngine.Instance.FileManager.GetDirectories(rootDir);
foreach (var capDataDir in dirs)
{
int tolerance = 20;
var builder = new EngineNS.Bricks.HollowMaker.PVSBuilder();
builder.LoadPVSVoxels(capDataDir);
builder.BuildUnitedCluster(tolerance);
var bvs = new List <EngineNS.Bricks.HollowMaker.CombineVoxel.BoxVolume>();
builder.BuildBoxVolume(bvs);
EngineNS.Profiler.Log.WriteLine(EngineNS.Profiler.ELogTag.Info, "PVSBuilder",
$"PVS({capDataDir}):容差={tolerance};BitSet={builder.UnitedCluster.Count}; BoxVolume={bvs.Count};");
//var xnd = EngineNS.IO.XndHolder.NewXNDHolder();
//builder.SaveXnd(xnd.Node, bvs);
var set = builder.CreatePVSSet(bvs);
pvsSets.Add(set);
//EngineNS.IO.XndHolder.SaveXND(EngineNS.RName.GetRName("Test.pvs").Address, xnd);
bool bDebugConvexMesh = false;
if (bDebugConvexMesh)
{
if (mConvexShowActor != null)
{
foreach (var i in mConvexShowActor)
{
VP1.World.RemoveEditorActor(i.ActorId);
}
mConvexShowActor = null;
}
var meshes = new List <EngineNS.Graphics.Mesh.CGfxMeshPrimitives>();
for (int i = 0; i < builder.UnitedCluster.Count; i++)
{
meshes.Add(builder.UnitedCluster[i].BuildMesh());
}
//int clustIndex = 1;
//meshes.Add(builder.UnitedCluster[clustIndex].BuildMesh());
mConvexShowActor = new List <EngineNS.GamePlay.Actor.GActor>();
foreach (var i in meshes)
{
var rc = EngineNS.CEngine.Instance.RenderContext;
var gms = EngineNS.CEngine.Instance.MeshManager.CreateMesh(rc, i);
var act = EngineNS.GamePlay.Actor.GActor.NewMeshActorDirect(gms);
var meshComp = act.GetComponent <EngineNS.GamePlay.Component.GMeshComponent>();
var mat = await EngineNS.CEngine.Instance.MaterialInstanceManager.GetMaterialInstanceAsync(rc, EngineNS.RName.GetRName(@"editor\icon\icon_3D\material\area.instmtl"));
await meshComp.SetMaterialInstanceAsync(rc, 0, mat, null);
VP1.World.AddEditorActor(act);
act.Placement.Location = EngineNS.Vector3.TransformCoordinate(EngineNS.Vector3.Zero, set.WorldMatrix);
act.Placement.Scale = EngineNS.Vector3.UnitXYZ;
act.Placement.Rotation = EngineNS.Quaternion.RotationMatrix(set.WorldMatrix);
mConvexShowActor.Add(act);
}
}
}
}
}
public void BuildGeoScene(EngineNS.GamePlay.SceneGraph.GSceneGraph scene)
{
if (scene.SceneFilename == null)
{
return;
}
EngineNS.Bricks.HollowMaker.GeomScene geomscene = new EngineNS.Bricks.HollowMaker.GeomScene();
HollowMakerAgent.AgentComponenetBox = new List <EngineNS.BoundingBox>();
float osize = HollowMakerAgent.AgentGridSize;
//先处理一遍摆放好的AgentGeomBoxComponent..
foreach (var value in scene.Actors)
{
EngineNS.GamePlay.Actor.GActor actor = value.Value;
if (actor != null)
{
EngineNS.Bricks.HollowMaker.AgentGeomBoxComponent acom = actor.GetComponent <EngineNS.Bricks.HollowMaker.AgentGeomBoxComponent>();
if (acom != null)
{
HollowMakerAgent.AgentGridSize = acom.AgentGridSize;
EngineNS.Vector3 scale;
EngineNS.Quaternion rotation;
EngineNS.Vector3 translation;
if (actor.Placement != null && actor.Placement.WorldMatrix.Decompose(out scale, out rotation, out translation))
{
geomscene.AgentData = new List <EngineNS.Bricks.HollowMaker.Agent.GeoBox>();
BuildWalkables(acom.StartPos, translation, scale, rotation);
HollowMakerAgent.BuildGeomScene(geomscene);
//TODO..
HollowMakerAgent.AgentComponenetBox.Add(acom.Box);
EngineNS.Bricks.HollowMaker.GeomScene.AgentBoxs AgentBoxs = new EngineNS.Bricks.HollowMaker.GeomScene.AgentBoxs();
AgentBoxs.AgentData = geomscene.AgentData;
AgentBoxs.Mat = EngineNS.Matrix.Transformation(EngineNS.Vector3.UnitXYZ, rotation, translation);
AgentBoxs.BVSize = scale;
geomscene.AgentDatas.Add(AgentBoxs);
}
}
}
}
//HollowMakerAgent.AgentGridSize = osize;
//foreach (var value in scene.Actors)
//{
// EngineNS.GamePlay.Actor.GActor actor;
// var compment = value.Value.TryGetTarget(out actor);
// if (actor != null)
// {
// EngineNS.LooseOctree.OctreeVolumeComponent com = actor.GetComponent<EngineNS.LooseOctree.OctreeVolumeComponent>();
// if (com != null)
// {
// EngineNS.BoundingBox box = new EngineNS.BoundingBox();
// actor.GetAABB(ref box);
// BuildWalkables(box);
// HollowMakerAgent.BuildGeomScene(geomscene);
// }
// }
//}
// var test = geomscene.CreateRenderInfos(VP1.World);
geomscene.SaveXND(scene.SceneFilename.Address + "/geoscene.dat");
//EngineNS.Bricks.HollowMaker.GeomScene temp = await EngineNS.Bricks.HollowMaker.GeomScene.CreateGeomScene(scene.SceneFilename.Address + "/geoscene.dat");
//int xx = 0;
}
/*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();
}
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 void SetSceneGraph(EngineNS.GamePlay.SceneGraph.GSceneGraph scene)
{
InitModulesTreeView(scene);
}
