Simple mesh object loaded from PLG-style indexed triangle data. More...

#include <mxvk/include/mxvk/mxvk_math.h>

Public Member Functions
void	BuildRenderList (RenderList &list) const
	Append this object's triangles to a render list.
void	BuildRenderList (RenderList &list) const
	Append this object's triangles to a render list.
float	ComputeRad ()
	Compute and cache average and maximum local-space radii.
float	ComputeRad ()
	Compute and cache average and maximum local-space radii.
bool	LoadMTL (const std::string &path)
	Replace this object's material library with an MTL file.
bool	LoadMTL (const std::string &path)
	Replace this object's material library with an MTL file.
bool	LoadMX (const std::string &path, const vec4D &scale, const vec4D &obj_pos, const vec4D &rotation)
	Load an MX mesh file using the PLG loader compatibility path.
bool	LoadMX (const std::string &path, const vec4D &scale, const vec4D &obj_pos, const vec4D &rotation)
	Load an MX mesh file using the PLG loader compatibility path.
bool	LoadOBJ (const std::string &path, const vec4D &scale, const vec4D &obj_pos, const vec4D &rotation)
	Load a Wavefront OBJ mesh and its referenced MTL material library.
bool	LoadOBJ (const std::string &path, const vec4D &scale, const vec4D &obj_pos, const vec4D &rotation)
	Load a Wavefront OBJ mesh and its referenced MTL material library.
bool	LoadPLG (const std::string &path, const vec4D &scale, const vec4D &obj_pos, const vec4D &rotation)
	Load a PLG mesh file.
bool	LoadPLG (const std::string &path, const vec4D &scale, const vec4D &obj_pos, const vec4D &rotation)
	Load a PLG mesh file.
void	ModelToWorld (int type=0)
	Convert local or transformed vertices to world space.
void	ModelToWorld (int type=0)
	Convert local or transformed vertices to world space.
void	RemoveFaces (const vec4D &pos)
	Mark object polygons that face away from a view position.
void	RemoveFaces (const vec4D &pos)
	Mark object polygons that face away from a view position.
void	Reset ()
	Reset object and polygon state to active.
void	Reset ()
	Reset object and polygon state to active.
void	SetState (int new_state)
	Replace the object state flags.
void	SetState (int new_state)
	Replace the object state flags.
void	TransformObject (const Mat4D &mrot, int type=0)
	Apply a transform to local vertices, transformed vertices, or local-to-transformed output.
void	TransformObject (const Mat4D &mrot, int type=0)
	Apply a transform to local vertices, transformed vertices, or local-to-transformed output.

Public Attributes
int	attr = 0
	Object attributes.
float	avg_rad = 0.0f
	Average radius from the local origin.
vec4D	dir
	Object direction.
std::vector< vec4D >	local
	Local-space vertices.
std::string	material_library_path
	Resolved path of the OBJ material library.
std::vector< OBJMaterial >	materials
	Materials loaded from the OBJ material library.
float	max_rad = 0.0f
	Maximum radius from the local origin.
int	num_polys = 0
	Number of loaded polygons.
int	num_vertices = 0
	Number of loaded vertices.
std::string	object_name
	Object name loaded from the model file.
int	state = MX_ACTIVE
	Object state flags.
std::vector< vec2D >	texcoords
	Optional texture coordinates corresponding to local-space vertices.
std::vector< vec4D >	trans
	Transformed vertices.
vec4D	ux
	Local X basis vector.
vec4D	uy
	Local Y basis vector.
vec4D	uz
	Local Z basis vector.
std::vector< Triangle >	vlist
	Indexed triangle list.
vec4D	world_pos
	Object world position.

Detailed Description

Simple mesh object loaded from PLG-style indexed triangle data.

Definition at line 1439 of file mxvk_math.h.

Member Function Documentation

◆ BuildRenderList() [1/2]

void mxvk::mxObject::BuildRenderList ( RenderList & list ) const

inline

Append this object's triangles to a render list.

Definition at line 1782 of file mxvk_math.h.

                                                     {
            for (const auto &poly : vlist) {
                Triangle tri = poly;
                for (int i = 0; i < 3; ++i) {
                    const auto index = static_cast<std::size_t>(poly.vert[i]);
                    if (index < local.size()) {
                        tri.vlist[i] = local[index];
                    }
                    if (index < trans.size()) {
                        tri.tlist[i] = trans[index];
                    }
                }
                list.BuildRenderList(tri);
            }
        }

◆ BuildRenderList() [2/2]

void mxvk::mxObject::BuildRenderList ( RenderList & list ) const

inline

Append this object's triangles to a render list.

