324 lines
9.7 KiB
JavaScript
324 lines
9.7 KiB
JavaScript
OV.Importer3dm = class extends OV.ImporterBase
|
|
{
|
|
constructor ()
|
|
{
|
|
super ();
|
|
this.rhino = null;
|
|
}
|
|
|
|
CanImportExtension (extension)
|
|
{
|
|
return extension === '3dm';
|
|
}
|
|
|
|
GetKnownFileFormats ()
|
|
{
|
|
return {
|
|
'3dm' : OV.FileFormat.Binary
|
|
};
|
|
}
|
|
|
|
GetUpDirection ()
|
|
{
|
|
return OV.Direction.Z;
|
|
}
|
|
|
|
ClearContent ()
|
|
{
|
|
this.instanceObjects = null;
|
|
this.instanceDefinitions = null;
|
|
}
|
|
|
|
ResetContent ()
|
|
{
|
|
this.instanceObjects = {};
|
|
this.instanceDefinitions = {};
|
|
}
|
|
|
|
ImportContent (fileContent, onFinish)
|
|
{
|
|
if (this.rhino === null) {
|
|
let obj = this;
|
|
rhino3dm ().then (function (rhino) {
|
|
obj.rhino = rhino;
|
|
obj.ImportRhinoContent (fileContent);
|
|
onFinish ();
|
|
});
|
|
} else {
|
|
this.ImportRhinoContent (fileContent);
|
|
onFinish ();
|
|
}
|
|
}
|
|
|
|
ImportRhinoContent (fileContent)
|
|
{
|
|
let rhinoDoc = this.rhino.File3dm.fromByteArray (fileContent);
|
|
if (rhinoDoc === null) {
|
|
this.SetError ();
|
|
this.SetMessage ('Failed to read Rhino file.');
|
|
return;
|
|
}
|
|
this.ImportRhinoDocument (rhinoDoc);
|
|
if (OV.IsModelEmpty (this.model)) {
|
|
this.SetError ();
|
|
this.SetMessage ('The model doesn\'t contain meshes.');
|
|
}
|
|
}
|
|
|
|
ImportRhinoDocument (rhinoDoc)
|
|
{
|
|
this.InitRhinoInstances (rhinoDoc);
|
|
this.ImportRhinoGeometry (rhinoDoc);
|
|
}
|
|
|
|
InitRhinoInstances (rhinoDoc)
|
|
{
|
|
let rhinoObjects = rhinoDoc.objects ();
|
|
for (let i = 0; i < rhinoObjects.count; i++) {
|
|
let rhinoObject = rhinoObjects.get (i);
|
|
let rhinoAttributes = rhinoObject.attributes ();
|
|
if (rhinoAttributes.isInstanceDefinitionObject) {
|
|
this.instanceObjects[rhinoAttributes.id] = rhinoObject;
|
|
}
|
|
}
|
|
let rhinoInstanceDefinitions = rhinoDoc.instanceDefinitions ();
|
|
for (let i = 0; i < rhinoInstanceDefinitions.count (); i++) {
|
|
let rhinoInstanceDefinition = rhinoInstanceDefinitions.get (i);
|
|
this.instanceDefinitions[rhinoInstanceDefinition.id] = rhinoInstanceDefinition;
|
|
}
|
|
}
|
|
|
|
ImportRhinoGeometry (rhinoDoc)
|
|
{
|
|
let rhinoObjects = rhinoDoc.objects ();
|
|
for (let i = 0; i < rhinoObjects.count; i++) {
|
|
let rhinoObject = rhinoObjects.get (i);
|
|
this.ImportRhinoGeometryObject (rhinoDoc, rhinoObject, []);
|
|
}
|
|
}
|
|
|
|
ImportRhinoGeometryObject (rhinoDoc, rhinoObject, rhinoInstanceReferences)
|
|
{
|
|
let rhinoGeometry = rhinoObject.geometry ();
|
|
let rhinoAttributes = rhinoObject.attributes ();
|
|
|
|
let objectType = rhinoGeometry.objectType;
|
|
if (rhinoAttributes.isInstanceDefinitionObject && rhinoInstanceReferences.length === 0) {
|
|
return;
|
|
}
|
|
|
|
let rhinoMesh = null;
|
|
let deleteMesh = false;
|
|
|
|
if (objectType === this.rhino.ObjectType.Mesh) {
|
|
rhinoMesh = rhinoGeometry;
|
|
deleteMesh = false;
|
|
} else if (objectType === this.rhino.ObjectType.Extrusion) {
|
|
rhinoMesh = rhinoGeometry.getMesh (this.rhino.MeshType.Any);
|
|
deleteMesh = true;
|
|
} else if (objectType === this.rhino.ObjectType.Brep) {
|
|
rhinoMesh = new this.rhino.Mesh ();
|
|
let faces = rhinoGeometry.faces ();
|
|
for (let i = 0; i < faces.count; i++) {
|
|
let face = faces.get (i);
|
|
let mesh = face.getMesh (this.rhino.MeshType.Any);
|
|
if (mesh) {
|
|
rhinoMesh.append (mesh);
|
|
mesh.delete ();
|
|
}
|
|
face.delete ();
|
|
}
|
|
faces.delete ();
|
|
rhinoMesh.compact ();
|
|
deleteMesh = true;
|
|
} else if (objectType === this.rhino.ObjectType.SubD) {
|
|
rhinoGeometry.subdivide (3);
|
|
rhinoMesh = this.rhino.Mesh.createFromSubDControlNet (rhinoGeometry);
|
|
deleteMesh = true;
|
|
} else if (objectType === this.rhino.ObjectType.InstanceReference) {
|
|
let parentDefinitionId = rhinoGeometry.parentIdefId;
|
|
let instanceDefinition = this.instanceDefinitions[parentDefinitionId];
|
|
if (instanceDefinition !== undefined) {
|
|
let instanceObjectIds = instanceDefinition.getObjectIds ();
|
|
for (let i = 0; i < instanceObjectIds.length; i++) {
|
|
let instanceObjectId = instanceObjectIds[i];
|
|
let instanceObject = this.instanceObjects[instanceObjectId];
|
|
if (instanceObject !== undefined) {
|
|
rhinoInstanceReferences.push (rhinoObject);
|
|
this.ImportRhinoGeometryObject (rhinoDoc, instanceObject, rhinoInstanceReferences);
|
|
rhinoInstanceReferences.pop ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rhinoMesh !== null) {
|
|
this.ImportRhinoMesh (rhinoDoc, rhinoMesh, rhinoObject, rhinoInstanceReferences);
|
|
if (deleteMesh) {
|
|
rhinoMesh.delete ();
|
|
}
|
|
}
|
|
}
|
|
|
|
ImportRhinoMesh (rhinoDoc, rhinoMesh, rhinoObject, rhinoInstanceReferences)
|
|
{
|
|
let rhinoAttributes = rhinoObject.attributes ();
|
|
|
|
let mesh = new OV.Mesh ();
|
|
mesh.SetName (rhinoAttributes.name);
|
|
|
|
let materialIndex = this.GetMaterialIndex (rhinoDoc, rhinoObject, rhinoInstanceReferences);
|
|
let threeJson = rhinoMesh.toThreejsJSON ();
|
|
let vertices = threeJson.data.attributes.position.array;
|
|
for (let i = 0; i < vertices.length; i += 3) {
|
|
let x = vertices[i];
|
|
let y = vertices[i + 1];
|
|
let z = vertices[i + 2];
|
|
mesh.AddVertex (new OV.Coord3D (x, y, z));
|
|
}
|
|
let hasNormals = (threeJson.data.attributes.normal !== undefined);
|
|
if (hasNormals) {
|
|
let normals = threeJson.data.attributes.normal.array;
|
|
for (let i = 0; i < normals.length; i += 3) {
|
|
let x = normals[i];
|
|
let y = normals[i + 1];
|
|
let z = normals[i + 2];
|
|
mesh.AddNormal (new OV.Coord3D (x, y, z));
|
|
}
|
|
}
|
|
let hasUVs = (threeJson.data.attributes.uv !== undefined);
|
|
if (hasUVs) {
|
|
let uvs = threeJson.data.attributes.uv.array;
|
|
for (let i = 0; i < uvs.length; i += 2) {
|
|
let x = uvs[i];
|
|
let y = uvs[i + 1];
|
|
mesh.AddTextureUV (new OV.Coord2D (x, y));
|
|
}
|
|
}
|
|
let indices = threeJson.data.index.array;
|
|
for (let i = 0; i < indices.length; i += 3) {
|
|
let v0 = indices[i];
|
|
let v1 = indices[i + 1];
|
|
let v2 = indices[i + 2];
|
|
let triangle = new OV.Triangle (v0, v1, v2);
|
|
if (hasNormals) {
|
|
triangle.SetNormals (v0, v1, v2);
|
|
}
|
|
if (hasUVs) {
|
|
triangle.SetTextureUVs (v0, v1, v2);
|
|
}
|
|
if (materialIndex !== null) {
|
|
triangle.SetMaterial (materialIndex);
|
|
}
|
|
mesh.AddTriangle (triangle);
|
|
}
|
|
if (rhinoInstanceReferences.length !== 0) {
|
|
let matrix = new OV.Matrix ().CreateIdentity ();
|
|
for (let i = rhinoInstanceReferences.length - 1; i >= 0; i--) {
|
|
let rhinoInstanceReference = rhinoInstanceReferences[i];
|
|
let rhinoInstanceReferenceGeometry = rhinoInstanceReference.geometry ();
|
|
let rhinoInstanceReferenceMatrix = rhinoInstanceReferenceGeometry.xform.toFloatArray (false);
|
|
let transformationMatrix = new OV.Matrix (rhinoInstanceReferenceMatrix);
|
|
matrix = matrix.MultiplyMatrix (transformationMatrix);
|
|
}
|
|
let transformation = new OV.Transformation (matrix);
|
|
OV.TransformMesh (mesh, transformation);
|
|
}
|
|
this.model.AddMesh (mesh);
|
|
}
|
|
|
|
GetMaterialIndex (rhinoDoc, rhinoObject, rhinoInstanceReferences)
|
|
{
|
|
function GetRhinoMaterial (rhino, rhinoObject, rhinoInstanceReferences)
|
|
{
|
|
let rhinoAttributes = rhinoObject.attributes ();
|
|
if (rhinoAttributes.materialSource === rhino.ObjectMaterialSource.MaterialFromObject) {
|
|
let materialIndex = rhinoAttributes.materialIndex;
|
|
if (materialIndex > -1) {
|
|
return rhinoDoc.materials ().get (materialIndex);
|
|
}
|
|
} else if (rhinoAttributes.materialSource === rhino.ObjectMaterialSource.MaterialFromLayer) {
|
|
let layerIndex = rhinoAttributes.layerIndex;
|
|
if (layerIndex > 0) {
|
|
let layer = rhinoDoc.layers ().get (layerIndex);
|
|
let layerMaterialIndex = layer.renderMaterialIndex;
|
|
if (layerMaterialIndex > -1) {
|
|
return rhinoDoc.materials ().get (layerMaterialIndex);
|
|
}
|
|
}
|
|
} else if (rhinoAttributes.materialSource === rhino.ObjectMaterialSource.MaterialFromParent) {
|
|
if (rhinoInstanceReferences.length !== 0) {
|
|
return GetRhinoMaterial (rhino, rhinoInstanceReferences[0], []);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function FindMatchingMaterial (model, rhinoMaterial)
|
|
{
|
|
function SetColor (color, rhinoColor)
|
|
{
|
|
color.Set (rhinoColor.r, rhinoColor.g, rhinoColor.b);
|
|
}
|
|
|
|
function IsBlack (rhinoColor)
|
|
{
|
|
return rhinoColor.r === 0 && rhinoColor.g === 0 && rhinoColor.b === 0;
|
|
}
|
|
|
|
function IsWhite (rhinoColor)
|
|
{
|
|
return rhinoColor.r === 255 && rhinoColor.g === 255 && rhinoColor.b === 255;
|
|
}
|
|
|
|
let material = new OV.Material ();
|
|
if (rhinoMaterial === null) {
|
|
material.diffuse.Set (255, 255, 255);
|
|
} else {
|
|
material.name = rhinoMaterial.name;
|
|
SetColor (material.ambient, rhinoMaterial.ambientColor);
|
|
SetColor (material.diffuse, rhinoMaterial.diffuseColor);
|
|
SetColor (material.specular, rhinoMaterial.specularColor);
|
|
material.opacity = 1.0 - rhinoMaterial.transparency;
|
|
material.transparent = OV.IsLower (material.opacity, 1.0);
|
|
// material.shininess = rhinoMaterial.shine / 255.0;
|
|
if (IsBlack (material.diffuse) && !IsWhite (rhinoMaterial.reflectionColor)) {
|
|
SetColor (material.diffuse, rhinoMaterial.reflectionColor);
|
|
}
|
|
if (IsBlack (material.diffuse) && !IsWhite (rhinoMaterial.transparentColor)) {
|
|
SetColor (material.diffuse, rhinoMaterial.transparentColor);
|
|
}
|
|
}
|
|
for (let i = 0; i < model.MaterialCount (); i++) {
|
|
let current = model.GetMaterial (i);
|
|
if (current.name !== material.name) {
|
|
continue;
|
|
}
|
|
if (!OV.ColorIsEqual (current.ambient, material.ambient)) {
|
|
continue;
|
|
}
|
|
if (!OV.ColorIsEqual (current.diffuse, material.diffuse)) {
|
|
continue;
|
|
}
|
|
if (!OV.ColorIsEqual (current.specular, material.specular)) {
|
|
continue;
|
|
}
|
|
if (!OV.IsEqual (current.opacity, material.opacity)) {
|
|
continue;
|
|
}
|
|
if (current.transparent !== material.transparent) {
|
|
continue;
|
|
}
|
|
if (!OV.IsEqual (current.shininess, material.shininess)) {
|
|
continue;
|
|
}
|
|
return i;
|
|
}
|
|
return model.AddMaterial (material);
|
|
}
|
|
|
|
let rhinoMaterial = GetRhinoMaterial (this.rhino, rhinoObject, rhinoInstanceReferences);
|
|
return FindMatchingMaterial (this.model, rhinoMaterial);
|
|
}
|
|
};
|