libvgcode Namespace Reference

|/ Copyright (c) Prusa Research 2023 Enrico Turri @enricoturri1966, Pavel Mikuš @Godrak |/ |/ libvgcode is released under the terms of the AGPLv3 or higher |/ More...

Classes
struct	ColorPrint
class	ColorRange
struct	GCodeInputData
struct	PathVertex
class	Viewer
struct	BitSet
class	ExtrusionRoles
class	Layers
class	OpenGLWrapper
class	OptionTemplate
class	Range
class	SegmentTemplate
struct	Settings
class	ViewerImpl
class	ViewRange
struct	VerticesData
class	WipeTowerHelper
class	ObjectHelper

Typedefs
using	Vec3 = std::array<float, 3>
using	Vec4 = std::array<float, 4>
using	Mat4x4 = std::array<float, 16>
using	Color = std::array<uint8_t, 3>
using	Palette = std::vector<Color>
using	ColorWithAlpha = std::array<uint8_t, 4>
using	PaletteWithAlpha = std::vector<ColorWithAlpha>
using	AABox = std::array<Vec3, 2>
using	Interval = std::array<std::size_t, 2>
template<class T, class O = T>
using	IntegerOnly = std::enable_if_t<std::is_integral<T>::value, O>

Enumerations
enum class	EViewType : uint8_t {   Summary , FeatureType , ColorPrint , Speed ,   ActualSpeed , Height , Width , VolumetricFlowRate ,   ActualVolumetricFlowRate , LayerTimeLinear , LayerTimeLogarithmic , FanSpeed ,   Temperature , PressureAdvance , Acceleration , Jerk ,   Tool , COUNT }
enum class	EMoveType : uint8_t {   Noop , Retract , Unretract , Seam ,   ToolChange , ColorChange , PausePrint , CustomGCode ,   Travel , Wipe , Extrude , COUNT }
enum class	EGCodeExtrusionRole : uint8_t {   None , Perimeter , ExternalPerimeter , OverhangPerimeter ,   InternalInfill , SolidInfill , TopSolidInfill , Ironing ,   BridgeInfill , GapFill , Skirt , SupportMaterial ,   SupportMaterialInterface , WipeTower , Custom , BottomSurface ,   InternalBridgeInfill , Brim , SupportTransition , Mixed ,   COUNT }
enum class	EOptionType : uint8_t {   Travels , Wipes , Retractions , Unretractions ,   Seams , ToolChanges , ColorChanges , PausePrints ,   CustomGCodes , COUNT }
enum class	ETimeMode : uint8_t { Normal , Stealth , COUNT }
enum class	EColorRangeType : uint8_t { Linear , Logarithmic , COUNT }

Functions
EOptionType	move_type_to_option (EMoveType type)
Color	lerp (const Color &c1, const Color &c2, float t)
static float	get_step_size (const ColorRange &color_range)
static bool	is_colorprint_option (const PathVertex &v)
void	glAssertRecentCallImpl (const char *file_name, unsigned int line, const char *function_name)
void	glAssertRecentCall ()
static uint8_t	lerp (uint8_t f1, uint8_t f2, float t)
void	add_vertex (const Vec3 &position, const Vec3 &normal, std::vector< float > &vertices)
void	add_triangle (uint16_t v1, uint16_t v2, uint16_t v3, std::vector< uint16_t > &indices)
Vec3	normalize (const Vec3 &v)
float	dot (const Vec3 &v1, const Vec3 &v2)
float	length (const Vec3 &v)
bool	operator== (const Vec3 &v1, const Vec3 &v2)
bool	operator!= (const Vec3 &v1, const Vec3 &v2)
Vec3	operator+ (const Vec3 &v1, const Vec3 &v2)
Vec3	operator- (const Vec3 &v1, const Vec3 &v2)
Vec3	operator* (float f, const Vec3 &v)
template<typename I>
IntegerOnly< I, I >	fast_round_up (double a)
static float	round_to_bin (const float value)
static Mat4x4	inverse (const Mat4x4 &m)
std::string	check_shader (GLuint handle)
std::string	check_program (GLuint handle)
unsigned int	init_shader (const std::string &shader_name, const char *vertex_shader, const char *fragment_shader, const std::vector< const char * > &fragment_outputs={})
static void	delete_textures (unsigned int &id)
static void	delete_buffers (unsigned int &id)
static std::string	with_define (const char *source, const char *define)
static bool	is_line (const std::vector< PathVertex > &vertices, size_t i)
static bool	is_joint (const std::vector< PathVertex > &vertices, size_t i)
static void	extract_pos_and_or_hwa (const std::vector< PathVertex > &vertices, float travels_radius, float wipes_radius, BitSet<> &valid_lines_bitset, std::vector< Vec4 > *positions=nullptr, std::vector< Vec4 > *heights_widths_angles=nullptr, bool update_bitset=false)
static bool	is_visible (const PathVertex &v, const Settings &settings)
Vec3	convert (const Slic3r::Vec3f &v)
Slic3r::Vec3f	convert (const Vec3 &v)
Mat4x4	convert (const Slic3r::Matrix4f &m)
Slic3r::ColorRGBA	convert (const Color &c)
Color	convert (const Slic3r::ColorRGBA &c)
Slic3r::ColorRGBA	convert (const ColorWithAlpha &c)
PaletteWithAlpha	convert_filament_colors (const std::vector< std::string > &colors_str)
Slic3r::ExtrusionRole	convert (EGCodeExtrusionRole role)
EGCodeExtrusionRole	convert (Slic3r::ExtrusionRole role)
EMoveType	convert (Slic3r::EMoveType type)
ETimeMode	convert (const Slic3r::PrintEstimatedStatistics::ETimeMode &mode)
Slic3r::PrintEstimatedStatistics::ETimeMode	convert (const ETimeMode &mode)
static bool	starts_path (const Slic3r::GCodeProcessorResult::MoveVertex &prev, const Slic3r::GCodeProcessorResult::MoveVertex &curr, bool first_move)
GCodeInputData	convert (const Slic3r::GCodeProcessorResult &result, const std::vector< std::string > &str_tool_colors, const std::vector< std::string > &str_color_print_colors, const Viewer &viewer, const Slic3r::Transform3d *belt_xform)
static void	convert_lines_to_vertices (const Slic3r::Lines &lines, const std::vector< float > &widths, const std::vector< float > &heights, float top_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, bool closed, std::vector< PathVertex > &vertices)
static void	convert_to_vertices (const Slic3r::ExtrusionPath &extrusion_path, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point &shift, std::vector< PathVertex > &vertices)
static void	convert_to_vertices (const Slic3r::ExtrusionMultiPath &extrusion_multi_path, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point &shift, std::vector< PathVertex > &vertices)
static void	convert_to_vertices (const Slic3r::ExtrusionLoop &extrusion_loop, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point &shift, std::vector< PathVertex > &vertices)
static void	convert_to_vertices (const Slic3r::ExtrusionEntityCollection &extrusion_entity_collection, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point &shift, std::vector< PathVertex > &vertices)
static void	convert_to_vertices (const Slic3r::ExtrusionEntity &extrusion_entity, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point &shift, std::vector< PathVertex > &vertices)
static void	convert_brim_skirt_to_vertices (const Slic3r::Print &print, std::vector< VerticesData > &vertices_data)
static void	convert_wipe_tower_to_vertices (const Slic3r::Print &print, const std::vector< std::string > &str_tool_colors, std::vector< VerticesData > &vertices_data)
static void	convert_object_to_vertices (const Slic3r::PrintObject &object, const std::vector< std::string > &str_tool_colors, const std::vector< std::string > &str_color_print_colors, const std::vector< Slic3r::CustomGCode::Item > &color_print_values, size_t extruders_count, VerticesData &data)
static void	convert_objects_to_vertices (const Slic3r::ConstPrintObjectPtrsAdaptor &objects, const std::vector< std::string > &str_tool_colors, const std::vector< std::string > &str_color_print_colors, const std::vector< Slic3r::CustomGCode::Item > &color_print_values, size_t extruders_count, std::vector< VerticesData > &data)
GCodeInputData	convert (const Slic3r::Print &print, const std::vector< std::string > &str_tool_colors, const std::vector< std::string > &str_color_print_colors, const std::vector< Slic3r::CustomGCode::Item > &color_print_values, size_t extruders_count)

Variables
static const Palette	DEFAULT_RANGES_COLORS
static constexpr float	PI = 3.141592f
static constexpr float	DEFAULT_TRAVELS_RADIUS_MM = 0.1f
static constexpr float	MIN_TRAVELS_RADIUS_MM = 0.05f
static constexpr float	MAX_TRAVELS_RADIUS_MM = 1.0f
static constexpr float	DEFAULT_WIPES_RADIUS_MM = 0.1f
static constexpr float	MIN_WIPES_RADIUS_MM = 0.05f
static constexpr float	MAX_WIPES_RADIUS_MM = 1.0f
static constexpr std::size_t	VIEW_TYPES_COUNT = static_cast<std::size_t>(EViewType::COUNT)
static constexpr std::size_t	MOVE_TYPES_COUNT = static_cast<std::size_t>(EMoveType::COUNT)
static constexpr std::size_t	GCODE_EXTRUSION_ROLES_COUNT = static_cast<std::size_t>(EGCodeExtrusionRole::COUNT)
static constexpr std::size_t	OPTION_TYPES_COUNT = static_cast<std::size_t>(EOptionType::COUNT)
static constexpr std::size_t	TIME_MODES_COUNT = static_cast<std::size_t>(ETimeMode::COUNT)
static constexpr std::size_t	COLOR_RANGE_TYPES_COUNT = static_cast<std::size_t>(EColorRangeType::COUNT)
static const Color	DUMMY_COLOR { 64, 64, 64 }
template<typename T>
auto constexpr	is_atomic = false
template<typename T>
auto constexpr	is_atomic< std::atomic< T > > = true
static const char *	OPENGL_ES_PREFIXES [] = { "OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", nullptr }
static constexpr const std::array< uint32_t, 8 >	VERTEX_DATA = { 0, 1, 2, 3, 4, 5, 6, 7 }
static constexpr const std::array< uint16_t, 24 >	INDEX_DATA
static const char *	Segments_Vertex_Shader
static const char *	Segments_Shadow_Caster_Vertex_Shader
static const char *	Segments_Shadow_Caster_Fragment_Shader
static const char *	Segments_Fragment_Shader
static const char *	Translucent_Composite_Vertex_Shader
static const char *	Translucent_Composite_Fragment_Shader
static const char *	Options_Vertex_Shader
static const char *	Options_Fragment_Shader
static const char *	Segments_Vertex_Shader_ES
static const char *	Segments_Shadow_Caster_Vertex_Shader_ES
static const char *	Segments_Shadow_Caster_Fragment_Shader_ES
static const char *	Segments_Fragment_Shader_ES
static const char *	Options_Vertex_Shader_ES
static const char *	Options_Fragment_Shader_ES
static constexpr int	TRANSLUCENT_TEXTURE_UNIT = 5
static const std::array< Color, size_t(EGCodeExtrusionRole::COUNT)>	DEFAULT_EXTRUSION_ROLES_COLORS
static const std::array< Color, size_t(EOptionType::COUNT)>	DEFAULT_OPTIONS_COLORS

Detailed Description

|/ Copyright (c) Prusa Research 2023 Enrico Turri @enricoturri1966, Pavel Mikuš @Godrak |/ |/ libvgcode is released under the terms of the AGPLv3 or higher |/

|/ Copyright (c) Prusa Research 2020 - 2023 Enrico Turri @enricoturri1966 |/ |/ PrusaSlicer is released under the terms of the AGPLv3 or higher |/

|/ Copyright (c) Prusa Research 2023 Enrico Turri @enricoturri1966, Pavel Mikuš @Godrak, Vojtěch Bubník @bubnikv, Oleksandra Iushchenko @YuSanka |/ |/ libvgcode is released under the terms of the AGPLv3 or higher |/

|/ Copyright (c) Prusa Research 2023 Enrico Turri @enricoturri1966, Pavel Mikuš @Godrak, Vojtěch Bubník @bubnikv |/ |/ libvgcode is released under the terms of the AGPLv3 or higher |/

|/ Copyright (c) Prusa Research 2023 Enrico Turri @enricoturri1966 |/ |/ libvgcode is released under the terms of the AGPLv3 or higher |/

---

Class Documentation

libvgcode::ColorPrint

struct libvgcode::ColorPrint

Collaboration diagram for libvgcode::ColorPrint:

Class Members
uint8_t	color_id { 0 }
uint8_t	extruder_id { 0 }
uint32_t	layer_id { 0 }
array< float, TIME_MODES_COUNT >	times { 0.0f, 0.0f }

libvgcode::GCodeInputData

struct libvgcode::GCodeInputData

Collaboration diagram for libvgcode::GCodeInputData:

Class Members
PaletteWithAlpha	color_print_colors
bool	spiral_vase_mode { false }
PaletteWithAlpha	tools_colors
vector< PathVertex >	vertices

libvgcode::Settings

struct libvgcode::Settings

Collaboration diagram for libvgcode::Settings:

Class Members
bool	dim_previous_layers { false }
float	dim_previous_layers_brightness { 0.4f }
array< bool, size_t(COUNT)>	extrusion_roles_visibility
array< bool, size_t(COUNT)>	options_visibility
bool	spiral_vase_mode { false }
ETimeMode	time_mode { ETimeMode::Normal }
bool	top_layer_only_view_range { false }
bool	translucent_filaments { true }
bool	update_colors { true }
bool	update_enabled_entities { true }
bool	update_view_full_range { true }
EViewType	view_type { EViewType::FeatureType }

