minetest/irrlicht
1
0
Fork 0
mirror of https://github.com/minetest/irrlicht.git synced 2025-02-22 13:50:25 +01:00
Code Issues Projects Releases Wiki Activity

Return vector from getVertices

Browse Source
This commit is contained in:
JosiahWI 2023-05-17 17:19:57 -05:00 committed by Josiah VanderZee
parent ea22b642c1
commit 60a5f5746f
2 changed files with 42 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
source/Irrlicht/CGLTFMeshFileLoader.cpp
View File

@ -86,44 +86,26 @@ IAnimatedMesh* CGLTFMeshFileLoader::createMesh(io::IReadFile* file)
{ {
tinygltf::Model model {}; tinygltf::Model model {};
if (file->getSize() == 0 || !tryParseGLTF(file, model)) { if (file->getSize() <= 0 || !tryParseGLTF(file, model)) {
return nullptr; return nullptr;
} }
ModelParser parser(std::move(model)); ModelParser parser(std::move(model));
SMesh* baseMesh(new SMesh {}); SMesh* baseMesh(new SMesh {});
// Iterate models for (std::size_t i = 0; i < parser.getMeshCount(); ++i) {
for (std::size_t meshIndex = 0; for (std::size_t j = 0; j < parser.getPrimitiveCount(i); ++j) {
meshIndex < parser.getMeshCount(); meshIndex++) { auto indices = parser.getIndices(i, j);
// Iterate primitives auto vertices = parser.getVertices(i, j);
for (std::size_t primitiveIndex = 0; primitiveIndex < parser.getPrimitiveCount(meshIndex); primitiveIndex++) {
const auto positionAccessorId = model.meshes[meshIndex]
.primitives[primitiveIndex].attributes["POSITION"];
// Creates counts for preallocation
std::size_t vertexCount = model.accessors[positionAccessorId].count;
// We must count to create containers for the data
// Create new buffer for vertices, positions, and normals
auto* vertexBuffer = new video::S3DVertex[vertexCount]();
// This is used to copy data into the vertexBuffer
Span<video::S3DVertex> verticesBuffer{vertexBuffer,vertexCount};
auto indices = parser.getIndices(meshIndex, primitiveIndex);
parser.getVertices(positionAccessorId,
verticesBuffer,
meshIndex,
primitiveIndex);
SMeshBuffer* meshbuf(new SMeshBuffer {}); SMeshBuffer* meshbuf(new SMeshBuffer {});
meshbuf->append(vertexBuffer, vertexCount, meshbuf->append(vertices.data(), vertices.size(),
indices.data(), indices.size()); indices.data(), indices.size());
baseMesh->addMeshBuffer(meshbuf); baseMesh->addMeshBuffer(meshbuf);
} }
} }
// Create the mesh animations SAnimatedMesh* animatedMesh(new SAnimatedMesh {});
SAnimatedMesh* animatedMesh { new SAnimatedMesh {} };
animatedMesh->addMesh(baseMesh); animatedMesh->addMesh(baseMesh);
return animatedMesh; return animatedMesh;
@ -159,31 +141,36 @@ std::vector<u16> CGLTFMeshFileLoader::ModelParser::getIndices(
return indices; return indices;
} }
//Returns a tuple of the current counts (current_vertex_index, std::vector<video::S3DVertex> CGLTFMeshFileLoader::ModelParser::getVertices(
// current_normals_index, current_tcoords_index) std::size_t meshIdx,
void CGLTFMeshFileLoader::ModelParser::getVertices( std::size_t primitiveIdx) const
const std::size_t accessorId,
Span<video::S3DVertex>& outVertices,
std::size_t meshIndex,
std::size_t primitiveIndex) const
{ {
copyPositions(outVertices, accessorId); auto positionAccessorIdx = getPositionAccessorIdx(meshIdx, primitiveIdx);
auto vertexCount = getElemCount(positionAccessorIdx);
std::vector<video::S3DVertex> vertices{};
vertices.resize(vertexCount);
const auto normalsField = m_model.meshes[meshIndex] Span<video::S3DVertex> outVertices {vertices.data(), vertexCount};
.primitives[primitiveIndex].attributes.find("NORMAL");
if (normalsField != m_model.meshes[meshIndex] copyPositions(outVertices, positionAccessorIdx);
.primitives[primitiveIndex].attributes.end()) {
const auto normalsField = m_model.meshes[meshIdx]
.primitives[primitiveIdx].attributes.find("NORMAL");
if (normalsField != m_model.meshes[meshIdx]
.primitives[primitiveIdx].attributes.end()) {
copyNormals(outVertices, normalsField->second); copyNormals(outVertices, normalsField->second);
} }
const auto tCoordsField = m_model.meshes[meshIndex] const auto tCoordsField = m_model.meshes[meshIdx]
.primitives[primitiveIndex].attributes.find("TEXCOORD_0"); .primitives[primitiveIdx].attributes.find("TEXCOORD_0");
if (tCoordsField != m_model.meshes[meshIndex] if (tCoordsField != m_model.meshes[meshIdx]
.primitives[primitiveIndex].attributes.end()) { .primitives[primitiveIdx].attributes.end()) {
copyTCoords(outVertices, tCoordsField->second); copyTCoords(outVertices, tCoordsField->second);
} }
return vertices;
} }
std::size_t CGLTFMeshFileLoader::ModelParser::getMeshCount() const std::size_t CGLTFMeshFileLoader::ModelParser::getMeshCount() const
@ -315,6 +302,14 @@ std::size_t CGLTFMeshFileLoader::ModelParser::getIndicesAccessorIdx(
return m_model.meshes[meshIdx].primitives[primitiveIdx].indices; return m_model.meshes[meshIdx].primitives[primitiveIdx].indices;
} }
std::size_t CGLTFMeshFileLoader::ModelParser::getPositionAccessorIdx(
std::size_t meshIdx,
std::size_t primitiveIdx) const
{
return m_model.meshes[meshIdx].primitives[primitiveIdx]
.attributes.find("POSITION")->second;
}
bool CGLTFMeshFileLoader::tryParseGLTF(io::IReadFile* file, bool CGLTFMeshFileLoader::tryParseGLTF(io::IReadFile* file,
tinygltf::Model& model) tinygltf::Model& model)
{ {

10
source/Irrlicht/CGLTFMeshFileLoader.h
View File

@ -67,12 +67,11 @@ private:
std::vector<u16> getIndices(std::size_t meshIdx, std::vector<u16> getIndices(std::size_t meshIdx,
std::size_t primitiveIdx) const; std::size_t primitiveIdx) const;
void getVertices(const std::size_t accessorId, std::vector<video::S3DVertex> getVertices(std::size_t meshIdx,
Span<video::S3DVertex>& outVertices, std::size_t primitiveIdx) const;
std::size_t meshIndex,
std::size_t primitiveIndex) const;
std::size_t getMeshCount() const; std::size_t getMeshCount() const;
std::size_t getPrimitiveCount(std::size_t meshIdx) const; std::size_t getPrimitiveCount(std::size_t meshIdx) const;
private: private:
@ -107,6 +106,9 @@ private:
std::size_t getIndicesAccessorIdx(std::size_t meshIdx, std::size_t getIndicesAccessorIdx(std::size_t meshIdx,
std::size_t primitiveIdx) const; std::size_t primitiveIdx) const;
std::size_t getPositionAccessorIdx(std::size_t meshIdx,
std::size_t primitiveIdx) const;
}; };
static bool tryParseGLTF(io::IReadFile* file, static bool tryParseGLTF(io::IReadFile* file,