Slic3r::anonymous_namespace{AssimpImport.cpp} Namespace Reference

Functions
void	clear_textured_mesh (TexturedMesh &out)
void	set_error_message (std::string *error_message, const std::string &message)
bool	is_fbx_path (const std::string &path)
bool	should_flip_uvs (const std::string &path)
unsigned int	assimp_import_flags (const std::string &path)
void	configure_importer (Assimp::Importer &importer, const std::string &path, unsigned int flags)
bool	read_external_texture_file (const boost::filesystem::path &path, TextureImage &out)
bool	read_embedded_texture (const aiTexture &texture, TextureImage &out)
bool	get_material_texture (const aiMaterial &material, aiString &texture_path)
std::array< float, 4 >	get_material_color (const aiMaterial &material)
bool	collect_mesh (const aiMesh &mesh, size_t &vertex_offset, TexturedMesh &out, std::string &error)
void	collect_materials (const aiScene &scene, const boost::filesystem::path &base_dir, TexturedMesh &out)
std::string	scene_failure_summary (const std::string &path, const char *assimp_error)

Function Documentation

assimp_import_flags()

unsigned int Slic3r::anonymous_namespace{AssimpImport.cpp}::assimp_import_flags

(

const std::string &

path

)

{
    unsigned int flags = aiProcess_Triangulate
                       | aiProcess_GenNormals
                       | aiProcess_PreTransformVertices
                       | aiProcess_SortByPType;
    if (should_flip_uvs(path))
        flags |= aiProcess_FlipUVs;
    return flags;
}

References assimp_import_flags(), and should_flip_uvs().

Referenced by assimp_import_flags().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_textured_mesh()

void Slic3r::anonymous_namespace{AssimpImport.cpp}::clear_textured_mesh

(

TexturedMesh &

out

)

{
    out.vertices.clear();
    out.indices.clear();
    out.uvs.clear();
    out.uv_coords.clear();
    out.uv_indices.clear();
    out.textures.clear();
    out.material_ids.clear();
    out.material_texture_map.clear();
    out.material_colors.clear();
}

References clear_textured_mesh(), Slic3r::TexturedMesh::indices, Slic3r::TexturedMesh::material_colors, Slic3r::TexturedMesh::material_ids, Slic3r::TexturedMesh::material_texture_map, Slic3r::TexturedMesh::textures, Slic3r::TexturedMesh::uv_coords, Slic3r::TexturedMesh::uv_indices, Slic3r::TexturedMesh::uvs, and Slic3r::TexturedMesh::vertices.

Referenced by clear_textured_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_materials()

void Slic3r::anonymous_namespace{AssimpImport.cpp}::collect_materials	(	const aiScene &	scene,
		const boost::filesystem::path &	base_dir,
		TexturedMesh &	out )

{
    out.material_texture_map.assign(scene.mNumMaterials, -1);
    out.material_colors.assign(scene.mNumMaterials, {1.f, 1.f, 1.f, 1.f});
 
    for (unsigned int material_index = 0; material_index < scene.mNumMaterials; ++material_index) {
        const aiMaterial* material = scene.mMaterials[material_index];
        if (!material)
            continue;
 
        out.material_colors[material_index] = get_material_color(*material);
 
        aiString texture_path;
        if (!get_material_texture(*material, texture_path))
            continue;
 
        TextureImage image;
        const aiTexture* embedded_texture = scene.GetEmbeddedTexture(texture_path.C_Str());
        if (embedded_texture) {
            if (!read_embedded_texture(*embedded_texture, image))
                continue;
        } else {
            const boost::filesystem::path resolved = resource_path::resolve_external_resource_path(
                base_dir, texture_path.C_Str(), "Assimp texture");
            if (resolved.empty()) {
                BOOST_LOG_TRIVIAL(warning) << "AssimpImport: texture file not found: "
                                           << texture_path.C_Str();
                continue;
            }
            if (!read_external_texture_file(resolved, image)) {
                BOOST_LOG_TRIVIAL(warning) << "AssimpImport: failed to read texture: "
                                           << resolved;
                continue;
            }
        }
 
        out.material_texture_map[material_index] = static_cast<int>(out.textures.size());
        out.textures.push_back(std::move(image));
    }
}

References collect_materials(), get_material_color(), get_material_texture(), Slic3r::TexturedMesh::material_colors, Slic3r::TexturedMesh::material_texture_map, read_embedded_texture(), read_external_texture_file(), Slic3r::resource_path::resolve_external_resource_path(), and Slic3r::TexturedMesh::textures.

Referenced by collect_materials().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_mesh()