libvgcode::VerticesData

struct libvgcode::VerticesData

Collaboration diagram for libvgcode::VerticesData:

Class Members
vector< float >	layers_zs
vector< PathVertex >	vertices

Typedef Documentation

AABox

using libvgcode::AABox = std::array<Vec3, 2>

Color

using libvgcode::Color = std::array<uint8_t, 3>

ColorWithAlpha

using libvgcode::ColorWithAlpha = std::array<uint8_t, 4>

IntegerOnly

template<class T, class O = T>

using libvgcode::IntegerOnly = std::enable_if_t<std::is_integral<T>::value, O>

Interval

using libvgcode::Interval = std::array<std::size_t, 2>

Mat4x4

using libvgcode::Mat4x4 = std::array<float, 16>

Palette

using libvgcode::Palette = std::vector<Color>

PaletteWithAlpha

using libvgcode::PaletteWithAlpha = std::vector<ColorWithAlpha>

Vec3

using libvgcode::Vec3 = std::array<float, 3>

Vec4

using libvgcode::Vec4 = std::array<float, 4>

Enumeration Type Documentation

EColorRangeType

enum class libvgcode::EColorRangeType : uint8_t

strong

Enumerator
Linear
Logarithmic
COUNT

{
    Linear,
    Logarithmic,
    COUNT
};

EGCodeExtrusionRole

enum class libvgcode::EGCodeExtrusionRole : uint8_t

strong

Enumerator
None
Perimeter
ExternalPerimeter
OverhangPerimeter
InternalInfill
SolidInfill
TopSolidInfill
Ironing
BridgeInfill
GapFill
Skirt
SupportMaterial
SupportMaterialInterface
WipeTower
Custom
BottomSurface
InternalBridgeInfill
Brim
SupportTransition
Mixed
COUNT

{
      // This enum is used as in index into extrusion_roles_visibility.
      // Better only add things to the end.
    None,
    Perimeter,
    ExternalPerimeter,
    OverhangPerimeter,
    InternalInfill,
    SolidInfill,
    TopSolidInfill,
    Ironing,
    BridgeInfill,
    GapFill,
    Skirt,
    SupportMaterial,
    SupportMaterialInterface,
    WipeTower,
    Custom,
      // ORCA
      BottomSurface,
      InternalBridgeInfill,
      Brim,
      SupportTransition,
      Mixed,
    COUNT
};

EMoveType

enum class libvgcode::EMoveType : uint8_t

strong

Enumerator
Noop
Retract
Unretract
Seam
ToolChange
ColorChange
PausePrint
CustomGCode
Travel
Wipe
Extrude
COUNT

{
    Noop,
    Retract,
    Unretract,
    Seam,
    ToolChange,
    ColorChange,
    PausePrint,
    CustomGCode,
    Travel,
    Wipe,
    Extrude,
    COUNT
};

EOptionType

enum class libvgcode::EOptionType : uint8_t

strong

Enumerator
Travels
Wipes
Retractions
Unretractions
Seams
ToolChanges
ColorChanges
PausePrints
CustomGCodes
COUNT

{
    // This enum is used as in index into options_visibility.
    // Better only add things to the end.
    Travels,
    Wipes,
    Retractions,
    Unretractions,
    Seams,
    ToolChanges,
    ColorChanges,
    PausePrints,
    CustomGCodes,
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    CenterOfGravity,
    ToolMarker,
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    COUNT
};

ETimeMode

enum class libvgcode::ETimeMode : uint8_t

strong

Enumerator
Normal
Stealth
COUNT

{
    Normal,
    Stealth,
    COUNT
};

EViewType

enum class libvgcode::EViewType : uint8_t

strong

Enumerator
Summary
FeatureType
ColorPrint
Speed
ActualSpeed
Height
Width
VolumetricFlowRate
ActualVolumetricFlowRate
LayerTimeLinear
LayerTimeLogarithmic
FanSpeed
Temperature
PressureAdvance
Acceleration
Jerk
Tool
COUNT

{
    Summary, // ORCA
    FeatureType,
    ColorPrint,
    Speed,
    ActualSpeed,
    Height,
    Width,
    VolumetricFlowRate,
    ActualVolumetricFlowRate,
    LayerTimeLinear,
    LayerTimeLogarithmic,
    FanSpeed,
    Temperature,
// ORCA: Add Pressure Advance visualization support
    PressureAdvance,
    // ORCA: Add Acceleration visualization support
    Acceleration,
    // ORCA: Add Jerk visualization support
    Jerk,
    Tool,
    COUNT
};

Function Documentation

add_triangle()

void libvgcode::add_triangle	(	uint16_t	v1,
		uint16_t	v2,
		uint16_t	v3,
		std::vector< uint16_t > &	indices )

{
    indices.emplace_back(v1);
    indices.emplace_back(v2);
    indices.emplace_back(v3);
}

add_vertex()

void libvgcode::add_vertex	(	const Vec3 &	position,
		const Vec3 &	normal,
		std::vector< float > &	vertices )

{
    vertices.emplace_back(position[0]);
    vertices.emplace_back(position[1]);
    vertices.emplace_back(position[2]);
    vertices.emplace_back(normal[0]);
    vertices.emplace_back(normal[1]);
    vertices.emplace_back(normal[2]);
}

Referenced by libvgcode::OptionTemplate::init().

Here is the caller graph for this function:

check_program()

std::string libvgcode::check_program

(

GLuint

handle

)

{
    std::string ret;
    GLint params;
    glsafe(glGetProgramiv(handle, GL_LINK_STATUS, &params));
    if (params == GL_FALSE) {
        glsafe(glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &params));
        ret.resize(params);
        glsafe(glGetProgramInfoLog(handle, params, &params, ret.data()));
    }
    return ret;
}

References GL_FALSE, GL_INFO_LOG_LENGTH, GL_LINK_STATUS, glGetProgramInfoLog, glGetProgramiv, and glsafe.

check_shader()

std::string libvgcode::check_shader

(

GLuint

handle

)

{
    std::string ret;
    GLint params;
    glsafe(glGetShaderiv(handle, GL_COMPILE_STATUS, &params));
    if (params == GL_FALSE) {
        glsafe(glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &params));
        ret.resize(params);
        glsafe(glGetShaderInfoLog(handle, params, &params, ret.data()));
    }
    return ret;
}

References GL_COMPILE_STATUS, GL_FALSE, GL_INFO_LOG_LENGTH, glGetShaderInfoLog, glGetShaderiv, and glsafe.

convert() [1/13]

Slic3r::ColorRGBA libvgcode::convert

(

const Color &

c

)

{
    static const float inv_255 = 1.0f / 255.0f;
    return { c[0] * inv_255, c[1] * inv_255, c[2] * inv_255, 1.0f };
}

convert() [2/13]

Slic3r::ColorRGBA libvgcode::convert

(

const ColorWithAlpha &

c

)

{
    static const float inv_255 = 1.0f / 255.0f;
    return { c[0] * inv_255, c[1] * inv_255, c[2] * inv_255, c[3] * inv_255 };
}

convert() [3/13]

Slic3r::PrintEstimatedStatistics::ETimeMode libvgcode::convert

(

const ETimeMode &

mode

)

{
    switch (mode)
    {
    case ETimeMode::Normal:  { return Slic3r::PrintEstimatedStatistics::ETimeMode::Normal; }
    case ETimeMode::Stealth: { return Slic3r::PrintEstimatedStatistics::ETimeMode::Stealth; }
    default:                 { return Slic3r::PrintEstimatedStatistics::ETimeMode::Count; }
    }
}

References Slic3r::PrintEstimatedStatistics::Count, Normal, Slic3r::PrintEstimatedStatistics::Normal, Stealth, and Slic3r::PrintEstimatedStatistics::Stealth.

convert() [4/13]

Color libvgcode::convert

(

const Slic3r::ColorRGBA &

c

)

{
    // ORCA: Fix dark color rendering. Ensure minimal brightness.
    auto safe_val = [](float v) -> uint8_t {
        return std::max((uint8_t)(v * 255.0f), (uint8_t)48);
    };
    return { safe_val(c.r()), safe_val(c.g()), safe_val(c.b()) };
}

References Slic3r::ColorRGBA::b(), Slic3r::ColorRGBA::g(), and Slic3r::ColorRGBA::r().

Here is the call graph for this function:

convert() [5/13]

GCodeInputData libvgcode::convert	(	const Slic3r::GCodeProcessorResult &	result,
		const std::vector< std::string > &	str_tool_colors,
		const std::vector< std::string > &	str_color_print_colors,
		const Viewer &	viewer,
		const Slic3r::Transform3d *	belt_xform )

{
    GCodeInputData ret;
 
    // Belt printers: optionally map each vertex DISPLAY position from machine
    // (G-code) space back to model/Cartesian space using the general belt
    // back-transform (handles any mesh rotation + shear + axis remap, not just
    // 45 deg). Only the rendered position is transformed; layer_id, times and
    // the volumetric/flow math below keep the original machine-space values.
    auto xform_pos = [belt_xform](const Slic3r::Vec3f& v) -> Vec3 {
        if (belt_xform != nullptr)
            return convert(Slic3r::Vec3f((*belt_xform * v.cast<double>()).cast<float>()));
        return convert(v);
    };
 
    ret.tools_colors = convert_filament_colors(str_tool_colors);
    ret.color_print_colors = convert_filament_colors(str_color_print_colors.empty() ? str_tool_colors : str_color_print_colors);
 
    const std::vector<Slic3r::GCodeProcessorResult::MoveVertex>& moves = result.moves;
    // One vertex per move after the first, plus a phantom in front of every path start. Reserving
    // the exact count leaves nothing to shrink afterwards, and shrinking would copy the whole array
    // while both copies are alive.
    size_t vertices_count = moves.empty() ? 0 : moves.size() - 1;
    for (size_t i = 1; i < moves.size(); ++i)
        if (starts_path(moves[i - 1], moves[i], i == 1))
            ++vertices_count;
    ret.vertices.reserve(vertices_count);
    // libvgcode numbers its layers from the vertices it is given and expects them to
    // arrive one layer after the other with consecutive ids: a layer without any move
    // (a belt file can carry layer changes that print nothing) would leave a gap, and
    // every later vertex would then be folded into the last layer created.  Renumber
    // the ids consecutively over the moves that exist.
    uint32_t src_layer_id = std::numeric_limits<uint32_t>::max();
    uint32_t layer_id     = 0;
    for (size_t i = 1; i < moves.size(); ++i) {
        const Slic3r::GCodeProcessorResult::MoveVertex& curr = moves[i];
        const Slic3r::GCodeProcessorResult::MoveVertex& prev = moves[i - 1];
        const EMoveType curr_type = convert(curr.type);
        if (curr.layer_id != src_layer_id) {
            if (src_layer_id != std::numeric_limits<uint32_t>::max())
                ++ layer_id;
            src_layer_id = curr.layer_id;
        }
        if (starts_path(prev, curr, i == 1)) {
            // to allow libvgcode to properly detect the start/end of a path we need to add a 'phantom' vertex
            // equal to the current one with the exception of the position, which should match the previous move position,
            // and the times, which are set to zero
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
            const libvgcode::PathVertex vertex = { xform_pos(prev.position), curr.height, curr.width, curr.feedrate, prev.actual_feedrate,
                curr.mm3_per_mm, curr.fan_speed, curr.temperature, 0.0f, convert(curr.extrusion_role), curr_type,
                static_cast<uint32_t>(curr.gcode_id), layer_id,
                static_cast<uint8_t>(curr.extruder_id), static_cast<uint8_t>(curr.cp_color_id), { 0.0f, 0.0f },
                /* ORCA: Add Pressure Advance visualization support */ 0.0f, curr.pressure_advance,
                /* ORCA: Add Acceleration visualization support */ curr.acceleration,
                /* ORCA: Add Jerk visualization support */ curr.jerk };
#else
            const libvgcode::PathVertex vertex = { xform_pos(prev.position), curr.height, curr.width, curr.feedrate, prev.actual_feedrate,
                curr.mm3_per_mm, curr.fan_speed, curr.temperature, convert(curr.extrusion_role), curr_type,
                static_cast<uint32_t>(curr.gcode_id), layer_id,
                static_cast<uint8_t>(curr.extruder_id), static_cast<uint8_t>(curr.cp_color_id), { 0.0f, 0.0f },
                /* ORCA: Add Pressure Advance visualization support */ 0.0f, curr.pressure_advance,
                /* ORCA: Add Acceleration visualization support */ curr.acceleration,
                /* ORCA: Add Jerk visualization support */ curr.jerk };
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
            ret.vertices.emplace_back(vertex);
        }
 
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
        const libvgcode::PathVertex vertex = { xform_pos(curr.position), curr.height, curr.width, curr.feedrate, curr.actual_feedrate,
            curr.mm3_per_mm, curr.fan_speed, curr.temperature,
            result.filament_densities[curr.extruder_id] * curr.mm3_per_mm * (curr.position - prev.position).norm(),
            convert(curr.extrusion_role), curr_type, static_cast<uint32_t>(curr.gcode_id), layer_id,
            static_cast<uint8_t>(curr.extruder_id), static_cast<uint8_t>(curr.cp_color_id), curr.time,
            /* ORCA: Add Pressure Advance visualization support */ 0.0f, curr.pressure_advance,
            /* ORCA: Add Acceleration visualization support */ curr.acceleration,
            /* ORCA: Add Jerk visualization support */ curr.jerk };
#else
        const libvgcode::PathVertex vertex = { xform_pos(curr.position), curr.height, curr.width, curr.feedrate, curr.actual_feedrate,
            curr.mm3_per_mm, curr.fan_speed, curr.temperature, convert(curr.extrusion_role), curr_type,
            static_cast<uint32_t>(curr.gcode_id), layer_id,
            static_cast<uint8_t>(curr.extruder_id), static_cast<uint8_t>(curr.cp_color_id), curr.time,
            /* ORCA: Add Pressure Advance visualization support */ 0.0f, curr.pressure_advance,
            /* ORCA: Add Acceleration visualization support */ curr.acceleration,
            /* ORCA: Add Jerk visualization support */ curr.jerk };
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
        ret.vertices.emplace_back(vertex);
    }
    assert(ret.vertices.size() == vertices_count);
    // A no-op when the count above is exact; restores the exact fit if the count ever drifts.
    ret.vertices.shrink_to_fit();
 
    // Note: the belt designed-view anchoring (recovering the per-object placement/
    // lift translation the linear back-transform cannot) is folded into belt_xform
    // by the caller (GCodeViewer::load_as_gcode), which anchors onto the upright
    // model bounding box. Nothing extra to do here.
 
    ret.spiral_vase_mode = result.spiral_vase_mode;
 
    return ret;
}

