StdMeshLoader::StdMeshXML Class Reference

Public Member Functions
	StdMeshXML (const char *filename, const char *xml_data)
const char *	RequireStrAttribute (TiXmlElement *element, const char *attribute) const
int	RequireIntAttribute (TiXmlElement *element, const char *attribute) const
float	RequireFloatAttribute (TiXmlElement *element, const char *attribute) const
TiXmlElement *	RequireFirstChild (TiXmlElement *element, const char *child)
void	LoadGeometry (StdMesh &mesh, std::vector< StdSubMesh::Vertex > &vertices, TiXmlElement *boneassignments_elem)
void	LoadBoneAssignments (StdMesh &mesh, std::vector< StdSubMesh::Vertex > &vertices, TiXmlElement *boneassignments_elem)
void	Error (const StdStrBuf &message, TiXmlElement *element) const
void	Error (const StdStrBuf &message, int row) const

Detailed Description

Definition at line 25 of file StdMeshLoaderXml.cpp.

Constructor & Destructor Documentation

StdMeshXML()

StdMeshLoader::StdMeshXML::StdMeshXML	(	const char *	filename,
		const char *	xml_data
	)

Definition at line 47 of file StdMeshLoaderXml.cpp.

                                                                             :
        FileName(filename)
{
    Document.Parse(xml_data);
    if (Document.Error())
        Error(StdStrBuf(Document.ErrorDesc()), Document.ErrorRow());
}

References Error().

Here is the call graph for this function:

Member Function Documentation

Error() [1/2]

void StdMeshLoader::StdMeshXML::Error	(	const StdStrBuf &	message,
		int	row
	)		const

Definition at line 103 of file StdMeshLoaderXml.cpp.

{
    throw StdMeshLoader::LoaderException(FormatString("%s:%u: %s", FileName.getData(), row, message.getData()).getData());
}

References FormatString(), and StdStrBuf::getData().

Here is the call graph for this function:

Error() [2/2]

void StdMeshLoader::StdMeshXML::Error	(	const StdStrBuf &	message,
		TiXmlElement *	element
	)		const

Definition at line 98 of file StdMeshLoaderXml.cpp.

{
    Error(message, element->Row());
}

Referenced by StdMeshLoader::LoadMeshXml(), and StdMeshXML().

Here is the caller graph for this function:

LoadBoneAssignments()

void StdMeshLoader::StdMeshXML::LoadBoneAssignments	(	StdMesh &	mesh,
		std::vector< StdSubMesh::Vertex > &	vertices,
		TiXmlElement *	boneassignments_elem
	)

Definition at line 209 of file StdMeshLoaderXml.cpp.

{
    for (TiXmlElement* vertexboneassignment_elem = boneassignments_elem->FirstChildElement("vertexboneassignment"); vertexboneassignment_elem != nullptr; vertexboneassignment_elem = vertexboneassignment_elem->NextSiblingElement("vertexboneassignment"))
    {
        int BoneID = RequireIntAttribute(vertexboneassignment_elem, "boneindex");
        int VertexIndex = RequireIntAttribute(vertexboneassignment_elem, "vertexindex");
        float weight = RequireFloatAttribute(vertexboneassignment_elem, "weight");
 
        if (VertexIndex < 0 || static_cast<unsigned int>(VertexIndex) >= vertices.size())
            Error(FormatString("Vertex index in bone assignment (%d) is out of range", VertexIndex), vertexboneassignment_elem);
 
        // maybe not needed, see comment below
        const StdMeshBone* bone = nullptr;
        for (unsigned int i = 0; !bone && i < mesh.GetSkeleton().GetNumBones(); ++i)
            if (mesh.GetSkeleton().GetBone(i).ID == BoneID)
                bone = &mesh.GetSkeleton().GetBone(i);
 
        if (!bone) Error(FormatString("There is no such bone with ID %d", BoneID), vertexboneassignment_elem);
 
        // Find first bone assignment with a zero weight (i.e. is unused)
        StdSubMesh::Vertex& vertex = vertices[VertexIndex];
        // Check quickly if all weight slots are used
        if (vertex.bone_weight[StdMeshVertex::MaxBoneWeightCount - 1] != 0)
        {
            Error(FormatString("Vertex %d is influenced by more than %d bones", VertexIndex, static_cast<int>(StdMeshVertex::MaxBoneWeightCount)), vertexboneassignment_elem);
        }
        for (size_t weight_index = 0; weight_index < StdMeshVertex::MaxBoneWeightCount; ++weight_index)
        {
            if (vertex.bone_weight[weight_index] == 0)
            {
                vertex.bone_weight[weight_index] = weight;
                vertex.bone_index[weight_index] = bone->Index;
                break;
            }
        }
    }
 
    // Normalize vertex bone assignment weights (this is not guaranteed in the
    // Ogre file format).
    for (auto & vertex : vertices)
    {
        float sum = 0.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;
    }
}

