mxvk::anonymous_namespace{mxvk_model.cpp} Namespace Reference

Classes
struct	MXMODParseResult
struct	OBJFaceVertex
struct	OBJIndex
struct	Vec2
struct	Vec3

Functions
void	appendOBJTriangle (std::vector< VKVertex > &vertices, OBJFaceVertex a, OBJFaceVertex b, OBJFaceVertex c)
void	assignNormalIfMissing (OBJFaceVertex &a, OBJFaceVertex &b, OBJFaceVertex &c)
float	edgeCross2 (const VKVertex &a, const VKVertex &b, const VKVertex &c, int dropAxis)
Vec3	faceNormal (const VKVertex &a, const VKVertex &b, const VKVertex &c)
std::string	inflateCompressedText (const std::vector< unsigned char > &compressedData)
void	logMXModelStep (const std::string &message, bool important=false)
std::string	materialNameForTextureIndex (uint32_t textureIndex, const std::vector< MXMaterial > &materials)
std::string	mtlReferencePath (const std::string &objPath, const std::string &mtlPath)
std::string	mtlTextureReferencePath (const std::filesystem::path &mtlPath, const std::string &texturePath)
void	parseMTLStream (std::istream &file, const std::string &textureBasePath, std::vector< MXMaterial > &materials)
std::string	parseMTLTexturePath (std::istream &stream)
MXMODParseResult	parseMXMODStream (std::istream &file, const std::string &sourcePath, float positionScale)
bool	parseOBJFaceToken (const std::string &token, OBJIndex &index)
bool	parseOBJIndexValue (const std::string &text, int &value)
bool	pointInProjectedTriangle (const VKVertex &point, const VKVertex &a, const VKVertex &b, const VKVertex &c, int dropAxis, float windingSign)
float	projectedArea2 (const std::vector< OBJFaceVertex > &face, int dropAxis)
std::string	resolveManifestPath (const std::string &basePath, const std::string &path)
template<typename T>
int	resolveOBJIndex (int objIndex, const std::vector< T > &values)
void	stripTrailingComment (std::string &s)
void	triangulateOBJFace (const std::vector< OBJFaceVertex > &face, std::vector< VKVertex > &vertices)
void	trim (std::string &s)
void	writeMTLMaterial (std::ostream &out, const MXMaterial &material)

Function Documentation

appendOBJTriangle()

void mxvk::anonymous_namespace{mxvk_model.cpp}::appendOBJTriangle	(	std::vector< VKVertex > &	vertices,
		OBJFaceVertex	a,
		OBJFaceVertex	b,
		OBJFaceVertex	c )

Definition at line 222 of file mxvk_model.cpp.

                                                                                                                 {
            assignNormalIfMissing(a, b, c);
            vertices.push_back(a.vertex);
            vertices.push_back(b.vertex);
            vertices.push_back(c.vertex);
        }

assignNormalIfMissing()

void mxvk::anonymous_namespace{mxvk_model.cpp}::assignNormalIfMissing	(	OBJFaceVertex &	a,
		OBJFaceVertex &	b,
		OBJFaceVertex &	c )

Definition at line 173 of file mxvk_model.cpp.

                                                                                         {
            if (a.hasNormal && b.hasNormal && c.hasNormal) {
                return;
            }
 
            const Vec3 normal = faceNormal(a.vertex, b.vertex, c.vertex);
            for (OBJFaceVertex *faceVertex : {&a, &b, &c}) {
                if (faceVertex->hasNormal) {
                    continue;
                }
                faceVertex->vertex.normal[0] = normal.x;
                faceVertex->vertex.normal[1] = normal.y;
                faceVertex->vertex.normal[2] = normal.z;
                faceVertex->hasNormal = true;
            }
        }

edgeCross2()

float mxvk::anonymous_namespace{mxvk_model.cpp}::edgeCross2 ( const VKVertex & a, const VKVertex & b, const VKVertex & c, int dropAxis )

nodiscard

Definition at line 204 of file mxvk_model.cpp.

                                                                                                              {
            const float ax = a.pos[(dropAxis + 1) % 3];
            const float ay = a.pos[(dropAxis + 2) % 3];
            const float bx = b.pos[(dropAxis + 1) % 3];
            const float by = b.pos[(dropAxis + 2) % 3];
            const float cx = c.pos[(dropAxis + 1) % 3];
            const float cy = c.pos[(dropAxis + 2) % 3];
            return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
        }

