StdMeshLoader Class Reference

#include <StdMeshLoader.h>

Classes
class	LoaderException
class	StdMeshXML

Static Public Member Functions
static StdMesh *	LoadMeshBinary (const char *sourcefile, size_t size, const StdMeshMatManager &mat_mgr, StdMeshSkeletonLoader &loader, const char *filename=nullptr)
static StdMesh *	LoadMeshXml (const char *sourcefile, size_t size, const StdMeshMatManager &mat_mgr, StdMeshSkeletonLoader &loader, const char *filename=nullptr)

Detailed Description

Definition at line 33 of file StdMeshLoader.h.

Member Function Documentation

LoadMeshBinary()

StdMesh * StdMeshLoader::LoadMeshBinary ( const char *  sourcefile, size_t  size, const StdMeshMatManager &  mat_mgr, StdMeshSkeletonLoader &  loader, const char *  filename = nullptr  )

static

Definition at line 436 of file StdMeshLoaderBinary.cpp.

{
    std::unique_ptr<Ogre::Mesh::Chunk> root;
    Ogre::DataStream stream(sourcefile, length);
 
    // First chunk must be the header
    root = Ogre::Mesh::Chunk::Read(&stream);
    if (root->GetType() != Ogre::Mesh::CID_Header)
        throw Ogre::Mesh::InvalidVersion();
 
    // Second chunk is the mesh itself
    root = Ogre::Mesh::Chunk::Read(&stream);
    if (root->GetType() != Ogre::Mesh::CID_Mesh)
        throw Ogre::Mesh::InvalidVersion();
 
    // Generate mesh from data
    Ogre::Mesh::ChunkMesh &cmesh = *static_cast<Ogre::Mesh::ChunkMesh*>(root.get());
    std::unique_ptr<StdMesh> mesh(new StdMesh);
 
    // if the mesh has a skeleton, then try loading
    // it from the loader by the definition name
    if (!cmesh.skeletonFile.empty())
    {
        StdCopyStrBuf skeleton_filename = StdCopyStrBuf();
        StdMeshSkeletonLoader::MakeFullSkeletonPath(skeleton_filename, filename, cmesh.skeletonFile.c_str());
 
        mesh->Skeleton = loader.GetSkeletonByName(skeleton_filename);
 
        // with this exception the assert below is useless
        // also, I think the bone_lookup should only be used if there is a skeleton anyway
        // so there could be meshes without bones even?
        if (mesh->Skeleton == nullptr)
        {
            StdCopyStrBuf exception("The specified skeleton file was not found: ");
            exception.Append(skeleton_filename.getData());
            throw Ogre::InsufficientData(exception.getData());
        }
    }
 
    assert(mesh->Skeleton != nullptr); // the bone assignments could instead be added only, if there is a skeleton
 
    // Build bone handle->index quick access table
    std::map<uint16_t, size_t> bone_lookup;
    for (size_t i = 0; i < mesh->GetSkeleton().GetNumBones(); ++i)
    {
        bone_lookup[mesh->GetSkeleton().GetBone(i).ID] = i;
    }
 
    // Read submeshes
    mesh->SubMeshes.reserve(cmesh.submeshes.size());
    for (size_t i = 0; i < cmesh.submeshes.size(); ++i)
    {
        mesh->SubMeshes.push_back(StdSubMesh());
        StdSubMesh &sm = mesh->SubMeshes.back();
        Ogre::Mesh::ChunkSubmesh &csm = *cmesh.submeshes[i];
        sm.Material = mat_mgr.GetMaterial(csm.material.c_str());
        if (!sm.Material)
            throw Ogre::Mesh::InvalidMaterial();
        if (csm.operation != Ogre::Mesh::ChunkSubmesh::SO_TriList)
            throw Ogre::Mesh::NotImplemented("Submesh operations other than TriList aren't implemented yet");
        sm.Faces.resize(csm.faceVertices.size() / 3);
        for (size_t face = 0; face < sm.Faces.size(); ++face)
        {
            sm.Faces[face].Vertices[0] = csm.faceVertices[face * 3 + 0];
            sm.Faces[face].Vertices[1] = csm.faceVertices[face * 3 + 1];
            sm.Faces[face].Vertices[2] = csm.faceVertices[face * 3 + 2];
        }
        Ogre::Mesh::ChunkGeometry &geo = *(csm.hasSharedVertices ? cmesh.geometry : csm.geometry);
        sm.Vertices = ReadSubmeshGeometry(geo, filename);
 
        // Read bone assignments
        std::vector<Ogre::Mesh::BoneAssignment> &boneAssignments = (csm.hasSharedVertices ? cmesh.boneAssignments : csm.boneAssignments);
        assert(!csm.hasSharedVertices || csm.boneAssignments.empty());
        for(const auto &ba : boneAssignments)
        {
            if (ba.vertex >= sm.GetNumVertices())
                throw Ogre::Mesh::VertexNotFound();
            if (bone_lookup.find(ba.bone) == bone_lookup.end())
                throw Ogre::Skeleton::BoneNotFound();
            size_t bone_index = bone_lookup[ba.bone];
            // Check quickly if all weight slots are used
            StdSubMesh::Vertex &vertex = sm.Vertices[ba.vertex];
            if (vertex.bone_weight[StdMeshVertex::MaxBoneWeightCount - 1] != 0)
            {
                throw Ogre::Mesh::NotImplemented("Vertex is influenced by too many bones");
            }
            for (size_t weight_index = 0; weight_index < StdMeshVertex::MaxBoneWeightCount; ++weight_index)
            {
                if (vertex.bone_weight[weight_index] == 0)
                {
                    vertex.bone_weight[weight_index] = ba.weight;
                    vertex.bone_index[weight_index] = bone_index;
                    break;
                }
            }
        }
 
        // Normalize bone assignments
        for(StdSubMesh::Vertex &vertex : sm.Vertices)
        {
            float sum = 0;
            for (float weight : vertex.bone_weight)
                sum += weight;
            if (sum != 0)
                for (float &weight : vertex.bone_weight)
                    weight /= sum;
            else
                vertex.bone_weight[0] = 1.0f;
        }
    }
 
    // Construct bounding box. Don't use bounds and radius from cmesh
    // because they are in a different coordinate frame.
    //mesh->BoundingBox = cmesh.bounds;
    //mesh->BoundingRadius = cmesh.radius;
 
    bool first = true;
    for (unsigned int i = 0; i < mesh->SubMeshes.size() + 1; ++i)
    {
        const std::vector<StdSubMesh::Vertex>* vertices = nullptr;
        if (i < mesh->SubMeshes.size())
            vertices = &mesh->SubMeshes[i].Vertices;
        else
            vertices = &mesh->SharedVertices;
 
        for (const auto & vertex : *vertices)
        {
            const float d = std::sqrt(vertex.x*vertex.x
                                    + vertex.y*vertex.y
                                    + vertex.z*vertex.z);
 
            // First vertex
            if (first)
            {
                mesh->BoundingBox.x1 = mesh->BoundingBox.x2 = vertex.x;
                mesh->BoundingBox.y1 = mesh->BoundingBox.y2 = vertex.y;
                mesh->BoundingBox.z1 = mesh->BoundingBox.z2 = vertex.z;
                mesh->BoundingRadius = d;
                first = false;
            }
            else
            {
                mesh->BoundingBox.x1 = std::min(vertex.x, mesh->BoundingBox.x1);
                mesh->BoundingBox.x2 = std::max(vertex.x, mesh->BoundingBox.x2);
                mesh->BoundingBox.y1 = std::min(vertex.y, mesh->BoundingBox.y1);
                mesh->BoundingBox.y2 = std::max(vertex.y, mesh->BoundingBox.y2);
                mesh->BoundingBox.z1 = std::min(vertex.z, mesh->BoundingBox.z1);
                mesh->BoundingBox.z2 = std::max(vertex.z, mesh->BoundingBox.z2);
                mesh->BoundingRadius = std::max(mesh->BoundingRadius, d);
            }
        }
    }
 
    // We allow bounding box to be empty if it's only due to Z direction since
    // this is what goes inside the screen in Clonk.
    if(mesh->BoundingBox.x1 == mesh->BoundingBox.x2 || mesh->BoundingBox.y1 == mesh->BoundingBox.y2)
        throw Ogre::Mesh::EmptyBoundingBox();
 
    return mesh.release();
}

