Does the FBX export supports mTextureCoordsNames

[dabblob]

when i load the output fbx file into blender it shows uv layers names as [Attribute.n] etc

if (uvChannels > 0) { mesh->mTextureCoordsNames = new aiString * [AI_MAX_NUMBER_OF_TEXTURECOORDS]; // Initialize pointers to null to avoid garbage data for (int k = 0; k < AI_MAX_NUMBER_OF_TEXTURECOORDS; k++) { mesh->mTextureCoordsNames[k] = nullptr; } } // Allocate UV channels and set names for (int i = 0; i < uvChannels; i++) { mesh->mTextureCoords[i] = new aiVector3D[mesh->mNumVertices]; mesh->mNumUVComponents[i] = 2; // 2D UVs

  if (primMesh->UvLayersNames[i] != nullptr)
  {
      mesh->mTextureCoordsNames[i] = new aiString(ManagedToStdString(primMesh->UvLayersNames[i]).c_str());
  }

}

is this array supported in fbx export ?

full exporter

static std::string ManagedToStdString(System::String^ managedStr) { if (managedStr == nullptr) return ""; return msclr::interop::marshal_as(managedStr); } // Helper to convert Float3 to aiVector3D static aiVector3D ToAiVector3D(Float3 vec) { return aiVector3D(vec.X, vec.Y, vec.Z); }

// Helper to convert Float4x4 to aiMatrix4x4
static aiMatrix4x4 ToAiMatrix4x4(Float4x4 mat)
{
return aiMatrix4x4(
mat.M11, mat.M12, mat.M13, mat.M14,
mat.M21, mat.M22, mat.M23, mat.M24,
mat.M31, mat.M32, mat.M33, mat.M34,
mat.M41, mat.M42, mat.M43, mat.M44
);
}

// Convert PrimordialNode to aiNode
static aiNode* ConvertNode(PrimordialNode^ node, aiNode* parentNode)
{
aiNode* ainode = new aiNode();
ainode->mName = aiString(ManagedToStdString(node->Name).c_str());
ainode->mTransformation = ToAiMatrix4x4(node->LocalTransform);
ainode->mParent = parentNode;

 // Handle children
 if (node->Children != nullptr && node->Children->Count > 0)
 {
     ainode->mNumChildren = node->Children->Count;
     ainode->mChildren = new aiNode * [ainode->mNumChildren];

     int idx = 0;
     for each (PrimordialNode ^ child in node->Children)
     {

         ainode->mChildren[idx] = ConvertNode(child, ainode);

         idx++;
     }

 }

 return ainode;

}

