Function appendNode

pj_scene3D/widgets/src/mesh_loader.cpp:217–300

Walk the node graph, accumulating each mesh's transformed vertices/indices. `node_transform` is the cumulative parent transform (column-major glm).

// Walk the node graph, accumulating each mesh's transformed vertices/indices.
// `node_transform` is the cumulative parent transform (column-major glm).
void appendNode(
    const aiScene* scene, const aiNode* node, const glm::mat4& parent_transform, const glm::mat3& extra_rotation,
    const std::vector<std::shared_ptr<const Material>>& materials, MeshData& out) {
  // assimp row-major aiMatrix4x4 -> glm column-major.
  const aiMatrix4x4& m = node->mTransformation;
  glm::mat4 local(
      m.a1, m.b1, m.c1, m.d1,   // col 0
      m.a2, m.b2, m.c2, m.d2,   // col 1
      m.a3, m.b3, m.c3, m.d3,   // col 2
      m.a4, m.b4, m.c4, m.d4);  // col 3
  const glm::mat4 node_transform = parent_transform * local;
  const glm::mat3 normal_matrix = glm::mat3(glm::transpose(glm::inverse(node_transform)));
  const glm::mat3 linear = glm::mat3(node_transform);

  for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
    const aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
    static const std::shared_ptr<const Material> k_fallback = std::make_shared<const Material>();
    const std::shared_ptr<const Material>& material =
        mesh->mMaterialIndex < materials.size() ? materials[mesh->mMaterialIndex] : k_fallback;
    const auto base_index = static_cast<std::uint32_t>(out.vertices.size());

    out.vertices.reserve(out.vertices.size() + mesh->mNumVertices);
    for (unsigned int v = 0; v < mesh->mNumVertices; ++v) {
      Vertex vert;
      const aiVector3D& p = mesh->mVertices[v];
      glm::vec3 pos = glm::vec3(node_transform * glm::vec4(p.x, p.y, p.z, 1.0f));
      glm::vec3 nrm(0.0f, 0.0f, 1.0f);
      if (mesh->HasNormals()) {
        const aiVector3D& n = mesh->mNormals[v];
        nrm = glm::normalize(normal_matrix * glm::vec3(n.x, n.y, n.z));
      }
      vert.position = extra_rotation * pos;
      vert.normal = glm::normalize(extra_rotation * nrm);
      // Vertex color carries ONLY genuine per-vertex colors (glTF COLOR_0); the
      // material base color lives in SubMesh::material and is applied by the
      // shader. A white default leaves untextured/non-vertex-colored meshes to be
      // driven purely by the material factor (no double-application).
      vert.color =
          mesh->HasVertexColors(0)
              ? glm::vec4(mesh->mColors[0][v].r, mesh->mColors[0][v].g, mesh->mColors[0][v].b, mesh->mColors[0][v].a)
              : glm::vec4(1.0f);
      if (mesh->HasTextureCoords(0)) {
        const aiVector3D& uv = mesh->mTextureCoords[0][v];
        vert.uv = glm::vec2(uv.x, uv.y);
      }
      // Tangent basis for normal mapping (aiProcess_CalcTangentSpace). Transform
      // into world like the geometry, re-orthogonalize against the final normal
      // (Gram-Schmidt), and store the bitangent handedness in .w.
      if (mesh->HasTangentsAndBitangents()) {
        const aiVector3D& t = mesh->mTangents[v];
        const aiVector3D& b = mesh->mBitangents[v];
        glm::vec3 tan = extra_rotation * (linear * glm::vec3(t.x, t.y, t.z));
        glm::vec3 bit = extra_rotation * (linear * glm::vec3(b.x, b.y, b.z));
        tan = tan - vert.normal * glm::dot(vert.normal, tan);
        if (glm::dot(tan, tan) > 1e-12f) {
          tan = glm::normalize(tan);
          const float sign = glm::dot(glm::cross(vert.normal, tan), bit) < 0.0f ? -1.0f : 1.0f;
          vert.tangent = glm::vec4(tan, sign);