Definition at line 1779 of file mxvk_math_eigen.hpp.

                                                     {
            for (const auto &poly : vlist) {
                Triangle tri = poly;
                for (int i = 0; i < 3; ++i) {
                    const auto index = static_cast<std::size_t>(poly.vert[i]);
                    if (index < local.size()) {
                        tri.vlist[i] = local[index];
                    }
                    if (index < trans.size()) {
                        tri.tlist[i] = trans[index];
                    }
                }
                list.BuildRenderList(tri);
            }
        }

◆ ComputeRad() [1/2]

float mxvk::mxObject::ComputeRad ( )

inline

Compute and cache average and maximum local-space radii.

Definition at line 1807 of file mxvk_math.h.

                           {
            max_rad = 0.0f;
            avg_rad = 0.0f;
            if (local.empty()) {
                return 0.0f;
            }
            for (const auto &vertex : local) {
                const float dist = std::sqrt(vertex.x * vertex.x + vertex.y * vertex.y + vertex.z * vertex.z);
                avg_rad += dist;
                max_rad = std::max(max_rad, dist);
            }
            avg_rad /= static_cast<float>(local.size());
            return max_rad;
        }

◆ ComputeRad() [2/2]

float mxvk::mxObject::ComputeRad ( )

inline

Compute and cache average and maximum local-space radii.

Definition at line 1804 of file mxvk_math_eigen.hpp.

                           {
            max_rad = 0.0f;
            avg_rad = 0.0f;
            if (local.empty()) {
                return 0.0f;
            }
            for (const auto &vertex : local) {
                const float dist = Eigen::Vector3f(vertex.x, vertex.y, vertex.z).norm();
                avg_rad += dist;
                max_rad = std::max(max_rad, dist);
            }
            avg_rad /= static_cast<float>(local.size());
            return max_rad;
        }

◆ LoadMTL() [1/2]

bool mxvk::mxObject::LoadMTL ( const std::string & path )

inlinenodiscard

Replace this object's material library with an MTL file.

Returns: True when the material file is parsed successfully.

Definition at line 1704 of file mxvk_math.h.

                                                          {
            std::vector<OBJMaterial> loaded_materials;
            std::string error;
            if (!detail::load_mtl_file(path, loaded_materials, error)) {
                std::cerr << "mxvk_math: failed to load MTL file '" << path << "': " << error << '\n';
                return false;
            }
 
            std::unordered_map<std::string, int> material_indices;
            for (std::size_t index = 0; index < loaded_materials.size(); ++index) {
                material_indices.emplace(loaded_materials[index].name, static_cast<int>(index));
            }
            for (std::size_t index = 0; index < vlist.size(); ++index) {
                const auto material = material_indices.find(vlist[index].material_name);
                vlist[index].material_index = material == material_indices.end() ? -1 : material->second;
                if (material != material_indices.end()) {
                    vlist[index].color = material_color(loaded_materials[static_cast<std::size_t>(material->second)]);
                }
            }
 
            materials = std::move(loaded_materials);
            material_library_path = path;
            return true;
        }

◆ LoadMTL() [2/2]

bool mxvk::mxObject::LoadMTL ( const std::string & path )

inlinenodiscard

Replace this object's material library with an MTL file.

Returns: True when the material file is parsed successfully.

Definition at line 1701 of file mxvk_math_eigen.hpp.

                                                          {
            std::vector<OBJMaterial> loaded_materials;
            std::string error;
            if (!detail::load_mtl_file(path, loaded_materials, error)) {
                std::cerr << "mxvk_math_eigen: failed to load MTL file '" << path << "': " << error << '\n';
                return false;
            }
 
            std::unordered_map<std::string, int> material_indices;
            for (std::size_t index = 0; index < loaded_materials.size(); ++index) {
                material_indices.emplace(loaded_materials[index].name, static_cast<int>(index));
            }
            for (std::size_t index = 0; index < vlist.size(); ++index) {
                const auto material = material_indices.find(vlist[index].material_name);
                vlist[index].material_index = material == material_indices.end() ? -1 : material->second;
                if (material != material_indices.end()) {
                    vlist[index].color = material_color(loaded_materials[static_cast<std::size_t>(material->second)]);
                }
            }
 
            materials = std::move(loaded_materials);
            material_library_path = path;
            return true;
        }

◆ LoadMX() [1/2]

bool mxvk::mxObject::LoadMX	(	const std::string &	path,
		const vec4D &	scale,
		const vec4D &	obj_pos,
		const vec4D &	rotation )

inlinenodiscard

Load an MX mesh file using the PLG loader compatibility path.

Definition at line 1624 of file mxvk_math.h.

                                                                                                                          {
            return LoadPLG(path, scale, obj_pos, rotation);
        }

◆ LoadMX() [2/2]

bool mxvk::mxObject::LoadMX	(	const std::string &	path,
		const vec4D &	scale,
		const vec4D &	obj_pos,
		const vec4D &	rotation )

