Slic3r::GUI::TextureDisplacementDebugJob Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/TextureDisplacementDebugJob.hpp>

Inheritance diagram for Slic3r::GUI::TextureDisplacementDebugJob:

Collaboration diagram for Slic3r::GUI::TextureDisplacementDebugJob:

Public Types
enum	JobPrepareState { PREPARE_STATE_DEFAULT = 0 , PREPARE_STATE_MENU = 1 }

Public Member Functions
	TextureDisplacementDebugJob (TextureDisplacementDebugInput &&input, std::function< void(std::vector< BakeStageSnapshot >)> on_finished)
void	process (Ctl &ctl) override
void	finalize (bool canceled, std::exception_ptr &eptr) override

Private Attributes
TextureDisplacementDebugInput	m_input
std::vector< BakeStageSnapshot >	m_stages
std::function< void(std::vector< BakeStageSnapshot >)>	m_on_finished

Detailed Description

Member Enumeration Documentation

JobPrepareState

enum Slic3r::GUI::Job::JobPrepareState

inherited

Enumerator
PREPARE_STATE_DEFAULT
PREPARE_STATE_MENU

                         {
        PREPARE_STATE_DEFAULT = 0,
        PREPARE_STATE_MENU = 1,
    };

Constructor & Destructor Documentation

TextureDisplacementDebugJob()

Slic3r::GUI::TextureDisplacementDebugJob::TextureDisplacementDebugJob	(	TextureDisplacementDebugInput &&	input,
		std::function< void(std::vector< BakeStageSnapshot >)>	on_finished )

    : m_input(std::move(input)), m_on_finished(std::move(on_finished))
{
}

References m_input, and m_on_finished.

Member Function Documentation

finalize()

void Slic3r::GUI::TextureDisplacementDebugJob::finalize ( bool canceled, std::exception_ptr & eptr )

overridevirtual

Reimplemented from Slic3r::GUI::Job.

{
    if (!m_on_finished)
        return;
    // The handler must run on every outcome - the caller uses it to clear its in-progress latch, and
    // an empty vector is its signal that nothing usable came back.
    if (canceled || eptr)
        m_on_finished({});
    else
        m_on_finished(std::move(m_stages));
}

References m_on_finished, and m_stages.

process()

void Slic3r::GUI::TextureDisplacementDebugJob::process ( Ctl & ctl )

overridevirtual

Implements Slic3r::GUI::Job.

{
    const std::string status = _u8L("Capturing bake stages");
    ctl.update_status(1, status);
 
    // Only ever touches m_input (captured by value before this job was queued) and local state - and,
    // unlike the bake job, never writes anything back either.
    int        last_reported = 1;
    const auto report        = [&ctl, &status, &last_reported](int percent) {
        if (ctl.was_canceled())
            return false;
        if (percent > last_reported) {
            last_reported = percent;
            ctl.update_status(percent, status);
        }
        return true;
    };
 
    BakeStageRecorder recorder;
    recorder.enable(true);
    recorder.set_check_topology(m_input.check_topology);
    recorder.set_mesh_cap(m_input.mesh_cap);
 
    indexed_triangle_set          mesh  = m_input.base_mesh;
    TextureDisplacementFacetsData masks = m_input.facets_data;
    std::vector<Vec2f>            uv    = m_input.model_uv;
 
    // The default pipeline can only move vertices the mesh already has, so its recipe starts with the
    // preparation - which is where "first it remeshes, then it refines" actually happens. The
    // experimental pipeline refines as part of the bake and has nothing to prepare.
    if (m_input.run_prepare && !m_input.options.pipeline_v2) {
        const TextureDisplacementPrepareResult prepared =
            GLGizmoTextureDisplacement::prepare_mesh(mesh, masks, m_input.layers, uv, m_input.prepare_texture_frame,
                                                     m_input.prepare_params, m_input.color,
                                                     // Preparation is roughly half the run; the bake
                                                     // takes the progress bar from there.
                                                     [&report](int pct) { return report(1 + pct / 2); },
                                                     &recorder);
        if (ctl.was_canceled())
            return;
        // An empty result means nothing needed doing, which is not a failure - the bake below simply
        // runs on the mesh as it stands. paint_lost means the remesh dropped every layer's paint, so
        // there is nothing left to displace and the stages recorded so far are the whole story.
        if (prepared.paint_lost) {
            m_stages = recorder.take();
            ctl.update_status(100, status);
            return;
        }
        if (!prepared.mesh.indices.empty()) {
            mesh  = prepared.mesh;
            masks = prepared.masks;
            uv    = prepared.uv; // resampled onto the prepared mesh, as the prepare commit stores it
        }
    }
 
    build_texture_displacement(mesh, m_input.layers, masks, m_input.options,
                               [&report](int pct) { return report(50 + pct / 2); },
                               /* color */ nullptr, m_input.volume_to_world, &recorder, /* stats */ nullptr,
                               uv.empty() ? nullptr : &uv, /* texture_anchor: the volume's own origin */ nullptr,
                               m_input.resting_drop);
 
    m_stages = recorder.take();
    ctl.update_status(100, status); // always finish at 100: this is what closes the notification
}

References _u8L, Slic3r::build_texture_displacement(), Slic3r::BakeStageRecorder::enable(), m_input, m_stages, Slic3r::TextureDisplacementPrepareResult::masks, Slic3r::TextureDisplacementPrepareResult::mesh, Slic3r::TextureDisplacementPrepareResult::paint_lost, Slic3r::GUI::GLGizmoTextureDisplacement::prepare_mesh(), Slic3r::BakeStageRecorder::set_check_topology(), Slic3r::BakeStageRecorder::set_mesh_cap(), Slic3r::BakeStageRecorder::take(), Slic3r::GUI::Job::Ctl::update_status(), Slic3r::TextureDisplacementPrepareResult::uv, and Slic3r::GUI::Job::Ctl::was_canceled().

Here is the call graph for this function:

Member Data Documentation

m_input

TextureDisplacementDebugInput Slic3r::GUI::TextureDisplacementDebugJob::m_input

private

Referenced by TextureDisplacementDebugJob(), and process().

m_on_finished

std::function<void(std::vector<BakeStageSnapshot>)> Slic3r::GUI::TextureDisplacementDebugJob::m_on_finished

private

Referenced by TextureDisplacementDebugJob(), and finalize().

m_stages

std::vector<BakeStageSnapshot> Slic3r::GUI::TextureDisplacementDebugJob::m_stages

private

Referenced by finalize(), and process().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/TextureDisplacementDebugJob.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/TextureDisplacementDebugJob.cpp