Slic3r::TriangleSelector::TriangleSplittingData Struct Reference

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

Collaboration diagram for Slic3r::TriangleSelector::TriangleSplittingData:

Public Member Functions
	TriangleSplittingData ()=default
void	reset_used_states ()
bool	update_used_states (size_t bitstream_start_idx)
bool	read_nibble (int &ibit, int &nibble) const

Public Attributes
std::vector< TriangleBitStreamMapping >	triangles_to_split
std::vector< bool >	bitstream
std::vector< bool >	used_states { std::vector<bool>(static_cast<size_t>(EnforcerBlockerType::ExtruderMax) + 1, false) }

Private Member Functions
template<class Archive>
void	serialize (Archive &ar)

Friends
class	cereal::access
bool	operator== (const TriangleSplittingData &lhs, const TriangleSplittingData &rhs)
bool	operator!= (const TriangleSplittingData &lhs, const TriangleSplittingData &rhs)

Detailed Description

Constructor & Destructor Documentation

TriangleSplittingData()

Slic3r::TriangleSelector::TriangleSplittingData::TriangleSplittingData ( )

default

Referenced by operator!=, and operator==.

Here is the caller graph for this function:

Member Function Documentation

read_nibble()

bool Slic3r::TriangleSelector::TriangleSplittingData::read_nibble ( int & ibit, int & nibble ) const

inline

                                                       {
            if (ibit < 0 || static_cast<size_t>(ibit) + 4 > bitstream.size())
                return false;
            nibble = 0;
            for (int i = 0; i < 4; ++i)
                nibble |= static_cast<int>(bitstream[ibit++]) << i;
            return true;
        }

References bitstream.

Referenced by Slic3r::TriangleSelector::deserialize(), Slic3r::TriangleSelector::has_facets(), and update_used_states().

Here is the caller graph for this function:

reset_used_states()

void Slic3r::TriangleSelector::TriangleSplittingData::reset_used_states ( )

inline

                                 {
            used_states.resize(static_cast<size_t>(EnforcerBlockerType::ExtruderMax) + 1, false);
            std::fill(used_states.begin(), used_states.end(), false);
        }

References Slic3r::ExtruderMax, and used_states.

serialize()

template<class Archive>

void Slic3r::TriangleSelector::TriangleSplittingData::serialize ( Archive & ar )

inlineprivate

{ ar(triangles_to_split, bitstream, used_states); }

References bitstream, triangles_to_split, and used_states.

Referenced by Slic3r::GUI::GLGizmoMmuSegmentation::update_used_filaments().

Here is the caller graph for this function:

update_used_states()

bool Slic3r::TriangleSelector::TriangleSplittingData::update_used_states

(

size_t

bitstream_start_idx

)

                                                                                               {
    int      ibit   = static_cast<int>(bitstream_start_idx);
    uint64_t states = 0;
    do {
        // Walk one triangle's tree depth-first, counting the nodes still to be read; a split node adds its children.
        for (int pending_nodes = 1; pending_nodes > 0; --pending_nodes) {
            int code;
            if (!this->read_nibble(ibit, code))
                return false;
 
            if (const int num_of_split_sides = code & 0b11; num_of_split_sides != 0) {
                if (!split_code_valid(code))
                    return false;
                pending_nodes += num_of_split_sides + 1;
                continue;
            }
 
            int facet_state = code >> 2;
            if (facet_state == 0b11) {
                // Leaf behind the "11" prefix: one nibble of (state-3), or 0b1111 + (state-18).
                int nibble;
                if (!this->read_nibble(ibit, nibble))
                    return false;
                facet_state = nibble + 3;
                if (nibble == 0b1111) {
                    if (!this->read_nibble(ibit, nibble))
                        return false;
                    facet_state = nibble + 18;
                }
            }
            states |= uint64_t(1) << facet_state;
        }
    } while (static_cast<size_t>(ibit) < this->bitstream.size());
 
    // The leaf encoding tops out at state 33, so every state fits the 64-bit mask.
    for (size_t state_idx = 0; state_idx < std::min<size_t>(this->used_states.size(), 64); ++state_idx)
        if (states & (uint64_t(1) << state_idx))
            this->used_states[state_idx] = true;
    return true;
}

References bitstream, read_nibble(), Slic3r::split_code_valid(), and used_states.

Here is the call graph for this function:

Friends And Related Symbol Documentation

cereal::access

friend class cereal::access

friend

References cereal::access.

Referenced by cereal::access.

operator!=

bool operator!= ( const TriangleSplittingData & lhs, const TriangleSplittingData & rhs )

friend

{ return !(lhs == rhs); }

References TriangleSplittingData().

operator==

bool operator== ( const TriangleSplittingData & lhs, const TriangleSplittingData & rhs )

friend

                                                                                                   {
            return lhs.triangles_to_split == rhs.triangles_to_split
                && lhs.bitstream          == rhs.bitstream
                && lhs.used_states        == rhs.used_states;
        }

References TriangleSplittingData(), bitstream, triangles_to_split, and used_states.

Member Data Documentation

bitstream

std::vector<bool> Slic3r::TriangleSelector::TriangleSplittingData::bitstream

Referenced by Slic3r::TriangleSelector::deserialize(), operator==, read_nibble(), Slic3r::TriangleSelector::remap_painting(), Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::remap_texture_paint_spatial(), Slic3r::ModelVolume::restore_painting(), Slic3r::TriangleSelector::serialize(), serialize(), Slic3r::transfer_facet_paint(), and update_used_states().

triangles_to_split

std::vector<TriangleBitStreamMapping> Slic3r::TriangleSelector::TriangleSplittingData::triangles_to_split

Referenced by Slic3r::build_texture_displacement_in_place(), Slic3r::GUI::GLGizmoTextureDisplacement::collect_paint_region(), Slic3r::TriangleSelector::deserialize(), Slic3r::extract_painted_patch(), Slic3r::TriangleSelector::has_facets(), main(), operator==, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::prepare_sampleable_layers(), Slic3r::GUI::GLGizmoTextureDisplacement::rebuild_painted_colors(), serialize(), Slic3r::GUI::GLGizmoTextureDisplacement::smooth_model(), and Slic3r::GUI::GLGizmoTextureDisplacement::update_from_model_object().

used_states

std::vector<bool> Slic3r::TriangleSelector::TriangleSplittingData::used_states { std::vector<bool>(static_cast<size_t>(EnforcerBlockerType::ExtruderMax) + 1, false) }

{ std::vector<bool>(static_cast<size_t>(EnforcerBlockerType::ExtruderMax) + 1, false) };

Referenced by Slic3r::TriangleSelector::extract_used_facet_states(), Slic3r::ModelVolume::get_extruders_from_multi_material_painting(), operator==, reset_used_states(), Slic3r::TriangleSelector::serialize(), serialize(), and update_used_states().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/TriangleSelector.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/TriangleSelector.cpp