References Slic3r::GCodeProcessorResult::MoveVertex::acceleration, Slic3r::GCodeProcessorResult::MoveVertex::actual_feedrate, libvgcode::GCodeInputData::color_print_colors, convert(), convert_filament_colors(), Slic3r::GCodeProcessorResult::MoveVertex::cp_color_id, Slic3r::GCodeProcessorResult::MoveVertex::extruder_id, Slic3r::GCodeProcessorResult::MoveVertex::extrusion_role, Slic3r::GCodeProcessorResult::MoveVertex::fan_speed, Slic3r::GCodeProcessorResult::MoveVertex::feedrate, Slic3r::GCodeProcessorResult::filament_densities, Slic3r::GCodeProcessorResult::MoveVertex::gcode_id, Slic3r::GCodeProcessorResult::MoveVertex::height, Slic3r::GCodeProcessorResult::MoveVertex::jerk, Slic3r::GCodeProcessorResult::MoveVertex::layer_id, Slic3r::GCodeProcessorResult::MoveVertex::mm3_per_mm, Slic3r::GCodeProcessorResult::moves, Slic3r::GCodeProcessorResult::MoveVertex::position, Slic3r::GCodeProcessorResult::MoveVertex::pressure_advance, libvgcode::GCodeInputData::spiral_vase_mode, Slic3r::GCodeProcessorResult::spiral_vase_mode, starts_path(), Slic3r::GCodeProcessorResult::MoveVertex::temperature, Slic3r::GCodeProcessorResult::MoveVertex::time, libvgcode::GCodeInputData::tools_colors, Slic3r::GCodeProcessorResult::MoveVertex::type, libvgcode::GCodeInputData::vertices, and Slic3r::GCodeProcessorResult::MoveVertex::width.

Here is the call graph for this function:

convert() [6/13]

Mat4x4 libvgcode::convert

(

const Slic3r::Matrix4f &

m

)

{
    Mat4x4 ret;
    std::memcpy(ret.data(), m.data(), 16 * sizeof(float));
    return ret;
}

convert() [7/13]

GCodeInputData libvgcode::convert	(	const Slic3r::Print &	print,
		const std::vector< std::string > &	str_tool_colors,
		const std::vector< std::string > &	str_color_print_colors,
		const std::vector< Slic3r::CustomGCode::Item > &	color_print_values,
		size_t	extruders_count )

{
    GCodeInputData ret;
    std::vector<VerticesData> data;
    if (print.is_step_done(Slic3r::psSkirtBrim) && (print.has_skirt() || print.has_brim()))
        // extract vertices and layers zs from skirt/brim
        convert_brim_skirt_to_vertices(print, data);
    if (!print.wipe_tower_data().tool_changes.empty() && print.is_step_done(Slic3r::psWipeTower))
        // extract vertices and layers zs from wipe tower
        convert_wipe_tower_to_vertices(print, str_tool_colors, data);
    // extract vertices and layers zs from objects
    convert_objects_to_vertices(print.objects(), str_tool_colors, str_color_print_colors, color_print_values, extruders_count, data);
 
    // collect layers zs
    std::vector<float> layers;
    for (const VerticesData& d : data) {
        layers.reserve(layers.size() + d.layers_zs.size());
        std::copy(d.layers_zs.begin(), d.layers_zs.end(), std::back_inserter(layers));
    }
    Slic3r::sort_remove_duplicates(layers);
 
    // Now we need to copy the vertices into ret.vertices to be consumed by the preliminary G-code preview.
    // We need to collect vertices in the first layer for all objects, push them into the output vector
    // and then do the same for all the layers. The algorithm relies on the fact that the vertices from
    // lower layers are always placed after vertices from the higher layer.
    std::vector<size_t> vert_indices(data.size(), 0);
    for (size_t layer_id = 0; layer_id < layers.size(); ++layer_id) {
        const float layer_z = layers[layer_id];
        for (size_t obj_idx = 0; obj_idx < data.size(); ++obj_idx) {
            // d contains PathVertices for one object. Let's stuff everything below this layer_z into ret.vertices.
            const size_t start_idx = vert_indices[obj_idx];
            size_t idx = start_idx;
            while (idx < data[obj_idx].vertices.size() && data[obj_idx].vertices[idx].position[2] <= layer_z)
                ++idx;
            // We have found a vertex above current layer_z. Let's copy the vertices into the output
            // and remember where to start when we process another layer.
            ret.vertices.insert(ret.vertices.end(),
                                data[obj_idx].vertices.begin() + start_idx,
                                data[obj_idx].vertices.begin() + idx);
            vert_indices[obj_idx] = idx;
        }
    }
 
 
    ret.tools_colors = convert_filament_colors(str_tool_colors);
    ret.color_print_colors = convert_filament_colors(str_color_print_colors.empty() ? str_tool_colors : str_color_print_colors);
 
    return ret;
}

References libvgcode::GCodeInputData::color_print_colors, convert(), convert_brim_skirt_to_vertices(), convert_filament_colors(), convert_objects_to_vertices(), convert_wipe_tower_to_vertices(), Slic3r::Print::has_brim(), Slic3r::Print::has_skirt(), Slic3r::Print::is_step_done(), Slic3r::Print::objects(), Slic3r::psSkirtBrim, Slic3r::psWipeTower, Slic3r::sort_remove_duplicates(), Slic3r::WipeTowerData::tool_changes, libvgcode::GCodeInputData::tools_colors, libvgcode::GCodeInputData::vertices, and Slic3r::Print::wipe_tower_data().

Here is the call graph for this function:

convert() [8/13]

ETimeMode libvgcode::convert

(

const Slic3r::PrintEstimatedStatistics::ETimeMode &

mode

)

{
    switch (mode)
    {
    case Slic3r::PrintEstimatedStatistics::ETimeMode::Normal:  { return ETimeMode::Normal; }
    case Slic3r::PrintEstimatedStatistics::ETimeMode::Stealth: { return ETimeMode::Stealth; }
    default:                                                   { return ETimeMode::COUNT; }
    }
}

References COUNT, Normal, Slic3r::PrintEstimatedStatistics::Normal, Stealth, and Slic3r::PrintEstimatedStatistics::Stealth.

convert() [9/13]

Vec3 libvgcode::convert

(

const Slic3r::Vec3f &

v

)

{
    return { v.x(), v.y(), v.z() };
}