inlinenodiscard

Load an MX mesh file using the PLG loader compatibility path.

Definition at line 1621 of file mxvk_math_eigen.hpp.

                                                                                                                          {
            return LoadPLG(path, scale, obj_pos, rotation);
        }

◆ LoadOBJ() [1/2]

bool mxvk::mxObject::LoadOBJ	(	const std::string &	path,
		const vec4D &	scale,
		const vec4D &	obj_pos,
		const vec4D &	rotation )

inlinenodiscard

Load a Wavefront OBJ mesh and its referenced MTL material library.

Wavefront faces may use independent position and texture-coordinate indices, negative indices, triangles, quads, or concave polygons. Faces are triangulated and de-indexed into the representation used by the software rasterizer. MTL diffuse colors become triangle colors.

Definition at line 1636 of file mxvk_math.h.

                                                                                                                           {
            std::cout << "mxvk_math: loading OBJ model: " << path << '\n';
            detail::OBJLoadResult loaded;
            std::string error;
            if (!detail::load_obj_file(path, loaded, error)) {
                std::cerr << "mxvk_math: failed to load OBJ model '" << path << "': " << error << '\n';
                return false;
            }
 
            std::unordered_map<std::string, int> material_indices;
            for (std::size_t index = 0; index < loaded.materials.size(); ++index) {
                material_indices.emplace(loaded.materials[index].name, static_cast<int>(index));
            }
 
            std::vector<vec4D> loaded_local;
            std::vector<vec2D> loaded_texcoords;
            std::vector<Triangle> loaded_vlist;
            loaded_local.reserve(loaded.triangles.size() * 3);
            loaded_texcoords.reserve(loaded.triangles.size() * 3);
            loaded_vlist.reserve(loaded.triangles.size());
 
            for (const detail::OBJTriangle &source_triangle : loaded.triangles) {
                Triangle triangle;
                triangle.state = MX_ACTIVE;
                triangle.material_name = source_triangle.material_name;
                triangle.source_object_name = source_triangle.object_name;
                const auto material = material_indices.find(source_triangle.material_name);
                if (material != material_indices.end()) {
                    triangle.material_index = material->second;
                    triangle.color = material_color(loaded.materials[static_cast<std::size_t>(material->second)]);
                }
 
                for (std::size_t vertex_index = 0; vertex_index < source_triangle.vertices.size(); ++vertex_index) {
                    const detail::OBJVertex &source_vertex = source_triangle.vertices[vertex_index];
                    const float x = source_vertex.position[0] * scale.x;
                    const float y = source_vertex.position[1] * scale.y;
                    const float z = source_vertex.position[2] * scale.z;
                    if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(z)) {
                        std::cerr << "mxvk_math: failed to load OBJ model '" << path << "': scaled vertex is not finite\n";
                        return false;
                    }
                    triangle.vert[vertex_index] = static_cast<int>(loaded_local.size());
                    loaded_local.emplace_back(x, y, z, 1.0f);
                    loaded_texcoords.emplace_back(source_vertex.texcoord[0], source_vertex.texcoord[1]);
                }
                loaded_vlist.push_back(triangle);
            }
 
            object_name = std::move(loaded.object_name);
            num_vertices = static_cast<int>(loaded_local.size());
            num_polys = static_cast<int>(loaded_vlist.size());
            local = std::move(loaded_local);
            trans.resize(local.size());
            texcoords = std::move(loaded_texcoords);
            vlist = std::move(loaded_vlist);
            materials = std::move(loaded.materials);
            material_library_path = std::move(loaded.material_library_path);
            world_pos = obj_pos;
            dir = rotation;
            ComputeRad();
            std::cout << "mxvk_math: OBJ model ready (object='" << object_name << "', vertices=" << num_vertices << ", triangles=" << num_polys << ", materials=" << materials.size() << ")\n";
            return true;
        }

◆ LoadOBJ() [2/2]

bool mxvk::mxObject::LoadOBJ	(	const std::string &	path,
		const vec4D &	scale,
		const vec4D &	obj_pos,
		const vec4D &	rotation )

inlinenodiscard

Load a Wavefront OBJ mesh and its referenced MTL material library.

Wavefront faces may use independent position and texture-coordinate indices, negative indices, triangles, quads, or concave polygons. Faces are triangulated and de-indexed into the representation used by the software rasterizer. MTL diffuse colors become triangle colors.

