private LineManager3DLines getChunkLines(ChunkCoordinate chunkCoordinate)
{
return(wireframes.GetOrCreate(chunkCoordinate, delegate
{
var ret = new LineManager3DLines(TW.Graphics.Device);
updateWireframeBox(ret, chunkCoordinate);
return ret;
}));
}
private static void drawLinesWithDepth(LineManager3DLines lines)
{
TW.Graphics.SetBackbuffer();
TW.Graphics.Device.ImmediateContext.OutputMerger.SetTargets(
TW.Graphics.AcquireRenderer().GBuffer.DepthStencilView,
TW.Graphics.Device.ImmediateContext.OutputMerger.GetRenderTargets(1));
TW.Graphics.LineManager3D.Render(lines, TW.Graphics.Camera);
TW.Graphics.SetBackbuffer();
}
public void Setup()
{
environment = new DualContouringTestEnvironment();
environment.AddToEngine(EngineFactory.CreateEngine());
gridWorldSize = 10f;
subdivision = 20;
cellSize = gridWorldSize / subdivision;
lines = new LineManager3DLines(TW.Graphics.Device);
}
public static void addQEFPoints(RawMeshData mesh, float scale, LineManager3DLines lineManager3DLines)
{
if (mesh.Positions.Length == 0)
{
return;
}
foreach (var p in mesh.Positions)
{
lineManager3DLines.AddCenteredBox(p * scale, 0.05f, Color.Orange);
}
}
public DualContouringTestEnvironment()
{
cellSize = 0.5f;
lines = new LineManager3DLines(TW.Graphics.Device);
this.lines.SetMaxLines(1000000);
PlaceableObjectGrid = new IntersectableCube();
cameraLightSimulator = new CameraLightSimulator();
surfaceRenderer = VoxelCustomRenderer.CreateDefault(TW.Graphics);
TW.Graphics.AcquireRenderer().AddCustomGBufferRenderer(surfaceRenderer);
}
public void TestImportGeometry()
{
XNAGame game = new XNAGame();
ObjImporter importer = new ObjImporter();
bool dirty = true;
Seeder seeder = new Seeder(489);
LineManager3DLines lines = null;
var fsCrate = new FileStream(TestFiles.CrateObj, FileMode.Open);
var fsMHouse = new FileStream(TestFiles.MerchantsHouseObj, FileMode.Open);
game.UpdateEvent += delegate
{
if (game.Keyboard.IsKeyPressed(Keys.C) || dirty)
{
lines = new LineManager3DLines();
importer.ImportObjFile(fsCrate);
renderWireframe(importer, lines, Color.Black, Vector3.Zero);
renderObjects(importer, lines, seeder, Vector3.Right * 5);
renderSubObjects(importer, lines, seeder, Vector3.Right * 10);
importer.ImportObjFile(fsMHouse);
renderWireframe(importer, lines, Color.Black, Vector3.Forward * 30);
renderObjects(importer, lines, seeder, Vector3.Right * 30 + Vector3.Forward * 30);
renderSubObjects(importer, lines, seeder, Vector3.Right * 60 + Vector3.Forward * 30);
dirty = false;
}
};
game.DrawEvent += delegate
{
game.LineManager3D.Render(lines);
};
game.Run();
fsCrate.Close();
fsMHouse.Close();
}
private void renderWireframe(ObjImporter importer, LineManager3DLines lines, Color col, Vector3 offset)
{
for (int i = 0; i < importer.Groups.Count; i++)
{
for (int j = 0; j < importer.Groups[i].SubObjects.Count; j++)
{
for (int k = 0; k < importer.Groups[i].SubObjects[j].Faces.Count; k++)
{
lines.AddTriangle(
importer.Vertices[
importer.Groups[i].SubObjects[j].Faces[k].V1.Position] + offset,
importer.Vertices[
importer.Groups[i].SubObjects[j].Faces[k].V2.Position] + offset,
importer.Vertices[
importer.Groups[i].SubObjects[j].Faces[k].V3.Position] + offset,
col);
}
}
}
}
public static void addFaceNormals(AbstractHermiteGrid grid, float cellSize, LineManager3DLines lines)
{
var vertices = new List <Vector3>();
var indices = new List <int>();
var algo = new DualContouringAlgorithm();
algo.GenerateSurface(vertices, indices, grid);
var builder = new DualContouringMeshBuilder();
var triangleNormals = builder.generateTriangleNormals(indices, vertices);
for (int i = 0; i < indices.Count; i += 3)
{
var v1 = vertices[indices[i]];
var v2 = vertices[indices[i + 1]];
var v3 = vertices[indices[i + 2]];
var mean = (v1 + v2 + v3) / 3f;
lines.AddCenteredBox(mean * cellSize, 0.05f, Color.DarkCyan);
lines.AddLine(mean * cellSize, (mean + triangleNormals[i / 3] * 0.5f) * cellSize, Color.Cyan);
}
}
public static void addLinesSimulator(TWEngine engine, LineManager3DLines lines)
{
bool visible = false;
engine.AddSimulator(() =>
{
if (TW.Graphics.Keyboard.IsKeyPressed(Key.Z))
{
TW.Graphics.AcquireRenderer().Wireframe = !TW.Graphics.AcquireRenderer().Wireframe;
}
if (TW.Graphics.Keyboard.IsKeyPressed(Key.X))
{
visible = !visible;
}
if (!visible)
{
return;
}
drawLinesWithDepth(lines);
}, "linerenderer");
}
public void Delete()
{
renderer.DeleteLinesElement(this);
Lines = null;
}
public DeferredLinesElement(DeferredRenderer renderer, Device device)
{
this.renderer = renderer;
Lines = new LineManager3DLines(device);
}
private void updateWireframeBox(LineManager3DLines ret, ChunkCoordinate chunk)
{
ret.ClearAllLines();
worldOctree.GetWorldObjects(chunk)
.ForEach(p => ret.AddAABB(p.BoundingBox, Matrix.Identity, new Color4(0, 0, 0)));
}
public void Initialize()
{
lineManager = new LineManager3DLines(game.Device);
lineManager.SetMaxLines(64 * 1024);
lineManager.DrawGroundShadows = true;
}
public static void addHermiteVertices(AbstractHermiteGrid grid, float cellSize, LineManager3DLines lines)
{
grid.ForEachGridPoint(p =>
{
var sign = grid.GetSign(p);
if (GridHelper.OrthogonalDirections3D.All(dir => grid.GetSign(p + dir) == sign))
{
return;
}
var vertPos = p.ToVector3() * cellSize;
var color = sign ? Color.Green.dx() : Color.LightGray.dx();
//if (!sign)
lines.AddCenteredBox(vertPos, cellSize * 0.1f, color);
});
}
public static void addHermiteNormals(AbstractHermiteGrid grid, float cellSize, LineManager3DLines lines)
{
grid.ForEachGridPoint(p =>
{
var sign = grid.GetSign(p);
var dirs = new[] { new Point3(1, 0, 0), new Point3(0, 1, 0), new Point3(0, 0, 1) };
foreach (var dir in dirs)
{
if (sign == grid.GetSign(p + dir))
{
continue;
}
//lines.AddLine(vertPos, end, Color.Black.dx());
var edge = grid.GetEdgeId(p, p + dir);
var edgeStart = grid.GetEdgeOffsets(edge)[0] + p;
var edgeEnd = grid.GetEdgeOffsets(edge)[1] + p;
var normal = grid.GetEdgeNormal(p, edge);
var pos = grid.GetEdgeIntersectionCubeLocal(p, edge);
pos = (p + pos) * cellSize;
lines.AddLine(pos, pos + normal * 0.4f * cellSize, Color.Blue);
lines.AddLine(edgeStart.ToVector3() * cellSize, edgeEnd.ToVector3() * cellSize, Color.LightBlue);
lines.AddCenteredBox(pos, 0.02f, Color.Red);
}
});
}