Referenced by convert(), convert(), convert_filament_colors(), convert_lines_to_vertices(), Slic3r::GUI::ToolpathsObjExporter::export_segment(), Slic3r::GUI::GCodeViewer::load_as_gcode(), Slic3r::GUI::GCodeViewer::load_as_preview(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::GUI::GCodeViewer::render_markers(), Slic3r::GUI::GCodeViewer::SequentialView::Marker::render_position_window(), Slic3r::GUI::GCodeViewer::render_shadow_casters(), Slic3r::GUI::GCodeViewer::render_toolpaths(), Slic3r::GUI::GCodeViewer::render_translucent_toolpaths(), Slic3r::GUI::GCodeViewer::set_light_top_dir(), Slic3r::GUI::GCodeViewer::set_shadow_map(), starts_path(), and Slic3r::GUI::GCodeViewer::update_sequential_view_current().

Here is the caller graph for this function:

convert() [10/13]

Slic3r::Vec3f libvgcode::convert

(

const Vec3 &

v

)

{
    return { v[0], v[1], v[2] };
}

convert() [11/13]

Slic3r::ExtrusionRole libvgcode::convert

(

EGCodeExtrusionRole

role

)

{
    switch (role)
    {
    case EGCodeExtrusionRole::None:                     { return Slic3r::ExtrusionRole::erNone; }
    case EGCodeExtrusionRole::Perimeter:                { return Slic3r::ExtrusionRole::erPerimeter; }
    case EGCodeExtrusionRole::ExternalPerimeter:        { return Slic3r::ExtrusionRole::erExternalPerimeter; }
    case EGCodeExtrusionRole::OverhangPerimeter:        { return Slic3r::ExtrusionRole::erOverhangPerimeter; }
    case EGCodeExtrusionRole::InternalInfill:           { return Slic3r::ExtrusionRole::erInternalInfill; }
    case EGCodeExtrusionRole::SolidInfill:              { return Slic3r::ExtrusionRole::erSolidInfill; }
    case EGCodeExtrusionRole::TopSolidInfill:           { return Slic3r::ExtrusionRole::erTopSolidInfill; }
    case EGCodeExtrusionRole::Ironing:                  { return Slic3r::ExtrusionRole::erIroning; }
    case EGCodeExtrusionRole::BridgeInfill:             { return Slic3r::ExtrusionRole::erBridgeInfill; }
    case EGCodeExtrusionRole::GapFill:                  { return Slic3r::ExtrusionRole::erGapFill; }
    case EGCodeExtrusionRole::Skirt:                    { return Slic3r::ExtrusionRole::erSkirt; }
    case EGCodeExtrusionRole::SupportMaterial:          { return Slic3r::ExtrusionRole::erSupportMaterial; }
    case EGCodeExtrusionRole::SupportMaterialInterface: { return Slic3r::ExtrusionRole::erSupportMaterialInterface; }
    case EGCodeExtrusionRole::WipeTower:                { return Slic3r::ExtrusionRole::erWipeTower; }
    case EGCodeExtrusionRole::Custom:                   { return Slic3r::ExtrusionRole::erCustom; }
    // ORCA
    case EGCodeExtrusionRole::BottomSurface:            { return Slic3r::ExtrusionRole::erBottomSurface; }
    case EGCodeExtrusionRole::InternalBridgeInfill:     { return Slic3r::ExtrusionRole::erInternalBridgeInfill; }
    case EGCodeExtrusionRole::Brim:                     { return Slic3r::ExtrusionRole::erBrim; }
    case EGCodeExtrusionRole::SupportTransition:        { return Slic3r::ExtrusionRole::erSupportTransition; }
    case EGCodeExtrusionRole::Mixed:                    { return Slic3r::ExtrusionRole::erMixed; }
    default:                                            { return Slic3r::ExtrusionRole::erNone; }
    }
}

References BottomSurface, BridgeInfill, Brim, Custom, Slic3r::erBottomSurface, Slic3r::erBridgeInfill, Slic3r::erBrim, Slic3r::erCustom, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erIroning, Slic3r::erMixed, Slic3r::erNone, Slic3r::erOverhangPerimeter, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erTopSolidInfill, Slic3r::erWipeTower, ExternalPerimeter, GapFill, InternalBridgeInfill, InternalInfill, Ironing, Mixed, None, OverhangPerimeter, Perimeter, Skirt, SolidInfill, SupportMaterial, SupportMaterialInterface, SupportTransition, TopSolidInfill, and WipeTower.

convert() [12/13]

EMoveType libvgcode::convert

(

Slic3r::EMoveType

type

)

{
    switch (type)
    {
    case Slic3r::EMoveType::Noop:         { return EMoveType::Noop; }
    case Slic3r::EMoveType::Retract:      { return EMoveType::Retract; }
    case Slic3r::EMoveType::Unretract:    { return EMoveType::Unretract; }
    case Slic3r::EMoveType::Seam:         { return EMoveType::Seam; }
    case Slic3r::EMoveType::Tool_change:  { return EMoveType::ToolChange; }
    case Slic3r::EMoveType::Color_change: { return EMoveType::ColorChange; }
    case Slic3r::EMoveType::Pause_Print:  { return EMoveType::PausePrint; }
    case Slic3r::EMoveType::Custom_GCode: { return EMoveType::CustomGCode; }
    case Slic3r::EMoveType::Travel:       { return EMoveType::Travel; }
    case Slic3r::EMoveType::Wipe:         { return EMoveType::Wipe; }
    case Slic3r::EMoveType::Extrude:      { return EMoveType::Extrude; }
    default:                              { return EMoveType::COUNT; }
    }
}

References Slic3r::Color_change, ColorChange, COUNT, Slic3r::Custom_GCode, CustomGCode, Extrude, Slic3r::Extrude, Noop, Slic3r::Noop, Slic3r::Pause_Print, PausePrint, Retract, Slic3r::Retract, Seam, Slic3r::Seam, Slic3r::Tool_change, ToolChange, Travel, Slic3r::Travel, Unretract, Slic3r::Unretract, Wipe, and Slic3r::Wipe.

convert() [13/13]

EGCodeExtrusionRole libvgcode::convert

(

Slic3r::ExtrusionRole

role

)

{
    switch (role)
    {
    case Slic3r::ExtrusionRole::erNone:                        { return EGCodeExtrusionRole::None; }
    case Slic3r::ExtrusionRole::erPerimeter:                   { return EGCodeExtrusionRole::Perimeter; }
    case Slic3r::ExtrusionRole::erExternalPerimeter:           { return EGCodeExtrusionRole::ExternalPerimeter; }
    case Slic3r::ExtrusionRole::erOverhangPerimeter:           { return EGCodeExtrusionRole::OverhangPerimeter; }
    case Slic3r::ExtrusionRole::erInternalInfill:              { return EGCodeExtrusionRole::InternalInfill; }
    case Slic3r::ExtrusionRole::erSolidInfill:                 { return EGCodeExtrusionRole::SolidInfill; }
    case Slic3r::ExtrusionRole::erTopSolidInfill:              { return EGCodeExtrusionRole::TopSolidInfill; }
    case Slic3r::ExtrusionRole::erIroning:                     { return EGCodeExtrusionRole::Ironing; }
    case Slic3r::ExtrusionRole::erBridgeInfill:                { return EGCodeExtrusionRole::BridgeInfill; }
    case Slic3r::ExtrusionRole::erGapFill:                     { return EGCodeExtrusionRole::GapFill; }
    case Slic3r::ExtrusionRole::erSkirt:                       { return EGCodeExtrusionRole::Skirt; }
    case Slic3r::ExtrusionRole::erSupportMaterial:             { return EGCodeExtrusionRole::SupportMaterial; }
    case Slic3r::ExtrusionRole::erSupportMaterialInterface:    { return EGCodeExtrusionRole::SupportMaterialInterface; }
    case Slic3r::ExtrusionRole::erWipeTower:                   { return EGCodeExtrusionRole::WipeTower; }
    case Slic3r::ExtrusionRole::erCustom:                      { return EGCodeExtrusionRole::Custom; }
    // ORCA
    case Slic3r::ExtrusionRole::erBottomSurface:               { return EGCodeExtrusionRole::BottomSurface; }
    case Slic3r::ExtrusionRole::erInternalBridgeInfill:        { return EGCodeExtrusionRole::InternalBridgeInfill; }
    case Slic3r::ExtrusionRole::erBrim:                        { return EGCodeExtrusionRole::Brim; }
    case Slic3r::ExtrusionRole::erSupportTransition:           { return EGCodeExtrusionRole::SupportTransition; }
    case Slic3r::ExtrusionRole::erMixed:                       { return EGCodeExtrusionRole::Mixed; }
    default:                                                   { return EGCodeExtrusionRole::None; }
    }
}

References BottomSurface, BridgeInfill, Brim, Custom, Slic3r::erBottomSurface, Slic3r::erBridgeInfill, Slic3r::erBrim, Slic3r::erCustom, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalBridgeInfill, Slic3r::erInternalInfill, Slic3r::erIroning, Slic3r::erMixed, Slic3r::erNone, Slic3r::erOverhangPerimeter, Slic3r::erPerimeter, Slic3r::erSkirt, Slic3r::erSolidInfill, Slic3r::erSupportMaterial, Slic3r::erSupportMaterialInterface, Slic3r::erSupportTransition, Slic3r::erTopSolidInfill, Slic3r::erWipeTower, ExternalPerimeter, GapFill, InternalBridgeInfill, InternalInfill, Ironing, Mixed, None, OverhangPerimeter, Perimeter, Skirt, SolidInfill, SupportMaterial, SupportMaterialInterface, SupportTransition, TopSolidInfill, and WipeTower.

convert_brim_skirt_to_vertices()

void libvgcode::convert_brim_skirt_to_vertices ( const Slic3r::Print & print, std::vector< VerticesData > & vertices_data )

static

{
    vertices_data.emplace_back(VerticesData());
    VerticesData& data = vertices_data.back();
 
    // number of skirt layers
    size_t total_layer_count = 0;
    for (const Slic3r::PrintObject* print_object : print.objects()) {
        total_layer_count = std::max(total_layer_count, print_object->total_layer_count());
    }
    size_t skirt_height = print.has_infinite_skirt() ? total_layer_count : std::min<size_t>(print.config().skirt_height.value, total_layer_count);
    if (skirt_height == 0 && print.has_brim())
        skirt_height = 1;
 
    // Get first skirt_height layers.
    //FIXME This code is fishy. It may not work for multiple objects with different layering due to variable layer height feature.
    // This is not critical as this is just an initial preview.
    const Slic3r::PrintObject* highest_object = *std::max_element(print.objects().begin(), print.objects().end(),
        [](auto l, auto r) { return l->layers().size() < r->layers().size(); });
    data.layers_zs.reserve(skirt_height * 2);
    for (size_t i = 0; i < std::min(skirt_height, highest_object->layers().size()); ++i) {
        data.layers_zs.emplace_back(float(highest_object->layers()[i]->print_z));
    }
    // Only add skirt for the raft layers.
    for (size_t i = 0; i < std::min(skirt_height, std::min(highest_object->slicing_parameters().raft_layers(), highest_object->support_layers().size())); ++i) {
        data.layers_zs.emplace_back(float(highest_object->support_layers()[i]->print_z));
    }
    Slic3r::sort_remove_duplicates(data.layers_zs);
    skirt_height = std::min(skirt_height, data.layers_zs.size());
    data.layers_zs.erase(data.layers_zs.begin() + skirt_height, data.layers_zs.end());
 
    for (size_t i = 0; i < skirt_height; ++i) {
        // TODO - brim map?
        // if (i == 0)
        //     convert_to_vertices(print.brim(), data.layers_zs[i], i, 0, 0, EGCodeExtrusionRole::Skirt, Slic3r::Point(0, 0), data.vertices);
        convert_to_vertices(print.skirt(), data.layers_zs[i], i, 0, 0, EGCodeExtrusionRole::Skirt, Slic3r::Point(0, 0), data.vertices);
    }
}

References Slic3r::ConstVectorOfPtrsAdaptor< T >::begin(), Slic3r::Print::config(), convert_to_vertices(), Slic3r::ConstVectorOfPtrsAdaptor< T >::end(), Slic3r::Print::has_brim(), Slic3r::Print::has_infinite_skirt(), Slic3r::PrintObject::layers(), libvgcode::VerticesData::layers_zs, Slic3r::Print::objects(), Slic3r::SlicingParameters::raft_layers(), Slic3r::ConstVectorOfPtrsAdaptor< T >::size(), Skirt, Slic3r::Print::skirt(), Slic3r::PrintObject::slicing_parameters(), Slic3r::sort_remove_duplicates(), Slic3r::PrintObject::support_layers(), and libvgcode::VerticesData::vertices.

Referenced by convert().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_filament_colors()

PaletteWithAlpha libvgcode::convert_filament_colors

(

const std::vector< std::string > &

colors_str

)

{
    PaletteWithAlpha ret;
    ret.reserve(colors_str.size());
    for (const std::string& color_str : colors_str) {
        Slic3r::ColorRGBA color_rgba;
        if (!decode_color(color_str, color_rgba)) {
            ret.push_back({ DUMMY_COLOR[0], DUMMY_COLOR[1], DUMMY_COLOR[2], 255 });
            continue;
        }
        // as the 3D view draws it: a clear color kept at the least opacity, black lifted
        color_rgba = adjust_color_for_rendering(color_rgba);
        const Color color = convert(color_rgba);
        ret.push_back({ color[0], color[1], color[2], static_cast<uint8_t>(std::lround(255.0f * color_rgba.a())) });
    }
    return ret;
}

References Slic3r::ColorRGBA::a(), adjust_color_for_rendering(), convert(), and DUMMY_COLOR.

Referenced by convert(), convert(), and Slic3r::GUI::GCodeViewer::load_as_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_lines_to_vertices()

void libvgcode::convert_lines_to_vertices ( const Slic3r::Lines & lines, const std::vector< float > & widths, const std::vector< float > & heights, float top_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, bool closed, std::vector< PathVertex > & vertices )

static

{
    if (lines.empty())
        return;
 
    // loop once more in case of closed loops
    const size_t lines_end = closed ? (lines.size() + 1) : lines.size();
    for (size_t ii = 0; ii < lines_end; ++ii) {
        const size_t i = (ii == lines.size()) ? 0 : ii;
        const Slic3r::Line& line = lines[i];
        // first segment of the polyline
        if (ii == 0) {
            // add a dummy vertex at the start, to separate the current line from the others
            const Slic3r::Vec2f a = unscale(line.a).cast<float>();
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
            libvgcode::PathVertex vertex = { convert(Slic3r::Vec3f(a.x(), a.y(), top_z)), heights[i], widths[i], 0.0f, 0.0f,
                0.0f, 0.0f, 0.0f, 0.0f, extrusion_role, EMoveType::Noop, 0, static_cast<uint32_t>(layer_id),
                static_cast<uint8_t>(extruder_id), static_cast<uint8_t>(color_id), { 0.0f, 0.0f } };
#else
            libvgcode::PathVertex vertex = { convert(Slic3r::Vec3f(a.x(), a.y(), top_z)), heights[i], widths[i], 0.0f, 0.0f,
                0.0f, 0.0f, 0.0f, extrusion_role, EMoveType::Noop, 0, static_cast<uint32_t>(layer_id),
                static_cast<uint8_t>(extruder_id), static_cast<uint8_t>(color_id), { 0.0f, 0.0f } };
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
            vertices.emplace_back(vertex);
            // add the starting vertex of the segment
            vertex.type = EMoveType::Extrude;
            vertices.emplace_back(vertex);
        }
        // add the ending vertex of the segment
        const Slic3r::Vec2f b = unscale(line.b).cast<float>();
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
        const libvgcode::PathVertex vertex = { convert(Slic3r::Vec3f(b.x(), b.y(), top_z)), heights[i], widths[i], 0.0f, 0.0f,
            0.0f, 0.0f, 0.0f, 0.0f, extrusion_role, EMoveType::Extrude, 0, static_cast<uint32_t>(layer_id),
            static_cast<uint8_t>(extruder_id), static_cast<uint8_t>(color_id), { 0.0f, 0.0f } };
#else
        const libvgcode::PathVertex vertex = { convert(Slic3r::Vec3f(b.x(), b.y(), top_z)), heights[i], widths[i], 0.0f, 0.0f,
            0.0f, 0.0f, 0.0f, extrusion_role, EMoveType::Extrude, 0, static_cast<uint32_t>(layer_id),
            static_cast<uint8_t>(extruder_id), static_cast<uint8_t>(color_id), { 0.0f, 0.0f } };
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
        vertices.emplace_back(vertex);
    }
}

References Slic3r::Line::a, Slic3r::Line::b, convert(), Extrude, and Noop.

Referenced by convert_to_vertices(), convert_to_vertices(), convert_to_vertices(), and convert_wipe_tower_to_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_object_to_vertices()

void libvgcode::convert_object_to_vertices ( const Slic3r::PrintObject & object, const std::vector< std::string > & str_tool_colors, const std::vector< std::string > & str_color_print_colors, const std::vector< Slic3r::CustomGCode::Item > & color_print_values, size_t extruders_count, VerticesData & data )

static

{
    const bool has_perimeters = object.is_step_done(Slic3r::posPerimeters);
    const bool has_infill     = object.is_step_done(Slic3r::posInfill);
    const bool has_support    = object.is_step_done(Slic3r::posSupportMaterial);
 
    // order layers by print_z
    std::vector<const Slic3r::Layer*> layers;
    if (has_perimeters || has_infill) {
        layers.reserve(layers.size() + object.layers().size());
        std::copy(object.layers().begin(), object.layers().end(), std::back_inserter(layers));
    }
    if (has_support) {
        layers.reserve(layers.size() + object.support_layers().size());
        std::copy(object.support_layers().begin(), object.support_layers().end(), std::back_inserter(layers));
    }
    std::sort(layers.begin(), layers.end(), [](const Slic3r::Layer* l1, const Slic3r::Layer* l2) { return l1->print_z < l2->print_z; });
 
    ObjectHelper object_helper(color_print_values, str_tool_colors.size(), str_color_print_colors.size(), extruders_count);
 
    data.layers_zs.reserve(layers.size());
    for (const Slic3r::Layer* layer : layers) {
        data.layers_zs.emplace_back(static_cast<float>(layer->print_z));
    }
 
    Slic3r::sort_remove_duplicates(data.layers_zs);
 
    for (const Slic3r::Layer* layer : layers) {
        const size_t old_vertices_count = data.vertices.size();
        const float layer_z = static_cast<float>(layer->print_z);
        const auto it = std::find(data.layers_zs.begin(), data.layers_zs.end(), layer_z);
        assert(it != data.layers_zs.end());
        const size_t layer_id = (it != data.layers_zs.end()) ? std::distance(data.layers_zs.begin(), it) : 0;
        for (const Slic3r::PrintInstance& instance : object.instances()) {
            const Slic3r::Point& copy = instance.shift;
            for (const Slic3r::LayerRegion* layerm : layer->regions()) {
                if (layerm->slices.empty())
                    continue;
                const Slic3r::PrintRegionConfig& cfg = layerm->region().config();
                if (has_perimeters) {
                    const size_t extruder_id = static_cast<size_t>(std::max(cfg.outer_wall_filament_id.value - 1, 0));
                    convert_to_vertices(layerm->perimeters, layer_z, layer_id, extruder_id,
                        object_helper.color_id(layer_z, extruder_id), EGCodeExtrusionRole::ExternalPerimeter,
                        copy, data.vertices);
                }
                if (has_infill) {
                    for (const Slic3r::ExtrusionEntity* ee : layerm->fills) {
                        // fill represents infill extrusions of a single island.
                        const auto& fill = *dynamic_cast<const Slic3r::ExtrusionEntityCollection*>(ee);
                        if (!fill.entities.empty()) {
                            const Slic3r::ExtrusionRole role = fill.entities.front()->role();
                            const bool is_solid_infill = Slic3r::is_solid_infill(role);
                            const size_t extruder_id = is_solid_infill ?
                                static_cast<size_t>(std::max((role == Slic3r::erTopSolidInfill || role == Slic3r::erIroning ? cfg.top_surface_filament_id.value :
                                                              role == Slic3r::erBottomSurface ? cfg.bottom_surface_filament_id.value :
                                                              cfg.internal_solid_filament_id.value) - 1, 0)) :
                                static_cast<size_t>(std::max(cfg.sparse_infill_filament_id.value - 1, 0));
                            convert_to_vertices(fill, layer_z, layer_id, extruder_id,
                                                object_helper.color_id(layer_z, extruder_id),
                                                is_solid_infill ? EGCodeExtrusionRole::SolidInfill : EGCodeExtrusionRole::InternalInfill,
                                                copy, data.vertices);
                        }
                    }
                }
            }
            if (has_support) {
                const Slic3r::SupportLayer* support_layer = dynamic_cast<const Slic3r::SupportLayer*>(layer);
                if (support_layer == nullptr)
                    continue;
                const Slic3r::PrintObjectConfig& cfg = support_layer->object()->config();
                for (const Slic3r::ExtrusionEntity* extrusion_entity : support_layer->support_fills.entities) {
                    const bool is_support_material = extrusion_entity->role() == Slic3r::ExtrusionRole::erSupportMaterial;
                    const size_t extruder_id = is_support_material ?
                        static_cast<size_t>(std::max(cfg.support_filament.value - 1, 0)) :
                        static_cast<size_t>(std::max(cfg.support_interface_filament.value - 1, 0));
                    convert_to_vertices(*extrusion_entity, layer_z, layer_id,
                                        extruder_id, object_helper.color_id(layer_z, extruder_id),
                                        is_support_material ? EGCodeExtrusionRole::SupportMaterial : EGCodeExtrusionRole::SupportMaterialInterface,
                                        copy, data.vertices);
                }
            }
        }
        // filter out empty layers
        const size_t new_vertices_count = data.vertices.size();
        if (new_vertices_count == old_vertices_count)
            data.layers_zs.erase(data.layers_zs.begin() + layer_id);
    }
}

References libvgcode::ObjectHelper::color_id(), Slic3r::PrintObject::config(), convert_object_to_vertices(), convert_to_vertices(), Slic3r::ExtrusionEntityCollection::entities, Slic3r::erBottomSurface, Slic3r::erIroning, Slic3r::erSupportMaterial, Slic3r::erTopSolidInfill, ExternalPerimeter, InternalInfill, Slic3r::is_solid_infill(), libvgcode::VerticesData::layers_zs, Slic3r::Layer::object(), Slic3r::posInfill, Slic3r::posPerimeters, Slic3r::posSupportMaterial, Slic3r::PrintObjectConfig, Slic3r::PrintRegionConfig, Slic3r::ExtrusionEntity::role(), SolidInfill, Slic3r::sort_remove_duplicates(), Slic3r::SupportLayer::support_fills, SupportMaterial, SupportMaterialInterface, and libvgcode::VerticesData::vertices.

Referenced by convert_object_to_vertices(), and convert_objects_to_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_objects_to_vertices()

void libvgcode::convert_objects_to_vertices ( const Slic3r::ConstPrintObjectPtrsAdaptor & objects, const std::vector< std::string > & str_tool_colors, const std::vector< std::string > & str_color_print_colors, const std::vector< Slic3r::CustomGCode::Item > & color_print_values, size_t extruders_count, std::vector< VerticesData > & data )

static

{
    // extract vertices and layers zs object by object
    data.reserve(data.size() + objects.size());
    for (size_t i = 0; i < objects.size(); ++i) {
        data.emplace_back(VerticesData());
        convert_object_to_vertices(*objects[i], str_tool_colors, str_color_print_colors, color_print_values, extruders_count, data.back());
    }
}

References convert_object_to_vertices(), convert_objects_to_vertices(), and Slic3r::ConstVectorOfPtrsAdaptor< T >::size().

Referenced by convert(), and convert_objects_to_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_to_vertices() [1/5]

void libvgcode::convert_to_vertices ( const Slic3r::ExtrusionEntity & extrusion_entity, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point & shift, std::vector< PathVertex > & vertices )

static

{
    auto* extrusion_path = dynamic_cast<const Slic3r::ExtrusionPath*>(&extrusion_entity);
    if (extrusion_path != nullptr)
        convert_to_vertices(*extrusion_path, print_z, layer_id, extruder_id, color_id, extrusion_role, shift, vertices);
    else {
        auto* extrusion_loop = dynamic_cast<const Slic3r::ExtrusionLoop*>(&extrusion_entity);
        if (extrusion_loop != nullptr)
            convert_to_vertices(*extrusion_loop, print_z, layer_id, extruder_id, color_id, extrusion_role, shift, vertices);
        else {
            auto* extrusion_multi_path = dynamic_cast<const Slic3r::ExtrusionMultiPath*>(&extrusion_entity);
            if (extrusion_multi_path != nullptr)
                convert_to_vertices(*extrusion_multi_path, print_z, layer_id, extruder_id, color_id, extrusion_role, shift, vertices);
            else {
                auto* extrusion_entity_collection = dynamic_cast<const Slic3r::ExtrusionEntityCollection*>(&extrusion_entity);
                if (extrusion_entity_collection != nullptr)
                    convert_to_vertices(*extrusion_entity_collection, print_z, layer_id, extruder_id, color_id, extrusion_role, shift, vertices);
                else
                    throw Slic3r::RuntimeError("Found unexpected extrusion_entity type");
            }
        }
    }
}

References convert_to_vertices().

Here is the call graph for this function:

convert_to_vertices() [2/5]

void libvgcode::convert_to_vertices ( const Slic3r::ExtrusionEntityCollection & extrusion_entity_collection, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point & shift, std::vector< PathVertex > & vertices )

static

{
    for (const Slic3r::ExtrusionEntity* extrusion_entity : extrusion_entity_collection.entities) {
        if (extrusion_entity != nullptr)
            convert_to_vertices(*extrusion_entity, print_z, layer_id, extruder_id, color_id, extrusion_role, shift, vertices);
    }
}

References convert_to_vertices(), and Slic3r::ExtrusionEntityCollection::entities.

Here is the call graph for this function:

convert_to_vertices() [3/5]

void libvgcode::convert_to_vertices ( const Slic3r::ExtrusionLoop & extrusion_loop, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point & shift, std::vector< PathVertex > & vertices )

static

{
    Slic3r::Lines lines;
    std::vector<float> widths;
    std::vector<float> heights;
    for (const Slic3r::ExtrusionPath& extrusion_path : extrusion_loop.paths) {
        Slic3r::Polyline polyline = extrusion_path.polyline.to_polyline();
        polyline.remove_duplicate_points();
        polyline.translate(shift);
        const Slic3r::Lines lines_this = polyline.lines();
        append(lines, lines_this);
        widths.insert(widths.end(), lines_this.size(), extrusion_path.width);
        heights.insert(heights.end(), lines_this.size(), extrusion_path.height);
    }
    convert_lines_to_vertices(lines, widths, heights, print_z, layer_id, extruder_id, color_id, extrusion_role, true, vertices);
}

References convert_lines_to_vertices(), Slic3r::ExtrusionPath::height, Slic3r::Polyline::lines(), Slic3r::ExtrusionLoop::paths, Slic3r::ExtrusionPath::polyline, Slic3r::MultiPoint::remove_duplicate_points(), Slic3r::Polyline3::to_polyline(), Slic3r::MultiPoint::translate(), and Slic3r::ExtrusionPath::width.

Here is the call graph for this function:

convert_to_vertices() [4/5]

void libvgcode::convert_to_vertices ( const Slic3r::ExtrusionMultiPath & extrusion_multi_path, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point & shift, std::vector< PathVertex > & vertices )

static

{
    Slic3r::Lines lines;
    std::vector<float> widths;
    std::vector<float> heights;
    for (const Slic3r::ExtrusionPath& extrusion_path : extrusion_multi_path.paths) {
        Slic3r::Polyline polyline = extrusion_path.polyline.to_polyline();
        polyline.remove_duplicate_points();
        polyline.translate(shift);
        const Slic3r::Lines lines_this = polyline.lines();
        append(lines, lines_this);
        widths.insert(widths.end(), lines_this.size(), extrusion_path.width);
        heights.insert(heights.end(), lines_this.size(), extrusion_path.height);
    }
    convert_lines_to_vertices(lines, widths, heights, print_z, layer_id, extruder_id, color_id, extrusion_role, false, vertices);
}

References convert_lines_to_vertices(), Slic3r::ExtrusionPath::height, Slic3r::Polyline::lines(), Slic3r::ExtrusionMultiPath::paths, Slic3r::ExtrusionPath::polyline, Slic3r::MultiPoint::remove_duplicate_points(), Slic3r::Polyline3::to_polyline(), Slic3r::MultiPoint::translate(), and Slic3r::ExtrusionPath::width.

Here is the call graph for this function:

convert_to_vertices() [5/5]

void libvgcode::convert_to_vertices ( const Slic3r::ExtrusionPath & extrusion_path, float print_z, size_t layer_id, size_t extruder_id, size_t color_id, EGCodeExtrusionRole extrusion_role, const Slic3r::Point & shift, std::vector< PathVertex > & vertices )

static

{
    Slic3r::Polyline polyline = extrusion_path.polyline.to_polyline();
    polyline.remove_duplicate_points();
    polyline.translate(shift);
    const Slic3r::Lines lines = polyline.lines();
    std::vector<float> widths(lines.size(), extrusion_path.width);
    std::vector<float> heights(lines.size(), extrusion_path.height);
    convert_lines_to_vertices(lines, widths, heights, print_z, layer_id, extruder_id, color_id, extrusion_role, false, vertices);
}

References convert_lines_to_vertices(), Slic3r::ExtrusionPath::height, Slic3r::Polyline::lines(), Slic3r::ExtrusionPath::polyline, Slic3r::MultiPoint::remove_duplicate_points(), Slic3r::Polyline3::to_polyline(), Slic3r::MultiPoint::translate(), and Slic3r::ExtrusionPath::width.

Referenced by convert_brim_skirt_to_vertices(), convert_object_to_vertices(), convert_to_vertices(), and convert_to_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_wipe_tower_to_vertices()

void libvgcode::convert_wipe_tower_to_vertices ( const Slic3r::Print & print, const std::vector< std::string > & str_tool_colors, std::vector< VerticesData > & vertices_data )

static

{
    vertices_data.emplace_back(VerticesData());
    VerticesData& data = vertices_data.back();
 
    WipeTowerHelper wipe_tower_helper(print);
    const float angle = wipe_tower_helper.get_angle();
    const Slic3r::Vec2f& position = wipe_tower_helper.get_position();
 
    for (size_t item = 0; item < wipe_tower_helper.get_layers_count(); ++item) {
        const std::vector<Slic3r::WipeTower::ToolChangeResult>& layer = wipe_tower_helper.tool_change(item);
        for (const Slic3r::WipeTower::ToolChangeResult& extrusions : layer) {
            data.layers_zs.emplace_back(extrusions.print_z);
            for (size_t i = 1; i < extrusions.extrusions.size(); /*no increment*/) {
                const Slic3r::WipeTower::Extrusion& e = extrusions.extrusions[i];
                if (e.width == 0.0f) {
                    ++i;
                    continue;
                }
                size_t j = i + 1;
                if (str_tool_colors.empty())
                    for (; j < extrusions.extrusions.size() && extrusions.extrusions[j].width > 0.0f; ++j);
                else
                    for (; j < extrusions.extrusions.size() && extrusions.extrusions[j].tool == e.tool && extrusions.extrusions[j].width > 0.0f; ++j);
 
                const size_t n_lines = j - i;
                Slic3r::Lines lines;
                std::vector<float> widths;
                std::vector<float> heights;
                lines.reserve(n_lines);
                widths.reserve(n_lines);
                heights.assign(n_lines, extrusions.layer_height);
                Slic3r::WipeTower::Extrusion e_prev = extrusions.extrusions[i - 1];
 
                if (!extrusions.priming) { // wipe tower extrusions describe the wipe tower at the origin with no rotation
                    e_prev.pos = Eigen::Rotation2Df(angle) * e_prev.pos;
                    e_prev.pos += position;
                }
 
                for (; i < j; ++i) {
                    Slic3r::WipeTower::Extrusion ee = extrusions.extrusions[i];
                    assert(ee.width > 0.0f);
                    if (!extrusions.priming) {
                        ee.pos = Eigen::Rotation2Df(angle) * ee.pos;
                        ee.pos += position;
                    }
                    lines.emplace_back(Slic3r::Point::new_scale(e_prev.pos.x(), e_prev.pos.y()), Slic3r::Point::new_scale(ee.pos.x(), ee.pos.y()));
                    widths.emplace_back(ee.width);
                    e_prev = ee;
                }
 
                convert_lines_to_vertices(lines, widths, heights, extrusions.print_z, item, static_cast<size_t>(e.tool), 0,
                                          EGCodeExtrusionRole::WipeTower, lines.front().a == lines.back().b, data.vertices);
            }
        }
    }
 
    Slic3r::sort_remove_duplicates(data.layers_zs);
}

References convert_lines_to_vertices(), convert_wipe_tower_to_vertices(), libvgcode::WipeTowerHelper::get_angle(), libvgcode::WipeTowerHelper::get_layers_count(), libvgcode::WipeTowerHelper::get_position(), libvgcode::VerticesData::layers_zs, Slic3r::Point::new_scale(), Slic3r::WipeTower::Extrusion::pos, Slic3r::sort_remove_duplicates(), Slic3r::WipeTower::Extrusion::tool, libvgcode::WipeTowerHelper::tool_change(), libvgcode::VerticesData::vertices, Slic3r::WipeTower::Extrusion::width, and WipeTower.

Referenced by convert(), and convert_wipe_tower_to_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_buffers()

void libvgcode::delete_buffers ( unsigned int & id )

static

{
    if (id != 0) {
        glsafe(glDeleteBuffers(1, &id));
        id = 0;
    }
}

References glDeleteBuffers, and glsafe.

Referenced by libvgcode::ViewerImpl::reset().

Here is the caller graph for this function:

delete_textures()

void libvgcode::delete_textures ( unsigned int & id )

static

{
    if (id != 0) {
        glsafe(glDeleteTextures(1, &id));
        id = 0;
    }
}

References glDeleteTextures, and glsafe.

Referenced by libvgcode::ViewerImpl::TranslucentTargets::release(), and libvgcode::ViewerImpl::reset().

Here is the caller graph for this function:

dot()

float libvgcode::dot	(	const Vec3 &	v1,
		const Vec3 &	v2 )

{
    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
}

Referenced by extract_pos_and_or_hwa(), length(), and normalize().

Here is the caller graph for this function:

extract_pos_and_or_hwa()

void libvgcode::extract_pos_and_or_hwa ( const std::vector< PathVertex > & vertices, float travels_radius, float wipes_radius, BitSet<> & valid_lines_bitset, std::vector< Vec4 > * positions = nullptr, std::vector< Vec4 > * heights_widths_angles = nullptr, bool update_bitset = false )

static

                                                                                                                        {
  static constexpr const Vec3 ZERO = { 0.0f, 0.0f, 0.0f };
    if (positions == nullptr && heights_widths_angles == nullptr)
        return;
    if (vertices.empty())
        return;
    if (travels_radius <= 0.0f || wipes_radius <= 0.0f)
        return;
 
    if (positions != nullptr)
        positions->reserve(vertices.size());
    if (heights_widths_angles != nullptr)
        heights_widths_angles->reserve(vertices.size());
    for (size_t i = 0; i < vertices.size(); ++i) {
        const PathVertex& v = vertices[i];
        const EMoveType move_type = v.type;
        const bool prev_line_valid = i > 0 && valid_lines_bitset[i - 1];
        const Vec3 prev_line = prev_line_valid ? v.position - vertices[i - 1].position : ZERO;
        const bool this_line_valid = is_line(vertices, i);
        const Vec3 this_line = this_line_valid ? vertices[i + 1].position - v.position : ZERO;
 
        if (this_line_valid) {
            // there is a valid path between point i and i+1.
        }
        else {
            // the connection is invalid, there should be no line rendered, ever
            if (update_bitset)
                valid_lines_bitset.reset(i);
        }
        
        if (positions != nullptr) {
            // ORCA: the last component, there to comply with GL_RGBA32F format, carries the layer the shaders grey and dim by,
            // plus 0.5 at the joint of two segments, which the shaders read as an int, see joint_a in Segments_Vertex_Shader
            Vec4 position = { v.position[0], v.position[1], v.position[2],
                              static_cast<float>(v.layer_id) + (is_joint(vertices, i) ? 0.5f : 0.0f) };
            if (move_type == EMoveType::Extrude)
                // push down extrusion vertices by half height to render them at the right z
                position[2] -= 0.5f * v.height;
            positions->emplace_back(position);
        }
 
        if (heights_widths_angles != nullptr) {
            float height = 0.0f;
            float width = 0.0f;
            if (v.is_travel()) {
                height = travels_radius;
                width  = travels_radius;
            }
            else if (v.is_wipe()) {
                height = wipes_radius;
                width  = wipes_radius;
            }
            else {
                height = v.height;
                width = v.width;
            }
            
            // ORCA: Set bias for wipes and options to avoid z-fighting
            float bias = 0.0f;
            if (v.is_wipe())
                bias = 0.05f;
            else if (v.is_option())
                bias = 0.1f;
 
            // the last component is a dummy float to comply with GL_RGBA32F format
            // ORCA: Pass bias to shader
            heights_widths_angles->push_back({ height, width,
                std::atan2(prev_line[0] * this_line[1] - prev_line[1] * this_line[0], dot(prev_line, this_line)), bias });
        }
    }
}

References dot(), Extrude, libvgcode::PathVertex::height, is_joint(), is_line(), libvgcode::PathVertex::is_option(), libvgcode::PathVertex::is_travel(), libvgcode::PathVertex::is_wipe(), libvgcode::PathVertex::layer_id, libvgcode::PathVertex::position, libvgcode::PathVertex::type, and libvgcode::PathVertex::width.

Referenced by libvgcode::ViewerImpl::load(), and libvgcode::ViewerImpl::update_heights_widths().

Here is the call graph for this function:

Here is the caller graph for this function:

fast_round_up()

template<typename I>

IntegerOnly< I, I > libvgcode::fast_round_up ( double a )

inline

{
    // Why does Java Math.round(0.49999999999999994) return 1?
    // https://stackoverflow.com/questions/9902968/why-does-math-round0-49999999999999994-return-1
    return a == 0.49999999999999994 ? I(0) : I(floor(a + 0.5));
}

Referenced by round_to_bin().

Here is the caller graph for this function:

get_step_size()

float libvgcode::get_step_size ( const ColorRange & color_range )

static

{
    const std::array<float, 2>& range = color_range.get_range();
    const Palette& palette = color_range.get_palette();
    switch (color_range.get_type())
    {
    default:
    case EColorRangeType::Linear:
    {
        return (range[1] - range[0]) / (static_cast<float>(palette.size()) - 1.0f);
    }
    case EColorRangeType::Logarithmic:
    {
        return (range[0] != 0.0f) ? std::log(range[1] / range[0]) / (static_cast<float>(palette.size()) - 1.0f) : 0.0f;
    }
    }
}

References libvgcode::ColorRange::get_palette(), libvgcode::ColorRange::get_range(), libvgcode::ColorRange::get_type(), Linear, and Logarithmic.

Referenced by libvgcode::ColorRange::get_color_at(), and libvgcode::ColorRange::get_values().

Here is the call graph for this function:

Here is the caller graph for this function:

glAssertRecentCall()

void libvgcode::glAssertRecentCall ( )

inline

{ glAssertRecentCallImpl(__FILE__, __LINE__, __FUNCTION__); }

References glAssertRecentCallImpl().

Here is the call graph for this function:

glAssertRecentCallImpl()

void libvgcode::glAssertRecentCallImpl	(	const char *	file_name,
		unsigned int	line,
		const char *	function_name )

{
    const GLenum err = glGetError();
    if (err == GL_NO_ERROR)
        return;
    const char* sErr = 0;
    switch (err) {
    case GL_INVALID_ENUM:      { sErr = "Invalid Enum"; break; }
    case GL_INVALID_VALUE:     { sErr = "Invalid Value"; break; }
    // be aware that GL_INVALID_OPERATION is generated if glGetError is executed between the execution of glBegin / glEnd 
    case GL_INVALID_OPERATION: { sErr = "Invalid Operation"; break; }
    case GL_OUT_OF_MEMORY:     { sErr = "Out Of Memory"; break; }
    case GL_INVALID_FRAMEBUFFER_OPERATION: { sErr = "Invalid framebuffer operation"; break; }
#if !defined(ENABLE_OPENGL_ES)
    case GL_STACK_OVERFLOW:    { sErr = "Stack Overflow"; break; }
    case GL_STACK_UNDERFLOW:   { sErr = "Stack Underflow"; break; }
#endif // ENABLE_OPENGL_ES
    default:                   { sErr = "Unknown"; break; }
    }
    std::cout << "OpenGL error in " << file_name << ":" << line << ", function " << function_name << "() : " << (int)err << " - " << sErr << "\n";
    assert(false);
}

References GL_INVALID_ENUM, GL_INVALID_FRAMEBUFFER_OPERATION, GL_INVALID_OPERATION, GL_INVALID_VALUE, GL_NO_ERROR, GL_OUT_OF_MEMORY, GL_STACK_OVERFLOW, GL_STACK_UNDERFLOW, and glGetError.

Referenced by glAssertRecentCall().

Here is the caller graph for this function:

init_shader()

unsigned int libvgcode::init_shader	(	const std::string &	shader_name,
		const char *	vertex_shader,
		const char *	fragment_shader,
		const std::vector< const char * > &	fragment_outputs = {} )

                                                                          {})
{
    const GLuint vs_id = glCreateShader(GL_VERTEX_SHADER);
    glcheck();
    glsafe(glShaderSource(vs_id, 1, &vertex_shader, nullptr));
    glsafe(glCompileShader(vs_id));
    std::string res = check_shader(vs_id);
    if (!res.empty()) {
        glsafe(glDeleteShader(vs_id));
        throw std::runtime_error("LibVGCode: Unable to compile vertex shader:\n" + shader_name + "\n" + res + "\n");
    }
 
    const GLuint fs_id = glCreateShader(GL_FRAGMENT_SHADER);
    glcheck();
    glsafe(glShaderSource(fs_id, 1, &fragment_shader, nullptr));
    glsafe(glCompileShader(fs_id));
    res = check_shader(fs_id);
    if (!res.empty()) {
        glsafe(glDeleteShader(vs_id));
        glsafe(glDeleteShader(fs_id));
        throw std::runtime_error("LibVGCode: Unable to compile fragment shader:\n" + shader_name + "\n" + res + "\n");
    }
 
    const GLuint shader_id = glCreateProgram();
    glcheck();
    glsafe(glAttachShader(shader_id, vs_id));
    glsafe(glAttachShader(shader_id, fs_id));
#ifndef ENABLE_OPENGL_ES
    for (size_t i = 0; i < fragment_outputs.size(); ++i)
        glsafe(glBindFragDataLocation(shader_id, static_cast<GLuint>(i), fragment_outputs[i]));
#endif // ENABLE_OPENGL_ES
    glsafe(glLinkProgram(shader_id));
    res = check_program(shader_id);
    if (!res.empty()) {
        glsafe(glDetachShader(shader_id, vs_id));
        glsafe(glDetachShader(shader_id, fs_id));
        glsafe(glDeleteShader(vs_id));
        glsafe(glDeleteShader(fs_id));
        glsafe(glDeleteProgram(shader_id));
        throw std::runtime_error("LibVGCode: Unable to link shader program:\n" + shader_name + "\n" + res + "\n");
    }
 
    glsafe(glDetachShader(shader_id, vs_id));
    glsafe(glDetachShader(shader_id, fs_id));
    glsafe(glDeleteShader(vs_id));
    glsafe(glDeleteShader(fs_id));
    return shader_id;
}