Definition at line 1633 of file mxvk_math_eigen.hpp.

                                                                                                                           {
            std::cout << "mxvk_math_eigen: loading OBJ model: " << path << '\n';
            detail::OBJLoadResult loaded;
            std::string error;
            if (!detail::load_obj_file(path, loaded, error)) {
                std::cerr << "mxvk_math_eigen: failed to load OBJ model '" << path << "': " << error << '\n';
                return false;
            }
 
            std::unordered_map<std::string, int> material_indices;
            for (std::size_t index = 0; index < loaded.materials.size(); ++index) {
                material_indices.emplace(loaded.materials[index].name, static_cast<int>(index));
            }
 
            std::vector<vec4D> loaded_local;
            std::vector<vec2D> loaded_texcoords;
            std::vector<Triangle> loaded_vlist;
            loaded_local.reserve(loaded.triangles.size() * 3);
            loaded_texcoords.reserve(loaded.triangles.size() * 3);
            loaded_vlist.reserve(loaded.triangles.size());
 
            for (const detail::OBJTriangle &source_triangle : loaded.triangles) {
                Triangle triangle;
                triangle.state = MX_ACTIVE;
                triangle.material_name = source_triangle.material_name;
                triangle.source_object_name = source_triangle.object_name;
                const auto material = material_indices.find(source_triangle.material_name);
                if (material != material_indices.end()) {
                    triangle.material_index = material->second;
                    triangle.color = material_color(loaded.materials[static_cast<std::size_t>(material->second)]);
                }
 
                for (std::size_t vertex_index = 0; vertex_index < source_triangle.vertices.size(); ++vertex_index) {
                    const detail::OBJVertex &source_vertex = source_triangle.vertices[vertex_index];
                    const Eigen::Vector3f scaled =
                        Eigen::Vector3f(source_vertex.position[0], source_vertex.position[1], source_vertex.position[2])
                            .cwiseProduct(Eigen::Vector3f(scale.x, scale.y, scale.z));
                    if (!scaled.allFinite()) {
                        std::cerr << "mxvk_math_eigen: failed to load OBJ model '" << path << "': scaled vertex is not finite\n";
                        return false;
                    }
                    triangle.vert[vertex_index] = static_cast<int>(loaded_local.size());
                    loaded_local.emplace_back(scaled.x(), scaled.y(), scaled.z(), 1.0f);
                    loaded_texcoords.emplace_back(source_vertex.texcoord[0], source_vertex.texcoord[1]);
                }
                loaded_vlist.push_back(triangle);
            }
 
            object_name = std::move(loaded.object_name);
            num_vertices = static_cast<int>(loaded_local.size());
            num_polys = static_cast<int>(loaded_vlist.size());
            local = std::move(loaded_local);
            trans.resize(local.size());
            texcoords = std::move(loaded_texcoords);
            vlist = std::move(loaded_vlist);
            materials = std::move(loaded.materials);
            material_library_path = std::move(loaded.material_library_path);
            world_pos = obj_pos;
            dir = rotation;
            ComputeRad();
            std::cout << "mxvk_math_eigen: OBJ model ready (object='" << object_name << "', vertices=" << num_vertices << ", triangles=" << num_polys << ", materials=" << materials.size() << ")\n";
            return true;
        }

◆ LoadPLG() [1/2]

bool mxvk::mxObject::LoadPLG	(	const std::string &	path,
		const vec4D &	scale,
		const vec4D &	obj_pos,
		const vec4D &	rotation )

inlinenodiscard

Load a PLG mesh file.

Parameters

path	File path to load.
scale	Per-axis scale applied to vertices.
obj_pos	World position assigned to the object.
rotation	Object direction assigned after loading.

Returns: True when the file is opened and parsed successfully.

Vertex lines may contain optional u v texture coordinates after x y z. Blank lines and lines beginning with # are ignored. If loading fails, the object retains its previous mesh, texture coordinates, and transform.