References StdStrBuf::Append(), StdMeshVertex::bone_index, StdMeshVertex::bone_weight, Ogre::Mesh::ChunkMesh::boneAssignments, Ogre::Mesh::ChunkSubmesh::boneAssignments, Ogre::Mesh::CID_Header, Ogre::Mesh::CID_Mesh, Ogre::Mesh::ChunkSubmesh::faceVertices, Ogre::Mesh::ChunkMesh::geometry, Ogre::Mesh::ChunkSubmesh::geometry, StdStrBuf::getData(), StdMeshMatManager::GetMaterial(), StdSubMesh::GetNumVertices(), StdMeshSkeletonLoader::GetSkeletonByName(), Ogre::Mesh::ChunkSubmesh::hasSharedVertices, StdMeshSkeletonLoader::MakeFullSkeletonPath(), Ogre::Mesh::ChunkSubmesh::material, StdMeshVertex::MaxBoneWeightCount, Ogre::Mesh::Chunk::Read(), Ogre::Mesh::ChunkMesh::skeletonFile, Ogre::Mesh::ChunkSubmesh::SO_TriList, Ogre::Mesh::ChunkMesh::submeshes, StdMeshVertex::x, StdMeshVertex::y, and StdMeshVertex::z.

Referenced by C4DefGraphics::LoadMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadMeshXml()

