public static void QuadAndCopyTest()
{
// Serialize a triangle g3d as bytes and read it back.
var vertices = new[]
{
new Vector3(0, 0, 0),
new Vector3(0, 1, 0),
new Vector3(0, 1, 1),
new Vector3(1, 1, 1)
};
var indices = new[] { 0, 1, 2, 3 };
var materialIndices = new[] { 5 };
var g3d = new G3DBuilder()
.AddVertices(vertices.ToIArray())
.AddIndices(indices.ToIArray())
.Add(materialIndices.ToIArray().ToFaceMaterialAttribute())
.ToG3D();
var bytes = g3d.WriteToBytes();
var g = G3D.Read(bytes);
Assert.IsNotNull(g);
Assert.AreEqual(4, g.NumCornersPerFace);
Assert.AreEqual(4, g.NumVertices);
Assert.AreEqual(4, g.NumCorners);
Assert.AreEqual(1, g.NumFaces);
Assert.AreEqual(0, g.NumMeshes);
Assert.AreEqual(0, g.NumInstances);
Assert.AreEqual(vertices, g.Vertices.ToArray());
Assert.AreEqual(indices, g.Indices.ToArray());
Assert.AreEqual(materialIndices, g.FaceMaterials.ToArray());
var g2 = g.TriangulateQuadMesh();
Assert.AreEqual(3, g2.NumCornersPerFace);
Assert.AreEqual(4, g2.NumVertices);
Assert.AreEqual(6, g2.NumCorners);
Assert.AreEqual(2, g2.NumFaces);
Assert.AreEqual(0, g2.NumMeshes);
Assert.AreEqual(0, g2.NumInstances);
Assert.AreEqual(vertices, g2.GetAttributeDataPosition().ToArray());
Assert.AreEqual(new[] { 0, 1, 2, 0, 2, 3 }, g2.GetAttributeDataIndex().ToArray());
Assert.AreEqual(new[] { 5, 5 }, g2.GetAttributeDataFaceMaterial().ToArray());
g2 = g2.CopyFaces(1, 1);
Assert.AreEqual(3, g2.NumCornersPerFace);
Assert.AreEqual(4, g2.NumVertices);
Assert.AreEqual(3, g2.NumCorners);
Assert.AreEqual(1, g2.NumFaces);
Assert.AreEqual(vertices, g2.GetAttributeDataPosition().ToArray());
Assert.AreEqual(new[] { 0, 2, 3 }, g2.GetAttributeDataIndex().ToArray());
Assert.AreEqual(new[] { 5 }, g2.GetAttributeDataFaceMaterial().ToArray());
}
public static void TriangleTest()
{
// Serialize a triangle g3d as bytes and read it back.
var vertices = new[]
{
new Vector3(0, 0, 0),
new Vector3(0, 1, 0),
new Vector3(0, 1, 1)
};
var indices = new[] { 0, 1, 2 };
var materialIndices = new[] { 5 };
var g3d = new G3DBuilder()
.AddVertices(vertices.ToIArray())
.AddIndices(indices.ToIArray())
.Add(materialIndices.ToIArray().ToFaceMaterialAttribute())
.ToG3D();
var bytes = g3d.WriteToBytes();
var g = G3D.Read(bytes);
Assert.IsNotNull(g);
Assert.AreEqual(3, g.NumVertices);
Assert.AreEqual(3, g.NumCorners);
Assert.AreEqual(1, g.NumFaces);
Assert.AreEqual(3, g.NumCornersPerFace);
Assert.AreEqual(0, g.NumMeshes);
Assert.AreEqual(0, g.NumInstances);
Assert.AreEqual(vertices, g.Vertices.ToArray());
Assert.AreEqual(indices, g.Indices.ToArray());
Assert.AreEqual(materialIndices, g.FaceMaterials.ToArray());
}
public static void SimpleCreateG3DTest()
{
// Should be a tetrahedron
var vertexBuffer = TestGeometries.TestTetrahedronVertices.ToVertexAttribute();
var indexBuffer = TestGeometries.TestTetrahedronIndices.ToIndexAttribute();
CheckAttribute(vertexBuffer, Association.assoc_vertex, AttributeType.attr_vertex, DataType.dt_float32, 3);
CheckAttribute(indexBuffer, Association.assoc_corner, AttributeType.attr_index, DataType.dt_int32, 1);
var g3d = G3D.Create(vertexBuffer, indexBuffer);
Assert.AreEqual(4, vertexBuffer.Count);
Assert.AreEqual(12, indexBuffer.Count);
var g = g3d.ToIGeometry();
CheckTestTetrahedron(g);
var b = g.ToBFast();
var g2 = b.ToG3D();
CheckTestTetrahedron(g2.ToIGeometry());
var tmpPath = Path.GetTempFileName();
g.WriteG3D(tmpPath);
var g3 = G3DExtensions.ReadFromFile(tmpPath);
CheckTestTetrahedron(g3.ToIGeometry());
}
public static void ReadG3DFiles()
{
foreach (var f in Directory.GetFiles(TestOutputFolder))
{
var g3d = G3D.Read(f);
G3dTestUtils.OutputStats(g3d);
}
}
private void ReturnVolumeData()
{
lblRisultato.Text = _risultato +
"\n Altezza Solido: " + txtAltezzaV.Text +
"\n Volume: " +
G3D.CalcoloVolume(_area, Double.Parse(txtAltezzaV.Text)).ToString();
txtAltezzaV.Text = "";
}
public override void OnImportAsset(AssetImportContext ctx)
{
Debug.Log($"Importing G3D file: {ctx.assetPath}");
ImportHelpers.TimeBlockingOperation();
var baseName = Path.GetFileNameWithoutExtension(ctx.assetPath);
var g3d = G3D.Read(ctx.assetPath);
g3d.OutputStats();
var obj = ctx.ImportG3D(g3d, baseName);
ctx.AddRandomMaterial(obj);
ctx.SetMainObject(obj);
}
public static void TestG3DReader()
{
foreach (var fileName in GetInputFiles("*.g3d"))
{
var g = Util.TimeIt(() => G3D.ReadFile(fileName), $"Reading G3D {fileName}");
var baseFileName = Path.GetFileName(fileName);
var outputFileName = Path.Combine(TestOutputFolder, baseFileName);
Console.WriteLine("Testing Ara 3D native writer");
TestWritingFile(outputFileName + ".ara.obj", f => g.ToIGeometry().WriteObj(f, false));
}
}
private void btnVolume_Click(object sender, EventArgs e)
{
double altezzaV = Math.Round(G3D.GetDouble(txtAltezzaV.Text), 2);
if (txtAltezzaV.Text == "" || G3D.IsNegative(altezzaV))
{
MessageBox.Show("Inserisci l' ALTEZZA del solido prima di continuare.");
}
else
{
ReturnVolumeData();
}
}
public static void OutputStats(this G3D g)
{
Debug.Log($"# corners per faces {g.CornersPerFace} ");
Debug.Log($"# vertices = {g.NumVertices}");
Debug.Log($"# faces = {g.NumFaces}");
Debug.Log($"# groups = {g.NumGroups}");
Debug.Log($"Number of attributes = {g.Attributes.Count}");
//Debug.Log("Header");
foreach (var attr in g.Attributes)
{
Debug.Log($"{attr.Name} #bytes={attr.Bytes.Length} #items={attr.ElementCount}");
}
}
public static void OutputStats(G3D g)
{
//Console.WriteLine("Header");
Console.WriteLine($"# corners per faces {g.NumCornersPerFace} ");
Console.WriteLine($"# vertices = {g.NumVertices}");
Console.WriteLine($"# faces = {g.NumFaces}");
Console.WriteLine($"# subgeos = {g.NumSubgeometries}");
Console.WriteLine($"# indices (corners/edges0 = {g.NumCorners}");
Console.WriteLine($"# instances = {g.NumInstances}");
Console.WriteLine($"Number of attributes = {g.Attributes.Count}");
foreach (var attr in g.Attributes.ToEnumerable())
{
Console.WriteLine($"{attr.Name} #items={attr.ElementCount}");
}
}
// NOTE: can't be run as part of NUnit because it requires the GC
public static void BigFileTest()
{
var nVerts = (300 * 1000 * 1000); // 300 * 12 = 3.6 GB
var vertices = nVerts.Select(i => new Vector3(i, i, i));
var bldr = new G3DBuilder();
bldr.AddVertices(vertices);
var g3d = bldr.ToG3D();
Assert.AreEqual(nVerts, g3d.NumVertices);
var tempFile = Path.Combine(Path.GetTempPath(), "bigfile.g3d");
g3d.Write(tempFile);
var tmp = G3D.Read(tempFile);
ValidateSameG3D(g3d, tmp);
}
public static void AssertSame(G3D g1, G3D g2)
{
Assert.AreEqual(g1.NumCornersPerFace, g2.NumCornersPerFace);
Assert.AreEqual(g1.NumFaces, g2.NumFaces);
Assert.AreEqual(g1.NumCorners, g2.NumCorners);
Assert.AreEqual(g1.NumVertices, g2.NumVertices);
Assert.AreEqual(g1.NumInstances, g2.NumInstances);
Assert.AreEqual(g1.NumSubgeometries, g2.NumSubgeometries);
Assert.AreEqual(g1.Attributes.Count, g2.Attributes.Count);
for (var i = 0; i < g1.Attributes.Count; ++i)
{
var attr1 = g1.Attributes[i];
var attr2 = g2.Attributes[i];
Assert.AreEqual(attr1.Name, attr2.Name);
Assert.AreEqual(attr1.GetByteSize(), attr2.GetByteSize());
Assert.AreEqual(attr1.ElementCount, attr2.ElementCount);
}
}
public static void ValidateSameG3D(G3D g1, G3D g2)
{
ValidateSame(g1.NumCornersPerFace, g2.NumCornersPerFace, "NumCornersPerFace");
ValidateSame(g1.NumFaces, g2.NumFaces, "NumFaces");
ValidateSame(g1.NumCorners, g2.NumCorners, "NumCorners");
ValidateSame(g1.NumVertices, g2.NumVertices, "NumVertices");
ValidateSame(g1.NumInstances, g2.NumInstances, "NumInstances");
ValidateSame(g1.NumSubgeometries, g2.NumSubgeometries, "NumSubgeometries");
ValidateSame(g1.Attributes.Count, g2.Attributes.Count, "NumAttributes");
for (var i = 0; i < g1.Attributes.Count; ++i)
{
var attr1 = g1.Attributes[i];
var attr2 = g2.Attributes[i];
ValidateSame(attr1.Name, attr2.Name, $"Attribute[{i}].Name");
ValidateSame(attr1.GetByteSize(), attr2.GetByteSize(), $"Attribute[{i}].ByteSize");
ValidateSame(attr1.ElementCount, attr2.ElementCount, $"Attribute[{i}].ElementCount");
}
}
public static GameObject ImportG3D(this AssetImportContext ctx, G3D g3d, string baseName)
{
var obj = ObjectFactory.CreateGameObject(baseName, typeof(MeshFilter), typeof(MeshRenderer));
// Create a Mesh filter and assign the mesh to it
var mf = obj.GetComponent <MeshFilter>();
mf.sharedMesh = g3d.ToMesh();
var nFace = g3d.NumFaces;
var nVert = g3d.Vertices.ElementCount;
var nAttr = g3d.Attributes.Count;
var meshName = $"mesh {baseName} ({nFace} polys, {nVert} verts, {nAttr} attributes)";
ctx.AddObjectToAsset(meshName, mf.sharedMesh);
// Add the game object as an asset
ctx.AddObjectToAsset(baseName, obj);
return(obj);
}
public static void TriangleSerializationTest()
{
// Serialize a triangle g3d to a bfast as bytes and read it back.
var vertices = new[]
{
new Vector3(0, 0, 0),
new Vector3(0, 1, 0),
new Vector3(0, 1, 1)
};
var indices = new[] { 0, 1, 2 };
var materialIds = new[] { 0 };
var faceGroupIds = new[] { 0 };
var g3d = new G3DBuilder()
.AddVertices(vertices.ToIArray())
.AddIndices(indices.ToIArray())
.Add(faceGroupIds.ToIArray().ToFaceGroupAttribute())
.Add(materialIds.ToIArray().ToFaceMaterialIdAttribute())
.ToG3D();
var bfastBytes = g3d.WriteToBytes();
var readG3d = G3D.Read(bfastBytes);
Assert.IsNotNull(readG3d);
var mesh = readG3d.ToIMesh();
ValidateGeometry(mesh);
Assert.AreEqual(3, mesh.NumVertices);
Assert.AreEqual(new Vector3(0, 0, 0), mesh.Vertices[0]);
Assert.AreEqual(new Vector3(0, 1, 0), mesh.Vertices[1]);
Assert.AreEqual(new Vector3(0, 1, 1), mesh.Vertices[2]);
Assert.AreEqual(1, mesh.NumFaces);
Assert.AreEqual(0, mesh.FaceGroups.First());
Assert.AreEqual(0, mesh.FaceMaterialIds.First());
}
public static void AssertSame(Mesh m, G3D g)
{
Assert.AreEqual(m.FaceCount, g.NumFaces);
Assert.AreEqual(m.GetIndices(), g.Indices.ToArray());
Assert.AreEqual(m.VertexCount, g.NumVertices);
}
public Validator(G3D g3d, Schema schema)
{
foreach (var attribute in g3d.)
}
public static SerializableDocument ReadBuffer(this SerializableDocument doc, Stream stream, string name, long numBytes)
{
Debug.WriteLine($"Reading buffer {name} of size {Util.BytesToString(numBytes)}");
switch (name)
{
case BufferNames.Header:
var bytes = stream.ReadArray <byte>((int)numBytes);
doc.Header = SerializableHeader.Parse(Encoding.UTF8.GetString(bytes));
return(doc);
case BufferNames.Assets:
if (doc.Options?.SkipAssets == true)
{
Debug.WriteLine("Skipping assets");
stream.Advance(numBytes);
return(doc);
}
doc.Assets = stream.ReadBFast().ToArray();
return(doc);
case BufferNames.Strings:
var stringBytes = stream.ReadArray <byte>((int)numBytes);
var joinedStringTable = Encoding.UTF8.GetString(stringBytes);
doc.StringTable = joinedStringTable.Split('\0');
return(doc);
case BufferNames.Geometry:
if (doc.Options?.SkipGeometry == true)
{
Debug.WriteLine("Skipping geometry");
stream.Advance(numBytes);
return(doc);
}
doc.Geometry = G3D.Read(stream);
return(doc);
case BufferNames.Nodes:
if (doc.Options?.SkipGeometry == true)
{
Debug.WriteLine("Skipping nodes");
stream.Advance(numBytes);
return(doc);
}
var cnt = (int)(numBytes / SerializableSceneNode.Size);
Debug.Assert(numBytes % SerializableSceneNode.Size == 0, $"Number of bytes is not divisible by {SerializableSceneNode.Size}");
if (cnt < 0)
{
throw new Exception($"More than {int.MaxValue} items in array");
}
doc.Nodes = stream.ReadArray <SerializableSceneNode>(cnt);
return(doc);
case BufferNames.Entities:
doc.EntityTables = ReadEntityTables(stream);
return(doc);
}
// NOTE: unrecognized buffers are not an error.
Debug.WriteLine($"Unrecognized buffer {name}");
stream.ReadArray <byte>((int)numBytes);
return(doc);
}
public static void OpenAndConvertAssimpFiles()
{
var files = GetInputFiles()
.Where(AssimpLoader.CanLoad)
.Select(f => new FileLoadData(f))
.ToArray();
// Load all the files
foreach (var f in files)
{
try
{
(f.MemoryConsumption, f.MSecToOpen) =
Util.GetMemoryConsumptionAndMSecElapsed(() =>
f.Scene = AssimpLoader.Load(f.SourceFile.FullName));
}
catch (Exception e)
{
f.Error = e;
}
}
// Convert all the Assimp scenes to G3D
foreach (var f in files)
{
if (f.Scene == null)
{
continue;
}
try
{
f.MSecToConvert = Util.GetMSecElapsed(() =>
f.G3d = f.Scene.ToG3d());
}
catch (Exception e)
{
f.Error = e;
}
}
// Save all the G3D scenes
Util.CreateAndClearDirectory(TestOutputFolder);
foreach (var f in files)
{
if (f.G3d == null)
{
continue;
}
try
{
var outputFilePath = Path.Combine(TestOutputFolder, f.ShortName + ".g3d");
f.G3DFile = new FileInfo(outputFilePath);
f.MSecToSaveG3d = Util.GetMSecElapsed(() =>
f.G3d.Write(outputFilePath));
}
catch (Exception e)
{
f.Error = e;
}
}
// Try reading back in all of the G3D scenes, measure load times and the memory consumption
foreach (var f in files)
{
if (f.G3DFile == null)
{
continue;
}
try
{
G3D localG3d = null;
(f.MemoryConsumptionG3d, f.MSecToOpenG3d) =
Util.GetMemoryConsumptionAndMSecElapsed(() =>
localG3d = G3D.Read(f.G3DFile.FullName));
ValidateSameG3D(f.G3d, localG3d);
}
catch (Exception e)
{
f.Error = e;
}
}
// Output the header for data
Console.WriteLine(
"Importer," +
"Extension," +
"File Name," +
"File Size(KB)," +
"Load Time(s)," +
"Memory(KB)," +
"# Meshes," +
"Time to Convert," +
"Time to Write G3D," +
"G3D File Size(KB)," +
"G3D Memory(KB)",
"G3D Load Time(s)",
"Error");
// Output the data rows
foreach (var f in files)
{
Console.WriteLine(
"Assimp," +
$"{Path.GetExtension(f.ShortName)}," +
$"{f.ShortName}," +
$"{f.SourceFile?.Length / 1000}," +
$"{f.MSecToOpen / 100f}," +
$"{f.MemoryConsumption / 1000}," +
$"{f.NumMeshes}," +
$"{f.MSecToConvert / 100f}," +
$"{f.MSecToSaveG3d / 100f}," +
$"{f.G3DFile?.Length / 1000}," +
$"{f.MemoryConsumptionG3d / 1000}," +
$"{f.MSecToOpenG3d / 100f}," +
$"{f.Error}");
}
Assert.AreEqual(0, files.Count(f => f.Error != null), "Errors occurred");
}
public static IMesh ReadG3D(string filePath) => G3D.Read(filePath).ToIMesh();
private void BtnCalcola_Click(object sender, EventArgs e)
{
{
switch (flag)
{
case 0:
double raggio = G3D.GetDouble(txtRaggio.Text);
if (rbtnCerchio.Checked && txtRaggio.Text == "" || G3D.IsNegative(raggio))
{
MessageBox.Show("Inserisci un RAGGIO valido prima di continuare.");
}
else
{
Cerchio c = new Cerchio(raggio);
FormRisultato cForm = new FormRisultato(c.ToString(), c.CalcoloArea());
cForm.Show();
}
break;
case 1:
double qLato = G3D.GetDouble(txtLato.Text);
if (rbtnQuadrato.Checked && txtLato.Text == "" || G3D.IsNegative(qLato))
{
MessageBox.Show("Inserisci un LATO valido prima di continuare.");
}
else
{
Quadrato q = new Quadrato(qLato);
FormRisultato qForm = new FormRisultato(q.ToString(), q.CalcoloArea());
qForm.Show();
}
break;
case 3:
double tBase = G3D.GetDouble(txtBase.Text);
double tAltezza = G3D.GetDouble(txtAltezza.Text);
if (rbtnTriangolo.Checked && txtBase.Text == "" || txtAltezza.Text == "" || G3D.IsNegative(tAltezza, tBase))
{
MessageBox.Show("Inserisci BASE e ALTEZZA validi prima di continuare.");
}
else
{
TriangoloIso t = new TriangoloIso(tBase, tAltezza);
FormRisultato tForm = new FormRisultato(t.ToString(), t.CalcoloArea());
tForm.Show();
}
break;
case 4:
double rBase = G3D.GetDouble(txtBase.Text);
double rAltezzaa = G3D.GetDouble(txtAltezza.Text);
if (rbtnRettangolo.Checked && txtBase.Text == "" || txtAltezza.Text == "" || G3D.IsNegative(rBase, rAltezzaa))
{
MessageBox.Show("Inserisci BASE e ALTEZZA validi prima di continuare.");
}
else
{
Rettangolo r = new Rettangolo(rBase, rAltezzaa);
FormRisultato rForm = new FormRisultato(r.ToString(), r.CalcoloArea());
rForm.Show();
}
break;
case 5:
double pLato = G3D.GetDouble(txtLato.Text);
if (rbtnPentagono.Checked && txtLato.Text == "" || G3D.IsNegative(pLato))
{
MessageBox.Show("Inserisci un LATO valido prima di continuare.");
}
else
{
Pentagono p = new Pentagono(pLato);
FormRisultato pForm = new FormRisultato(p.ToString(), p.CalcoloArea());
pForm.Show();
}
break;
case 6:
double esLato = G3D.GetDouble(txtLato.Text);
if (rbtnEsagono.Checked && txtLato.Text == "" || G3D.IsNegative(esLato))
{
MessageBox.Show("Inserisci un LATO valido prima di continuare.");
}
else
{
Esagono es = new Esagono(esLato);
FormRisultato esForm = new FormRisultato(es.ToString(), es.CalcoloArea());
esForm.Show();
}
break;
default:
MessageBox.Show("Errore!");
break;
}
}
}