bool Slic3r::anonymous_namespace{AssimpImport.cpp}::collect_mesh	(	const aiMesh &	mesh,
		size_t &	vertex_offset,
		TexturedMesh &	out,
		std::string &	error )

{
    if (mesh.mNumVertices > static_cast<size_t>(std::numeric_limits<int>::max()) - vertex_offset) {
        error = "Assimp mesh has too many vertices for TexturedMesh indices";
        return false;
    }
 
    for (unsigned int i = 0; i < mesh.mNumVertices; ++i) {
        const aiVector3D& v = mesh.mVertices[i];
        out.vertices.push_back({v.x, v.y, v.z});
 
        if (mesh.HasTextureCoords(0)) {
            const aiVector3D& uv = mesh.mTextureCoords[0][i];
            out.uvs.push_back({uv.x, uv.y});
        } else {
            out.uvs.push_back({0.f, 0.f});
        }
    }
 
    const int material_index = static_cast<int>(mesh.mMaterialIndex);
    for (unsigned int i = 0; i < mesh.mNumFaces; ++i) {
        const aiFace& face = mesh.mFaces[i];
        if (face.mNumIndices != 3)
            continue;
        if (face.mIndices[0] >= mesh.mNumVertices ||
            face.mIndices[1] >= mesh.mNumVertices ||
            face.mIndices[2] >= mesh.mNumVertices) {
            error = "Assimp mesh face index is out of bounds";
            return false;
        }
        out.indices.push_back({
            static_cast<int>(static_cast<size_t>(face.mIndices[0]) + vertex_offset),
            static_cast<int>(static_cast<size_t>(face.mIndices[1]) + vertex_offset),
            static_cast<int>(static_cast<size_t>(face.mIndices[2]) + vertex_offset)});
        out.material_ids.push_back(material_index);
    }
 
    vertex_offset += mesh.mNumVertices;
    return true;
}

References collect_mesh(), Slic3r::TexturedMesh::indices, Slic3r::TexturedMesh::material_ids, Slic3r::TexturedMesh::uvs, and Slic3r::TexturedMesh::vertices.

Referenced by collect_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

configure_importer()

void Slic3r::anonymous_namespace{AssimpImport.cpp}::configure_importer	(	Assimp::Importer &	importer,
		const std::string &	path,
		unsigned int	flags )

{
    importer.SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE,
        aiPrimitiveType_POINT | aiPrimitiveType_LINE);
 
    if (flags & aiProcess_PreTransformVertices)
        importer.SetPropertyBool(AI_CONFIG_PP_PTV_KEEP_HIERARCHY, true);
 
    if (is_fbx_path(path)) {
        importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS, true);
        importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_MATERIALS, true);
        importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_TEXTURES, true);
        importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ANIMATIONS, false);
        importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_LIGHTS, false);
        importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_CAMERAS, false);
    }
}

References configure_importer(), and is_fbx_path().

Referenced by configure_importer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_material_color()

std::array< float, 4 > Slic3r::anonymous_namespace{AssimpImport.cpp}::get_material_color

(

const aiMaterial &

material

)

{
    aiColor4D color(1.f, 1.f, 1.f, 1.f);
    if (material.Get(AI_MATKEY_BASE_COLOR, color) == AI_SUCCESS)
        return {color.r, color.g, color.b, color.a};
    if (material.Get(AI_MATKEY_COLOR_DIFFUSE, color) == AI_SUCCESS)
        return {color.r, color.g, color.b, color.a};
    return {1.f, 1.f, 1.f, 1.f};
}

References get_material_color().

Referenced by collect_materials(), and get_material_color().

Here is the call graph for this function:

Here is the caller graph for this function:

get_material_texture()

bool Slic3r::anonymous_namespace{AssimpImport.cpp}::get_material_texture	(	const aiMaterial &	material,
		aiString &	texture_path )

{
    if (material.GetTextureCount(aiTextureType_DIFFUSE) > 0 &&
        material.GetTexture(aiTextureType_DIFFUSE, 0, &texture_path) == AI_SUCCESS) {
        return true;
    }
 
    if (material.GetTextureCount(aiTextureType_BASE_COLOR) > 0 &&
        material.GetTexture(aiTextureType_BASE_COLOR, 0, &texture_path) == AI_SUCCESS) {
        return true;
    }
 
    return false;
}

References get_material_texture().

Referenced by collect_materials(), and get_material_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

is_fbx_path()

bool Slic3r::anonymous_namespace{AssimpImport.cpp}::is_fbx_path

(

const std::string &

path

)

{
    return boost::algorithm::iends_with(path, ".fbx");
}

