संपादित करें: इसलिए असिंप देव के साथ एक संक्षिप्त संपर्क के बाद, मुझे आयात प्रक्रिया की ओर इशारा किया गया था। मैं किसी और से कोड पदभार संभाल लिया है के रूप में, मुझे लगता है कि हिस्सा देख सोचा नहीं:प्रतिबिंबित जाल और गलत यूवी मानचित्र रनटाइम निर्यात
using (var importer = new AssimpContext())
{
scene = importer.ImportFile(file, PostProcessSteps.Triangulate | PostProcessSteps.FlipUVs | PostProcessSteps.JoinIdenticalVertices);
}
FlipUVs यह वास्तव में क्या कहते हैं करता है, यह y अक्ष पर flips तो मूल अब ऊपरी बाएँ कोने है। तो अब मैं उचित यूवी के साथ मॉडल प्राप्त करने में सक्षम हूं लेकिन अभी भी प्रतिबिंबित जाल है। पैरेंट ऑब्जेक्ट को स्केल x = -1 के साथ सेट करना इसे वापस सामान्य पर फ़्लिप करता है और यह ठीक दिखता है लेकिन मुझे लगता है कि यह होना नहीं है। तो मैं देख रहा हूँ।
तस्वीर देखें, दो क्रेन मॉडल हैं। बायीं तरफ एक को क्रमबद्धता और पुनर्निर्माण के माध्यम से रनटाइम पर लोड किया जाता है जबकि सही व्यक्ति मूल रूप से दृश्य में खींचा जाता है। असीमित लाइब्रेरी के साथ सीरियलाइजेशन होता है।
मंजिल पहले बनाया जाना होता है और सही यूवी नक्शा प्राप्त करने के लिए लगता है। जबकि अन्य वस्तुओं को गलत यूवी मानचित्र मिलता है। हालांकि मैं यूवी मानचित्रों के मूल्यों को प्रिंट कर रहा हूं और वे मूल रूप से मेल खाते हैं जैसा कि उन्हें करना चाहिए।
यह कैसे क्रमानुसार करने है, इस Assimp से जाल वर्ग है, नहीं एकता मेष वर्ग, एप्लिकेशन serializing विंडोज UWP में बनाया गया अनुप्रयोग है:
private static void SerializeMeshes(BinaryWriter writer, IEnumerable<Mesh> meshes)
{
foreach (Mesh mesh in meshes)
{
ICollection<int> triangles = MeshLoadTriangles(mesh);
MeshSerializeHeader(writer, mesh.Name, mesh.VertexCount, triangles.Count, mesh.MaterialIndex);
MeshSerializeVertices(writer, mesh.Vertices);
MeshSerializeUVCoordinate(writer, mesh.TextureCoordinateChannels);
MeshSerializeTriangleIndices(writer, triangles);
}
}
private static void MeshSerializeUVCoordinate(BinaryWriter writer, List<Vector3D>[] textureCoordinateChannels)
{
// get first channel and serialize to writer. Discard z channel
// This is Vector3D since happening outside Unity
List<Vector3D> list = textureCoordinateChannels[0];
foreach (Vector3D v in list)
{
float x = v.X;
float y = v.Y;
writer.Write(x);
writer.Write(y);
}
}
private static void MeshSerializeVertices(BinaryWriter writer, IEnumerable<Vector3D> vertices)
{
foreach (Vector3D vertex in vertices)
{
Vector3D temp = vertex;
writer.Write(temp.X);
writer.Write(temp.Y);
writer.Write(temp.Z);
}
}
private static void MeshSerializeTriangleIndices(BinaryWriter writer, IEnumerable<int> triangleIndices)
{
foreach (int index in triangleIndices) { writer.Write(index); }
}
और यह की विपरीत प्रक्रिया है:
private static void DeserializeMeshes(BinaryReader reader, SceneGraph scene)
{
MeshData[] meshes = new MeshData[scene.meshCount];
for (int i = 0; i < scene.meshCount; i++)
{
meshes[i] = new MeshData();
MeshReadHeader(reader, meshes[i]);
MeshReadVertices(reader, meshes[i]);
MeshReadUVCoordinate(reader, meshes[i]);
MeshReadTriangleIndices(reader, meshes[i]);
}
scene.meshes = meshes as IEnumerable<MeshData>;
}
private static void MeshReadUVCoordinate(BinaryReader reader, MeshData meshData)
{
bool hasUv = reader.ReadBoolean();
if(hasUv == false) { return; }
Vector2[] uvs = new Vector2[meshData.vertexCount];
for (int i = 0; i < uvs.Length; i++)
{
uvs[i] = new Vector2();
uvs[i].x = reader.ReadSingle();
uvs[i].y = reader.ReadSingle();
}
meshData.uvs = uvs;
}
private static void MeshReadHeader(BinaryReader reader, MeshData meshData)
{
meshData.name = reader.ReadString();
meshData.vertexCount = reader.ReadInt32();
meshData.triangleCount = reader.ReadInt32();
meshData.materialIndex = reader.ReadInt32();
}
private static void MeshReadVertices(BinaryReader reader, MeshData meshData)
{
Vector3[] vertices = new Vector3[meshData.vertexCount];
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = new Vector3();
vertices[i].x = reader.ReadSingle();
vertices[i].y = reader.ReadSingle();
vertices[i].z = reader.ReadSingle();
}
meshData.vertices = vertices;
}
private static void MeshReadTriangleIndices(BinaryReader reader, MeshData meshData)
{
int[] triangleIndices = new int[meshData.triangleCount];
for (int i = 0; i < triangleIndices.Length; i++)
{
triangleIndices[i] = reader.ReadInt32();
}
meshData.triangles = triangleIndices;
}
मेषडेटा केवल एक अस्थायी कंटेनर है जो fbx से deserialized मानों के साथ है। फिर, meshes बनाई गई हैं:
private static Mesh[] CreateMeshes(SceneGraph scene)
{
Mesh[] meshes = new Mesh[scene.meshCount];
int index = 0;
foreach (MeshData meshData in scene.meshes)
{
meshes[index] = new Mesh();
Vector3[] vec = meshData.vertices;
meshes[index].vertices = vec;
meshes[index].triangles = meshData.triangles;
meshes[index].uv = meshData.uvs;
meshes[index].normals = meshData.normals;
meshes[index].RecalculateNormals();
index++;
}
return meshes;
}
मैं कोड है कि इस तरह का व्यवहार में परिणाम चाहिए में किसी भी कारण नहीं दिख रहा है, मैं कहेंगे यह पूरी तरह से जाल पेंच अगर मूल्यों गलत थे होगा।
मैं देख सकता हूं कि मेरे पास मौजूद एफबीएक्स फाइलें इंडेक्सिंग के लिए त्रिकोण के बजाय क्वाड का उपयोग कर रही हैं।
क्या यह हो सकता है कि असिंप इस के साथ अच्छी तरह से नहीं जाए?
एकमात्र कारण मैं के बारे में सोच सकता है रेंडर करने के लिए जाल foreach छोरों का उपयोग है । कभी-कभी पूर्वानुमान अपेक्षित के रूप में पुनरावृत्ति नहीं करता है। दोनों में क्लासिक() लूप के लिए क्लासिक का उपयोग करने का प्रयास करें - क्रमिकरण और deserialization।उम्मीद है कि यह –
शायद इन 3 डी मॉडलिंग सॉफ्टवेयर से अलग सेटिंग्स के साथ निर्यात करने में मदद करता है? –
डीबगिंग करते समय आपको किस बिंदु पर अपवाद मिल रहा है? –