faceNormal()

Vec3 mxvk::anonymous_namespace{mxvk_model.cpp}::faceNormal ( const VKVertex & a, const VKVertex & b, const VKVertex & c )

nodiscard

Definition at line 151 of file mxvk_model.cpp.

                                                                                               {
            const float ax = b.pos[0] - a.pos[0];
            const float ay = b.pos[1] - a.pos[1];
            const float az = b.pos[2] - a.pos[2];
            const float bx = c.pos[0] - a.pos[0];
            const float by = c.pos[1] - a.pos[1];
            const float bz = c.pos[2] - a.pos[2];
 
            Vec3 normal{
                ay * bz - az * by,
                az * bx - ax * bz,
                ax * by - ay * bx,
            };
            const float len = std::sqrt(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z);
            if (len > 0.0f) {
                normal.x /= len;
                normal.y /= len;
                normal.z /= len;
            }
            return normal;
        }

inflateCompressedText()

std::string mxvk::anonymous_namespace{mxvk_model.cpp}::inflateCompressedText ( const std::vector< unsigned char > & compressedData )

nodiscard

Definition at line 304 of file mxvk_model.cpp.

                                                                                                      {
            z_stream stream{};
            stream.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(compressedData.data()));
            stream.avail_in = static_cast<uInt>(compressedData.size());
 
            if (inflateInit2(&stream, 15 + 32) != Z_OK) {
                throw mxvk::Exception("MXModel::loadMXMODZ failed to initialize zlib inflater");
            }
 
            std::string output{};
            std::array<char, 16384> buffer{};
 
            int result = Z_OK;
            while (result != Z_STREAM_END) {
                stream.next_out = reinterpret_cast<Bytef *>(buffer.data());
                stream.avail_out = static_cast<uInt>(buffer.size());
 
                result = inflate(&stream, Z_NO_FLUSH);
                if (result != Z_OK && result != Z_STREAM_END) {
                    inflateEnd(&stream);
                    throw mxvk::Exception("MXModel::loadMXMODZ failed to inflate compressed data");
                }
 
                const size_t producedBytes = buffer.size() - static_cast<size_t>(stream.avail_out);
                output.append(buffer.data(), producedBytes);
            }
 
            inflateEnd(&stream);
 
            if (output.empty()) {
                throw mxvk::Exception("MXModel::loadMXMODZ produced empty decompressed payload");
            }
 
            return output;
        }

logMXModelStep()

void mxvk::anonymous_namespace{mxvk_model.cpp}::logMXModelStep	(	const std::string &	message,
		bool	important = false )

Definition at line 48 of file mxvk_model.cpp.

                                                                            {
            if (important) {
                std::cout << "mxvk_model: " << message << '\n';
            }
        }

materialNameForTextureIndex()

std::string mxvk::anonymous_namespace{mxvk_model.cpp}::materialNameForTextureIndex ( uint32_t textureIndex, const std::vector< MXMaterial > & materials )

nodiscard

Definition at line 443 of file mxvk_model.cpp.

                                                                                                                           {
            if (textureIndex < static_cast<uint32_t>(materials.size()) && !materials[textureIndex].name.empty()) {
                return materials[textureIndex].name;
            }
            return "material_" + std::to_string(textureIndex);
        }

mtlReferencePath()

std::string mxvk::anonymous_namespace{mxvk_model.cpp}::mtlReferencePath ( const std::string & objPath, const std::string & mtlPath )

nodiscard

Definition at line 427 of file mxvk_model.cpp.

                                                                                                     {
            const std::filesystem::path objDir = std::filesystem::path(objPath).parent_path();
            const std::filesystem::path materialPath(mtlPath);
            if (objDir.empty()) {
                return materialPath.filename().string();
            }
 
            std::error_code ec{};
            const std::filesystem::path relative = std::filesystem::relative(materialPath, objDir, ec);
            if (!ec && !relative.empty()) {
                return relative.string();
            }
 
            return materialPath.filename().string();
        }

mtlTextureReferencePath()

std::string mxvk::anonymous_namespace{mxvk_model.cpp}::mtlTextureReferencePath ( const std::filesystem::path & mtlPath, const std::string & texturePath )

nodiscard

Definition at line 450 of file mxvk_model.cpp.

                                                                                                                        {
            if (texturePath.empty()) {
                return {};
            }
 
            std::filesystem::path resolvedTexturePath(texturePath);
            if (resolvedTexturePath.is_relative()) {
                resolvedTexturePath = std::filesystem::absolute(resolvedTexturePath);
            }
 
            std::filesystem::path mtlDir = mtlPath.parent_path();
            if (mtlDir.empty()) {
                mtlDir = std::filesystem::current_path();
            } else if (mtlDir.is_relative()) {
                mtlDir = std::filesystem::absolute(mtlDir);
            }
 
            std::error_code ec{};
            const std::filesystem::path relative = std::filesystem::relative(resolvedTexturePath, mtlDir, ec);
            if (!ec && !relative.empty()) {
                return relative.string();
            }
 
            return resolvedTexturePath.lexically_normal().string();
        }

parseMTLStream()

void mxvk::anonymous_namespace{mxvk_model.cpp}::parseMTLStream	(	std::istream &	file,
		const std::string &	textureBasePath,
		std::vector< MXMaterial > &	materials )

Definition at line 381 of file mxvk_model.cpp.

                                                                                                                  {
            MXMaterial *current = nullptr;
            std::string line{};
            while (std::getline(file, line)) {
                stripTrailingComment(line);
                if (line.empty()) {
                    continue;
                }
 
                std::istringstream stream(line);
                std::string tag{};
                stream >> tag;
 
                if (tag == "newmtl") {
                    materials.emplace_back();
                    current = &materials.back();
                    std::getline(stream, current->name);
                    trim(current->name);
                    continue;
                }
 
                if (current == nullptr) {
                    continue;
                }
 
                if (tag == "Ka") {
                    stream >> current->ka[0] >> current->ka[1] >> current->ka[2];
                } else if (tag == "Kd") {
                    stream >> current->kd[0] >> current->kd[1] >> current->kd[2];
                } else if (tag == "Ks") {
                    stream >> current->ks[0] >> current->ks[1] >> current->ks[2];
                } else if (tag == "Ns") {
                    stream >> current->ns;
                } else if (tag == "d") {
                    stream >> current->d;
                } else if (tag == "illum") {
                    stream >> current->illum;
                } else if (tag == "map_Kd") {
                    const std::string mapPath = parseMTLTexturePath(stream);
                    if (!mapPath.empty()) {
                        current->map_kd = resolveManifestPath(textureBasePath, mapPath);
                    }
                }
            }
        }

parseMTLTexturePath()

std::string mxvk::anonymous_namespace{mxvk_model.cpp}::parseMTLTexturePath ( std::istream & stream )

nodiscard

Definition at line 353 of file mxvk_model.cpp.

                                                                        {
            std::string mapPath{};
            std::string mapToken{};
            while (stream >> mapToken) {
                if (!mapToken.empty() && mapToken[0] == '-') {
                    if (mapToken == "-blendu" || mapToken == "-blendv" || mapToken == "-cc" || mapToken == "-clamp" || mapToken == "-imfchan" || mapToken == "-type") {
                        stream >> mapToken;
                    } else if (mapToken == "-mm") {
                        stream >> mapToken;
                        stream >> mapToken;
                    } else if (mapToken == "-o" || mapToken == "-s" || mapToken == "-t") {
                        stream >> mapToken;
                        stream >> mapToken;
                        stream >> mapToken;
                    } else if (mapToken == "-bm" || mapToken == "-boost" || mapToken == "-texres") {
                        stream >> mapToken;
                    }
                    continue;
                }
 
                if (!mapPath.empty()) {
                    mapPath += ' ';
                }
                mapPath += mapToken;
            }
            return mapPath;
        }

parseMXMODStream()

MXMODParseResult mxvk::anonymous_namespace{mxvk_model.cpp}::parseMXMODStream ( std::istream & file, const std::string & sourcePath, float positionScale )

nodiscard

Definition at line 490 of file mxvk_model.cpp.

                                                                                                                            {
            struct TriBlock {
                uint32_t textureIndex = 0;
                std::vector<Vec3> pos{};
                std::vector<Vec2> uv{};
                std::vector<Vec3> nrm{};
                std::vector<uint32_t> fileIndices{};
            };
 
            std::vector<TriBlock> triBlocks{};
            TriBlock *current = nullptr;
            int sectionType = -1;
 
            std::string line{};
            while (std::getline(file, line)) {
                stripTrailingComment(line);
                if (line.empty()) {
                    continue;
                }
 
                std::istringstream stream(line);
                const char c = line[line.find_first_not_of(" \t")];
                const bool isData = (c >= '0' && c <= '9') || c == '-' || c == '+' || c == '.';
 
                if (isData && current != nullptr) {
                    float x = 0.0f;
                    float y = 0.0f;
                    float z = 0.0f;
 
                    switch (sectionType) {
                    case 0:
                        if (stream >> x >> y >> z) {
                            current->pos.push_back({x * positionScale, y * positionScale, z * positionScale});
                        }
                        break;
                    case 1:
                        if (stream >> x >> y) {
                            current->uv.push_back({x, y});
                        }
                        break;
                    case 2:
                        if (stream >> x >> y >> z) {
                            current->nrm.push_back({x, y, z});
                        }
                        break;
                    case 5: {
                        uint32_t idx = 0;
                        while (stream >> idx) {
                            current->fileIndices.push_back(idx);
                        }
                    } break;
                    default:
                        break;
                    }
 
                    continue;
                }
 
                std::string tag{};
                stream >> tag;
                if (tag == "tri") {
                    uint32_t surfaceType = 0;
                    uint32_t textureIndex = 0;
                    stream >> surfaceType >> textureIndex;
                    static_cast<void>(surfaceType);
                    triBlocks.emplace_back();
                    current = &triBlocks.back();
                    current->textureIndex = textureIndex;
                    sectionType = -1;
                    continue;
                }
 
                if (tag == "vert") {
                    sectionType = 0;
                    continue;
                }
                if (tag == "tex") {
                    sectionType = 1;
                    continue;
                }
                if (tag == "norm") {
                    sectionType = 2;
                    continue;
                }
                if (tag == "indices") {
                    sectionType = 5;
                    continue;
                }
            }
 
            if (triBlocks.empty()) {
                throw mxvk::Exception("MXModel::loadMXMOD no geometry found in " + sourcePath);
            }
 
            MXMODParseResult parsed{};
            for (const TriBlock &blk : triBlocks) {
                if (blk.pos.empty()) {
                    continue;
                }
 
                const uint32_t vertexBase = static_cast<uint32_t>(parsed.vertices.size());
                for (size_t i = 0; i < blk.pos.size(); ++i) {
                    VKVertex v{};
                    v.pos[0] = blk.pos[i].x;
                    v.pos[1] = blk.pos[i].y;
                    v.pos[2] = blk.pos[i].z;
 
                    if (i < blk.uv.size()) {
                        v.texCoord[0] = blk.uv[i].x;
                        v.texCoord[1] = blk.uv[i].y;
                    }
                    if (i < blk.nrm.size()) {
                        v.normal[0] = blk.nrm[i].x;
                        v.normal[1] = blk.nrm[i].y;
                        v.normal[2] = blk.nrm[i].z;
                    }
 
                    parsed.vertices.push_back(v);
                }
 
                const uint32_t firstIndex = static_cast<uint32_t>(parsed.indices.size());
                if (!blk.fileIndices.empty()) {
                    for (uint32_t idx : blk.fileIndices) {
                        parsed.indices.push_back(vertexBase + idx);
                    }
                } else {
                    for (uint32_t i = 0; i < static_cast<uint32_t>(blk.pos.size()); ++i) {
                        parsed.indices.push_back(vertexBase + i);
                    }
                }
 
                SubMesh sm{};
                sm.firstIndex = firstIndex;
                sm.indexCount = static_cast<uint32_t>(parsed.indices.size()) - firstIndex;
                sm.textureIndex = blk.textureIndex;
                parsed.subMeshes.push_back(sm);
            }
 
            if (parsed.vertices.empty() || parsed.indices.empty()) {
                throw mxvk::Exception("MXModel::loadMXMOD no renderable data found in " + sourcePath);
            }
 
            return parsed;
        }

parseOBJFaceToken()

bool mxvk::anonymous_namespace{mxvk_model.cpp}::parseOBJFaceToken ( const std::string & token, OBJIndex & index )

nodiscard

Definition at line 116 of file mxvk_model.cpp.

                                                                                      {
            std::array<std::string, 3> fields{};
            size_t fieldIndex = 0;
            size_t fieldBegin = 0;
 
            while (true) {
                if (fieldIndex >= fields.size()) {
                    return false;
                }
 
                const size_t slashPos = token.find('/', fieldBegin);
                fields[fieldIndex++] = token.substr(fieldBegin, slashPos == std::string::npos ? std::string::npos : slashPos - fieldBegin);
                if (slashPos == std::string::npos) {
                    break;
                }
                fieldBegin = slashPos + 1;
            }
 
            if (!parseOBJIndexValue(fields[0], index.position) || !parseOBJIndexValue(fields[1], index.texcoord) || !parseOBJIndexValue(fields[2], index.normal)) {
                return false;
            }
 
            return index.position != 0;
        }

parseOBJIndexValue()

bool mxvk::anonymous_namespace{mxvk_model.cpp}::parseOBJIndexValue ( const std::string & text, int & value )

nodiscard

Definition at line 100 of file mxvk_model.cpp.

                                                                                 {
            if (text.empty()) {
                value = 0;
                return true;
            }
 
            size_t consumed = 0;
            try {
                value = std::stoi(text, &consumed, 10);
            } catch (const std::exception &) {
                return false;
            }
 
            return consumed == text.size();
        }

pointInProjectedTriangle()

bool mxvk::anonymous_namespace{mxvk_model.cpp}::pointInProjectedTriangle ( const VKVertex & point, const VKVertex & a, const VKVertex & b, const VKVertex & c, int dropAxis, float windingSign )

nodiscard

Definition at line 214 of file mxvk_model.cpp.

                                                                                                                                                                     {
            constexpr float epsilon = 1e-6f;
            const float ab = edgeCross2(a, b, point, dropAxis) * windingSign;
            const float bc = edgeCross2(b, c, point, dropAxis) * windingSign;
            const float ca = edgeCross2(c, a, point, dropAxis) * windingSign;
            return ab >= -epsilon && bc >= -epsilon && ca >= -epsilon;
        }

projectedArea2()

float mxvk::anonymous_namespace{mxvk_model.cpp}::projectedArea2 ( const std::vector< OBJFaceVertex > & face, int dropAxis )

nodiscard

Definition at line 190 of file mxvk_model.cpp.

                                                                                               {
            float area = 0.0f;
            for (size_t i = 0; i < face.size(); ++i) {
                const VKVertex &a = face[i].vertex;
                const VKVertex &b = face[(i + 1) % face.size()].vertex;
                const float ax = a.pos[(dropAxis + 1) % 3];
                const float ay = a.pos[(dropAxis + 2) % 3];
                const float bx = b.pos[(dropAxis + 1) % 3];
                const float by = b.pos[(dropAxis + 2) % 3];
                area += ax * by - bx * ay;
            }
            return area;
        }

resolveManifestPath()

std::string mxvk::anonymous_namespace{mxvk_model.cpp}::resolveManifestPath ( const std::string & basePath, const std::string & path )

nodiscard

Definition at line 340 of file mxvk_model.cpp.

                                                                                                      {
            if (path.empty()) {
                return {};
            }
 
            std::filesystem::path resolved(path);
            if (resolved.is_absolute() || basePath.empty()) {
                return resolved.lexically_normal().string();
            }
 
            return (std::filesystem::path(basePath) / resolved).lexically_normal().string();
        }

resolveOBJIndex()

template<typename T>

int mxvk::anonymous_namespace{mxvk_model.cpp}::resolveOBJIndex ( int objIndex, const std::vector< T > & values )

nodiscard

Definition at line 141 of file mxvk_model.cpp.

                                                                                                          {
            if (objIndex > 0) {
                return objIndex - 1;
            }
            if (objIndex < 0) {
                return static_cast<int>(values.size()) + objIndex;
            }
            return -1;
        }

stripTrailingComment()

void mxvk::anonymous_namespace{mxvk_model.cpp}::stripTrailingComment

(

std::string &

s

)

Definition at line 92 of file mxvk_model.cpp.

                                                {
            const size_t commentPos = s.find('#');
            if (commentPos != std::string::npos) {
                s = s.substr(0, commentPos);
            }
            trim(s);
        }

triangulateOBJFace()

