static void exportBone(BinaryWriter dest, MeshNode target, Assimp.Scene scene, int boneID)
{
Assimp.Node node = target.node;
exportString(dest, node.Name);
if (node.Parent!=null)
exportString(dest, node.Parent.Name);
else
exportString(dest, "");
Matrix4x4 mat = new Matrix4x4(node.Transform.A1, node.Transform.A2, node.Transform.A3, node.Transform.A4, node.Transform.B1, node.Transform.B2, node.Transform.B3, node.Transform.B4, node.Transform.C1, node.Transform.C2, node.Transform.C3, node.Transform.C4, node.Transform.D1, node.Transform.D2, node.Transform.D3, node.Transform.D4);
mat.Transpose();
exportMatrix(dest, mat);
Bone bone = target.bone;
if (bone != null)
{
mat = new Matrix4x4(bone.OffsetMatrix.A1, bone.OffsetMatrix.A2, bone.OffsetMatrix.A3, bone.OffsetMatrix.A4, bone.OffsetMatrix.B1, bone.OffsetMatrix.B2, bone.OffsetMatrix.B3, bone.OffsetMatrix.B4, bone.OffsetMatrix.C1, bone.OffsetMatrix.C2, bone.OffsetMatrix.C3, bone.OffsetMatrix.C4, bone.OffsetMatrix.D1, bone.OffsetMatrix.D2, bone.OffsetMatrix.D3, bone.OffsetMatrix.D4);
mat.Transpose();
}
else
mat = Matrix4x4.Identity;
exportMatrix(dest, mat);
}
private static GeometryData GenerateGeometryDataFromAssimpMesh(Assimp.Mesh mesh)
{
var geometryData = new GeometryData
{
Vertices = new VertexPositionNormalTexture[mesh.VertexCount],
Indices = new ushort[mesh.FaceCount * 3]
};
geometryData.Vertices = new VertexPositionNormalTexture[mesh.VertexCount];
for (var i = 0; i < mesh.VertexCount; i++)
{
var vertex = mesh.Vertices[i];
geometryData.Vertices[i].Position = new Vector3(vertex.X, vertex.Y, vertex.Z);
var normal = mesh.Normals[i];
geometryData.Vertices[i].Normal = new Vector3(normal.X, normal.Y, normal.Z);
var texcoord = mesh.TextureCoordinateChannels[0][i];
geometryData.Vertices[i].TextureCoordinate = new Vector2(texcoord.X, texcoord.Y);
}
for (var i = 0; i < mesh.FaceCount; i++)
{
geometryData.Indices[i * 3 + 0] = (ushort)mesh.Faces[i].Indices[0];
geometryData.Indices[i * 3 + 1] = (ushort)mesh.Faces[i].Indices[1];
geometryData.Indices[i * 3 + 2] = (ushort)mesh.Faces[i].Indices[2];
}
return geometryData;
}
public static void AreEqual(Assimp.Matrix4x4 a, SharpDX.Matrix b)
{
Vector3D transA;
Vector3 transB;
Vector3D scaleA;
Vector3 scaleB;
Assimp.Quaternion rotA;
SharpDX.Quaternion rotB;
a.Decompose(out scaleA, out rotA, out transA);
b.Decompose(out scaleB, out rotB, out transB);
AreEqual(transA, transB);
AreEqual(rotA, rotB);
AreEqual(scaleA, scaleB);
//AreNearEqual(a.A1, b.M11);
//AreNearEqual(a.A2, b.M12);
//AreNearEqual(a.A3, b.M13);
//AreNearEqual(a.A4, b.M14);
//AreNearEqual(a.B1, b.M21);
//AreNearEqual(a.B2, b.M22);
//AreNearEqual(a.B3, b.M23);
//AreNearEqual(a.B4, b.M24);
//AreNearEqual(a.C1, b.M31);
//AreNearEqual(a.C2, b.M32);
//AreNearEqual(a.C3, b.M33);
//AreNearEqual(a.C4, b.M34);
//AreNearEqual(a.D1, b.M41);
//AreNearEqual(a.D2, b.M42);
//AreNearEqual(a.D3, b.M43);
//AreNearEqual(a.D4, b.M44);
}
public static void AreEqual(Assimp.Color4D a, SharpDX.Color4 b)
{
Assert.AreEqual(a.A, b.Alpha);
Assert.AreEqual(a.R, b.Red);
Assert.AreEqual(a.G, b.Green);
Assert.AreEqual(a.B, b.Blue);
}
public static void AreEqual(Assimp.Vector3D[] a, SharpDX.Vector3[] b)
{
Assert.AreEqual(a.Length, b.Length);
for (int i = 0; i < a.Length; i++)
{
AreEqual(a[i], b[i]);
}
}
/// <summary>
/// Creates an Assimp.Animation by copying the given source Assimp.Animation content.<br />
/// </summary>
/// <param name="rootNode"></param>
/// <param name="sourceAnimation">The source Assimp.Animation to copy.</param>
/// <returns></returns>
private static Assimp.Animation CreateAssimpAnimation(Node rootNode, Assimp.Animation sourceAnimation)
{
Assimp.Animation animation = new Assimp.Animation();
animation.DurationInTicks = sourceAnimation.DurationInTicks;
animation.Name = sourceAnimation.Name;
animation.TicksPerSecond = sourceAnimation.TicksPerSecond;
CreateNodeAnimationChannels(animation, sourceAnimation.NodeAnimationChannels, rootNode);
return animation;
}
private static void processNodes(IntPtr scene, IntPtr node, ref List <AssimpJoint> listJoints)
{
AssimpJoint joint = new AssimpJoint();
string name = Assimp.aiNode_GetName(node);
if (name == "")
{
name = "REMOVE-ME";
}
joint.Name = name;
joint.parentName = "NONE";
joint.Position = Assimp.aiNode_GetPosition(node);
//assimp quaternion is w,x,y,z and unity x,y,z,w bu int this lib i fix this for unity
Quaternion quad = Assimp.aiNode_GetRotation(node);
joint.Orientation = quad;
if (Assimp.aiNode_GetParent(node) != null)
{
string parentName = Assimp.aiNode_GetName(Assimp.aiNode_GetParent(node));
joint.parentName = parentName;
}
listJoints.Add(joint);
for (int i = 0; i < listJoints.Count; i++)
{
AssimpJoint parent = listJoints[i];
if (joint.parentName == parent.Name)
{
joint.parent = parent;
joint.Path += parent.Path + "/";
break;
}
}
joint.Path += name;
if (joint.parent != null)
{
// Debug.Log(string.Format(" Joint name: {0} ; parent:{1} ; animation path:{2} ", joint.Name, joint.parent.Name,"Skeleton/" + joint.Path));
}
else
{
// Debug.Log(string.Format(" Joint name: {0} ; animation path:{1} ", joint.Name,"Skeleton/" + joint.Path));
}
for (int n = 0; n < Assimp.aiNode_GetNumChildren(node); n++)
{
processNodes(scene, Assimp.aiNode_GetChild(node, n), ref listJoints);
}
}
/// <summary>
/// Creates an Assimp.NodeAnimationChannel from the given NodeAnimationChannel list and Assimp.Node.<br />
/// Adds the Assimp.NodeAnimationChannel to the given Assimp.Animation
/// </summary>
/// <param name="node"></param>
/// <param name="channel"></param>
private static void CreateNodeAnimationChannels(Assimp.Animation animation, List<NodeAnimationChannel> sourceNodeAnimationChannels, Node node)
{
NodeAnimationChannel nodeAnimationChannel = new NodeAnimationChannel();
nodeAnimationChannel = sourceNodeAnimationChannels[animation.NodeAnimationChannelCount];
nodeAnimationChannel.NodeName = node.Name;
animation.NodeAnimationChannels.Add(nodeAnimationChannel);
for (int i = 0; i < node.ChildCount; i++)
CreateNodeAnimationChannels(animation, sourceNodeAnimationChannels, node.Children[i]);
}
public TexturedMaterial(Assimp.Material m, string materialDirectory)
: this()
{
Diffuse = m.ColorDiffuse.ToNETColor();
Specular = m.ColorSpecular.ToNETColor();
//Ambient = m.ColorAmbient.ToNETColor();
Emissive = m.ColorEmissive.ToNETColor();
textureSlots = new List<Assimp.TextureSlot>(m.GetAllTextures());
LoadTextures(materialDirectory);
}
/// <summary>
/// Applies a 4x4 Assimp matrix to all of the vertices
/// </summary>
/// <param name="vertices">The vertices to apply the matrix to</param>
/// <param name="mat">The matrix</param>
private static void ApplyMatrixLocal(List<ObjVertex> vertices, Assimp.Matrix4x4 mat)
{
//Console.WriteLine("Applying: {0}", mat);
foreach (var v in vertices) {
var pos = v.Position;
Vector4 newPos = new Vector4(mat.A1 * pos.X + mat.B1 * pos.Y + mat.C1 * pos.Z + mat.D1 * pos.W,
mat.A2 * pos.X + mat.B2 * pos.Y + mat.C2 * pos.Z + mat.D2 * pos.W,
mat.A3 * pos.X + mat.B3 * pos.Y + mat.C3 * pos.Z + mat.D3 * pos.W,
mat.A4 * pos.X + mat.B4 * pos.Y + mat.C4 * pos.Z + mat.D4 * pos.W);
v.Position = newPos;
}
}
/// <summary>
/// Sets the contents of the info pop-up given an assimp node.
///
/// At the time this method is called, the node info popup's
/// location has already been adjusted by the caller.
/// </summary>
public void Populate(Assimp.Scene scene, Node node, NodePurpose purpose)
{
Debug.Assert(scene != null);
Debug.Assert(node != null);
Debug.Assert(_owner != null);
switch (purpose)
{
case NodePurpose.Joint:
labelCaption.Text = "Joint";
break;
case NodePurpose.ImporterGenerated:
labelCaption.Text = "Root";
break;
case NodePurpose.GenericMeshHolder:
labelCaption.Text = "Node";
break;
case NodePurpose.Camera:
labelCaption.Text = "Camera";
break;
case NodePurpose.Light:
labelCaption.Text = "Light";
break;
default:
Debug.Assert(false);
break;
}
// count children recursively
var children = 0;
CountChildren(node, ref children);
var animated = false;
// check whether there are any animation channels for this node
for (var i = 0; i < scene.AnimationCount && !animated; ++i )
{
var anim = scene.Animations[i];
for(var j = 0; j < anim.NodeAnimationChannelCount; ++j)
{
if(anim.NodeAnimationChannels[j].NodeName == node.Name)
{
animated = true;
break;
}
}
}
labelInfo.Text = string.Format("{0} Children\n{1}", children, (animated ? "Animated" : "Not animated"));
}
static void addNodes(List<MeshNode> nodes, Assimp.Node node, Mesh mesh)
{
Bone bone =null;
for (int i = 0; i < mesh.BoneCount; i++ )
if (mesh.Bones[i].Name.Equals(node.Name))
{
bone = mesh.Bones[i];
break;
}
nodes.Add(new MeshNode(node, bone));
for (int i = 0; i < node.ChildCount; i++)
{
addNodes(nodes, node.Children[i], mesh);
}
}
public int Initialize(string rootPath, string modelName, int viewStep, Assimp.Material meterial)
{
Name = modelName + "." + meterial.Name;
ViewStep = viewStep;
Color.Opacity = meterial.Opacity;
Color.Shininess = meterial.Shininess;
for(int i = 0; i < 4; i++)
{
Color.Ambient[i] = meterial.ColorAmbient[i];
Color.Diffuse[i] = meterial.ColorDiffuse[i];
Color.Emissive[i] = meterial.ColorEmissive[i];
Color.Reflective[i] = meterial.ColorReflective[i];
Color.Specular[i] = meterial.ColorSpecular[i];
Color.Transparent[i] = meterial.ColorTransparent[i];
}
SetTexture(rootPath, meterial);
return viewStep + 5 * Engine.Instance.Core.Device.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
}
/// <summary>
/// Writes mesh data to the .obj.
/// </summary>
/// <param name="reader">The mesh reader to use.</param>
/// <param name="compressor">The vertex compressor to use.</param>
/// <param name="resourceStream">A stream open on the resource data.</param>
public void ExtractMesh(MeshReader reader, Assimp.Matrix4x4 matrix_local, VertexCompressor compressor, Stream resourceStream)
{
// Read the vertex buffer and decompress each vertex
var vertices = ReadVertices(reader, resourceStream);
DecompressVertices(vertices, compressor);
ApplyMatrixLocal(vertices, matrix_local);
// Write out the vertices
WriteVertices(vertices);
// Read and write out the triangles for each part
foreach (var part in reader.Mesh.Parts)
{
var indexes = ReadIndexes(reader, part, resourceStream);
WriteTriangles(indexes);
}
_baseIndex += (uint)vertices.Count;
}
void TestAnimationChannel(Assimp.NodeAnimationChannel netChannel, AssimpSharp.NodeAnim sharpChannel)
{
Assert.AreEqual(netChannel.NodeName, sharpChannel.NodeName);
Assert.AreEqual(netChannel.PositionKeyCount, sharpChannel.PositionKeys.Length);
for (int i = 0; i < netChannel.PositionKeyCount; i++)
{
Assert.AreEqual(netChannel.PositionKeys[i].Time, sharpChannel.PositionKeys[i].Time);
MathAssert.AreEqual(netChannel.PositionKeys[i].Value, sharpChannel.PositionKeys[i].Value);
}
Assert.AreEqual(netChannel.RotationKeyCount, sharpChannel.RotationKeys.Length);
for (int i = 0; i < netChannel.RotationKeyCount; i++)
{
Assert.AreEqual(netChannel.RotationKeys[i].Time, sharpChannel.RotationKeys[i].Time);
MathAssert.AreEqual(netChannel.RotationKeys[i].Value, sharpChannel.RotationKeys[i].Value);
}
Assert.AreEqual(netChannel.ScalingKeyCount, sharpChannel.ScalingKeys.Length);
for (int i = 0; i < netChannel.ScalingKeyCount; i++)
{
Assert.AreEqual(netChannel.ScalingKeys[i].Time, sharpChannel.ScalingKeys[i].Time);
MathAssert.AreEqual(netChannel.ScalingKeys[i].Value, sharpChannel.ScalingKeys[i].Value);
}
}
public void TestEachNode(Assimp.Node netNode, AssimpSharp.Node sharpNode)
{
Assert.AreEqual(netNode.Name, sharpNode.Name);
MathAssert.AreEqual(netNode.Transform, sharpNode.Transformation);
Assert.AreEqual(netNode.HasMeshes, sharpNode.Meshes != null && sharpNode.Meshes.Count > 0);
if (netNode.HasMeshes)
{
Assert.AreEqual(netNode.MeshCount, sharpNode.Meshes.Count);
for (int i = 0; i < netNode.MeshCount; i++)
{
Assert.AreEqual(netNode.MeshIndices, sharpNode.Meshes);
}
}
Assert.AreEqual(netNode.HasChildren, sharpNode.Children != null);
if (netNode.HasChildren)
{
Assert.AreEqual(netNode.ChildCount, sharpNode.Children.Count);
for (int nodeIndex = 0; nodeIndex < netNode.ChildCount; nodeIndex++)
{
TestEachNode(netNode.Children[nodeIndex], sharpNode.Children[nodeIndex]);
}
}
}
void TestAnimationAttachment(Assimp.MeshAnimationAttachment netAnimMesh, AssimpSharp.AnimMesh sharpAnimMesh)
{
Assert.AreEqual(netAnimMesh.HasVertices, sharpAnimMesh.HasPosition);
if (netAnimMesh.HasVertices)
{
Assert.AreEqual(netAnimMesh.Vertices, sharpAnimMesh.Vertices);
}
Assert.AreEqual(netAnimMesh.HasNormals, sharpAnimMesh.HasNormals);
if (netAnimMesh.HasNormals)
{
Assert.AreEqual(netAnimMesh.Normals, sharpAnimMesh.Normals);
}
Assert.AreEqual(netAnimMesh.HasTangentBasis, sharpAnimMesh.HasTangentsAndBitangets);
if (netAnimMesh.HasTangentBasis)
{
Assert.AreEqual(netAnimMesh.Tangents, sharpAnimMesh.Tangents);
Assert.AreEqual(netAnimMesh.BiTangents, sharpAnimMesh.Bitangents);
}
for (int i = 0; i < netAnimMesh.TextureCoordinateChannelCount; i++)
{
Assert.AreEqual(netAnimMesh.HasTextureCoords(i), sharpAnimMesh.HasTextureCoords(i));
if (netAnimMesh.HasTextureCoords(i))
{
Assert.AreEqual(netAnimMesh.TextureCoordinateChannels[i], sharpAnimMesh.TextureCoords[i]);
}
}
for (int i = 0; i < netAnimMesh.VertexColorChannelCount; i++)
{
Assert.AreEqual(netAnimMesh.HasVertexColors(i), sharpAnimMesh.HasVertexColors(i));
if (netAnimMesh.HasVertexColors(i))
{
Assert.AreEqual(netAnimMesh.VertexColorChannels[i], sharpAnimMesh.Colors[i]);
}
}
}
private static void readMesh(string path, string filename, string texturepath)
{
string importingAssetsDir;
if (File.Exists(path + "/" + filename))
{
Assimp.PostProcessSteps flags = (
// Assimp.PostProcessSteps.MakeLeftHanded |
Assimp.PostProcessSteps.Triangulate |
Assimp.PostProcessSteps.CalculateTangentSpace |
Assimp.PostProcessSteps.GenerateUVCoords |
Assimp.PostProcessSteps.GenerateSmoothNormals |
Assimp.PostProcessSteps.RemoveComponent |
Assimp.PostProcessSteps.JoinIdenticalVertices);
IntPtr config = Assimp.aiCreatePropertyStore();
Assimp.aiSetImportPropertyFloat(config, Assimp.AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, 60.0f);
Assimp.aiSetImportPropertyInteger(config, Assimp.AI_CONFIG_PP_LBW_MAX_WEIGHTS, 4);
// IntPtr scene = Assimp.aiImportFile(path + "/" + filename, (uint)flags);
IntPtr scene = Assimp.aiImportFileWithProperties(path + "/" + filename, (uint)flags, config);
Assimp.aiReleasePropertyStore(config);
if (scene == null)
{
Debug.LogWarning("failed to read file: " + path + "/" + filename);
return;
}
else
{
string nm = Path.GetFileNameWithoutExtension(filename);
importingAssetsDir = "Assets/Prefabs/" + nm + "/";
if (saveAssets)
{
if (!Directory.Exists(importingAssetsDir))
{
Directory.CreateDirectory(importingAssetsDir);
}
AssetDatabase.Refresh();
}
GameObject ObjectRoot = new GameObject(nm);
GameObject meshContainer = new GameObject(nm + "_Mesh");
meshContainer.transform.parent = ObjectRoot.transform;
// List<CombineInstance> combineInstances = new List<CombineInstance>();
List <Material> materials = new List <Material>();
List <AssimpMesh> MeshList = new List <AssimpMesh>();
for (int i = 0; i < Assimp.aiScene_GetNumMaterials(scene); i++)
{
string matName = Assimp.aiMaterial_GetName(scene, i);
matName = nm + "_mat" + i;
// string fname = Path.GetFileNameWithoutExtension(Assimp.aiMaterial_GetTexture(scene, i, (int)Assimp.TextureType.Diffuse));
string fname = Path.GetFileName(Assimp.aiMaterial_GetTexture(scene, i, (int)Assimp.TextureType.Diffuse));
Debug.Log("texture " + fname + "Material :" + matName);
Color ambient = Assimp.aiMaterial_GetAmbient(scene, i);
Color diffuse = Assimp.aiMaterial_GetDiffuse(scene, i);
Color specular = Assimp.aiMaterial_GetSpecular(scene, i);
Color emissive = Assimp.aiMaterial_GetEmissive(scene, i);
Material mat = new Material(Shader.Find("Diffuse"));
mat.name = matName;
string texturename = path + "/" + fname;
Texture2D tex = null;
if (File.Exists(texturename))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename, typeof(Texture2D));
}
else
if (File.Exists(texturename + ".PNG"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".PNG", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".JPG"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".JPG", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".BMP"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".BMP", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".TGA"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".TGA", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".DDS"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".DDS", typeof(Texture2D));
}
if (tex != null)
{
string p = AssetDatabase.GetAssetPath(tex);
ConfigureForAtlas(p);
Debug.Log("LOAD (" + texturename + ") texture");
mat.SetTexture("_MainTex", tex);
}
else
{
Debug.LogError("Fail LOAD (" + texturename + ") error");
}
materials.Add(mat);
}
AssetDatabase.Refresh();
if (Assimp.aiScene_GetRootNode(scene) != null)
{
ObjectRoot.transform.position = Assimp.aiNode_GetPosition(Assimp.aiScene_GetRootNode(scene));
//assimp quaternion is w,x,y,z and unity x,y,z,w bu int this lib i fix this for unity
Quaternion assQuad = Assimp.aiNode_GetRotation(Assimp.aiScene_GetRootNode(scene));
ObjectRoot.transform.rotation = assQuad;
GameObject skeleton = new GameObject("Skeleton");
skeleton.transform.parent = ObjectRoot.transform;
processNodes(scene, Assimp.aiScene_GetRootNode(scene), ref listJoints);
for (int i = 0; i < listJoints.Count; i++)
{
AssimpJoint joint = listJoints[i];
//Transform bone = GameObject.CreatePrimitive(PrimitiveType.Sphere).transform;
Transform bone = new GameObject(joint.Name).transform;
// DebugBone debug = (DebugBone)bone.gameObject.AddComponent(typeof(DebugBone));
bone.name = joint.Name;
bone.parent = skeleton.transform;
if (getBoneByName(joint.parentName) != null)
{
int index = findBoneByName(joint.parentName);
bone.parent = joint.parent.transform;
}
bone.localPosition = joint.Position;
bone.localRotation = joint.Orientation;
joint.transform = bone;
}
}
if (Assimp.aiScene_HasMeshes(scene))
{
for (int i = 0; i < Assimp.aiScene_GetNumMeshes(scene); i++)
{
string name = "Mesh_";
name += i.ToString();
bool HasNormals = Assimp.aiMesh_HasNormals(scene, i);
bool HasTexCoord = Assimp.aiMesh_HasTextureCoords(scene, i, 0);
bool HasFaces = Assimp.aiMesh_HasFaces(scene, i);
AssimpMesh mesh = new AssimpMesh(meshContainer, ObjectRoot, name);
mesh.setmaterial(materials[Assimp.aiMesh_GetMaterialIndex(scene, i)]);
MeshList.Add(mesh);
for (int v = 0; v < Assimp.aiMesh_GetNumVertices(scene, i); v++)
{
Vector3 vertex = Assimp.aiMesh_Vertex(scene, i, v);
Vector3 n = Assimp.aiMesh_Normal(scene, i, v);
float x = Assimp.aiMesh_TextureCoordX(scene, i, v, 0);
float y = Assimp.aiMesh_TextureCoordY(scene, i, v, 0);
Vector3 binormalf = Assimp.aiMesh_Bitangent(scene, i, v);
Vector3 tangentf = Assimp.aiMesh_Tangent(scene, i, v);
Vector4 outputTangent = new Vector4(tangentf.x, tangentf.y, tangentf.z, 0.0F);
float dp = Vector3.Dot(Vector3.Cross(n, tangentf), binormalf);
if (dp > 0.0F)
{
outputTangent.w = 1.0F;
}
else
{
outputTangent.w = -1.0F;
}
mesh.addVertex(vertex, n, outputTangent, new Vector2(x, y));
}
for (int f = 0; f < Assimp.aiMesh_GetNumFaces(scene, i); f++)
{
int a = Assimp.aiMesh_Indice(scene, i, f, 0);
int b = Assimp.aiMesh_Indice(scene, i, f, 1);
int c = Assimp.aiMesh_Indice(scene, i, f, 2);
mesh.addFace(a, b, c);
}
//****
int numBone = Assimp.aiMesh_GetNumBones(scene, i);
for (int b = 0; b < numBone; b++)
{
string bname = Assimp.aiMesh_GetBoneName(scene, i, b);
AssimpJoint joint = getBoneByName(bname);
int boneID = findBoneByName(bname);
int numWeights = Assimp.aiMesh_GetNumBoneWeights(scene, i, b);
for (int w = 0; w < numWeights; w++)
{
float Weight = Assimp.aiMesh_GetBoneWeight(scene, i, b, w);
int VertexId = Assimp.aiMesh_GetBoneVertexId(scene, i, b, w);
mesh.addBone(VertexId, boneID, Weight);
}
}
for (int j = 0; j < listJoints.Count; j++)
{
AssimpJoint joint = listJoints[j];
mesh.addJoint(joint);
}
//**********
mesh.BuilSkin();
mesh.build();
mesh.dispose();
}
}
Mesh m = CombineInstance(ObjectRoot, meshContainer, importingAssetsDir);
//create key frames
if (Assimp.aiScene_HasAnimation(scene))
{
Animation anim = (UnityEngine.Animation)ObjectRoot.AddComponent(typeof(Animation));
int numAnimation = Assimp.aiScene_GetNumAnimations(scene);
Debug.Log("count animation :" + numAnimation);
for (int a = 0; a < numAnimation; a++)
{
AnimationClip clip = new AnimationClip();
string anima = Assimp.aiAnim_GetName(scene, a);
clip.name = nm + "_" + anima + "_" + a;
clip.legacy = true;
clip.wrapMode = WrapMode.Loop;
float tinks = (float)Assimp.aiAnim_GetTicksPerSecond(scene, a);
if (tinks <= 1f)
{
tinks = 1f;
}
float fps = tinks;
clip.frameRate = tinks;
Debug.Log("animation fps :" + fps);
int numchannels = Assimp.aiAnim_GetNumChannels(scene, a);
for (int i = 0; i < numchannels; i++)
{
string name = Assimp.aiAnim_GetChannelName(scene, a, i);
AssimpJoint joint = getBoneByName(name);
// Debug.Log(String.Format("anim channel {0} bone name {1} poskeys {2} rotkeys{2}", i, name, Assimp.aiAnim_GetNumPositionKeys(scene, 0, i), Assimp.aiAnim_GetNumRotationKeys(scene, 0, i)));
//public static bool ignoreRotations = true;
// public static bool ignorePositions = true;
// public static bool ignoreScalling = true;
if (!ignoreScalling)
{
if (Assimp.aiAnim_GetNumScalingKeys(scene, a, i) != 0)
{
AnimationCurve scaleXcurve = new AnimationCurve();
AnimationCurve scaleYcurve = new AnimationCurve();
AnimationCurve scaleZcurve = new AnimationCurve();
for (int j = 0; j < Assimp.aiAnim_GetNumScalingKeys(scene, a, i); j++)
{
float time = (float)Assimp.aiAnim_GetScalingFrame(scene, a, i, j);/// fps;
Vector3 scale = Assimp.aiAnim_GetScalingKey(scene, a, i, j);
// time = (float)j;
scaleXcurve.AddKey(time, scale.x);
scaleYcurve.AddKey(time, scale.y);
scaleZcurve.AddKey(time, scale.z);
}
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "m_LocalScale.x", scaleXcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "m_LocalScale.y", scaleYcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "m_LocalScale.z", scaleZcurve);
}
}
if (!ignorePositions)
{
if (Assimp.aiAnim_GetNumPositionKeys(scene, a, i) != 0)
{
AnimationCurve posXcurve = new AnimationCurve();
AnimationCurve posYcurve = new AnimationCurve();
AnimationCurve posZcurve = new AnimationCurve();
for (int j = 0; j < Assimp.aiAnim_GetNumPositionKeys(scene, a, i); j++)
{
float time = (float)Assimp.aiAnim_GetPositionFrame(scene, a, i, j);// / fps;
Vector3 pos = Assimp.aiAnim_GetPositionKey(scene, a, i, j);
// time = (float)j;
posXcurve.AddKey(time, pos.x);
posYcurve.AddKey(time, pos.y);
posZcurve.AddKey(time, pos.z);
}
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localPosition.x", posXcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localPosition.y", posYcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localPosition.z", posZcurve);
}
}
if (!ignoreRotations)
{
if (Assimp.aiAnim_GetNumRotationKeys(scene, a, i) != 0)
{
AnimationCurve rotXcurve = new AnimationCurve();
AnimationCurve rotYcurve = new AnimationCurve();
AnimationCurve rotZcurve = new AnimationCurve();
AnimationCurve rotWcurve = new AnimationCurve();
for (int j = 0; j < Assimp.aiAnim_GetNumRotationKeys(scene, a, i); j++)
{
float time = (float)Assimp.aiAnim_GetRotationFrame(scene, a, i, j);// / fps;
Quaternion rotation = Assimp.aiAnim_GetRotationKey(scene, a, i, j);
// time = (float)j;
rotXcurve.AddKey(time, rotation.x);
rotYcurve.AddKey(time, rotation.y);
rotZcurve.AddKey(time, rotation.z);
rotWcurve.AddKey(time, rotation.w);
}
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.x", rotXcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.y", rotYcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.z", rotZcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.w", rotWcurve);
}
}
}
clip.EnsureQuaternionContinuity();
anim.AddClip(clip, clip.name);
anim.clip = clip;
string clipAssetPath = AssetDatabase.GenerateUniqueAssetPath(importingAssetsDir + clip.name + ".asset");
AssetDatabase.CreateAsset(clip, clipAssetPath);
}
}
if (saveAssets)
{
string prefabPath = AssetDatabase.GenerateUniqueAssetPath(importingAssetsDir + filename + ".prefab");
var prefab = PrefabUtility.CreateEmptyPrefab(prefabPath);
PrefabUtility.ReplacePrefab(ObjectRoot, prefab, ReplacePrefabOptions.ConnectToPrefab);
AssetDatabase.Refresh();
}
MeshList.Clear();
}
listJoints.Clear();
Assimp.aiReleaseImport(scene);
Debug.LogWarning(path + "/" + filename + " Imported ;) ");
}
}
private static void readMesh(string path, string filename, string texturepath)
{
string importingAssetsDir;
if (File.Exists(path + "/" + filename))
{
Assimp.PostProcessSteps flags = (
Assimp.PostProcessSteps.RemoveComponent);
IntPtr config = Assimp.aiCreatePropertyStore();
Assimp.aiSetImportPropertyFloat(config, Assimp.AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, 60.0f);
Assimp.aiSetImportPropertyInteger(config, Assimp.AI_CONFIG_PP_LBW_MAX_WEIGHTS, 4);
// IntPtr scene = Assimp.aiImportFile(path + "/" + filename, (uint)flags);
IntPtr scene = Assimp.aiImportFileWithProperties(path + "/" + filename, (uint)flags, config);
Assimp.aiReleasePropertyStore(config);
if (scene == null)
{
Debug.LogWarning("failed to read file: " + path + "/" + filename);
return;
}
else
{
string nm = Path.GetFileNameWithoutExtension(filename);
importingAssetsDir = "Assets/Prefabs/" + nm + "/";
if (saveAssets)
{
if (!Directory.Exists(importingAssetsDir))
{
Directory.CreateDirectory(importingAssetsDir);
}
AssetDatabase.Refresh();
}
GameObject ObjectRoot = new GameObject(nm);
AssetDatabase.Refresh();
if (Assimp.aiScene_GetRootNode(scene) != null)
{
ObjectRoot.transform.position = Assimp.aiNode_GetPosition(Assimp.aiScene_GetRootNode(scene));
//assimp quaternion is w,x,y,z and unity x,y,z,w bu int this lib i fix this for unity
Quaternion assQuad = Assimp.aiNode_GetRotation(Assimp.aiScene_GetRootNode(scene));
ObjectRoot.transform.rotation = assQuad;
GameObject skeleton = new GameObject("Skeleton");
skeleton.transform.parent = ObjectRoot.transform;
processNodes(scene, Assimp.aiScene_GetRootNode(scene), ref listJoints);
for (int i = 0; i < listJoints.Count; i++)
{
AssimpJoint joint = listJoints[i];
Transform bone = GameObject.CreatePrimitive(PrimitiveType.Sphere).transform;
// Transform bone = new GameObject(joint.Name).transform;
// DebugBone debug = (DebugBone)bone.gameObject.AddComponent(typeof(DebugBone));
bone.name = joint.Name;
bone.parent = skeleton.transform;
if (getBoneByName(joint.parentName) != null)
{
int index = findBoneByName(joint.parentName);
bone.parent = joint.parent.transform;
}
bone.localPosition = joint.Position;
bone.localRotation = joint.Orientation;
joint.transform = bone;
}
}
//create key frames
if (Assimp.aiScene_HasAnimation(scene))
{
Animation anim = (UnityEngine.Animation)ObjectRoot.AddComponent(typeof(Animation));
int numAnimation = Assimp.aiScene_GetNumAnimations(scene);
for (int a = 0; a < numAnimation; a++)
{
AnimationClip clip = new AnimationClip();
string anima = Assimp.aiAnim_GetName(scene, a);
clip.name = nm + "_" + anima + "_" + a;
clip.wrapMode = WrapMode.Loop;
float tinks = (float)Assimp.aiAnim_GetTicksPerSecond(scene, a);
if (tinks <= 1f)
{
tinks = 1f;
}
float fps = tinks;
clip.frameRate = tinks;
Debug.Log("animation fps :" + fps);
int numchannels = Assimp.aiAnim_GetNumChannels(scene, a);
for (int i = 0; i < numchannels; i++)
{
string name = Assimp.aiAnim_GetChannelName(scene, a, i);
AssimpJoint joint = getBoneByName(name);
// Debug.Log(String.Format("anim channel {0} bone name {1} poskeys {2} rotkeys{2}", i, name, Assimp.aiAnim_GetNumPositionKeys(scene, 0, i), Assimp.aiAnim_GetNumRotationKeys(scene, 0, i)));
if (Assimp.aiAnim_GetNumScalingKeys(scene, a, i) != 0)
{
AnimationCurve scaleXcurve = new AnimationCurve();
AnimationCurve scaleYcurve = new AnimationCurve();
AnimationCurve scaleZcurve = new AnimationCurve();
for (int j = 0; j < Assimp.aiAnim_GetNumScalingKeys(scene, a, i); j++)
{
float time = (float)Assimp.aiAnim_GetScalingFrame(scene, a, i, j);// *fps;
Vector3 scale = Assimp.aiAnim_GetScalingKey(scene, a, i, j);
//time = (float)j;
scaleXcurve.AddKey(time, scale.x);
scaleYcurve.AddKey(time, scale.y);
scaleZcurve.AddKey(time, scale.z);
}
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "m_LocalScale.x", scaleXcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "m_LocalScale.y", scaleYcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "m_LocalScale.z", scaleZcurve);
}
if (Assimp.aiAnim_GetNumPositionKeys(scene, a, i) != 0)
{
AnimationCurve posXcurve = new AnimationCurve();
AnimationCurve posYcurve = new AnimationCurve();
AnimationCurve posZcurve = new AnimationCurve();
for (int j = 0; j < Assimp.aiAnim_GetNumPositionKeys(scene, a, i); j++)
{
float time = (float)Assimp.aiAnim_GetPositionFrame(scene, a, i, j);// *fps;
Vector3 pos = Assimp.aiAnim_GetPositionKey(scene, a, i, j);
// time = (float)j;
posXcurve.AddKey(time, pos.x);
posYcurve.AddKey(time, pos.y);
posZcurve.AddKey(time, pos.z);
}
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localPosition.x", posXcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localPosition.y", posYcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localPosition.z", posZcurve);
}
if (Assimp.aiAnim_GetNumRotationKeys(scene, a, i) != 0)
{
AnimationCurve rotXcurve = new AnimationCurve();
AnimationCurve rotYcurve = new AnimationCurve();
AnimationCurve rotZcurve = new AnimationCurve();
AnimationCurve rotWcurve = new AnimationCurve();
for (int j = 0; j < Assimp.aiAnim_GetNumRotationKeys(scene, a, i); j++)
{
float time = (float)Assimp.aiAnim_GetRotationFrame(scene, a, i, j);// *fps;
Quaternion rotation = Assimp.aiAnim_GetRotationKey(scene, a, i, j);
// time = (float)j;
rotXcurve.AddKey(time, rotation.x);
rotYcurve.AddKey(time, rotation.y);
rotZcurve.AddKey(time, rotation.z);
rotWcurve.AddKey(time, rotation.w);
}
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.x", rotXcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.y", rotYcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.z", rotZcurve);
clip.SetCurve("Skeleton/" + joint.Path, typeof(Transform), "localRotation.w", rotWcurve);
}
}
clip.EnsureQuaternionContinuity();
anim.AddClip(clip, clip.name);
anim.clip = clip;
string clipAssetPath = AssetDatabase.GenerateUniqueAssetPath(importingAssetsDir + clip.name + ".asset");
AssetDatabase.CreateAsset(clip, clipAssetPath);
// AssetDatabase.CreateAsset(clip, "Assets/Models/" + nm +"_"+a+ ".anim");
// AssetDatabase.SaveAssets();
}
}
if (saveAssets)
{
string prefabPath = AssetDatabase.GenerateUniqueAssetPath(importingAssetsDir + filename + ".prefab");
var prefab = PrefabUtility.CreateEmptyPrefab(prefabPath);
PrefabUtility.ReplacePrefab(ObjectRoot, prefab, ReplacePrefabOptions.ConnectToPrefab);
AssetDatabase.Refresh();
}
}
listJoints.Clear();
Assimp.aiReleaseImport(scene);
Debug.LogWarning(path + "/" + filename + " Imported ;) ");
}
}
void TestTexture(Assimp.EmbeddedTexture netTexture, AssimpSharp.Texture sharpTexture)
{
throw (new NotImplementedException());
}
public EmbeddedTextureLoader(Assimp.EmbeddedTexture tex)
{
if(tex.IsCompressed)
{
var compTex = tex;
if(!compTex.HasCompressedData)
{
return;
}
// note: have to keep the stream open for the lifetime of the image, so don't Dispose()
SetFromStream(new MemoryStream(compTex.CompressedData));
return;
}
var rawTex = tex;
if (!rawTex.HasNonCompressedData || rawTex.Width < 1 || rawTex.Height < 1)
{
return;
}
var texels = rawTex.NonCompressedData;
var image = new Bitmap(rawTex.Width, rawTex.Height, PixelFormat.Format32bppArgb);
var bounds = new Rectangle(0, 0, rawTex.Width, rawTex.Height);
BitmapData bmpData;
try
{
bmpData = image.LockBits(bounds, ImageLockMode.WriteOnly, image.PixelFormat);
// ignore exceptions thrown by LockBits - we just can't read the image in this case
}
catch
{
return;
}
var ptr = bmpData.Scan0;
Debug.Assert(bmpData.Stride > 0);
var countBytes = bmpData.Stride*image.Height;
var tempBuffer = new byte[countBytes];
var dataLineLength = image.Width*4;
var padding = bmpData.Stride - dataLineLength;
Debug.Assert(padding >= 0);
var n = 0;
foreach(var texel in texels)
{
tempBuffer[n++] = texel.B;
tempBuffer[n++] = texel.G;
tempBuffer[n++] = texel.R;
tempBuffer[n++] = texel.A;
if(n % dataLineLength == 0)
{
n += padding;
}
}
Marshal.Copy(tempBuffer, 0, ptr, countBytes);
image.UnlockBits(bmpData);
_image = image;
_result = LoadResult.Good;
}
private static OutlineItem CreateOutlineItem(Assimp.Scene scene)
{
var item = new OutlineItem
{
Text = "Assimp scene",
Icon = MultiColorGlyphs.SceneNode,
Children = new OutlineItemCollection(),
ToolTip = ToolTipAssimpNode,
UserData = scene,
IsExpanded = false,
};
item.Children.Add(CreateOutlineItem(scene.RootNode));
return item;
}
private static OutlineItem CreateOutlineItem(Assimp.Node node)
{
var item = new OutlineItem
{
Text = node.Name,
Icon = node.HasMeshes ? MultiColorGlyphs.Mesh : MultiColorGlyphs.SceneNode,
Children = new OutlineItemCollection(),
ToolTip = ToolTipAssimpNode,
UserData = node,
};
if (node.HasChildren)
foreach (var child in node.Children)
item.Children.Add(CreateOutlineItem(child));
return item;
}
private Material GenerateMaterialFromMesh(int materialIndex, Assimp.Scene assimpScene)
{
var assimpMaterial = assimpScene.Materials[materialIndex];
var texture = string.IsNullOrEmpty(assimpMaterial.TextureDiffuse.FilePath) ? null : GetTexture2D(assimpMaterial.TextureDiffuse.FilePath);
return new Material(texture);
}
/// <summary>
/// Build a transformation matrix from rotation, scaling and translation components.
/// The transformation order is scaling, rotation, translation (left to right).
/// </summary>
/// <param name="presentRotation"></param>
/// <param name="presentScaling"></param>
/// <param name="presentPosition"></param>
/// <param name="outMatrix"></param>
private static void BuildTransform(ref Assimp.Quaternion presentRotation, ref Vector3D presentScaling,
ref Vector3D presentPosition, out Matrix4 outMatrix)
{
// build a transformation matrix from it
var mat = new Matrix4x4(presentRotation.GetMatrix());
mat.A1 *= presentScaling.X;
mat.B1 *= presentScaling.X;
mat.C1 *= presentScaling.X;
mat.A2 *= presentScaling.Y;
mat.B2 *= presentScaling.Y;
mat.C2 *= presentScaling.Y;
mat.A3 *= presentScaling.Z;
mat.B3 *= presentScaling.Z;
mat.C3 *= presentScaling.Z;
mat.A4 = presentPosition.X;
mat.B4 = presentPosition.Y;
mat.C4 = presentPosition.Z;
outMatrix = AssimpToOpenTk.FromMatrix(ref mat);
}
//determine the number of elements in the vertex
private int GetNoofInputElements(Assimp.Mesh mesh)
{
bool hasTexCoords = mesh.HasTextureCoords(0);
bool hasColors = mesh.HasVertexColors(0);
bool hasNormals = mesh.HasNormals;
bool hasTangents = mesh.Tangents != null;
bool hasBitangents = mesh.BiTangents != null;
int noofElements = 1;
if (hasColors)
noofElements++;
if (hasNormals)
noofElements++;
if (hasTangents)
noofElements++;
if (hasBitangents)
noofElements++;
if (hasTexCoords)
noofElements++;
return noofElements;
}
public static void Run(Assimp.Scene scene)
{
}
/// <summary>
/// Update a 3D Joint in the joint Collection
/// </summary>
/// <param name="nodeName">The joint Name</param>
/// <param name="absoluteMatrix">Destintation Matrix of the specified node</param>
private void SetJoint(string nodeName, Matrix3D absoluteMatrix, Assimp.Vector3D delta)
{
Joint myJoint = joints.FindJointByName(nodeName);
if (myJoint == null)
{
myJoint = new Joint();
myJoint.Name = nodeName;
myJoint.Matrix.Add(absoluteMatrix);
myJoint.Delta.Add(delta);
joints.Add(myJoint);
}
else
{
myJoint.Matrix.Add(absoluteMatrix);
myJoint.Delta.Add(delta);
}
}
void TestAnimationChannel(Assimp. MeshAnimationChannel netChannel, AssimpSharp.MeshAnim sharpChannel)
{
Assert.AreEqual(netChannel.MeshName, sharpChannel.Name);
Assert.AreEqual(netChannel.MeshKeyCount, sharpChannel.Keys.Length);
for (int i = 0; i < netChannel.MeshKeyCount; i++)
{
Assert.AreEqual(netChannel.MeshKeys[i].Time, sharpChannel.Keys[i].Time);
Assert.AreEqual(netChannel.MeshKeys[i].Value, sharpChannel.Keys[i].Value);
}
}
private void RecursiveRender(Assimp.Scene scene, Node node, ref OpenGL gl)
{
Matrix4 m = FromMatrix(node.Transform);
m.Transpose();
gl.PushMatrix();
gl.MultMatrix(FloatFromMatrix(m));
if (node.HasMeshes)
{
foreach (int index in node.MeshIndices)
{
Mesh mesh = scene.Meshes[index];
ApplyMaterial(m_model.Materials[mesh.MaterialIndex], ref gl);
if (mesh.HasNormals)
{
gl.Enable(OpenGL.GL_LIGHTING);
}
else
{
gl.Disable(OpenGL.GL_LIGHTING);
}
bool hasColors = mesh.HasVertexColors(0);
if (hasColors)
{
gl.Enable(OpenGL.GL_COLOR_MATERIAL);
}
else
{
gl.Disable(OpenGL.GL_COLOR_MATERIAL);
}
bool hasTexCoords = mesh.HasTextureCoords(0);
foreach (Assimp.Face face in mesh.Faces)
{
BeginMode faceMode;
switch (face.IndexCount)
{
case 1:
faceMode = BeginMode.Points;
break;
case 2:
faceMode = BeginMode.Lines;
break;
case 3:
faceMode = BeginMode.Triangles;
break;
default:
faceMode = BeginMode.Polygon;
break;
}
gl.Begin(faceMode);
for (int i = 0; i < face.IndexCount; i++)
{
int indice = face.Indices[i];
if (hasColors)
{
Color4 vertColor = FromColor(mesh.VertexColorChannels[0][indice]);
if (mesh.HasNormals)
{
Vector3 normal = FromVector(mesh.Normals[indice]);
gl.Normal(normal.X, normal.Y, normal.Z);
}
if (hasTexCoords)
{
Vector3 uvw = FromVector(mesh.TextureCoordinateChannels[0][indice]);
gl.TexCoord(uvw.X, 1 - uvw.Y);
}
Vector3 pos = FromVector(mesh.Vertices[indice]);
gl.Vertex(pos.X, pos.Y, pos.Z);
}
gl.End();
}
}
}
for (int i = 0; i < node.ChildCount; i++)
{
RecursiveRender(m_model, node.Children[i], ref gl);
}
}
}
void TestMesh(Assimp.Mesh netMesh, AssimpSharp.Mesh sharpMesh)
{
// Vertices
Assert.AreEqual(netMesh.HasVertices, sharpMesh.Vertices != null);
if (netMesh.HasVertices)
{
Assert.AreEqual(netMesh.VertexCount, sharpMesh.Vertices.Length);
MathAssert.AreEqual(netMesh.Vertices, sharpMesh.Vertices);
}
// Faces
Assert.AreEqual(netMesh.HasFaces, sharpMesh.Faces != null);
if (netMesh.HasFaces)
{
Assert.AreEqual(netMesh.FaceCount, sharpMesh.Faces.Length);
for (int i = 0; i < netMesh.FaceCount; i++)
{
Assert.AreEqual(netMesh.Faces[i].HasIndices, sharpMesh.Faces[i].Indices != null);
Assert.AreEqual(netMesh.Faces[i].IndexCount, sharpMesh.Faces[i].Indices.Length);
Assert.AreEqual(netMesh.Faces[i].Indices, sharpMesh.Faces[i].Indices);
}
}
// Normals
Assert.AreEqual(netMesh.HasNormals, sharpMesh.Normals != null);
if (netMesh.HasNormals)
{
MathAssert.AreEqual(netMesh.Normals, sharpMesh.Normals);
}
// BiTangents
Assert.AreEqual(netMesh.HasTangentBasis, sharpMesh.Bitangents != null && sharpMesh.Bitangents.Length > 0);
if (netMesh.HasTangentBasis)
{
MathAssert.AreEqual(netMesh.BiTangents, sharpMesh.Bitangents);
}
// PrimitiveType
// AssimpNet BUG!!
//Assert.AreEqual(netMesh.PrimitiveType.ToString(), Enum.GetName(typeof(AssimpSharp.PrimitiveType), sharpMesh.PrimitiveTypes));
// TexureCoord
for (int i = 0; i < netMesh.TextureCoordinateChannelCount; i++)
{
Assert.AreEqual(netMesh.HasTextureCoords(i), sharpMesh.HasTextureCoords(i));
MathAssert.AreEqual(netMesh.TextureCoordinateChannels[i], sharpMesh.TextureCoords[i]);
}
// VertexColorChannels
for (int i = 0; i < netMesh.VertexColorChannelCount; i++)
{
Assert.AreEqual(netMesh.HasVertexColors(i), sharpMesh.HasVertexColors(i));
if (netMesh.HasVertexColors(i))
{
Assert.AreEqual(netMesh.VertexColorChannels[i], sharpMesh.Colors[i]);
}
}
// MaterialIndex
Assert.AreEqual(netMesh.MaterialIndex, sharpMesh.MaterialIndex);
// Name
Assert.AreEqual(netMesh.Name, sharpMesh.Name);
// UVComponentCount
Assert.AreEqual(netMesh.UVComponentCount, sharpMesh.NumUVComponents);
// MeshAnimationAttachments
Assert.AreEqual(netMesh.HasMeshAnimationAttachments, sharpMesh.AnimMeshes != null);
if (netMesh.HasMeshAnimationAttachments)
{
for (int i = 0; i < netMesh.MeshAnimationAttachmentCount; i++)
{
TestAnimationAttachment(netMesh.MeshAnimationAttachments[i], sharpMesh.AnimMeshes[i]);
}
}
}
public void SetTexture(string rootPath, Assimp.Material meterial)
{
SetTexture(rootPath, meterial.TextureDiffuse.FilePath, TextureType.Diffuse);
SetTexture(rootPath, meterial.TextureNormal.FilePath, TextureType.Normal);
SetTexture(rootPath, meterial.TextureDiffuse.FilePath, TextureType.Gamma);
SetTexture(rootPath, meterial.TextureDiffuse.FilePath, TextureType.Shadow);
SetTexture(rootPath, meterial.TextureDiffuse.FilePath, TextureType.Bump);
}
/// <summary>
/// Add a texture to the TextureSet. This is the only place where
/// Texture instances are actually created. The actual image for textures
/// added to the set is loaded using a background thread.
/// </summary>
/// <param name="path">Texture's given path or, in case an embedded data source
/// is specified for the texture, an arbitrary but unique value to identify
/// the texture (preferably not a file path)
/// </param>
/// <param name="embeddedDataSource">Optional parameter that specifies
/// an in-memory, embedded data source for the texture. </param>
public void Add(string path, Assimp.EmbeddedTexture embeddedDataSource = null)
{
if(_dict.ContainsKey(path))
{
return;
}
Texture.CompletionCallback closure = self =>
{
lock(_loaded)
{
if (_disposed)
{
return;
}
Debug.Assert(_dict.ContainsKey(path));
_loaded.Add(path);
// If this texture is being used as replacement for another texture,
// we need to invoke callbacks for its ID too
// TODO obviously, all the replacement code needs a re-design.
foreach (var kv in _replacements)
{
if (kv.Value.Value == path)
{
for (int i = 0, e = _textureCallbacks.Count; i < e; )
{
var callback = _textureCallbacks[i];
if (!callback(kv.Value.Key, self))
{
_textureCallbacks.RemoveAt(i);
--e;
continue;
}
++i;
}
}
}
for (int i = 0, e = _textureCallbacks.Count; i < e; )
{
var callback = _textureCallbacks[i];
if (!callback(path, self))
{
_textureCallbacks.RemoveAt(i);
--e;
continue;
}
++i;
}
}
};
_dict.Add(path, embeddedDataSource == null
? new Texture(path, _baseDir, closure)
: new Texture(embeddedDataSource, path, closure));
}
public static void readMesh(string path, string filename, string texturepath)
{
string importingAssetsDir;
if (File.Exists(path + "/" + filename))
{
Assimp.PostProcessSteps flags = (
// Assimp.PostProcessSteps.MakeLeftHanded |
Assimp.PostProcessSteps.OptimizeMeshes |
Assimp.PostProcessSteps.OptimizeGraph |
Assimp.PostProcessSteps.RemoveRedundantMaterials |
Assimp.PostProcessSteps.SortByPrimitiveType |
Assimp.PostProcessSteps.SplitLargeMeshes |
Assimp.PostProcessSteps.Triangulate |
Assimp.PostProcessSteps.CalculateTangentSpace |
Assimp.PostProcessSteps.GenerateUVCoords |
Assimp.PostProcessSteps.GenerateSmoothNormals |
Assimp.PostProcessSteps.RemoveComponent |
Assimp.PostProcessSteps.JoinIdenticalVertices);
IntPtr config = Assimp.aiCreatePropertyStore();
Assimp.aiSetImportPropertyFloat(config, Assimp.AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, 60.0f);
// IntPtr scene = Assimp.aiImportFile(path + "/" + filename, (uint)flags);
IntPtr scene = Assimp.aiImportFileWithProperties(path + "/" + filename, (uint)flags, config);
Assimp.aiReleasePropertyStore(config);
if (scene == null)
{
Debug.LogWarning("failed to read file: " + path + "/" + filename);
return;
}
else
{
string nm = Path.GetFileNameWithoutExtension(filename);
importingAssetsDir = "Assets/Prefabs/" + nm + "/";
if (saveAssets)
{
if (!Directory.Exists(importingAssetsDir))
{
Directory.CreateDirectory(importingAssetsDir);
}
AssetDatabase.Refresh();
}
GameObject ObjectRoot = new GameObject(nm);
GameObject meshContainer = new GameObject(nm + "_Mesh");
meshContainer.transform.parent = ObjectRoot.transform;
List <Material> materials = new List <Material>();
List <AssimpMesh> MeshList = new List <AssimpMesh>();
for (int i = 0; i < Assimp.aiScene_GetNumMaterials(scene); i++)
{
string matName = Assimp.aiMaterial_GetName(scene, i);
matName = nm + "_mat" + i;
// string fname = Path.GetFileNameWithoutExtension(Assimp.aiMaterial_GetTexture(scene, i, (int)Assimp.TextureType.Diffuse));
string fname = Path.GetFileName(Assimp.aiMaterial_GetTexture(scene, i, (int)Assimp.TextureType.Diffuse));
Debug.Log("texture " + fname + "Material :" + matName);
Color ambient = Assimp.aiMaterial_GetAmbient(scene, i);
Color diffuse = Assimp.aiMaterial_GetDiffuse(scene, i);
Color specular = Assimp.aiMaterial_GetSpecular(scene, i);
Color emissive = Assimp.aiMaterial_GetEmissive(scene, i);
Material mat = new Material(Shader.Find("Diffuse"));
mat.name = matName;
string texturename = path + "/" + fname;
Texture2D tex = null;
if (File.Exists(texturename))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename, typeof(Texture2D));
}
else
if (File.Exists(texturename + ".PNG"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".PNG", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".JPG"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".JPG", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".BMP"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".BMP", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".TGA"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".TGA", typeof(Texture2D));
}
else
if (File.Exists(texturename + ".DDS"))
{
tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename + ".DDS", typeof(Texture2D));
}
//Texture2D tex = Resources.Load(texturename) as Texture2D;
// Texture2D tex = (Texture2D)AssetDatabase.LoadAssetAtPath(texturename, typeof(Texture2D));
if (tex != null)
{
Debug.Log("LOAD (" + texturename + ") texture");
mat.SetTexture("_MainTex", tex);
}
else
{
Debug.LogError("Fail LOAD (" + texturename + ") error");
}
if (saveAssets)
{
string materialAssetPath = AssetDatabase.GenerateUniqueAssetPath(importingAssetsDir + mat.name + ".asset");
AssetDatabase.CreateAsset(mat, materialAssetPath);
}
materials.Add(mat);
}
AssetDatabase.Refresh();
if (Assimp.aiScene_HasMeshes(scene))
{
for (int i = 0; i < Assimp.aiScene_GetNumMeshes(scene); i++)
{
string name = "Mesh_";
name += i.ToString();
bool HasNormals = Assimp.aiMesh_HasNormals(scene, i);
bool HasTexCoord = Assimp.aiMesh_HasTextureCoords(scene, i, 0);
bool HasFaces = Assimp.aiMesh_HasFaces(scene, i);
AssimpMesh mesh = new AssimpMesh(meshContainer, ObjectRoot, name);
mesh.setmaterial(materials[Assimp.aiMesh_GetMaterialIndex(scene, i)]);
MeshList.Add(mesh);
for (int v = 0; v < Assimp.aiMesh_GetNumVertices(scene, i); v++)
{
Vector3 vertex = Assimp.aiMesh_Vertex(scene, i, v);
Vector3 n = Assimp.aiMesh_Normal(scene, i, v);
float x = Assimp.aiMesh_TextureCoordX(scene, i, v, 0);
float y = Assimp.aiMesh_TextureCoordY(scene, i, v, 0);
Vector3 binormalf = Assimp.aiMesh_Bitangent(scene, i, v);
Vector3 tangentf = Assimp.aiMesh_Tangent(scene, i, v);
Vector4 outputTangent = new Vector4(tangentf.x, tangentf.y, tangentf.z, 0.0F);
float dp = Vector3.Dot(Vector3.Cross(n, tangentf), binormalf);
if (dp > 0.0F)
{
outputTangent.w = 1.0F;
}
else
{
outputTangent.w = -1.0F;
}
mesh.addVertex(vertex, n, new Vector2(x, y), outputTangent);
//mesh.addVertex(vertex, new Vector3(1 * -n.x, n.y, n.z), new Vector2(x, y), outputTangent);
}
for (int f = 0; f < Assimp.aiMesh_GetNumFaces(scene, i); f++)
{
int a = Assimp.aiMesh_Indice(scene, i, f, 0);
int b = Assimp.aiMesh_Indice(scene, i, f, 1);
int c = Assimp.aiMesh_Indice(scene, i, f, 2);
mesh.addFace(a, b, c);
}
//**********
mesh.build();
if (saveAssets)
{
string meshAssetPath = AssetDatabase.GenerateUniqueAssetPath(importingAssetsDir + mesh.name + ".asset");
AssetDatabase.CreateAsset(mesh.geometry, meshAssetPath);
}
mesh.dispose();
}
}
if (saveAssets)
{
string prefabPath = AssetDatabase.GenerateUniqueAssetPath(importingAssetsDir + filename + ".prefab");
var prefab = PrefabUtility.CreateEmptyPrefab(prefabPath);
PrefabUtility.ReplacePrefab(ObjectRoot, prefab, ReplacePrefabOptions.ConnectToPrefab);
AssetDatabase.Refresh();
}
MeshList.Clear();
}
Assimp.aiReleaseImport(scene);
Debug.LogWarning(path + "/" + filename + " Imported ;) ");
}
}