Referenced by StdMeshLoader::LoadMeshXml().

Here is the caller graph for this function:

LoadGeometry()

void StdMeshLoader::StdMeshXML::LoadGeometry	(	StdMesh &	mesh,
		std::vector< StdSubMesh::Vertex > &	vertices,
		TiXmlElement *	boneassignments_elem
	)

Definition at line 108 of file StdMeshLoaderXml.cpp.

{
    // Check whether mesh has any vertices so far -- we need this later for
    // initialization of bounding box and bounding sphere.
    bool hasVertices = false;
    if(!mesh.SharedVertices.empty()) hasVertices = true;
    for(auto & SubMesh : mesh.SubMeshes)
        if(!SubMesh.Vertices.empty())
            hasVertices = true;
 
    int VertexCount = RequireIntAttribute(geometry_elem, "vertexcount");
    vertices.resize(VertexCount);
 
    static const unsigned int POSITIONS = 1;
    static const unsigned int NORMALS = 2;
    static const unsigned int TEXCOORDS = 4;
 
    // Individual vertex attributes can be split up in multiple vertex buffers
    unsigned int loaded_attributes = 0;
    for(TiXmlElement* buffer_elem = geometry_elem->FirstChildElement("vertexbuffer"); buffer_elem != nullptr; buffer_elem = buffer_elem->NextSiblingElement("vertexbuffer"))
    {
        unsigned int attributes = 0;
        if(buffer_elem->Attribute("positions")) attributes |= POSITIONS;
        if(buffer_elem->Attribute("normals")) attributes |= NORMALS;
        if(buffer_elem->Attribute("texture_coords")) attributes |= TEXCOORDS;
 
        unsigned int i;
        TiXmlElement* vertex_elem;
        for (vertex_elem = buffer_elem->FirstChildElement("vertex"), i = 0; vertex_elem != nullptr && i < vertices.size(); vertex_elem = vertex_elem->NextSiblingElement("vertex"), ++i)
        {
            if(attributes & POSITIONS)
            {
                TiXmlElement* position_elem = RequireFirstChild(vertex_elem, "position");
 
                vertices[i].x = RequireFloatAttribute(position_elem, "x");
                vertices[i].y = RequireFloatAttribute(position_elem, "y");
                vertices[i].z = RequireFloatAttribute(position_elem, "z");
            }
 
            if(attributes & NORMALS)
            {
                TiXmlElement* normal_elem = RequireFirstChild(vertex_elem, "normal");
 
                vertices[i].nx = RequireFloatAttribute(normal_elem, "x");
                vertices[i].ny = RequireFloatAttribute(normal_elem, "y");
                vertices[i].nz = RequireFloatAttribute(normal_elem, "z");
            }
 
            if(attributes & TEXCOORDS)
            {
                // FIXME: The Ogre format supports denoting multiple texture coordinates, but the rendering code only supports one
                // currently only the first set is read, any additional ones are ignored
                TiXmlElement* texcoord_elem = RequireFirstChild(vertex_elem, "texcoord");
                vertices[i].u = RequireFloatAttribute(texcoord_elem, "u");
                vertices[i].v = RequireFloatAttribute(texcoord_elem, "v");
            }
 
            vertices[i] = OgreToClonk::TransformVertex(vertices[i]);
 
            if (attributes & POSITIONS)
            {
                const float d = std::sqrt(vertices[i].x*vertices[i].x
                                        + vertices[i].y*vertices[i].y
                                        + vertices[i].z*vertices[i].z);
 
                // Construct BoundingBox
                StdMeshBox& BoundingBox = mesh.BoundingBox;
                if (i == 0 && !hasVertices)
                {
                    // First vertex
                    BoundingBox.x1 = BoundingBox.x2 = vertices[i].x;
                    BoundingBox.y1 = BoundingBox.y2 = vertices[i].y;
                    BoundingBox.z1 = BoundingBox.z2 = vertices[i].z;
                    mesh.BoundingRadius = d;
                }
                else
                {
                    BoundingBox.x1 = std::min(vertices[i].x, BoundingBox.x1);
                    BoundingBox.x2 = std::max(vertices[i].x, BoundingBox.x2);
                    BoundingBox.y1 = std::min(vertices[i].y, BoundingBox.y1);
                    BoundingBox.y2 = std::max(vertices[i].y, BoundingBox.y2);
                    BoundingBox.z1 = std::min(vertices[i].z, BoundingBox.z1);
                    BoundingBox.z2 = std::max(vertices[i].z, BoundingBox.z2);
                    mesh.BoundingRadius = std::max(mesh.BoundingRadius, d);
                }
            }
        }
 
        if(vertex_elem != nullptr)
            Error(FormatString("Too many vertices in vertexbuffer"), buffer_elem);
        if(i < vertices.size())
            Error(FormatString("Not enough vertices in vertexbuffer"), buffer_elem);
 
        loaded_attributes |= attributes;
    }
 
    static const unsigned int REQUIRED_ATTRIBUTES = POSITIONS | NORMALS | TEXCOORDS;
    if((loaded_attributes & REQUIRED_ATTRIBUTES) != REQUIRED_ATTRIBUTES)
        Error(FormatString("Not all required vertex attributes (positions, normals, texcoords) present in mesh geometry"), geometry_elem);
}