References is_fbx_path().

Referenced by configure_importer(), and is_fbx_path().

Here is the call graph for this function:

Here is the caller graph for this function:

read_embedded_texture()

bool Slic3r::anonymous_namespace{AssimpImport.cpp}::read_embedded_texture	(	const aiTexture &	texture,
		TextureImage &	out )

{
    out.data.clear();
    if (texture.mHeight == 0) {
        if (texture.mWidth == 0)
            return false;
        out.width = -1;
        out.height = -1;
        out.channels = 0;
        out.data.assign(
            reinterpret_cast<const unsigned char*>(texture.pcData),
            reinterpret_cast<const unsigned char*>(texture.pcData) + texture.mWidth);
        return !out.data.empty();
    }
 
    if (texture.mWidth == 0 || texture.mHeight == 0)
        return false;
    if (texture.mWidth > static_cast<unsigned int>(std::numeric_limits<int>::max()) ||
        texture.mHeight > static_cast<unsigned int>(std::numeric_limits<int>::max())) {
        return false;
    }
    const size_t width = static_cast<size_t>(texture.mWidth);
    const size_t height = static_cast<size_t>(texture.mHeight);
    if (width > std::numeric_limits<size_t>::max() / height ||
        width * height > std::numeric_limits<size_t>::max() / 4) {
        return false;
    }
 
    out.width = static_cast<int>(texture.mWidth);
    out.height = static_cast<int>(texture.mHeight);
    out.channels = 4;
    const size_t pixel_count = width * height;
    out.data.resize(pixel_count * 4);
    for (size_t i = 0; i < pixel_count; ++i) {
        const aiTexel& texel = texture.pcData[i];
        out.data[i * 4 + 0] = texel.r;
        out.data[i * 4 + 1] = texel.g;
        out.data[i * 4 + 2] = texel.b;
        out.data[i * 4 + 3] = texel.a;
    }
    return !out.data.empty();
}

References Slic3r::TextureImage::channels, Slic3r::TextureImage::data, Slic3r::TextureImage::height, read_embedded_texture(), and Slic3r::TextureImage::width.

Referenced by collect_materials(), and read_embedded_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

read_external_texture_file()

bool Slic3r::anonymous_namespace{AssimpImport.cpp}::read_external_texture_file	(	const boost::filesystem::path &	path,
		TextureImage &	out )

{
    boost::nowide::ifstream file(path.string(), std::ios::binary | std::ios::ate);
    if (!file.is_open())
        return false;
 
    const std::streamoff size = file.tellg();
    if (size <= 0)
        return false;
    if (static_cast<uintmax_t>(size) > static_cast<uintmax_t>(std::numeric_limits<size_t>::max()))
        return false;
 
    file.seekg(0);
    out.width = -1;
    out.height = -1;
    out.channels = 0;
    out.data.resize(static_cast<size_t>(size));
    file.read(reinterpret_cast<char*>(out.data.data()), size);
    if (!file && !file.eof()) {
        out.data.clear();
        return false;
    }
    return true;
}

References Slic3r::TextureImage::channels, Slic3r::TextureImage::data, Slic3r::TextureImage::height, read_external_texture_file(), and Slic3r::TextureImage::width.

Referenced by collect_materials(), and read_external_texture_file().

Here is the call graph for this function:

Here is the caller graph for this function:

scene_failure_summary()

std::string Slic3r::anonymous_namespace{AssimpImport.cpp}::scene_failure_summary	(	const std::string &	path,
		const char *	assimp_error )

{
    std::ostringstream ss;
    ss << "Assimp failed to import " << path;
    if (assimp_error && assimp_error[0] != '\0')
        ss << ": " << assimp_error;
    return ss.str();
}

References scene_failure_summary().

Referenced by scene_failure_summary().

Here is the call graph for this function:

Here is the caller graph for this function:

set_error_message()

void Slic3r::anonymous_namespace{AssimpImport.cpp}::set_error_message	(	std::string *	error_message,
		const std::string &	message )

{
    if (error_message)
        *error_message = message;
}

References set_error_message().

Referenced by set_error_message().

Here is the call graph for this function:

Here is the caller graph for this function:

should_flip_uvs()

bool Slic3r::anonymous_namespace{AssimpImport.cpp}::should_flip_uvs

(

const std::string &

path

)

{
    return boost::algorithm::iends_with(path, ".fbx") ||
           boost::algorithm::iends_with(path, ".glb");
}

References should_flip_uvs().

Referenced by assimp_import_flags(), and should_flip_uvs().

Here is the call graph for this function:

Here is the caller graph for this function: