/// <summary>
/// Draw hermite info for given cube and outputs the info to a textarea
/// </summary>
private void drawHermiteInfoForCube(Point3 gridPoint, Textarea textarea)
{
textarea.Text = "";
foreach (var edgeID in grid.GetAllEdgeIds())
{
var points = grid.GetEdgeOffsets(edgeID);
Vector3 edgeWorldStart = (gridPoint + points[0]).ToVector3() * CellSize;
TW.Graphics.LineManager3D.AddLine(edgeWorldStart, (gridPoint + points[1]).ToVector3() * CellSize,
Color.Purple.dx());
var hasEdge = false;
if (grid.HasEdgeData(gridPoint, edgeID))
{
textarea.Text += grid.GetEdgeIntersectionCubeLocal(gridPoint, edgeID) + "n: " +
grid.getEdgeData(gridPoint, edgeID).TakeXYZ() + "\n";
hasEdge = true;
var normal = grid.GetEdgeNormal(gridPoint, edgeID);
Vector3 worldIntersection = (grid.GetEdgeIntersectionCubeLocal(gridPoint, edgeID) + gridPoint) * CellSize;
TW.Graphics.LineManager3D.AddCenteredBox(worldIntersection, 0.04f, Color.LawnGreen.dx());
TW.Graphics.LineManager3D.AddLine(worldIntersection, worldIntersection + normal * 0.2f, Color.Blue.dx());
}
if (hasEdge)
{
var qef = (Vector3)DualContouringAlgorithm.calculateQefPoint(grid, grid.GetCubeSigns(gridPoint), gridPoint);
TW.Graphics.LineManager3D.AddCenteredBox(((Vector3)gridPoint.ToVector3() + qef) * CellSize, 0.05f, Color.Orange.dx());
}
}
}
public VoxelSurface CreateSurface(AbstractHermiteGrid grid, Matrix world)
{
var vertices = new List <Vector3>();
var indices = new List <int>();
var materials = new List <DCVoxelMaterial>();
var algo = new DualContouringAlgorithm();
algo.GenerateSurface(vertices, indices, materials, grid);
var triangleNormals = dcMeshBuilder.generateTriangleNormals(indices, vertices);
var uniqueMaterials = materials.Distinct().ToArray();
if (!uniqueMaterials.Any())
{
return new VoxelSurface(this)
{
WorldMatrix = world
}
}
;
var ret = new VoxelSurface(this);
ret.WorldMatrix = world;
surfaces.Add(ret);
foreach (var imat in uniqueMaterials)
{
var mat = imat;
var mesh = new RawMeshData(
indices.Where((i, index) => materials[index / 3] == mat).Select(i => vertices[i].dx()).ToArray(),
indices.Select((i, index) => triangleNormals[index / 3].dx()).Where((i, index) => materials[index / 3] == mat).ToArray(),
indices.Where((i, index) => materials[index / 3] == mat).Select(i => new Vector2().dx()).ToArray(),
indices.Where((i, index) => materials[index / 3] == mat).Select(i => new Vector3().dx()).ToArray()
);
var actualMat = mat;
if (actualMat == null)
{
actualMat = defaultMaterial;
}
ret.MeshesWithMaterial.Add(new MeshWithMaterial(mesh, actualMat, renderDataFactory.CreateMeshPartData(mesh)));
}
return(ret);
}
public VoxelCustomRenderer(DX11Game game, DeferredRenderer dRenderer, DualContouringMeshBuilder dcMeshBuilder, DualContouringAlgorithm dcAlgo, MeshRenderDataFactory renderDataFactory)
{
this.game = game;
this.dRenderer = dRenderer;
this.dcMeshBuilder = dcMeshBuilder;
this.dcAlgo = dcAlgo;
this.renderDataFactory = renderDataFactory;
var tex = new RAMTexture();
defaultMaterial = new DCVoxelMaterial()
{
Texture = DCFiles.UVCheckerMap11_512
};
objectBuffer = DeferredMaterial.CreatePerObjectCB(game);
}
private static void testExtractSurface(DelegateHermiteGrid srcGrid)
{
var grid = HermiteDataGrid.CopyGrid(srcGrid);
int times = 40;
var vertices = new List <Vector3>(10 * 1000 * 1000);
var indices = new List <int>(10 * 1000 * 1000);
var extractor = new DualContouringAlgorithm();
var time = PerformanceHelper.Measure(() =>
{
for (int i = 0; i < times; i++)
{
vertices.Clear();
indices.Clear();
extractor.GenerateSurface(vertices, indices, srcGrid);
}
});
Console.WriteLine("Time: " + time.Multiply(1f / times).PrettyPrint());
Console.WriteLine("{0:#.0}x{0:#.0}x{0:#.0} grid per second", Math.Pow(srcGrid.Dimensions.X * srcGrid.Dimensions.Y * srcGrid.Dimensions.Z / (time.TotalSeconds / times), 1 / 3f));
}
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);
}
}