// Convert PrimordialMesh to aiMesh
static aiMesh* ConvertMesh(PrimordialMesh^ primMesh)
{
aiMesh* mesh = new aiMesh();
mesh->mName = aiString(ManagedToStdString(primMesh->Name).c_str());

 // Vertices
 if (primMesh->Vertices != nullptr)
 {
     mesh->mNumVertices = primMesh->Vertices->Length;
     mesh->mVertices = new aiVector3D[mesh->mNumVertices];
     mesh->mNormals = new aiVector3D[mesh->mNumVertices];

     // Determine UV and color channel counts
     int uvChannels = (primMesh->UvLayersNames != nullptr) ?
         System::Math::Min(primMesh->UvLayersNames->Length, AI_MAX_NUMBER_OF_TEXTURECOORDS) : 0;
     int colorChannels = (primMesh->ColorsLayersNames != nullptr) ?
         System::Math::Min(primMesh->ColorsLayersNames->Length, AI_MAX_NUMBER_OF_COLOR_SETS) : 0;

     if (uvChannels > 0)
     {
         mesh->mTextureCoordsNames = new aiString * [AI_MAX_NUMBER_OF_TEXTURECOORDS];
         // Initialize pointers to null to avoid garbage data
         for (int k = 0; k < AI_MAX_NUMBER_OF_TEXTURECOORDS; k++) {
             mesh->mTextureCoordsNames[k] = nullptr;
         }
     }
     // Allocate UV channels and set names
     for (int i = 0; i < uvChannels; i++)
     {
         mesh->mTextureCoords[i] = new aiVector3D[mesh->mNumVertices];
         mesh->mNumUVComponents[i] = 2; // 2D UVs

         if (primMesh->UvLayersNames[i] != nullptr)
         {
             mesh->mTextureCoordsNames[i] = new aiString(ManagedToStdString(primMesh->UvLayersNames[i]).c_str());
         }
     }

     // Allocate color channels and set names
     for (int i = 0; i < colorChannels; i++)
     {
         mesh->mColors[i] = new aiColor4D[mesh->mNumVertices];


     }

     // Fill vertex data
     for (unsigned int i = 0; i < mesh->mNumVertices; i++)
     {
         PrimordialVertex^ vert = primMesh->Vertices[i];

         mesh->mVertices[i] = ToAiVector3D(vert->Position);
         mesh->mNormals[i] = ToAiVector3D(vert->Normal);

         // UVs
         if (vert->UVs != nullptr)
         {
             for (int ch = 0; ch < System::Math::Min(vert->UVs->Length, uvChannels); ch++)
             {
                 mesh->mTextureCoords[ch][i] = aiVector3D(
                     vert->UVs[ch].X,
                     vert->UVs[ch].Y,
                     0.0f
                 );
             }
         }

         // Colors
         if (vert->Colors != nullptr)
         {
             for (int ch = 0; ch < System::Math::Min(vert->Colors->Length, colorChannels); ch++)
             {
                 mesh->mColors[ch][i] = aiColor4D(
                     vert->Colors[ch].X,
                     vert->Colors[ch].Y,
                     vert->Colors[ch].Z,
                     vert->Colors[ch].W
                 );
             }
         }

         // Tangents (use first tangent if available)
         if (vert->Tangents != nullptr && vert->Tangents->Length > 0)
         {
             if (mesh->mTangents == nullptr)
                 mesh->mTangents = new aiVector3D[mesh->mNumVertices];

             mesh->mTangents[i] = aiVector3D(
                 vert->Tangents[0].X,
                 vert->Tangents[0].Y,
                 vert->Tangents[0].Z
             );
         }

         // Bitangents
         if (mesh->mBitangents == nullptr)
             mesh->mBitangents = new aiVector3D[mesh->mNumVertices];

         mesh->mBitangents[i] = aiVector3D(
             vert->Bitangent.X,
             vert->Bitangent.Y,
             vert->Bitangent.Z
         );
     }
 }

 // Indices (faces)
 if (primMesh->Indices != nullptr)
 {
     mesh->mNumFaces = primMesh->Indices->Length / 3;
     mesh->mFaces = new aiFace[mesh->mNumFaces];

     for (unsigned int i = 0; i < mesh->mNumFaces; i++)
     {
         aiFace& face = mesh->mFaces[i];
         face.mNumIndices = 3;
         face.mIndices = new unsigned int[3];
         face.mIndices[0] = primMesh->Indices[i * 3 + 0];
         face.mIndices[1] = primMesh->Indices[i * 3 + 1];
         face.mIndices[2] = primMesh->Indices[i * 3 + 2];
     }
 }

 // Bones
 if (primMesh->Bones != nullptr && primMesh->Bones->Length > 0)
 {
     mesh->mNumBones = primMesh->Bones->Length;
     mesh->mBones = new aiBone * [mesh->mNumBones];

     for (int i = 0; i < primMesh->Bones->Length; i++)
     {
         aiBone* bone = new aiBone();
         String^ boneName = (primMesh->Bones[i]);
         bone->mName = aiString(ManagedToStdString(boneName).c_str());

         // Collect weights for this bone using native std::vector
         std::vector<aiVertexWeight> weights;

         for (int v = 0; v < primMesh->Vertices->Length; v++)
         {
             PrimordialVertex^ vert = primMesh->Vertices[v];
             if (vert->VertexWeights != nullptr)
             {
                 for (int w = 0; w < vert->VertexWeights->Length; w++)
                 {
                     if (vert->VertexWeights[w].Index == i)
                     {
                         aiVertexWeight vw;
                         vw.mVertexId = v;
                         vw.mWeight = vert->VertexWeights[w].Weight;
                         weights.push_back(vw);
                     }
                 }
             }
         }

         bone->mNumWeights = weights.size();
         if (bone->mNumWeights > 0)
         {
             bone->mWeights = new aiVertexWeight[bone->mNumWeights];
             for (size_t w = 0; w < weights.size(); w++)
             {
                 bone->mWeights[w] = weights[w];
             }
         }

         mesh->mBones[i] = bone;
     }
 }

 mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 return mesh;

}

