Slic3r::BakeStageRecorder Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/TextureBake/TextureBakeDebug.hpp>

Collaboration diagram for Slic3r::BakeStageRecorder:

Public Member Functions
void	enable (bool on)
bool	enabled () const
void	set_check_topology (bool on)
bool	check_topology () const
void	set_mesh_cap (size_t triangles)
size_t	mesh_cap () const
void	capture (const char *name, const TextureBake::TriSoup &soup, double ms, const std::string &detail={})
void	capture (const char *name, const std::vector< Vec3f > &vertices, const std::vector< Vec3i32 > &indices, double ms, const std::string &detail={})
void	capture_note (const char *name, double ms, const std::string &detail)
size_t	mark () const
void	rebase (size_t from, const Transform3d *to_local, bool flip_winding)
const std::vector< BakeStageSnapshot > &	stages () const
std::vector< BakeStageSnapshot >	take ()
void	clear ()
bool	empty () const
double	total_ms () const
size_t	dump_obj (const std::string &dir) const

Private Member Functions
void	finish (BakeStageSnapshot &s)

Private Attributes
std::vector< BakeStageSnapshot >	m_stages
bool	m_enabled = false
bool	m_check_topology = true
size_t	m_mesh_cap = 4'000'000

Detailed Description

Member Function Documentation

capture() [1/2]

void Slic3r::BakeStageRecorder::capture	(	const char *	name,
		const std::vector< Vec3f > &	vertices,
		const std::vector< Vec3i32 > &	indices,
		double	ms,
		const std::string &	detail = {} )

{
    if (!m_enabled)
        return;
    BakeStageSnapshot s;
    s.name          = name;
    s.detail        = detail;
    s.ms            = ms;
    s.mesh.vertices = vertices;
    s.mesh.indices  = indices;
    finish(s);
}

References Slic3r::BakeStageSnapshot::detail, finish(), Slic3r::BakeStageMesh::indices, m_enabled, Slic3r::BakeStageSnapshot::mesh, Slic3r::BakeStageSnapshot::ms, Slic3r::BakeStageSnapshot::name, and Slic3r::BakeStageMesh::vertices.

Here is the call graph for this function:

capture() [2/2]

void Slic3r::BakeStageRecorder::capture	(	const char *	name,
		const TextureBake::TriSoup &	soup,
		double	ms,
		const std::string &	detail = {} )

{
    if (!m_enabled)
        return;
 
    BakeStageSnapshot s;
    s.name   = name;
    s.detail = detail;
    s.ms     = ms;
 
    // The pipeline works on non-indexed soup, so welding here is what turns it back into something
    // renderable. The geometry grid, matching to_indexed_triangle_set(), so the debug view shows the
    // same sharing the bake's own output would have.
    const size_t                 n = soup.pos.size();
    TextureBake::QuantizedPointMap map(TextureBake::WELD_GRID_GEOMETRY, std::min(n, size_t(1) << 22));
    std::vector<int>             id(n);
    s.mesh.vertices.reserve(n / 3);
    for (size_t i = 0; i < n; ++i) {
        id[i] = map.get_or_set(soup.pos[i], int(s.mesh.vertices.size()));
        if (map.inserted())
            s.mesh.vertices.push_back(soup.pos[i]);
    }
    s.mesh.indices.reserve(n / 3);
    for (size_t t = 0; t + 2 < n; t += 3) {
        // Corners that welded together carry no area; the bake's own conversion drops them too, so
        // dropping them here keeps the stage count honest against what would be committed.
        if (id[t] == id[t + 1] || id[t + 1] == id[t + 2] || id[t] == id[t + 2])
            continue;
        s.mesh.indices.emplace_back(id[t], id[t + 1], id[t + 2]);
    }
    finish(s);
}

References Slic3r::BakeStageSnapshot::detail, finish(), Slic3r::TextureBake::QuantizedPointMap::get_or_set(), Slic3r::BakeStageMesh::indices, Slic3r::TextureBake::QuantizedPointMap::inserted(), m_enabled, Slic3r::BakeStageSnapshot::mesh, Slic3r::BakeStageSnapshot::ms, Slic3r::BakeStageSnapshot::name, Slic3r::TextureBake::TriSoup::pos, Slic3r::BakeStageMesh::vertices, and Slic3r::TextureBake::WELD_GRID_GEOMETRY.

Referenced by Slic3r::build_texture_displacement_in_place(), Slic3r::GUI::GLGizmoTextureDisplacement::prepare_mesh(), and Slic3r::TextureBake::run_pipeline().

Here is the call graph for this function:

Here is the caller graph for this function:

capture_note()

void Slic3r::BakeStageRecorder::capture_note	(	const char *	name,
		double	ms,
		const std::string &	detail )

{
    if (!m_enabled)
        return;
    BakeStageSnapshot s;
    s.name             = name;
    s.detail           = detail;
    s.ms               = ms;
    s.topology_checked = false;
    m_stages.push_back(std::move(s));
}

References Slic3r::BakeStageSnapshot::detail, m_enabled, m_stages, Slic3r::BakeStageSnapshot::ms, Slic3r::BakeStageSnapshot::name, and Slic3r::BakeStageSnapshot::topology_checked.

check_topology()

bool Slic3r::BakeStageRecorder::check_topology ( ) const

inline

{ return m_check_topology; }

References m_check_topology.

clear()

void Slic3r::BakeStageRecorder::clear ( )

inline

{ m_stages.clear(); }

References m_stages.

dump_obj()

size_t Slic3r::BakeStageRecorder::dump_obj ( const std::string & dir ) const

inline