Definition at line 1507 of file mxvk_math.h.

                                                                                                                           {
            std::cout << "mxvk_math: loading PLG model: " << path << '\n';
            const auto load_failed = [&path](const char *reason) {
                std::cerr << "mxvk_math: failed to load PLG model '" << path << "': " << reason << '\n';
                return false;
            };
 
            std::ifstream file(path);
            if (!file.is_open()) {
                return load_failed("could not open file");
            }
 
            const auto read_data_line = [&file](std::string &line) {
                while (std::getline(file, line)) {
                    const std::size_t comment = line.find('#');
                    if (comment != std::string::npos) {
                        line.erase(comment);
                    }
                    if (line.find_first_not_of(" \t\r\n") != std::string::npos) {
                        return true;
                    }
                }
                return false;
            };
 
            std::string line;
            if (!read_data_line(line)) {
                return load_failed("missing model header");
            }
 
            std::string name;
            int vertex_count = 0;
            int poly_count = 0;
            std::istringstream header(line);
            if (!(header >> name >> vertex_count >> poly_count) || vertex_count < 0 || poly_count < 0) {
                return load_failed("invalid model header");
            }
            std::cout << "mxvk_math: PLG header parsed (object='" << name << "', vertices=" << vertex_count << ", triangles=" << poly_count << ")\n";
 
            std::vector<vec4D> loaded_local;
            std::vector<vec4D> loaded_trans;
            std::vector<vec2D> loaded_texcoords;
            std::vector<Triangle> loaded_vlist;
            loaded_local.reserve(static_cast<std::size_t>(vertex_count));
            loaded_trans.resize(static_cast<std::size_t>(vertex_count));
            loaded_texcoords.reserve(static_cast<std::size_t>(vertex_count));
            loaded_vlist.reserve(static_cast<std::size_t>(poly_count));
 
            for (int i = 0; i < vertex_count; ++i) {
                if (!read_data_line(line)) {
                    return load_failed("vertex data ended early");
                }
 
                vec4D vertex;
                std::istringstream vertex_line(line);
                if (!(vertex_line >> vertex.x >> vertex.y >> vertex.z) ||
                    !std::isfinite(vertex.x) || !std::isfinite(vertex.y) || !std::isfinite(vertex.z)) {
                    return load_failed("invalid vertex data");
                }
 
                vec2D texcoord;
                if (vertex_line >> texcoord.x) {
                    if (!(vertex_line >> texcoord.y) || !std::isfinite(texcoord.x) || !std::isfinite(texcoord.y)) {
                        return load_failed("invalid texture coordinates");
                    }
                }
 
                vertex.x *= scale.x;
                vertex.y *= scale.y;
                vertex.z *= scale.z;
                if (!std::isfinite(vertex.x) || !std::isfinite(vertex.y) || !std::isfinite(vertex.z)) {
                    return load_failed("scaled vertex is not finite");
                }
                vertex.w = 1.0f;
                loaded_local.push_back(vertex);
                loaded_texcoords.push_back(texcoord);
            }
 
            for (int i = 0; i < poly_count; ++i) {
                if (!read_data_line(line)) {
                    return load_failed("triangle data ended early");
                }
 
                Triangle tri;
                int count = 0;
                std::istringstream polygon_line(line);
                if (!(polygon_line >> std::hex >> tri.state >> std::dec >> count) || count != 3 ||
                    !(polygon_line >> tri.vert[0] >> tri.vert[1] >> tri.vert[2])) {
                    return load_failed("invalid triangle data");
                }
                for (const int index : tri.vert) {
                    if (index < 0 || index >= vertex_count) {
                        return load_failed("triangle vertex index is out of range");
                    }
                }
                loaded_vlist.push_back(tri);
            }
 
            for (auto &triangle : loaded_vlist) {
                triangle.color = MXVK_RGB(rrand(0, 255), rrand(0, 255), rrand(0, 255));
            }
 
            object_name = std::move(name);
            num_vertices = vertex_count;
            num_polys = poly_count;
            local = std::move(loaded_local);
            trans = std::move(loaded_trans);
            texcoords = std::move(loaded_texcoords);
            vlist = std::move(loaded_vlist);
            world_pos = obj_pos;
            dir = rotation;
            ComputeRad();
            std::cout << "mxvk_math: PLG model ready (object='" << object_name << "', average radius=" << avg_rad << ", maximum radius=" << max_rad << ")\n";
            return true;
        }

◆ LoadPLG() [2/2]

bool mxvk::mxObject::LoadPLG	(	const std::string &	path,
		const vec4D &	scale,
		const vec4D &	obj_pos,
		const vec4D &	rotation )

inlinenodiscard

Load a PLG mesh file.

Parameters

path	File path to load.
scale	Per-axis scale applied to vertices.
obj_pos	World position assigned to the object.
rotation	Object direction assigned after loading.

Returns: True when the file is opened and parsed successfully.

Vertex lines may contain optional u v texture coordinates after x y z. Blank lines and lines beginning with # are ignored. If loading fails, the object retains its previous mesh, texture coordinates, and transform.