StdMesh * StdMeshLoader::LoadMeshXml ( const char *  sourcefile, size_t  size, const StdMeshMatManager &  mat_mgr, StdMeshSkeletonLoader &  loader, const char *  filename = nullptr  )

static

Definition at line 261 of file StdMeshLoaderXml.cpp.

{
    StdMeshXML xml(filename ? filename : "<unknown>", xml_data);
 
    std::unique_ptr<StdMesh> mesh(new StdMesh);
 
    TiXmlElement* mesh_elem = xml.RequireFirstChild(nullptr, "mesh");
 
    // Load shared geometry, if any
    TiXmlElement* sharedgeometry_elem = mesh_elem->FirstChildElement("sharedgeometry");
    if(sharedgeometry_elem != nullptr)
        xml.LoadGeometry(*mesh, mesh->SharedVertices, sharedgeometry_elem);
 
    TiXmlElement* submeshes_elem = xml.RequireFirstChild(mesh_elem, "submeshes");
 
    TiXmlElement* submesh_elem_base = xml.RequireFirstChild(submeshes_elem, "submesh");
    for (TiXmlElement* submesh_elem = submesh_elem_base; submesh_elem != nullptr; submesh_elem = submesh_elem->NextSiblingElement("submesh"))
    {
        mesh->SubMeshes.push_back(StdSubMesh());
        StdSubMesh& submesh = mesh->SubMeshes.back();
 
        const char* material = xml.RequireStrAttribute(submesh_elem, "material");
        submesh.Material = manager.GetMaterial(material);
        if (!submesh.Material)
            xml.Error(FormatString("There is no such material named '%s'", material), submesh_elem);
 
        const char* usesharedvertices = submesh_elem->Attribute("usesharedvertices");
        const std::vector<StdMesh::Vertex>* vertices;
        if(!usesharedvertices || strcmp(usesharedvertices, "true") != 0)
        {
            TiXmlElement* geometry_elem = xml.RequireFirstChild(submesh_elem, "geometry");
            xml.LoadGeometry(*mesh, submesh.Vertices, geometry_elem);
            vertices = &submesh.Vertices;
        }
        else
        {
            if(mesh->SharedVertices.empty())
                xml.Error(StdCopyStrBuf("Submesh specifies to use shared vertices but there is no shared geometry"), submesh_elem);
            vertices = &mesh->SharedVertices;
        }
 
        TiXmlElement* faces_elem = xml.RequireFirstChild(submesh_elem, "faces");
        int FaceCount = xml.RequireIntAttribute(faces_elem, "count");
        submesh.Faces.resize(FaceCount);
 
        unsigned int i = 0;
        for (TiXmlElement* face_elem = faces_elem->FirstChildElement("face"); face_elem != nullptr && i < submesh.Faces.size(); face_elem = face_elem->NextSiblingElement("face"), ++i)
        {
            int v[3];
 
            v[0] = xml.RequireIntAttribute(face_elem, "v1");
            v[1] = xml.RequireIntAttribute(face_elem, "v2");
            v[2] = xml.RequireIntAttribute(face_elem, "v3");
 
            for (unsigned int j = 0; j < 3; ++j)
            {
                if (v[j] < 0 || static_cast<unsigned int>(v[j]) >= vertices->size())
                    xml.Error(FormatString("Vertex index v%u (%d) is out of range", j+1, v[j]), face_elem);
                submesh.Faces[i].Vertices[j] = v[j];
            }
        }
    }
 
    // We allow bounding box to be empty if it's only due to Z direction since
    // this is what goes inside the screen in Clonk.
    if(mesh->BoundingBox.x1 == mesh->BoundingBox.x2 || mesh->BoundingBox.y1 == mesh->BoundingBox.y2)
        xml.Error(StdCopyStrBuf("Bounding box is empty"), mesh_elem);
 
    // Read skeleton, if any
    TiXmlElement* skeletonlink_elem = mesh_elem->FirstChildElement("skeletonlink");
    if (skeletonlink_elem)
    {
        const char* name = xml.RequireStrAttribute(skeletonlink_elem, "name");
        StdCopyStrBuf xml_filename(name); xml_filename.Append(".xml");
 
        StdCopyStrBuf skeleton_filename;
        StdMeshSkeletonLoader::MakeFullSkeletonPath(skeleton_filename, filename, xml_filename.getData());
 
        mesh->Skeleton = skel_loader.GetSkeletonByName(skeleton_filename);
        if (!mesh->Skeleton) xml.Error(FormatString("Failed to load '%s'", skeleton_filename.getData()), skeletonlink_elem);
 
        // Vertex<->Bone assignments for shared geometry
        if (sharedgeometry_elem)
        {
            TiXmlElement* boneassignments_elem = xml.RequireFirstChild(mesh_elem, "boneassignments");
            xml.LoadBoneAssignments(*mesh, mesh->SharedVertices, boneassignments_elem);
        }
 
        // Vertex<->Bone assignments for all vertices (need to go through SubMeshes again...)
        unsigned int submesh_index = 0;
        for (TiXmlElement* submesh_elem = submesh_elem_base; submesh_elem != nullptr; submesh_elem = submesh_elem->NextSiblingElement("submesh"), ++submesh_index)
        {
            StdSubMesh& submesh = mesh->SubMeshes[submesh_index];
            if (!submesh.Vertices.empty())
            {
                TiXmlElement* boneassignments_elem = xml.RequireFirstChild(submesh_elem, "boneassignments");
                xml.LoadBoneAssignments(*mesh, submesh.Vertices, boneassignments_elem);
            }
        }
    }
    else
    {
        // Mesh has no skeleton
        // Bone assignements do not make sense then, as the
        // actual bones are defined in the skeleton file.
        for (TiXmlElement* submesh_elem = submesh_elem_base; submesh_elem != nullptr; submesh_elem = submesh_elem->NextSiblingElement("submesh"))
        {
            TiXmlElement* boneassignments_elem = submesh_elem->FirstChildElement("boneassignments");
            if (boneassignments_elem)
                xml.Error(StdStrBuf("Mesh has bone assignments, but no skeleton"), boneassignments_elem);
        }
 
        TiXmlElement* boneassignments_elem = mesh_elem->FirstChildElement("boneassignments");
        if (boneassignments_elem)
            xml.Error(StdStrBuf("Mesh has bone assignments, but no skeleton"), boneassignments_elem);
    }
 
    return mesh.release();
}

References StdStrBuf::Append(), StdMeshLoader::StdMeshXML::Error(), FormatString(), StdStrBuf::getData(), StdMeshMatManager::GetMaterial(), StdMeshSkeletonLoader::GetSkeletonByName(), StdMeshLoader::StdMeshXML::LoadBoneAssignments(), StdMeshLoader::StdMeshXML::LoadGeometry(), StdMeshSkeletonLoader::MakeFullSkeletonPath(), StdMeshLoader::StdMeshXML::RequireFirstChild(), StdMeshLoader::StdMeshXML::RequireIntAttribute(), and StdMeshLoader::StdMeshXML::RequireStrAttribute().

Referenced by C4DefGraphics::LoadMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• StdMeshLoader.h
• StdMeshLoaderBinary.cpp
• StdMeshLoaderXml.cpp