404 lines
14 KiB
JavaScript
404 lines
14 KiB
JavaScript
var assert = require ('assert');
|
|
|
|
describe ('Model', function () {
|
|
it ('Default Initialization', function () {
|
|
var model = new OV.Model ();
|
|
assert.strictEqual (model.MaterialCount (), 0);
|
|
assert.strictEqual (model.MeshCount (), 0);
|
|
});
|
|
|
|
it ('Add Material', function () {
|
|
var model = new OV.Model ();
|
|
var material = new OV.Material (OV.MaterialType.Phong);
|
|
material.name = 'example';
|
|
var index = model.AddMaterial (material);
|
|
assert.strictEqual (model.MaterialCount (), 1);
|
|
var theMaterial = model.GetMaterial (index);
|
|
assert.strictEqual (theMaterial.name, 'example');
|
|
});
|
|
|
|
it ('Add Mesh', function () {
|
|
var model = new OV.Model ();
|
|
var mesh = new OV.Mesh ();
|
|
mesh.SetName ('example');
|
|
var index = model.AddMesh (mesh);
|
|
assert.strictEqual (model.MeshCount (), 1);
|
|
var theMesh = model.GetMesh (index);
|
|
assert.strictEqual (theMesh.GetName (), 'example');
|
|
});
|
|
|
|
it ('Add Mesh To Index', function () {
|
|
var model = new OV.Model ();
|
|
var mesh1 = new OV.Mesh ();
|
|
var mesh2 = new OV.Mesh ();
|
|
var mesh3 = new OV.Mesh ();
|
|
var mesh4 = new OV.Mesh ();
|
|
mesh1.SetName ('A');
|
|
mesh2.SetName ('B');
|
|
mesh3.SetName ('C');
|
|
mesh4.SetName ('D');
|
|
model.AddMesh (mesh1);
|
|
model.AddMesh (mesh2);
|
|
model.AddMeshToIndex (mesh3, 1);
|
|
model.AddMeshToIndex (mesh4, 3);
|
|
assert.strictEqual (model.GetMesh (0).GetName (), 'A');
|
|
assert.strictEqual (model.GetMesh (1).GetName (), 'C');
|
|
assert.strictEqual (model.GetMesh (2).GetName (), 'B');
|
|
assert.strictEqual (model.GetMesh (3).GetName (), 'D');
|
|
});
|
|
|
|
it ('Counters', function () {
|
|
var model = new OV.Model ();
|
|
let mesh = new OV.Mesh ();
|
|
mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
mesh.AddNormal (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
mesh.AddTextureUV (new OV.Coord2D (0.0, 0.0));
|
|
mesh.AddTriangle (new OV.Triangle (0, 1, 2));
|
|
mesh.AddTriangle (new OV.Triangle (0, 1, 2));
|
|
mesh.AddTriangle (new OV.Triangle (0, 1, 2));
|
|
mesh.AddTriangle (new OV.Triangle (0, 1, 2));
|
|
model.AddMesh (mesh);
|
|
assert.strictEqual (model.VertexCount (), 3);
|
|
assert.strictEqual (model.NormalCount (), 2);
|
|
assert.strictEqual (model.TextureUVCount (), 1);
|
|
assert.strictEqual (model.TriangleCount (), 4);
|
|
});
|
|
|
|
it ('Remove Mesh', function () {
|
|
var model = new OV.Model ();
|
|
|
|
let mesh1 = new OV.Mesh ();
|
|
mesh1.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
mesh1.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
|
|
mesh1.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
|
|
mesh1.AddTriangle (new OV.Triangle (0, 1, 2));
|
|
model.AddMesh (mesh1);
|
|
|
|
let mesh2 = new OV.Mesh ();
|
|
mesh2.AddVertex (new OV.Coord3D (0.0, 0.0, 1.0));
|
|
mesh2.AddVertex (new OV.Coord3D (1.0, 0.0, 1.0));
|
|
mesh2.AddVertex (new OV.Coord3D (1.0, 1.0, 1.0));
|
|
mesh2.AddTriangle (new OV.Triangle (0, 1, 2));
|
|
model.AddMesh (mesh2);
|
|
|
|
assert.strictEqual (model.MeshCount (), 2);
|
|
assert.strictEqual (model.VertexCount (), 6);
|
|
assert.strictEqual (model.TriangleCount (), 2);
|
|
|
|
model.RemoveMesh (0);
|
|
assert.strictEqual (model.MeshCount (), 1);
|
|
assert.strictEqual (model.VertexCount (), 3);
|
|
assert.strictEqual (model.TriangleCount (), 1);
|
|
|
|
model.RemoveMesh (0);
|
|
assert.strictEqual (model.MeshCount (), 0);
|
|
assert.strictEqual (model.VertexCount (), 0);
|
|
assert.strictEqual (model.TriangleCount (), 0);
|
|
});
|
|
});
|
|
|
|
describe ('Model Finalization', function () {
|
|
it ('Calculate Normal', function () {
|
|
var mesh = new OV.Mesh ();
|
|
var v0 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
var v1 = mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
|
|
var v2 = mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
|
|
var triangleIndex = mesh.AddTriangle (new OV.Triangle (v0, v1, v2));
|
|
var model = new OV.Model ();
|
|
var meshIndex = model.AddMesh (mesh);
|
|
assert.strictEqual (model.MaterialCount (), 0);
|
|
OV.FinalizeModel (model, function () { return new OV.Material (OV.MaterialType.Phong) });
|
|
assert.strictEqual (model.MaterialCount (), 1);
|
|
var theMesh = model.GetMesh (meshIndex);
|
|
assert.strictEqual (theMesh.NormalCount (), 1);
|
|
var triangle = theMesh.GetTriangle (triangleIndex);
|
|
assert.strictEqual (triangle.n0, 0);
|
|
assert.strictEqual (triangle.n1, 0);
|
|
assert.strictEqual (triangle.n2, 0);
|
|
assert.strictEqual (triangle.mat, 0);
|
|
});
|
|
|
|
it ('Calculate Curved Normal', function () {
|
|
var mesh = new OV.Mesh ();
|
|
var v0 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
var v1 = mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
|
|
var v2 = mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
|
|
var v3 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, -1.0));
|
|
|
|
var triangle1 = new OV.Triangle (v0, v1, v2);
|
|
triangle1.curve = 1;
|
|
var triangle2 = new OV.Triangle (v0, v3, v1);
|
|
triangle2.curve = 1;
|
|
|
|
var triangle1 = mesh.AddTriangle (triangle1);
|
|
var triangle1 = mesh.AddTriangle (triangle2);
|
|
|
|
var model = new OV.Model ()
|
|
var meshIndex = model.AddMesh (mesh);
|
|
|
|
OV.FinalizeModel (model, function () { return new OV.Material (OV.MaterialType.Phong) });
|
|
|
|
var theMesh = model.GetMesh (meshIndex);
|
|
assert.strictEqual (theMesh.NormalCount (), 6);
|
|
|
|
var normal = theMesh.GetNormal (0);
|
|
assert.strictEqual (normal.x, 0.0);
|
|
assert.strictEqual (normal.y, -0.7071067811865475);
|
|
assert.strictEqual (normal.z, 0.7071067811865475);
|
|
});
|
|
|
|
it ('Calculate Curved Normal 2', function () {
|
|
var mesh = new OV.Mesh ();
|
|
var v0 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, 0.0));
|
|
var v1 = mesh.AddVertex (new OV.Coord3D (1.0, 0.0, 0.0));
|
|
var v2 = mesh.AddVertex (new OV.Coord3D (1.0, 1.0, 0.0));
|
|
var v3 = mesh.AddVertex (new OV.Coord3D (0.0, 0.0, -1.0));
|
|
var v4 = mesh.AddVertex (new OV.Coord3D (0.0, 1.0, 0.0));
|
|
|
|
var triangle1 = new OV.Triangle (v0, v1, v2);
|
|
triangle1.curve = 1;
|
|
var triangle2 = new OV.Triangle (v0, v2, v4);
|
|
triangle2.curve = 1;
|
|
var triangle3 = new OV.Triangle (v0, v3, v1);
|
|
triangle3.curve = 1;
|
|
|
|
mesh.AddTriangle (triangle1);
|
|
mesh.AddTriangle (triangle2);
|
|
mesh.AddTriangle (triangle3);
|
|
|
|
var model = new OV.Model ()
|
|
var meshIndex = model.AddMesh (mesh);
|
|
|
|
OV.FinalizeModel (model, function () { return new OV.Material (OV.MaterialType.Phong) });
|
|
|
|
var theMesh = model.GetMesh (meshIndex);
|
|
assert.strictEqual (theMesh.NormalCount (), 9);
|
|
|
|
var normal = theMesh.GetNormal (0);
|
|
assert.strictEqual (normal.x, 0.0);
|
|
assert.strictEqual (normal.y, -0.7071067811865475);
|
|
assert.strictEqual (normal.z, 0.7071067811865475);
|
|
});
|
|
});
|
|
|
|
describe ('Color Conversion', function () {
|
|
it ('Color equality check', function () {
|
|
assert (OV.ColorIsEqual (new OV.Color (10, 20, 30), new OV.Color (10, 20, 30)));
|
|
assert (!OV.ColorIsEqual (new OV.Color (10, 20, 30), new OV.Color (11, 20, 30)));
|
|
assert (!OV.ColorIsEqual (new OV.Color (10, 20, 30), new OV.Color (10, 21, 30)));
|
|
assert (!OV.ColorIsEqual (new OV.Color (10, 20, 30), new OV.Color (10, 20, 31)));
|
|
});
|
|
|
|
it ('Color hex string conversion', function () {
|
|
let color = new OV.Color (10, 20, 30);
|
|
let hexString = '0a141e';
|
|
assert.strictEqual (OV.ColorToHexString (color), hexString);
|
|
assert.deepStrictEqual (OV.HexStringToColor (hexString), color);
|
|
});
|
|
});
|
|
|
|
function CreateHierarchicModel ()
|
|
{
|
|
/*
|
|
+ <Root>
|
|
+ Node 1
|
|
+ Node 3
|
|
Mesh 5
|
|
Mesh 6
|
|
+ Node 4
|
|
Mesh 7
|
|
Mesh 3
|
|
Mesh 4
|
|
+ Node 2
|
|
Mesh 1
|
|
Mesh 2
|
|
*/
|
|
|
|
let model = new OV.Model ();
|
|
let root = model.GetRootNode ();
|
|
|
|
let node1 = new OV.Node ();
|
|
node1.SetName ('Node 1');
|
|
|
|
let node2 = new OV.Node ();
|
|
node2.SetName ('Node 2');
|
|
|
|
let node3 = new OV.Node ();
|
|
node3.SetName ('Node 3');
|
|
|
|
let node4 = new OV.Node ();
|
|
node4.SetName ('Node 4');
|
|
|
|
root.AddChildNode (node1);
|
|
root.AddChildNode (node2);
|
|
node1.AddChildNode (node3);
|
|
node1.AddChildNode (node4);
|
|
|
|
let mesh1 = new OV.Mesh ();
|
|
mesh1.SetName ('Mesh 1');
|
|
|
|
let mesh2 = new OV.Mesh ();
|
|
mesh2.SetName ('Mesh 2');
|
|
|
|
let mesh3 = new OV.Mesh ();
|
|
mesh3.SetName ('Mesh 3');
|
|
|
|
let mesh4 = new OV.Mesh ();
|
|
mesh4.SetName ('Mesh 4');
|
|
|
|
let mesh5 = new OV.Mesh ();
|
|
mesh5.SetName ('Mesh 5');
|
|
|
|
let mesh6 = new OV.Mesh ();
|
|
mesh6.SetName ('Mesh 6');
|
|
|
|
let mesh7 = new OV.Mesh ();
|
|
mesh7.SetName ('Mesh 7');
|
|
|
|
let mesh1Ind = model.AddMesh (mesh1);
|
|
let mesh2Ind = model.AddMesh (mesh2);
|
|
let mesh3Ind = model.AddMesh (mesh3);
|
|
let mesh4Ind = model.AddMesh (mesh4);
|
|
let mesh5Ind = model.AddMesh (mesh5);
|
|
let mesh6Ind = model.AddMesh (mesh6);
|
|
let mesh7Ind = model.AddMesh (mesh7);
|
|
|
|
root.AddMeshIndex (mesh1Ind);
|
|
root.AddMeshIndex (mesh2Ind);
|
|
node1.AddMeshIndex (mesh3Ind);
|
|
node1.AddMeshIndex (mesh4Ind);
|
|
node3.AddMeshIndex (mesh5Ind);
|
|
node3.AddMeshIndex (mesh6Ind);
|
|
node4.AddMeshIndex (mesh7Ind);
|
|
|
|
return model;
|
|
}
|
|
|
|
function GetModelTree (model)
|
|
{
|
|
function AddNodeToModelTree (model, node, modelTree)
|
|
{
|
|
modelTree.name = node.HasParent () ? node.GetName () : '<Root>';
|
|
modelTree.childNodes = [];
|
|
for (const childNode of node.GetChildNodes ()) {
|
|
let childTree = {};
|
|
AddNodeToModelTree (model, childNode, childTree);
|
|
modelTree.childNodes.push (childTree);
|
|
}
|
|
modelTree.meshNames = [];
|
|
for (const meshIndex of node.GetMeshIndices ()) {
|
|
modelTree.meshNames.push (model.GetMesh (meshIndex).GetName ());
|
|
}
|
|
}
|
|
|
|
let modelTree = {};
|
|
let root = model.GetRootNode ();
|
|
AddNodeToModelTree (model, root, modelTree);
|
|
return modelTree;
|
|
}
|
|
|
|
describe ('Node Hierarchy', function () {
|
|
it ('Enumerate hierarchy', function () {
|
|
let model = CreateHierarchicModel ();
|
|
let modelTree = GetModelTree (model);
|
|
assert.deepStrictEqual (modelTree, {
|
|
name : '<Root>',
|
|
childNodes : [
|
|
{
|
|
name : 'Node 1',
|
|
childNodes : [
|
|
{
|
|
name : 'Node 3',
|
|
childNodes : [],
|
|
meshNames : ['Mesh 5', 'Mesh 6']
|
|
},
|
|
{
|
|
name : 'Node 4',
|
|
childNodes : [],
|
|
meshNames : ['Mesh 7']
|
|
}
|
|
],
|
|
meshNames : ['Mesh 3', 'Mesh 4']
|
|
},
|
|
{
|
|
name : 'Node 2',
|
|
childNodes : [],
|
|
meshNames : []
|
|
}
|
|
],
|
|
meshNames : ['Mesh 1', 'Mesh 2']
|
|
});
|
|
});
|
|
|
|
it ('Remove mesh', function () {
|
|
let model = CreateHierarchicModel ();
|
|
model.RemoveMesh (2);
|
|
let modelTree = GetModelTree (model);
|
|
assert.deepStrictEqual (modelTree, {
|
|
name : '<Root>',
|
|
childNodes : [
|
|
{
|
|
name : 'Node 1',
|
|
childNodes : [
|
|
{
|
|
name : 'Node 3',
|
|
childNodes : [],
|
|
meshNames : ['Mesh 5', 'Mesh 6']
|
|
},
|
|
{
|
|
name : 'Node 4',
|
|
childNodes : [],
|
|
meshNames : ['Mesh 7']
|
|
}
|
|
],
|
|
meshNames : ['Mesh 4']
|
|
},
|
|
{
|
|
name : 'Node 2',
|
|
childNodes : [],
|
|
meshNames : []
|
|
}
|
|
],
|
|
meshNames : ['Mesh 1', 'Mesh 2']
|
|
});
|
|
});
|
|
|
|
it ('Add mesh to index', function () {
|
|
let model = CreateHierarchicModel ();
|
|
let mesh = new OV.Mesh ();
|
|
mesh.SetName ('Mesh 8');
|
|
model.AddMeshToIndex (mesh, 3);
|
|
let modelTree = GetModelTree (model);
|
|
assert.deepStrictEqual (modelTree, {
|
|
name : '<Root>',
|
|
childNodes : [
|
|
{
|
|
name : 'Node 1',
|
|
childNodes : [
|
|
{
|
|
name : 'Node 3',
|
|
childNodes : [],
|
|
meshNames : ['Mesh 5', 'Mesh 6']
|
|
},
|
|
{
|
|
name : 'Node 4',
|
|
childNodes : [],
|
|
meshNames : ['Mesh 7']
|
|
}
|
|
],
|
|
meshNames : ['Mesh 3', 'Mesh 4']
|
|
},
|
|
{
|
|
name : 'Node 2',
|
|
childNodes : [],
|
|
meshNames : []
|
|
}
|
|
],
|
|
meshNames : ['Mesh 1', 'Mesh 2']
|
|
});
|
|
});
|
|
});
|