Definition at line 1507 of file mxvk_math_eigen.hpp.

                                                                                                                           {
            std::cout << "mxvk_math_eigen: loading PLG model: " << path << '\n';
            const auto load_failed = [&path](const char *reason) {
                std::cerr << "mxvk_math_eigen: failed to load PLG model '" << path << "': " << reason << '\n';
                return false;
            };
 
            std::ifstream file(path);
            if (!file.is_open()) {
                return load_failed("could not open file");
            }
 
            const auto read_data_line = [&file](std::string &line) {
                while (std::getline(file, line)) {
                    const std::size_t comment = line.find('#');
                    if (comment != std::string::npos) {
                        line.erase(comment);
                    }
                    if (line.find_first_not_of(" \t\r\n") != std::string::npos) {
                        return true;
                    }
                }
                return false;
            };
 
            std::string line;
            if (!read_data_line(line)) {
                return load_failed("missing model header");
            }
 
            std::string name;
            int vertex_count = 0;
            int poly_count = 0;
            std::istringstream header(line);
            if (!(header >> name >> vertex_count >> poly_count) || vertex_count < 0 || poly_count < 0) {
                return load_failed("invalid model header");
            }
            std::cout << "mxvk_math_eigen: PLG header parsed (object='" << name << "', vertices=" << vertex_count << ", triangles=" << poly_count << ")\n";
 
            std::vector<vec4D> loaded_local;
            std::vector<vec4D> loaded_trans;
            std::vector<vec2D> loaded_texcoords;
            std::vector<Triangle> loaded_vlist;
            loaded_local.reserve(static_cast<std::size_t>(vertex_count));
            loaded_trans.resize(static_cast<std::size_t>(vertex_count));
            loaded_texcoords.reserve(static_cast<std::size_t>(vertex_count));
            loaded_vlist.reserve(static_cast<std::size_t>(poly_count));
 
            for (int i = 0; i < vertex_count; ++i) {
                if (!read_data_line(line)) {
                    return load_failed("vertex data ended early");
                }
 
                Eigen::Vector3f coordinates;
                std::istringstream vertex_line(line);
                if (!(vertex_line >> coordinates.x() >> coordinates.y() >> coordinates.z()) || !coordinates.allFinite()) {
                    return load_failed("invalid vertex data");
                }
 
                vec2D texcoord;
                if (vertex_line >> texcoord.x) {
                    if (!(vertex_line >> texcoord.y) || !std::isfinite(texcoord.x) || !std::isfinite(texcoord.y)) {
                        return load_failed("invalid texture coordinates");
                    }
                }
 
                const Eigen::Vector3f scaled =
                    coordinates.cwiseProduct(Eigen::Vector3f(scale.x, scale.y, scale.z));
                if (!scaled.allFinite()) {
                    return load_failed("scaled vertex is not finite");
                }
                loaded_local.emplace_back(scaled.x(), scaled.y(), scaled.z(), 1.0f);
                loaded_texcoords.push_back(texcoord);
            }
 
            for (int i = 0; i < poly_count; ++i) {
                if (!read_data_line(line)) {
                    return load_failed("triangle data ended early");
                }
 
                Triangle tri;
                int count = 0;
                std::istringstream polygon_line(line);
                if (!(polygon_line >> std::hex >> tri.state >> std::dec >> count) || count != 3 ||
                    !(polygon_line >> tri.vert[0] >> tri.vert[1] >> tri.vert[2])) {
                    return load_failed("invalid triangle data");
                }
                for (const int index : tri.vert) {
                    if (index < 0 || index >= vertex_count) {
                        return load_failed("triangle vertex index is out of range");
                    }
                }
                loaded_vlist.push_back(tri);
            }
 
            for (auto &triangle : loaded_vlist) {
                triangle.color = MXVK_RGB(rrand(0, 255), rrand(0, 255), rrand(0, 255));
            }
 
            object_name = std::move(name);
            num_vertices = vertex_count;
            num_polys = poly_count;
            local = std::move(loaded_local);
            trans = std::move(loaded_trans);
            texcoords = std::move(loaded_texcoords);
            vlist = std::move(loaded_vlist);
            world_pos = obj_pos;
            dir = rotation;
            ComputeRad();
            std::cout << "mxvk_math_eigen: PLG model ready (object='" << object_name << "', average radius=" << avg_rad << ", maximum radius=" << max_rad << ")\n";
            return true;
        }

◆ ModelToWorld() [1/2]

void mxvk::mxObject::ModelToWorld ( int type = 0 )

inline

Convert local or transformed vertices to world space.

Definition at line 1730 of file mxvk_math.h.

                                      {
            if (type == 0) {
                trans.resize(local.size());
                for (std::size_t i = 0; i < local.size(); ++i) {
                    trans[i] = local[i] + world_pos;
                }
            } else if (type == 1) {
                for (auto &vertex : trans) {
                    vertex += world_pos;
                }
            }
        }

◆ ModelToWorld() [2/2]

void mxvk::mxObject::ModelToWorld ( int type = 0 )

inline

Convert local or transformed vertices to world space.

Definition at line 1727 of file mxvk_math_eigen.hpp.

                                      {
            if (type == 0) {
                trans.resize(local.size());
                for (std::size_t i = 0; i < local.size(); ++i) {
                    trans[i] = local[i] + world_pos;
                }
            } else if (type == 1) {
                for (auto &vertex : trans) {
                    vertex += world_pos;
                }
            }
        }

◆ RemoveFaces() [1/2]

void mxvk::mxObject::RemoveFaces ( const vec4D & pos )