bool AssimpSceneExporter::ExportScene(PrimordialScene^ primScene, String^ filePath,String^ formatId)
{
 try
 {
   

     Assimp::Exporter exporter;

     aiScene* scene = new aiScene();

     // Convert meshes
     if (primScene->Meshes != nullptr)
     {
         scene->mNumMeshes = primScene->Meshes->Length;
         scene->mMeshes = new aiMesh * [scene->mNumMeshes];

         for (int i = 0; i < primScene->Meshes->Length; i++)
         {
             scene->mMeshes[i] = ConvertMesh(primScene->Meshes[i]);
         }
     }

    // Create root node
     scene->mRootNode = new aiNode();
     scene->mRootNode->mName = aiString("RootNode");

     // Create a child node for each mesh
     if (scene->mNumMeshes > 0)
     {
         scene->mRootNode->mNumChildren = scene->mNumMeshes;
         scene->mRootNode->mChildren = new aiNode * [scene->mNumMeshes];

         for (unsigned int i = 0; i < scene->mNumMeshes; i++)
         {
             aiNode* meshNode = new aiNode();
             meshNode->mName = scene->mMeshes[i]->mName; 
             meshNode->mParent = scene->mRootNode;

             meshNode->mNumMeshes = 1;
             meshNode->mMeshes = new unsigned int[1];
             meshNode->mMeshes[0] = i;

             scene->mRootNode->mChildren[i] = meshNode;
         }
     }

     // Add bone nodes as additional children if needed
     if (primScene->Bones != nullptr && primScene->Bones->Length > 0)
     {
         unsigned int totalChildren = scene->mNumMeshes + primScene->Bones->Length;
         aiNode** newChildren = new aiNode * [totalChildren];

         // Copy existing mesh nodes
         for (unsigned int i = 0; i < scene->mNumMeshes; i++)
         {
             newChildren[i] = scene->mRootNode->mChildren[i];
         }

         // Add bone nodes
         for (int i = 0; i < primScene->Bones->Length; i++)
         {
             newChildren[scene->mNumMeshes + i] = ConvertNode(primScene->Bones[i], scene->mRootNode);
         }

         delete[] scene->mRootNode->mChildren;
         scene->mRootNode->mChildren = newChildren;
         scene->mRootNode->mNumChildren = totalChildren;
     }

     // Create a default material
     scene->mNumMaterials = 1;
     scene->mMaterials = new aiMaterial * [1];
     scene->mMaterials[0] = new aiMaterial();

     // Export
     std::string fileStr = ManagedToStdString(filePath).c_str();
     std::string formatStr = ManagedToStdString(formatId).c_str();

     aiReturn result = exporter.Export(scene, formatStr, fileStr);

     // Cleanup
   //  delete scene;
     return result == AI_SUCCESS;
 }
 catch (System::Exception^ ex)
 {
     System::Console::WriteLine("Export failed: " + ex->Message);
     return false;
 }

}