Referenced by libvgcode::ViewerImpl::init().

Here is the caller graph for this function:

inverse()

Mat4x4 libvgcode::inverse ( const Mat4x4 & m )

static

{
    // ref: https://stackoverflow.com/questions/1148309/inverting-a-4x4-matrix
 
    Mat4x4 inv;
 
    inv[0] = m[5] * m[10] * m[15] -
             m[5] * m[11] * m[14] -
             m[9] * m[6] * m[15] +
             m[9] * m[7] * m[14] +
             m[13] * m[6] * m[11] -
             m[13] * m[7] * m[10];
 
    inv[4] = -m[4] * m[10] * m[15] +
             m[4] * m[11] * m[14] +
             m[8] * m[6] * m[15] -
             m[8] * m[7] * m[14] -
             m[12] * m[6] * m[11] +
             m[12] * m[7] * m[10];
 
    inv[8] = m[4] * m[9] * m[15] -
             m[4] * m[11] * m[13] -
             m[8] * m[5] * m[15] +
             m[8] * m[7] * m[13] +
             m[12] * m[5] * m[11] -
             m[12] * m[7] * m[9];
 
    inv[12] = -m[4] * m[9] * m[14] +
               m[4] * m[10] * m[13] +
               m[8] * m[5] * m[14] -
               m[8] * m[6] * m[13] -
               m[12] * m[5] * m[10] +
               m[12] * m[6] * m[9];
 
    inv[1] = -m[1] * m[10] * m[15] +
             m[1] * m[11] * m[14] +
             m[9] * m[2] * m[15] -
             m[9] * m[3] * m[14] -
             m[13] * m[2] * m[11] +
             m[13] * m[3] * m[10];
 
    inv[5] = m[0] * m[10] * m[15] -
             m[0] * m[11] * m[14] -
             m[8] * m[2] * m[15] +
             m[8] * m[3] * m[14] +
             m[12] * m[2] * m[11] -
             m[12] * m[3] * m[10];
 
    inv[9] = -m[0] * m[9] * m[15] +
             m[0] * m[11] * m[13] +
             m[8] * m[1] * m[15] -
             m[8] * m[3] * m[13] -
             m[12] * m[1] * m[11] +
             m[12] * m[3] * m[9];
 
    inv[13] = m[0] * m[9] * m[14] -
             m[0] * m[10] * m[13] -
             m[8] * m[1] * m[14] +
             m[8] * m[2] * m[13] +
             m[12] * m[1] * m[10] -
             m[12] * m[2] * m[9];
 
    inv[2] = m[1] * m[6] * m[15] -
             m[1] * m[7] * m[14] -
             m[5] * m[2] * m[15] +
             m[5] * m[3] * m[14] +
             m[13] * m[2] * m[7] -
             m[13] * m[3] * m[6];
 
    inv[6] = -m[0] * m[6] * m[15] +
             m[0] * m[7] * m[14] +
             m[4] * m[2] * m[15] -
             m[4] * m[3] * m[14] -
             m[12] * m[2] * m[7] +
             m[12] * m[3] * m[6];
 
    inv[10] = m[0] * m[5] * m[15] -
              m[0] * m[7] * m[13] -
              m[4] * m[1] * m[15] +
              m[4] * m[3] * m[13] +
              m[12] * m[1] * m[7] -
              m[12] * m[3] * m[5];
 
    inv[14] = -m[0] * m[5] * m[14] +
              m[0] * m[6] * m[13] +
              m[4] * m[1] * m[14] -
              m[4] * m[2] * m[13] -
              m[12] * m[1] * m[6] +
              m[12] * m[2] * m[5];
 
    inv[3] = -m[1] * m[6] * m[11] +
             m[1] * m[7] * m[10] +
             m[5] * m[2] * m[11] -
             m[5] * m[3] * m[10] -
             m[9] * m[2] * m[7] +
             m[9] * m[3] * m[6];
 
    inv[7] = m[0] * m[6] * m[11] -
             m[0] * m[7] * m[10] -
             m[4] * m[2] * m[11] +
             m[4] * m[3] * m[10] +
             m[8] * m[2] * m[7] -
             m[8] * m[3] * m[6];
 
    inv[11] = -m[0] * m[5] * m[11] +
             m[0] * m[7] * m[9] +
             m[4] * m[1] * m[11] -
             m[4] * m[3] * m[9] -
             m[8] * m[1] * m[7] +
             m[8] * m[3] * m[5];
 
    inv[15] = m[0] * m[5] * m[10] -
              m[0] * m[6] * m[9] -
              m[4] * m[1] * m[10] +
              m[4] * m[2] * m[9] +
              m[8] * m[1] * m[6] -
              m[8] * m[2] * m[5];
 
    float det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
    assert(det != 0.0f);
 
    det = 1.0f / det;
 
    std::array<float, 16> ret = {};
    for (int i = 0; i < 16; ++i) {
        ret[i] = inv[i] * det;
    }
 
    return ret;
}

