minetest
/
minetest
mirror of https://github.com/minetest/minetest.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Move parsing methods into ModelParser class

This commit is contained in:
JosiahWI 2023-05-17 11:30:58 -05:00 committed by Josiah VanderZee
parent ca8d972982
commit 9e6c8fa80c
2 changed files with 120 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
source/Irrlicht/CGLTFMeshFileLoader.cpp
View File

@ -106,9 +106,13 @@ IAnimatedMesh* CGLTFMeshFileLoader::createMesh(io::IReadFile* file)
std::vector<u16> indicesBuffer(model.accessors[ std::vector<u16> indicesBuffer(model.accessors[
indicesAccessorId].count); indicesAccessorId].count);
getIndices(model, indicesAccessorId, indicesBuffer); ModelParser parser(model);
getVertices(model, positionAccessorId, verticesBuffer,
mesh_index, primitive_index); parser.getIndices(indicesAccessorId, indicesBuffer);
parser.getVertices(positionAccessorId,
verticesBuffer,
mesh_index,
primitive_index);
// Inverse the order of indices due to the axis of the model being // Inverse the order of indices due to the axis of the model being
// inverted when going from left handed to right handed coordinates // inverted when going from left handed to right handed coordinates
@ -131,8 +135,59 @@ IAnimatedMesh* CGLTFMeshFileLoader::createMesh(io::IReadFile* file)
return animatedMesh; return animatedMesh;
} }
CGLTFMeshFileLoader::ModelParser::ModelParser(
const tinygltf::Model& model)
: m_model(model)
{
}
void CGLTFMeshFileLoader::ModelParser::getIndices(
const std::size_t accessorId,
std::vector<u16>& outIndices) const
{
const auto& view = m_model.bufferViews[
m_model.accessors[accessorId].bufferView];
const auto& modelIndices = m_model.buffers[view.buffer];
auto buffOffset = BufferOffset(modelIndices.data, view.byteOffset);
auto count = m_model.accessors[accessorId].count;
for (std::size_t i = 0; i < count; i++) {
outIndices[i] = readPrimitive<u16>(BufferOffset(
buffOffset, i * sizeof(u16)));
}
}
//Returns a tuple of the current counts (current_vertex_index,
// current_normals_index, current_tcoords_index)
void CGLTFMeshFileLoader::ModelParser::getVertices(
const std::size_t accessorId,
Span<video::S3DVertex>& outVertices,
std::size_t meshIndex,
std::size_t primitiveIndex) const
{
copyPositions(outVertices, accessorId);
const auto normalsField = m_model.meshes[meshIndex]
.primitives[primitiveIndex].attributes.find("NORMAL");
if (normalsField != m_model.meshes[meshIndex]
.primitives[primitiveIndex].attributes.end()) {
copyNormals(outVertices, normalsField->second);
}
const auto tCoordsField = m_model.meshes[meshIndex]
.primitives[primitiveIndex].attributes.find("TEXCOORD_0");
if (tCoordsField != m_model.meshes[meshIndex]
.primitives[primitiveIndex].attributes.end()) {
copyTCoords(outVertices, tCoordsField->second);
}
}
template <typename T> template <typename T>
T CGLTFMeshFileLoader::readPrimitive(const BufferOffset& readFrom) T CGLTFMeshFileLoader::ModelParser::readPrimitive(
const BufferOffset& readFrom)
{ {
unsigned char d[sizeof(T)]{}; unsigned char d[sizeof(T)]{};
for (std::size_t i = 0; i < sizeof(T); ++i) { for (std::size_t i = 0; i < sizeof(T); ++i) {
@ -143,7 +198,7 @@ T CGLTFMeshFileLoader::readPrimitive(const BufferOffset& readFrom)
return dest; return dest;
} }
core::vector2df CGLTFMeshFileLoader::readVec2DF( core::vector2df CGLTFMeshFileLoader::ModelParser::readVec2DF(
const CGLTFMeshFileLoader::BufferOffset& readFrom) const CGLTFMeshFileLoader::BufferOffset& readFrom)
{ {
return core::vector2df(readPrimitive<float>(readFrom), return core::vector2df(readPrimitive<float>(readFrom),
@ -151,8 +206,8 @@ core::vector2df CGLTFMeshFileLoader::readVec2DF(
} }
core::vector3df CGLTFMeshFileLoader::readVec3DF( core::vector3df CGLTFMeshFileLoader::ModelParser::readVec3DF(
const CGLTFMeshFileLoader::BufferOffset& readFrom, const BufferOffset& readFrom,
const float scale = 1.0f) const float scale = 1.0f)
{ {
// glTF's coordinate system is right-handed, Irrlicht's is left-handed // glTF's coordinate system is right-handed, Irrlicht's is left-handed
@ -164,33 +219,33 @@ core::vector3df CGLTFMeshFileLoader::readVec3DF(
sizeof(float)))); sizeof(float))));
} }
void CGLTFMeshFileLoader::copyPositions(const tinygltf::Model& model, void CGLTFMeshFileLoader::ModelParser::copyPositions(
const Span<video::S3DVertex> vertices, const Span<video::S3DVertex> vertices,
const std::size_t accessorId) const std::size_t accessorId) const
{ {
const auto& view = model.bufferViews[ const auto& view = m_model.bufferViews[
model.accessors[accessorId].bufferView]; m_model.accessors[accessorId].bufferView];
const auto& buffer = model.buffers[view.buffer]; const auto& buffer = m_model.buffers[view.buffer];
const auto count = model.accessors[accessorId].count; const auto count = m_model.accessors[accessorId].count;
float scale = getScale(model);
for (std::size_t i = 0; i < count; i++) { for (std::size_t i = 0; i < count; i++) {
const auto v = readVec3DF(BufferOffset( const auto v = readVec3DF(BufferOffset(
buffer.data, view.byteOffset + (3 * sizeof(float) * i)),scale); buffer.data,
view.byteOffset + (3 * sizeof(float) * i)),
getScale());
vertices.buffer[i].Pos = v; vertices.buffer[i].Pos = v;
} }
} }
void CGLTFMeshFileLoader::copyNormals(const tinygltf::Model& model, void CGLTFMeshFileLoader::ModelParser::copyNormals(
const Span<video::S3DVertex> vertices, const Span<video::S3DVertex> vertices,
const std::size_t accessorId) const std::size_t accessorId) const
{ {
const auto& view = model.bufferViews[ const auto& view = m_model.bufferViews[
model.accessors[accessorId].bufferView]; m_model.accessors[accessorId].bufferView];
const auto& buffer = model.buffers[view.buffer]; const auto& buffer = m_model.buffers[view.buffer];
const auto count = model.accessors[accessorId].count; const auto count = m_model.accessors[accessorId].count;
for (std::size_t i = 0; i < count; i++) { for (std::size_t i = 0; i < count; i++) {
const auto n = readVec3DF(BufferOffset( buffer.data, const auto n = readVec3DF(BufferOffset( buffer.data,
@ -199,14 +254,14 @@ void CGLTFMeshFileLoader::copyNormals(const tinygltf::Model& model,
} }
} }
void CGLTFMeshFileLoader::copyTCoords(const tinygltf::Model& model, void CGLTFMeshFileLoader::ModelParser::copyTCoords(
const Span<video::S3DVertex> vertices, const Span<video::S3DVertex> vertices,
const std::size_t accessorId) const std::size_t accessorId) const
{ {
const auto& view = model.bufferViews[ const auto& view = m_model.bufferViews[
model.accessors[accessorId].bufferView]; m_model.accessors[accessorId].bufferView];
const auto& buffer = model.buffers[view.buffer]; const auto& buffer = m_model.buffers[view.buffer];
const auto count = model.accessors[accessorId].count; const auto count = m_model.accessors[accessorId].count;
for (std::size_t i = 0; i < count; ++i) { for (std::size_t i = 0; i < count; ++i) {
const auto t = readVec2DF(BufferOffset( const auto t = readVec2DF(BufferOffset(
@ -215,48 +270,13 @@ void CGLTFMeshFileLoader::copyTCoords(const tinygltf::Model& model,
} }
} }
void CGLTFMeshFileLoader::getIndices(const tinygltf::Model& model, float CGLTFMeshFileLoader::ModelParser::getScale() const
const std::size_t accessorId,
std::vector<u16>& indicesBuffer)
{ {
const auto& view = model.bufferViews[ if (m_model.nodes[0].scale.size() > 0) {
model.accessors[accessorId].bufferView]; return static_cast<float>(m_model.nodes[0].scale[0]);
const auto& modelIndices = model.buffers[view.buffer];
auto buffOffset = BufferOffset(modelIndices.data, view.byteOffset);
auto count = model.accessors[accessorId].count;
for (std::size_t i = 0; i < count; i++) {
indicesBuffer[i] = readPrimitive<u16>(BufferOffset(
buffOffset, i * sizeof(u16)));
} }
}
//Returns a tuple of the current counts (current_vertex_index, return 1.0f;
// current_normals_index, current_tcoords_index)
void CGLTFMeshFileLoader::getVertices(const tinygltf::Model& model,
const std::size_t accessorId,
Span<video::S3DVertex>& verticesBuffer,
std::size_t mesh_index,
std::size_t primitive_index)
{
copyPositions(model, verticesBuffer, accessorId);
const auto normalsField = model.meshes[mesh_index]
.primitives[primitive_index].attributes.find("NORMAL");
if (normalsField != model.meshes[mesh_index]
.primitives[primitive_index].attributes.end()) {
copyNormals(model, verticesBuffer, normalsField->second);
}
const auto tCoordsField = model.meshes[mesh_index]
.primitives[primitive_index].attributes.find("TEXCOORD_0");
if (tCoordsField != model.meshes[mesh_index]
.primitives[primitive_index].attributes.end()) {
copyTCoords(model, verticesBuffer, tCoordsField->second);
}
} }
bool CGLTFMeshFileLoader::tryParseGLTF(io::IReadFile* file, bool CGLTFMeshFileLoader::tryParseGLTF(io::IReadFile* file,
@ -281,14 +301,6 @@ bool CGLTFMeshFileLoader::tryParseGLTF(io::IReadFile* file,
file->getSize(), "", 1); file->getSize(), "", 1);
} }
float CGLTFMeshFileLoader::getScale(const tinygltf::Model& model)
{
if (model.nodes[0].scale.size() > 0) {
return static_cast<float>(model.nodes[0].scale[0]);
}
return 1.0f;
}
} // namespace scene } // namespace scene
} // namespace irr } // namespace irr

62
source/Irrlicht/CGLTFMeshFileLoader.h
View File

@ -4,6 +4,7 @@
#include "IAnimatedMesh.h" #include "IAnimatedMesh.h"
#include "IMeshLoader.h" #include "IMeshLoader.h"
#include "IReadFile.h" #include "IReadFile.h"
#include "irrTypes.h"
#include "path.h" #include "path.h"
#include "S3DVertex.h" #include "S3DVertex.h"
#include "vector2d.h" #include "vector2d.h"
@ -53,42 +54,45 @@ private:
int m_filesize; int m_filesize;
}; };
template <typename T> class ModelParser {
static T readPrimitive(const BufferOffset& readFrom); public:
ModelParser(const tinygltf::Model& model);
static core::vector2df readVec2DF( void getIndices(const std::size_t accessorId,
const BufferOffset& readFrom); std::vector<u16>& outIndices) const;
static core::vector3df readVec3DF( void getVertices(const std::size_t accessorId,
const BufferOffset& readFrom,
const float scale);
static void copyPositions(const tinygltf::Model& model,
const Span<video::S3DVertex> vertices,
const std::size_t accessorId);
static void copyNormals(const tinygltf::Model& model,
const Span<video::S3DVertex> vertices,
const std::size_t accessorId);
static void copyTCoords(const tinygltf::Model& model,
const Span<video::S3DVertex> vertices,
const std::size_t accessorId);
static void getIndices(const tinygltf::Model& model,
const std::size_t accessorId,
std::vector<u16>& indicesBuffer);
static void getVertices(const tinygltf::Model& model,
const std::size_t accessorId,
Span<video::S3DVertex>& outVertices, Span<video::S3DVertex>& outVertices,
std::size_t meshIndex, std::size_t meshIndex,
std::size_t primitiveIndex); std::size_t primitiveIndex) const;
private:
tinygltf::Model m_model;
template <typename T>
static T readPrimitive(const BufferOffset& readFrom);
static core::vector2df readVec2DF(
const BufferOffset& readFrom);
static core::vector3df readVec3DF(
const BufferOffset& readFrom,
const float scale);
void copyPositions(const Span<video::S3DVertex> vertices,
const std::size_t accessorId) const;
void copyNormals(const Span<video::S3DVertex> vertices,
const std::size_t accessorId) const;
void copyTCoords(const Span<video::S3DVertex> vertices,
const std::size_t accessorId) const;
float getScale() const;
};
static bool tryParseGLTF(io::IReadFile* file, static bool tryParseGLTF(io::IReadFile* file,
tinygltf::Model& model); tinygltf::Model& model);
static float getScale(const tinygltf::Model& model);
}; };
} // namespace scene } // namespace scene