{ return dump_bake_stages(m_stages, dir); }

References Slic3r::dump_bake_stages(), and m_stages.

Here is the call graph for this function:

empty()

bool Slic3r::BakeStageRecorder::empty ( ) const

inline

{ return m_stages.empty(); }

References m_stages.

enable()

void Slic3r::BakeStageRecorder::enable ( bool on )

inline

{ m_enabled = on; }

References m_enabled.

Referenced by Slic3r::GUI::TextureDisplacementDebugJob::process().

Here is the caller graph for this function:

enabled()

bool Slic3r::BakeStageRecorder::enabled ( ) const

inline

{ return m_enabled; }

References m_enabled.

finish()

void Slic3r::BakeStageRecorder::finish ( BakeStageSnapshot & s )

private

{
    s.triangles = s.mesh.indices.size();
    s.vertices  = s.mesh.vertices.size();
    if (m_check_topology)
        bake_stage_topology(s.mesh, s.open_edges, s.non_manifold_edges, s.degenerate);
    s.topology_checked = m_check_topology;
    if (s.triangles > m_mesh_cap) {
        s.mesh_dropped = true;
        s.mesh.vertices.clear();
        s.mesh.vertices.shrink_to_fit();
        s.mesh.indices.clear();
        s.mesh.indices.shrink_to_fit();
    }
    m_stages.push_back(std::move(s));
}

References Slic3r::bake_stage_topology(), Slic3r::BakeStageSnapshot::degenerate, Slic3r::BakeStageMesh::indices, m_check_topology, m_mesh_cap, m_stages, Slic3r::BakeStageSnapshot::mesh, Slic3r::BakeStageSnapshot::mesh_dropped, Slic3r::BakeStageSnapshot::non_manifold_edges, Slic3r::BakeStageSnapshot::open_edges, Slic3r::BakeStageSnapshot::topology_checked, Slic3r::BakeStageSnapshot::triangles, Slic3r::BakeStageMesh::vertices, and Slic3r::BakeStageSnapshot::vertices.

Referenced by capture(), and capture().

Here is the call graph for this function:

Here is the caller graph for this function:

mark()

size_t Slic3r::BakeStageRecorder::mark ( ) const

inline

{ return m_stages.size(); }

References m_stages.

Referenced by Slic3r::build_texture_displacement(), and Slic3r::anonymous_namespace{TextureDisplacement.cpp}::build_texture_displacement_v2().

Here is the caller graph for this function:

mesh_cap()

size_t Slic3r::BakeStageRecorder::mesh_cap ( ) const

inline

{ return m_mesh_cap; }

References m_mesh_cap.

rebase()

void Slic3r::BakeStageRecorder::rebase	(	size_t	from,
		const Transform3d *	to_local,
		bool	flip_winding )

{
    for (size_t i = from; i < m_stages.size(); ++i) {
        BakeStageMesh &m = m_stages[i].mesh;
        if (to_local != nullptr)
            for (Vec3f &v : m.vertices)
                v = (*to_local * v.cast<double>()).cast<float>();
        if (flip_winding)
            for (Vec3i32 &t : m.indices)
                std::swap(t[1], t[2]);
    }
}

References Slic3r::cast(), Slic3r::BakeStageMesh::indices, m_stages, and Slic3r::BakeStageMesh::vertices.

Referenced by Slic3r::build_texture_displacement(), and Slic3r::anonymous_namespace{TextureDisplacement.cpp}::build_texture_displacement_v2().

Here is the call graph for this function:

Here is the caller graph for this function:

set_check_topology()

void Slic3r::BakeStageRecorder::set_check_topology ( bool on )

inline

{ m_check_topology = on; }

References m_check_topology.

Referenced by Slic3r::GUI::TextureDisplacementDebugJob::process().

Here is the caller graph for this function:

set_mesh_cap()

void Slic3r::BakeStageRecorder::set_mesh_cap ( size_t triangles )

inline

{ m_mesh_cap = triangles; }

References m_mesh_cap.

Referenced by Slic3r::GUI::TextureDisplacementDebugJob::process().

Here is the caller graph for this function:

stages()

const std::vector< BakeStageSnapshot > & Slic3r::BakeStageRecorder::stages ( ) const

inline

{ return m_stages; }

References m_stages.

take()

std::vector< BakeStageSnapshot > Slic3r::BakeStageRecorder::take ( )

inline

{ return std::move(m_stages); }

References m_stages.

Referenced by Slic3r::GUI::TextureDisplacementDebugJob::process().

Here is the caller graph for this function:

total_ms()

double Slic3r::BakeStageRecorder::total_ms

(

)

const

{
    double sum = 0.0;
    for (const BakeStageSnapshot &s : m_stages)
        sum += s.ms;
    return sum;
}

References m_stages.

Member Data Documentation

m_check_topology

bool Slic3r::BakeStageRecorder::m_check_topology = true

private

Referenced by check_topology(), finish(), and set_check_topology().

m_enabled

bool Slic3r::BakeStageRecorder::m_enabled = false

private

Referenced by capture(), capture(), capture_note(), enable(), and enabled().

m_mesh_cap

size_t Slic3r::BakeStageRecorder::m_mesh_cap = 4'000'000

private

Referenced by finish(), mesh_cap(), and set_mesh_cap().

m_stages

std::vector<BakeStageSnapshot> Slic3r::BakeStageRecorder::m_stages

private

Referenced by capture_note(), clear(), dump_obj(), empty(), finish(), mark(), rebase(), stages(), take(), and total_ms().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/TextureBake/TextureBakeDebug.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/TextureBake/TextureBakeDebug.cpp