inline

Mark object polygons that face away from a view position.

Definition at line 1763 of file mxvk_math.h.

                                           {
            for (auto &poly : vlist) {
                if (poly.state == 0 || (poly.state & MX_BACKFACE) != 0 || (poly.state & MX_CULLED) != 0) {
                    continue;
                }
                if (poly.vert[0] < 0 || poly.vert[1] < 0 || poly.vert[2] < 0 || static_cast<std::size_t>(poly.vert[0]) >= trans.size() || static_cast<std::size_t>(poly.vert[1]) >= trans.size() || static_cast<std::size_t>(poly.vert[2]) >= trans.size()) {
                    continue;
                }
                const vec4D u = vec4D().Build(trans[static_cast<std::size_t>(poly.vert[0])], trans[static_cast<std::size_t>(poly.vert[1])]);
                const vec4D v = vec4D().Build(trans[static_cast<std::size_t>(poly.vert[0])], trans[static_cast<std::size_t>(poly.vert[2])]);
                const vec4D n = u.CrossProduct(v);
                const vec4D view = vec4D().Build(trans[static_cast<std::size_t>(poly.vert[0])], pos);
                if (n.DotProduct(view) <= 0.0f) {
                    poly.state |= MX_BACKFACE;
                }
            }
        }

◆ RemoveFaces() [2/2]

void mxvk::mxObject::RemoveFaces ( const vec4D & pos )

inline

Mark object polygons that face away from a view position.

Definition at line 1760 of file mxvk_math_eigen.hpp.

                                           {
            for (auto &poly : vlist) {
                if (poly.state == 0 || (poly.state & MX_BACKFACE) != 0 || (poly.state & MX_CULLED) != 0) {
                    continue;
                }
                if (poly.vert[0] < 0 || poly.vert[1] < 0 || poly.vert[2] < 0 || static_cast<std::size_t>(poly.vert[0]) >= trans.size() || static_cast<std::size_t>(poly.vert[1]) >= trans.size() || static_cast<std::size_t>(poly.vert[2]) >= trans.size()) {
                    continue;
                }
                const vec4D u = vec4D().Build(trans[static_cast<std::size_t>(poly.vert[0])], trans[static_cast<std::size_t>(poly.vert[1])]);
                const vec4D v = vec4D().Build(trans[static_cast<std::size_t>(poly.vert[0])], trans[static_cast<std::size_t>(poly.vert[2])]);
                const vec4D n = u.CrossProduct(v);
                const vec4D view = vec4D().Build(trans[static_cast<std::size_t>(poly.vert[0])], pos);
                if (n.DotProduct(view) <= 0.0f) {
                    poly.state |= MX_BACKFACE;
                }
            }
        }

◆ Reset() [1/2]

void mxvk::mxObject::Reset ( )

inline

Reset object and polygon state to active.

Definition at line 1799 of file mxvk_math.h.

                     {
            for (auto &poly : vlist) {
                poly.state = MX_ACTIVE;
            }
            state = MX_ACTIVE;
        }

◆ Reset() [2/2]

void mxvk::mxObject::Reset ( )

inline

Reset object and polygon state to active.

Definition at line 1796 of file mxvk_math_eigen.hpp.

                     {
            for (auto &poly : vlist) {
                poly.state = MX_ACTIVE;
            }
            state = MX_ACTIVE;
        }

◆ SetState() [1/2]

void mxvk::mxObject::SetState ( int new_state )

inline

Replace the object state flags.

Definition at line 1823 of file mxvk_math.h.

                                     {
            state = new_state;
        }

◆ SetState() [2/2]

void mxvk::mxObject::SetState ( int new_state )

inline

Replace the object state flags.

Definition at line 1820 of file mxvk_math_eigen.hpp.

                                     {
            state = new_state;
        }

◆ TransformObject() [1/2]

void mxvk::mxObject::TransformObject	(	const Mat4D &	mrot,
		int	type = 0 )

inline

Apply a transform to local vertices, transformed vertices, or local-to-transformed output.

Definition at line 1744 of file mxvk_math.h.

                                                            {
            auto transform = [&mrot](std::vector<vec4D> &vertices) {
                for (auto &vertex : vertices) {
                    vertex = mrot.MulVec(vertex);
                }
            };
            if (type == 0) {
                transform(local);
            } else if (type == 1) {
                transform(trans);
            } else if (type == 2) {
                trans.resize(local.size());
                for (std::size_t i = 0; i < local.size(); ++i) {
                    trans[i] = mrot.MulVec(local[i]);
                }
            }
        }

◆ TransformObject() [2/2]

void mxvk::mxObject::TransformObject	(	const Mat4D &	mrot,
		int	type = 0 )

inline