Referenced by libvgcode::ViewerImpl::render(), and libvgcode::ViewerImpl::render_translucent().

Here is the caller graph for this function:

is_colorprint_option()

bool libvgcode::is_colorprint_option ( const PathVertex & v )

static

{
    return v.type == EMoveType::PausePrint || v.type == EMoveType::CustomGCode;
}

References CustomGCode, PausePrint, and libvgcode::PathVertex::type.

Referenced by libvgcode::Layers::update().

Here is the caller graph for this function:

is_joint()

bool libvgcode::is_joint ( const std::vector< PathVertex > & vertices, size_t i )

static

{
    auto repeated = [&vertices](size_t j) {
        return j + 1 < vertices.size() && vertices[j + 1].position == vertices[j].position && vertices[j + 1].type == vertices[j].type;
    };
    const bool before = i > 0 && (is_line(vertices, i - 1) || (i > 1 && repeated(i - 1) && is_line(vertices, i - 2)));
    const bool after = is_line(vertices, i) || (repeated(i) && is_line(vertices, i + 1));
    return before && after;
}

References is_line().

Referenced by extract_pos_and_or_hwa().

Here is the call graph for this function:

Here is the caller graph for this function:

is_line()

bool libvgcode::is_line ( const std::vector< PathVertex > & vertices, size_t i )