void mxvk::anonymous_namespace{mxvk_model.cpp}::triangulateOBJFace	(	const std::vector< OBJFaceVertex > &	face,
		std::vector< VKVertex > &	vertices )

Definition at line 229 of file mxvk_model.cpp.

                                                                                                     {
            if (face.size() < 3) {
                return;
            }
 
            if (face.size() == 3) {
                appendOBJTriangle(vertices, face[0], face[1], face[2]);
                return;
            }
 
            const Vec3 normal = faceNormal(face[0].vertex, face[1].vertex, face[2].vertex);
            int dropAxis = 0;
            if (std::fabs(normal.y) > std::fabs(normal.x) && std::fabs(normal.y) >= std::fabs(normal.z)) {
                dropAxis = 1;
            } else if (std::fabs(normal.z) > std::fabs(normal.x) && std::fabs(normal.z) > std::fabs(normal.y)) {
                dropAxis = 2;
            }
 
            float windingSign = projectedArea2(face, dropAxis) >= 0.0f ? 1.0f : -1.0f;
            if (std::fabs(projectedArea2(face, dropAxis)) <= 1e-6f) {
                for (size_t i = 2; i < face.size(); ++i) {
                    appendOBJTriangle(vertices, face[0], face[i - 1], face[i]);
                }
                return;
            }
 
            std::vector<size_t> remaining(face.size());
            for (size_t i = 0; i < remaining.size(); ++i) {
                remaining[i] = i;
            }
 
            while (remaining.size() > 3) {
                bool clippedEar = false;
                for (size_t i = 0; i < remaining.size(); ++i) {
                    const size_t previous = remaining[(i + remaining.size() - 1) % remaining.size()];
                    const size_t current = remaining[i];
                    const size_t next = remaining[(i + 1) % remaining.size()];
 
                    const float cross = edgeCross2(face[previous].vertex, face[current].vertex, face[next].vertex, dropAxis) * windingSign;
                    if (cross <= 1e-6f) {
                        continue;
                    }
 
                    bool containsPoint = false;
                    for (const size_t test : remaining) {
                        if (test == previous || test == current || test == next) {
                            continue;
                        }
                        if (pointInProjectedTriangle(face[test].vertex, face[previous].vertex, face[current].vertex, face[next].vertex, dropAxis, windingSign)) {
                            containsPoint = true;
                            break;
                        }
                    }
 
                    if (containsPoint) {
                        continue;
                    }
 
                    appendOBJTriangle(vertices, face[previous], face[current], face[next]);
                    remaining.erase(remaining.begin() + static_cast<std::ptrdiff_t>(i));
                    clippedEar = true;
                    break;
                }
 
                if (!clippedEar) {
                    for (size_t i = 2; i < remaining.size(); ++i) {
                        appendOBJTriangle(vertices, face[remaining[0]], face[remaining[i - 1]], face[remaining[i]]);
                    }
                    return;
                }
            }
 
            appendOBJTriangle(vertices, face[remaining[0]], face[remaining[1]], face[remaining[2]]);
        }

trim()

void mxvk::anonymous_namespace{mxvk_model.cpp}::trim

(

std::string &

s

)

Definition at line 82 of file mxvk_model.cpp.

                                {
            const size_t begin = s.find_first_not_of(" \t\r\n");
            if (begin == std::string::npos) {
                s.clear();
                return;
            }
            const size_t end = s.find_last_not_of(" \t\r\n");
            s = s.substr(begin, end - begin + 1);
        }

writeMTLMaterial()

void mxvk::anonymous_namespace{mxvk_model.cpp}::writeMTLMaterial	(	std::ostream &	out,
		const MXMaterial &	material )

Definition at line 476 of file mxvk_model.cpp.

                                                                           {
            out << "newmtl " << material.name << '\n';
            out << "Ka " << material.ka[0] << ' ' << material.ka[1] << ' ' << material.ka[2] << '\n';
            out << "Kd " << material.kd[0] << ' ' << material.kd[1] << ' ' << material.kd[2] << '\n';
            out << "Ks " << material.ks[0] << ' ' << material.ks[1] << ' ' << material.ks[2] << '\n';
            out << "Ns " << material.ns << '\n';
            out << "d " << material.d << '\n';
            out << "illum " << material.illum << '\n';
            if (!material.map_kd.empty()) {
                out << "map_Kd " << material.map_kd << '\n';
            }
            out << '\n';
        }