Apply a transform to local vertices, transformed vertices, or local-to-transformed output.

Definition at line 1741 of file mxvk_math_eigen.hpp.

                                                            {
            auto transform = [&mrot](std::vector<vec4D> &vertices) {
                for (auto &vertex : vertices) {
                    vertex = mrot.MulVec(vertex);
                }
            };
            if (type == 0) {
                transform(local);
            } else if (type == 1) {
                transform(trans);
            } else if (type == 2) {
                trans.resize(local.size());
                for (std::size_t i = 0; i < local.size(); ++i) {
                    trans[i] = mrot.MulVec(local[i]);
                }
            }
        }

Member Data Documentation

◆ attr

int mxvk::mxObject::attr = 0

Object attributes.

Definition at line 1445 of file mxvk_math.h.

◆ avg_rad

float mxvk::mxObject::avg_rad = 0.0f

Average radius from the local origin.

Definition at line 1448 of file mxvk_math.h.

◆ dir

vec4D mxvk::mxObject::dir

Object direction.

Definition at line 1457 of file mxvk_math.h.

◆ local

std::vector< vec4D > mxvk::mxObject::local

Local-space vertices.

Definition at line 1475 of file mxvk_math.h.

◆ material_library_path

std::string mxvk::mxObject::material_library_path

Resolved path of the OBJ material library.

Definition at line 1493 of file mxvk_math.h.

◆ materials

std::vector< OBJMaterial > mxvk::mxObject::materials

Materials loaded from the OBJ material library.

Definition at line 1490 of file mxvk_math.h.

◆ max_rad

float mxvk::mxObject::max_rad = 0.0f

Maximum radius from the local origin.

Definition at line 1451 of file mxvk_math.h.

◆ num_polys

int mxvk::mxObject::num_polys = 0

Number of loaded polygons.

Definition at line 1472 of file mxvk_math.h.

◆ num_vertices

int mxvk::mxObject::num_vertices = 0

Number of loaded vertices.

Definition at line 1469 of file mxvk_math.h.

◆ object_name

std::string mxvk::mxObject::object_name

Object name loaded from the model file.

Definition at line 1487 of file mxvk_math.h.

◆ state

int mxvk::mxObject::state = MX_ACTIVE

Object state flags.

Definition at line 1442 of file mxvk_math.h.

◆ texcoords

std::vector< vec2D > mxvk::mxObject::texcoords

Optional texture coordinates corresponding to local-space vertices.

Definition at line 1481 of file mxvk_math.h.

◆ trans

std::vector< vec4D > mxvk::mxObject::trans

Transformed vertices.

Definition at line 1478 of file mxvk_math.h.

◆ ux

vec4D mxvk::mxObject::ux

Local X basis vector.

Definition at line 1460 of file mxvk_math.h.

◆ uy

vec4D mxvk::mxObject::uy

Local Y basis vector.

Definition at line 1463 of file mxvk_math.h.

◆ uz

vec4D mxvk::mxObject::uz

Local Z basis vector.

Definition at line 1466 of file mxvk_math.h.

◆ vlist

std::vector< Triangle > mxvk::mxObject::vlist

Indexed triangle list.

Definition at line 1484 of file mxvk_math.h.

◆ world_pos

vec4D mxvk::mxObject::world_pos

Object world position.

Definition at line 1454 of file mxvk_math.h.

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

mxvk/include/mxvk/mxvk_math.h
mxvk/include/mxvk/mxvk_math_eigen.hpp

MXVK Vulkan Framework 0.24.0 C++20 Vulkan rendering framework for practical 2D and 3D application development with SDL3.

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ BuildRenderList() [1/2]

◆ BuildRenderList() [2/2]

◆ ComputeRad() [1/2]

◆ ComputeRad() [2/2]

◆ LoadMTL() [1/2]

◆ LoadMTL() [2/2]

◆ LoadMX() [1/2]

◆ LoadMX() [2/2]

◆ LoadOBJ() [1/2]

◆ LoadOBJ() [2/2]

◆ LoadPLG() [1/2]

◆ LoadPLG() [2/2]

◆ ModelToWorld() [1/2]

◆ ModelToWorld() [2/2]

◆ RemoveFaces() [1/2]

◆ RemoveFaces() [2/2]

◆ Reset() [1/2]

◆ Reset() [2/2]

◆ SetState() [1/2]

◆ SetState() [2/2]

◆ TransformObject() [1/2]

◆ TransformObject() [2/2]

Member Data Documentation

◆ attr

◆ avg_rad

◆ dir

◆ local

◆ material_library_path

◆ materials

◆ max_rad

◆ num_polys

◆ num_vertices

◆ object_name

◆ state

◆ texcoords

◆ trans

◆ ux

◆ uy

◆ uz

◆ vlist

◆ world_pos