static

{
    return i + 1 < vertices.size() && vertices[i + 1].position != vertices[i].position &&
           vertices[i + 1].type == vertices[i].type && vertices[i].type != EMoveType::Seam;
}

References Seam.

Referenced by extract_pos_and_or_hwa(), and is_joint().

Here is the caller graph for this function:

is_visible()

bool libvgcode::is_visible ( const PathVertex & v, const Settings & settings )

static

{
    const EOptionType option_type = move_type_to_option(v.type);
    try
    {
        return (option_type == EOptionType::COUNT) ?
            (v.type == EMoveType::Extrude) ? settings.extrusion_roles_visibility[size_t(v.role)] : false :
            settings.options_visibility[size_t(option_type)];
    }
    catch (...)
    {
        return false;
    }
}

References COUNT, Extrude, libvgcode::Settings::extrusion_roles_visibility, move_type_to_option(), libvgcode::Settings::options_visibility, libvgcode::PathVertex::role, and libvgcode::PathVertex::type.

Referenced by libvgcode::ViewerImpl::update_view_full_range().

Here is the call graph for this function:

Here is the caller graph for this function:

length()

float libvgcode::length

(

const Vec3 &

v

)

{
    return std::sqrt(dot(v, v));
}

References dot().

Referenced by libvgcode::OpenGLWrapper::load_opengl(), and normalize().

Here is the call graph for this function:

Here is the caller graph for this function:

lerp() [1/2]

Color libvgcode::lerp ( const Color & c1, const Color & c2, float t )

extern

{
    t = std::clamp(t, 0.0f, 1.0f);
    return { lerp(c1[0], c2[0], t), lerp(c1[1], c2[1], t), lerp(c1[2], c2[2], t) };
}

References lerp().

Referenced by libvgcode::ColorRange::get_color_at(), and lerp().

Here is the call graph for this function:

Here is the caller graph for this function:

lerp() [2/2]

uint8_t libvgcode::lerp ( uint8_t f1, uint8_t f2, float t )

static

{
    const float one_minus_t = 1.0f - t;
    return static_cast<uint8_t>(one_minus_t * static_cast<float>(f1) + t * static_cast<float>(f2));
}

move_type_to_option()

EOptionType libvgcode::move_type_to_option ( EMoveType type )

extern

{
    switch (type)
    {
    case EMoveType::Travel:      { return EOptionType::Travels; }
    case EMoveType::Wipe:        { return EOptionType::Wipes; }
    case EMoveType::Retract:     { return EOptionType::Retractions; }
    case EMoveType::Unretract:   { return EOptionType::Unretractions; }
    case EMoveType::Seam:        { return EOptionType::Seams; }
    case EMoveType::ToolChange:  { return EOptionType::ToolChanges; }
    case EMoveType::ColorChange: { return EOptionType::ColorChanges; }
    case EMoveType::PausePrint:  { return EOptionType::PausePrints; }
    case EMoveType::CustomGCode: { return EOptionType::CustomGCodes; }
    default:                     { return EOptionType::COUNT; }
    }
}

References ColorChange, ColorChanges, COUNT, CustomGCode, CustomGCodes, PausePrint, PausePrints, Retract, Retractions, Seam, Seams, ToolChange, ToolChanges, Travel, Travels, Unretract, Unretractions, Wipe, and Wipes.

Referenced by libvgcode::ViewerImpl::get_vertex_color(), is_visible(), libvgcode::ViewerImpl::load(), starts_path(), and libvgcode::ViewerImpl::update_enabled_entities().

Here is the caller graph for this function:

normalize()

Vec3 libvgcode::normalize

(

const Vec3 &

v

)

{
    const float length = std::sqrt(dot(v, v));
    assert(length > 0.0f);
    const float inv_length = 1.0f / length;
    return { v[0] * inv_length, v[1] * inv_length, v[2] * inv_length };
}

References dot(), and length().

Referenced by libvgcode::OptionTemplate::init().

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

bool libvgcode::operator!=	(	const Vec3 &	v1,
		const Vec3 &	v2 )

                                                  {
    return v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2];
}

operator*()

Vec3 libvgcode::operator*	(	float	f,
		const Vec3 &	v )

                                         {
    return { f * v[0], f * v[1], f * v[2] };
}

operator+()

Vec3 libvgcode::operator+	(	const Vec3 &	v1,
		const Vec3 &	v2 )

                                                 {
    return { v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2] };
}

operator-()

Vec3 libvgcode::operator-	(	const Vec3 &	v1,
		const Vec3 &	v2 )

                                                 {
    return { v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2] };
}

operator==()

bool libvgcode::operator==	(	const Vec3 &	v1,
		const Vec3 &	v2 )

                                                  {
    return v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2];
}

round_to_bin()

float libvgcode::round_to_bin ( const float value )

static

{
//    assert(value >= 0);
    constexpr float const scale[5]     = { 100.f,  1000.f,  10000.f,  100000.f,  1000000.f };
    constexpr float const invscale[5]  = { 0.01f,  0.001f,  0.0001f,  0.00001f,  0.000001f };
    constexpr float const threshold[5] = { 0.095f, 0.0095f, 0.00095f, 0.000095f, 0.0000095f };
    // Scaling factor, pointer to the tables above.
    int                   i = 0;
    // While the scaling factor is not yet large enough to get two integer digits after scaling and rounding:
    for (; value < threshold[i] && i < 4; ++i);
    // At least on MSVC std::round() calls a complex function, which is pretty expensive.
    // our fast_round_up is much cheaper and it could be inlined.
//    return std::round(value * scale[i]) * invscale[i];
    double a = value * scale[i];
    assert(std::abs(a) < double(std::numeric_limits<int64_t>::max()));
    return fast_round_up<int64_t>(a) * invscale[i];
}

References fast_round_up(), and scale().

Referenced by libvgcode::ViewerImpl::update_color_ranges().

Here is the call graph for this function:

Here is the caller graph for this function:

starts_path()

bool libvgcode::starts_path ( const Slic3r::GCodeProcessorResult::MoveVertex & prev, const Slic3r::GCodeProcessorResult::MoveVertex & curr, bool first_move )

static

{
    const EOptionType option_type = move_type_to_option(convert(curr.type));
    if (option_type != EOptionType::COUNT && option_type != EOptionType::Travels && option_type != EOptionType::Wipes)
        return false;
    return first_move || prev.type != curr.type || prev.extrusion_role != curr.extrusion_role
        // ORCA: Split the path when a preview value changes.
        || prev.mm3_per_mm != curr.mm3_per_mm || prev.acceleration != curr.acceleration || prev.jerk != curr.jerk;
}

References Slic3r::GCodeProcessorResult::MoveVertex::acceleration, convert(), COUNT, Slic3r::GCodeProcessorResult::MoveVertex::extrusion_role, Slic3r::GCodeProcessorResult::MoveVertex::jerk, Slic3r::GCodeProcessorResult::MoveVertex::mm3_per_mm, move_type_to_option(), Travels, Slic3r::GCodeProcessorResult::MoveVertex::type, and Wipes.

Referenced by convert().

Here is the call graph for this function:

Here is the caller graph for this function:

with_define()

std::string libvgcode::with_define ( const char * source, const char * define )

static

{
    const std::string src(source);
    const size_t body = src.find('\n') + 1;
    return src.substr(0, body) + "#define " + define + "\n" + src.substr(body);
}

Referenced by libvgcode::ViewerImpl::init().

Here is the caller graph for this function:

Variable Documentation

COLOR_RANGE_TYPES_COUNT

std::size_t libvgcode::COLOR_RANGE_TYPES_COUNT = static_cast<std::size_t>(EColorRangeType::COUNT)

staticconstexpr

Referenced by libvgcode::ViewerImpl::get_used_cpu_memory().

DEFAULT_EXTRUSION_ROLES_COLORS

const std::array<Color, size_t(EGCodeExtrusionRole::COUNT)> libvgcode::DEFAULT_EXTRUSION_ROLES_COLORS

static

Initial value:

= { {
    { 230, 179, 179 }, 
    { 255, 230,  77 }, 
    { 255, 125,  56 }, 
    {  31,  31, 255 }, 
    { 176,  48,  41 }, 
    { 150,  84, 204 }, 
    { 240,  64,  64 }, 
    { 255, 140, 105 }, 
    {  77, 128, 186 }, 
    { 255, 255, 255 }, 
    {   0, 135, 110 }, 
    {   0, 255,   0 }, 
    {   0, 128,   0 }, 
    { 179, 227, 171 }, 
    {  94, 209, 148 },  
    
    { 102,  92, 199 }, 
    {  77, 128, 186 }, 
    {   0,  59, 110 }, 
    {   0,  64,   0 }, 
    { 128, 128, 128 }, 
} }

                                                                                                { {
    { 230, 179, 179 }, // None
    { 255, 230,  77 }, // Perimeter
    { 255, 125,  56 }, // ExternalPerimeter
    {  31,  31, 255 }, // OverhangPerimeter
    { 176,  48,  41 }, // InternalInfill
    { 150,  84, 204 }, // SolidInfill
    { 240,  64,  64 }, // TopSolidInfill
    { 255, 140, 105 }, // Ironing
    {  77, 128, 186 }, // BridgeInfill
    { 255, 255, 255 }, // GapFill
    {   0, 135, 110 }, // Skirt
    {   0, 255,   0 }, // SupportMaterial
    {   0, 128,   0 }, // SupportMaterialInterface
    { 179, 227, 171 }, // WipeTower
    {  94, 209, 148 },  // Custom
    // ORCA
    { 102,  92, 199 }, // BottomSurface
    {  77, 128, 186 }, // InternalBridgeInfill
    {   0,  59, 110 }, // Brim
    {   0,  64,   0 }, // SupportTransition
    { 128, 128, 128 }, // Mixed
} };