References OgreToClonk::TransformVertex(), StdMeshBox::x1, StdMeshBox::x2, StdMeshBox::y1, StdMeshBox::y2, z, StdMeshBox::z1, and StdMeshBox::z2.

Referenced by StdMeshLoader::LoadMeshXml().

Here is the call graph for this function:

Here is the caller graph for this function:

RequireFirstChild()

TiXmlElement * StdMeshLoader::StdMeshXML::RequireFirstChild	(	TiXmlElement *	element,
		const char *	child
	)

Definition at line 78 of file StdMeshLoaderXml.cpp.

{
    TiXmlElement* retval;
 
    if (element)
    {
        retval = element->FirstChildElement(child);
        if (!retval)
            Error(FormatString("Element '%s' does not contain '%s' child", element->Value(), child), element);
    }
    else
    {
        retval = Document.RootElement();
        if (strcmp(retval->Value(), child) != 0)
            Error(FormatString("Root element is not '%s'", child), retval);
    }
 
    return retval;
}

Referenced by StdMeshLoader::LoadMeshXml().

Here is the caller graph for this function:

RequireFloatAttribute()

float StdMeshLoader::StdMeshXML::RequireFloatAttribute	(	TiXmlElement *	element,
		const char *	attribute
	)		const

Definition at line 70 of file StdMeshLoaderXml.cpp.

{
    float retval = 0;
    if (element->QueryFloatAttribute(attribute, &retval) != TIXML_SUCCESS)
        Error(FormatString("Element '%s' does not have floating point attribute '%s'", element->Value(), attribute), element);
    return retval;
}

RequireIntAttribute()

int StdMeshLoader::StdMeshXML::RequireIntAttribute	(	TiXmlElement *	element,
		const char *	attribute
	)		const

Definition at line 62 of file StdMeshLoaderXml.cpp.

{
    int retval;
    if (element->QueryIntAttribute(attribute, &retval) != TIXML_SUCCESS)
        Error(FormatString("Element '%s' does not have integer attribute '%s'", element->Value(), attribute), element);
    return retval;
}

Referenced by StdMeshLoader::LoadMeshXml().

Here is the caller graph for this function:

RequireStrAttribute()

const char * StdMeshLoader::StdMeshXML::RequireStrAttribute	(	TiXmlElement *	element,
		const char *	attribute
	)		const

Definition at line 55 of file StdMeshLoaderXml.cpp.

{
    const char* value = element->Attribute(attribute);
    if (!value) Error(FormatString("Element '%s' does not have attribute '%s'", element->Value(), attribute), element);
    return value;
}

Referenced by StdMeshLoader::LoadMeshXml().

Here is the caller graph for this function:

---

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

• StdMeshLoaderXml.cpp