Referenced by libvgcode::ViewerImpl::reset_default_extrusion_roles_colors().

DEFAULT_OPTIONS_COLORS

const std::array<Color, size_t(EOptionType::COUNT)> libvgcode::DEFAULT_OPTIONS_COLORS

static

Initial value:

{ {
    {  56,  72, 155 }, 
    { 255, 255,   0 }, 
    { 205,  34, 214 }, 
    {  73, 173, 207 }, 
    { 230, 230, 230 }, 
    { 193, 190,  99 }, 
    { 218, 148, 139 }, 
    {  82, 240, 131 }, 
    { 226, 210,  67 }  
} }

                                                                             { {
    {  56,  72, 155 }, // Travels
    { 255, 255,   0 }, // Wipes
    { 205,  34, 214 }, // Retractions
    {  73, 173, 207 }, // Unretractions
    { 230, 230, 230 }, // Seams
    { 193, 190,  99 }, // ToolChanges
    { 218, 148, 139 }, // ColorChanges
    {  82, 240, 131 }, // PausePrints
    { 226, 210,  67 }  // CustomGCodes
} };

Referenced by libvgcode::ViewerImpl::reset_default_options_colors().

DEFAULT_RANGES_COLORS

const Palette libvgcode::DEFAULT_RANGES_COLORS

static

Initial value:

{ {
    {  11,  44, 122 }, 
    {  19,  89, 133 },
    {  28, 136, 145 },
    {   4, 214,  15 },
    { 170, 242,   0 },
    { 252, 249,   3 },
    { 245, 206,  10 },
    { 227, 136,  32 },
    { 209, 104,  48 },
    { 194,  82,  60 },
    { 148,  38,  22 }  
} }

                                          { {
    {  11,  44, 122 }, // bluish
    {  19,  89, 133 },
    {  28, 136, 145 },
    {   4, 214,  15 },
    { 170, 242,   0 },
    { 252, 249,   3 },
    { 245, 206,  10 },
    { 227, 136,  32 },
    { 209, 104,  48 },
    { 194,  82,  60 },
    { 148,  38,  22 }  // reddish
} };

Referenced by libvgcode::ColorRange::ColorRange().

DEFAULT_TRAVELS_RADIUS_MM

float libvgcode::DEFAULT_TRAVELS_RADIUS_MM = 0.1f

staticconstexpr

DEFAULT_WIPES_RADIUS_MM

float libvgcode::DEFAULT_WIPES_RADIUS_MM = 0.1f

staticconstexpr

DUMMY_COLOR

const Color libvgcode::DUMMY_COLOR { 64, 64, 64 }

static

{ 64, 64, 64 };

Referenced by Slic3r::GUI::ToolpathsObjExporter::color_id(), convert_filament_colors(), libvgcode::ViewerImpl::get_vertex_color(), and libvgcode::ViewerImpl::update_colors().

GCODE_EXTRUSION_ROLES_COUNT

std::size_t libvgcode::GCODE_EXTRUSION_ROLES_COUNT = static_cast<std::size_t>(EGCodeExtrusionRole::COUNT)

staticconstexpr

Referenced by Slic3r::GUI::GCodeViewer::shadow_casters_signature().

INDEX_DATA

const std::array<uint16_t, 24> libvgcode::INDEX_DATA

staticconstexpr

Initial value:

= {
    0, 1, 2, 
    0, 2, 3, 
    0, 3, 4, 
    0, 4, 5, 
    0, 5, 6, 
    0, 6, 1, 
    5, 4, 7, 
    5, 7, 6, 
}

                                                           {
    0, 1, 2, // front spike
    0, 2, 3, // front spike
    0, 3, 4, // right/bottom body 
    0, 4, 5, // right/bottom body 
    0, 5, 6, // left/top body 
    0, 6, 1, // left/top body 
    5, 4, 7, // back spike
    5, 7, 6, // back spike
};

Referenced by libvgcode::SegmentTemplate::init(), and libvgcode::SegmentTemplate::render().

is_atomic

template<typename T>

auto constexpr libvgcode::is_atomic = false

constexpr

is_atomic< std::atomic< T > >

template<typename T>

auto constexpr libvgcode::is_atomic< std::atomic< T > > = true

constexpr

MAX_TRAVELS_RADIUS_MM

float libvgcode::MAX_TRAVELS_RADIUS_MM = 1.0f

staticconstexpr

Referenced by libvgcode::ViewerImpl::set_travels_radius().

MAX_WIPES_RADIUS_MM

float libvgcode::MAX_WIPES_RADIUS_MM = 1.0f

staticconstexpr

Referenced by libvgcode::ViewerImpl::set_wipes_radius().

MIN_TRAVELS_RADIUS_MM

float libvgcode::MIN_TRAVELS_RADIUS_MM = 0.05f

staticconstexpr

Referenced by libvgcode::ViewerImpl::set_travels_radius().

MIN_WIPES_RADIUS_MM

float libvgcode::MIN_WIPES_RADIUS_MM = 0.05f

staticconstexpr

Referenced by libvgcode::ViewerImpl::set_wipes_radius().

MOVE_TYPES_COUNT

std::size_t libvgcode::MOVE_TYPES_COUNT = static_cast<std::size_t>(EMoveType::COUNT)

staticconstexpr

OPENGL_ES_PREFIXES

const char* libvgcode::OPENGL_ES_PREFIXES[] = { "OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", nullptr }

static

{ "OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", nullptr };

Referenced by libvgcode::OpenGLWrapper::load_opengl().

OPTION_TYPES_COUNT

std::size_t libvgcode::OPTION_TYPES_COUNT = static_cast<std::size_t>(EOptionType::COUNT)

staticconstexpr

Options_Fragment_Shader

const char* libvgcode::Options_Fragment_Shader

static

Initial value:

=
"#version 150\n"
"in vec3 color;\n"
"in float clipping_plane_dot;\n"
"out vec4 fragment_color;\n"
"void main() {\n"
"  if (clipping_plane_dot < 0.0)\n"
"    discard;\n"
"  fragment_color = vec4(color, 1.0);\n"
"}\n"

Referenced by libvgcode::ViewerImpl::init().

Options_Fragment_Shader_ES

const char* libvgcode::Options_Fragment_Shader_ES

static

Initial value:

=
"#version 300 es\n"
"precision highp float;\n"
"in vec3 color;\n"
"in float clipping_plane_dot;\n"
"out vec4 fragment_color;\n"
"void main() {\n"
"  if (clipping_plane_dot < 0.0)\n"
"    discard;\n"
"  fragment_color = vec4(color, 1.0);\n"
"}\n"

Referenced by libvgcode::ViewerImpl::init().

Options_Vertex_Shader

const char* libvgcode::Options_Vertex_Shader

static

Referenced by libvgcode::ViewerImpl::init().

Options_Vertex_Shader_ES

const char* libvgcode::Options_Vertex_Shader_ES

static

Referenced by libvgcode::ViewerImpl::init().

PI

float libvgcode::PI = 3.141592f

staticconstexpr

Referenced by libvgcode::OptionTemplate::init().

Segments_Fragment_Shader

const char* libvgcode::Segments_Fragment_Shader

static

Referenced by libvgcode::ViewerImpl::init().

Segments_Fragment_Shader_ES

const char* libvgcode::Segments_Fragment_Shader_ES

static

Referenced by libvgcode::ViewerImpl::init().

Segments_Shadow_Caster_Fragment_Shader

const char* libvgcode::Segments_Shadow_Caster_Fragment_Shader

static

Initial value:

=
"#version 150\n"
"uniform vec4 clipping_plane;\n"
"in vec3 world_position;\n"
"flat in float alpha;\n"
"flat in int segment_id;\n"
 
 
"const float BAYER[16] = float[](0.0, 8.0, 2.0, 10.0, 12.0, 4.0, 14.0, 6.0, 3.0, 11.0, 1.0, 9.0, 15.0, 7.0, 13.0, 5.0);\n"
"void main() {\n"
"  if (dot(vec4(world_position, 1.0), clipping_plane) < 0.0)\n"
"    discard;\n"
"  ivec2 cell = (ivec2(gl_FragCoord.xy) + ivec2(segment_id, segment_id >> 2)) & 3;\n"
"  if (alpha < 1.0 && (BAYER[4 * cell.y + cell.x] + 0.5) / 16.0 > alpha)\n"
"    discard;\n"
"}\n"

Referenced by libvgcode::ViewerImpl::init().

Segments_Shadow_Caster_Fragment_Shader_ES

const char* libvgcode::Segments_Shadow_Caster_Fragment_Shader_ES

static

Initial value:

=
"#version 300 es\n"
"precision highp float;\n"
"precision highp int;\n"
"uniform vec4 clipping_plane;\n"
"in vec3 world_position;\n"
"flat in float alpha;\n"
"flat in int segment_id;\n"
 
 
"const float BAYER[16] = float[](0.0, 8.0, 2.0, 10.0, 12.0, 4.0, 14.0, 6.0, 3.0, 11.0, 1.0, 9.0, 15.0, 7.0, 13.0, 5.0);\n"
"void main() {\n"
"  if (dot(vec4(world_position, 1.0), clipping_plane) < 0.0)\n"
"    discard;\n"
"  ivec2 cell = (ivec2(gl_FragCoord.xy) + ivec2(segment_id, segment_id >> 2)) & 3;\n"
"  if (alpha < 1.0 && (BAYER[4 * cell.y + cell.x] + 0.5) / 16.0 > alpha)\n"
"    discard;\n"
"}\n"

Referenced by libvgcode::ViewerImpl::init().

Segments_Shadow_Caster_Vertex_Shader

const char* libvgcode::Segments_Shadow_Caster_Vertex_Shader

static

Referenced by libvgcode::ViewerImpl::init().

Segments_Shadow_Caster_Vertex_Shader_ES

const char* libvgcode::Segments_Shadow_Caster_Vertex_Shader_ES

static

Referenced by libvgcode::ViewerImpl::init().

Segments_Vertex_Shader

const char* libvgcode::Segments_Vertex_Shader

static

Referenced by libvgcode::ViewerImpl::init().

Segments_Vertex_Shader_ES

const char* libvgcode::Segments_Vertex_Shader_ES

static

Referenced by libvgcode::ViewerImpl::init().

TIME_MODES_COUNT

std::size_t libvgcode::TIME_MODES_COUNT = static_cast<std::size_t>(ETimeMode::COUNT)

staticconstexpr

Referenced by libvgcode::ExtrusionRoles::add(), libvgcode::ViewerImpl::get_estimated_time_at(), libvgcode::ViewerImpl::get_time_modes(), libvgcode::ViewerImpl::load(), and libvgcode::Layers::update().

Translucent_Composite_Fragment_Shader

const char* libvgcode::Translucent_Composite_Fragment_Shader

static

Initial value:

=
"#version 150\n"
"uniform sampler2D accum_tex;\n"
"uniform sampler2D reveal_tex;\n"
"uniform sampler2D front_tex;\n"
"uniform ivec2 origin;\n"
"out vec4 fragment_color;\n"
"void main() {\n"
"  ivec2 coord = ivec2(gl_FragCoord.xy) - origin;\n"
"  vec4 front = texelFetch(front_tex, coord, 0);\n"
"  vec4 accum = texelFetch(accum_tex, coord, 0);\n"
"  if (front.a <= 0.0 && accum.a <= 0.0)\n"
"    discard;\n"
"  float coverage = accum.a > 0.0 ? 1.0 - exp(-texelFetch(reveal_tex, coord, 0).r) : 0.0;\n"
"  vec3 behind = accum.a > 0.0 ? accum.rgb / accum.a * coverage : vec3(0.0);\n"
 
"  float front_alpha = min(front.a, 1.0);\n"
"  fragment_color = vec4(front.rgb + (1.0 - front_alpha) * behind, 1.0 - (1.0 - front_alpha) * (1.0 - coverage));\n"
"}\n"

Referenced by libvgcode::ViewerImpl::init().

Translucent_Composite_Vertex_Shader

const char* libvgcode::Translucent_Composite_Vertex_Shader

static

Initial value:

=
"#version 150\n"
"void main() {\n"
"  vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2);\n"
"  gl_Position = vec4(2.0 * corner - 1.0, 0.0, 1.0);\n"
"}\n"

Referenced by libvgcode::ViewerImpl::init().

TRANSLUCENT_TEXTURE_UNIT

int libvgcode::TRANSLUCENT_TEXTURE_UNIT = 5

staticconstexpr

Referenced by libvgcode::ViewerImpl::render_segments(), and libvgcode::ViewerImpl::render_translucent_segments().

VERTEX_DATA

const std::array<uint32_t, 8> libvgcode::VERTEX_DATA = { 0, 1, 2, 3, 4, 5, 6, 7 }

staticconstexpr

{ 0, 1, 2, 3, 4, 5, 6, 7 };

Referenced by libvgcode::SegmentTemplate::init().

VIEW_TYPES_COUNT

std::size_t libvgcode::VIEW_TYPES_COUNT = static_cast<std::size_t>(EViewType::COUNT)

staticconstexpr