mirror of
https://github.com/SoftFever/OrcaSlicer.git
synced 2025-10-23 00:31:11 -06:00
Merge branch 'master' into updating
This commit is contained in:
Vojtech Kral
commit
a50bde4267
14 changed files with 280 additions and 174 deletions
|
|
@ -67,7 +67,7 @@ public:
|
|||
|
||||
// Set the extruder properties.
|
||||
void set_extruder(size_t idx, material_type material, int temp, int first_layer_temp, float loading_speed,
|
||||
float unloading_speed, float delay, float cooling_time, std::string ramming_parameters, float nozzle_diameter)
|
||||
float unloading_speed, float delay, std::string ramming_parameters, float nozzle_diameter)
|
||||
{
|
||||
//while (m_filpar.size() < idx+1) // makes sure the required element is in the vector
|
||||
m_filpar.push_back(FilamentParameters());
|
||||
|
|
@ -78,7 +78,7 @@ public:
|
|||
m_filpar[idx].loading_speed = loading_speed;
|
||||
m_filpar[idx].unloading_speed = unloading_speed;
|
||||
m_filpar[idx].delay = delay;
|
||||
m_filpar[idx].cooling_time = cooling_time;
|
||||
m_filpar[idx].cooling_time = 14.f; // let's fix it for now, cooling moves will be reworked for 1.41 anyway
|
||||
m_filpar[idx].nozzle_diameter = nozzle_diameter; // to be used in future with (non-single) multiextruder MM
|
||||
|
||||
m_perimeter_width = nozzle_diameter * Width_To_Nozzle_Ratio; // all extruders are now assumed to have the same diameter
|
||||
|
|
|
|||
|
|
@ -186,7 +186,6 @@ bool Print::invalidate_state_by_config_options(const std::vector<t_config_option
|
|||
|| opt_key == "filament_loading_speed"
|
||||
|| opt_key == "filament_unloading_speed"
|
||||
|| opt_key == "filament_toolchange_delay"
|
||||
|| opt_key == "filament_cooling_time"
|
||||
|| opt_key == "filament_ramming_parameters"
|
||||
|| opt_key == "gcode_flavor"
|
||||
|| opt_key == "single_extruder_multi_material"
|
||||
|
|
@ -1091,7 +1090,6 @@ void Print::_make_wipe_tower()
|
|||
this->config.filament_loading_speed.get_at(i),
|
||||
this->config.filament_unloading_speed.get_at(i),
|
||||
this->config.filament_toolchange_delay.get_at(i),
|
||||
this->config.filament_cooling_time.get_at(i),
|
||||
this->config.filament_ramming_parameters.get_at(i),
|
||||
this->config.nozzle_diameter.get_at(i));
|
||||
|
||||
|
|
|
|||
|
|
@ -481,15 +481,6 @@ PrintConfigDef::PrintConfigDef()
|
|||
def->cli = "filament-toolchange-delay=f@";
|
||||
def->min = 0;
|
||||
def->default_value = new ConfigOptionFloats { 0. };
|
||||
|
||||
def = this->add("filament_cooling_time", coFloats);
|
||||
def->label = L("Cooling time");
|
||||
def->tooltip = L("The filament is slowly moved back and forth after retraction into the cooling tube "
|
||||
"for this amount of time.");
|
||||
def->cli = "filament_cooling_time=i@";
|
||||
def->sidetext = L("s");
|
||||
def->min = 0;
|
||||
def->default_value = new ConfigOptionFloats { 14.f };
|
||||
|
||||
def = this->add("filament_ramming_parameters", coStrings);
|
||||
def->label = L("Ramming parameters");
|
||||
|
|
|
|||
|
|
@ -476,7 +476,6 @@ public:
|
|||
ConfigOptionFloats filament_loading_speed;
|
||||
ConfigOptionFloats filament_unloading_speed;
|
||||
ConfigOptionFloats filament_toolchange_delay;
|
||||
ConfigOptionFloats filament_cooling_time;
|
||||
ConfigOptionStrings filament_ramming_parameters;
|
||||
ConfigOptionBool gcode_comments;
|
||||
ConfigOptionEnum<GCodeFlavor> gcode_flavor;
|
||||
|
|
@ -534,7 +533,6 @@ protected:
|
|||
OPT_PTR(filament_loading_speed);
|
||||
OPT_PTR(filament_unloading_speed);
|
||||
OPT_PTR(filament_toolchange_delay);
|
||||
OPT_PTR(filament_cooling_time);
|
||||
OPT_PTR(filament_ramming_parameters);
|
||||
OPT_PTR(gcode_comments);
|
||||
OPT_PTR(gcode_flavor);
|
||||
|
|
|
|||
|
|
@ -788,15 +788,14 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
#define TOP 2
|
||||
#define BOTTOM 3
|
||||
|
||||
Line prev_line;
|
||||
// right, left, top, bottom
|
||||
int idx_prev[4] = { -1, -1, -1, -1 };
|
||||
double bottom_z_prev = 0.;
|
||||
Pointf b1_prev;
|
||||
Pointf b2_prev;
|
||||
Vectorf v_prev;
|
||||
int idx_initial[4] = { -1, -1, -1, -1 };
|
||||
double width_initial = 0.;
|
||||
double bottom_z_initial = 0.0;
|
||||
|
||||
// loop once more in case of closed loops
|
||||
size_t lines_end = closed ? (lines.size() + 1) : lines.size();
|
||||
|
|
@ -804,13 +803,18 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
size_t i = (ii == lines.size()) ? 0 : ii;
|
||||
const Line &line = lines[i];
|
||||
double len = unscale(line.length());
|
||||
double inv_len = 1.0 / len;
|
||||
double bottom_z = top_z - heights[i];
|
||||
double middle_z = (top_z + bottom_z) / 2.;
|
||||
double middle_z = 0.5 * (top_z + bottom_z);
|
||||
double width = widths[i];
|
||||
|
||||
|
||||
bool is_first = (ii == 0);
|
||||
bool is_last = (ii == lines_end - 1);
|
||||
bool is_closing = closed && is_last;
|
||||
|
||||
Vectorf v = Vectorf::new_unscale(line.vector());
|
||||
v.scale(1. / len);
|
||||
|
||||
v.scale(inv_len);
|
||||
|
||||
Pointf a = Pointf::new_unscale(line.a);
|
||||
Pointf b = Pointf::new_unscale(line.b);
|
||||
Pointf a1 = a;
|
||||
|
|
@ -818,17 +822,19 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
Pointf b1 = b;
|
||||
Pointf b2 = b;
|
||||
{
|
||||
double dist = width / 2.; // scaled
|
||||
a1.translate(+dist*v.y, -dist*v.x);
|
||||
a2.translate(-dist*v.y, +dist*v.x);
|
||||
b1.translate(+dist*v.y, -dist*v.x);
|
||||
b2.translate(-dist*v.y, +dist*v.x);
|
||||
double dist = 0.5 * width; // scaled
|
||||
double dx = dist * v.x;
|
||||
double dy = dist * v.y;
|
||||
a1.translate(+dy, -dx);
|
||||
a2.translate(-dy, +dx);
|
||||
b1.translate(+dy, -dx);
|
||||
b2.translate(-dy, +dx);
|
||||
}
|
||||
|
||||
// calculate new XY normals
|
||||
Vector n = line.normal();
|
||||
Vectorf3 xy_right_normal = Vectorf3::new_unscale(n.x, n.y, 0);
|
||||
xy_right_normal.scale(1.f / len);
|
||||
xy_right_normal.scale(inv_len);
|
||||
|
||||
int idx_a[4];
|
||||
int idx_b[4];
|
||||
|
|
@ -837,14 +843,21 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
bool bottom_z_different = bottom_z_prev != bottom_z;
|
||||
bottom_z_prev = bottom_z;
|
||||
|
||||
if (!is_first && bottom_z_different)
|
||||
{
|
||||
// Found a change of the layer thickness -> Add a cap at the end of the previous segment.
|
||||
volume.push_quad(idx_b[BOTTOM], idx_b[LEFT], idx_b[TOP], idx_b[RIGHT]);
|
||||
}
|
||||
|
||||
// Share top / bottom vertices if possible.
|
||||
if (ii == 0) {
|
||||
idx_a[TOP] = idx_last ++;
|
||||
if (is_first) {
|
||||
idx_a[TOP] = idx_last++;
|
||||
volume.push_geometry(a.x, a.y, top_z , 0., 0., 1.);
|
||||
} else {
|
||||
idx_a[TOP] = idx_prev[TOP];
|
||||
}
|
||||
if (ii == 0 || bottom_z_different) {
|
||||
|
||||
if (is_first || bottom_z_different) {
|
||||
// Start of the 1st line segment or a change of the layer thickness while maintaining the print_z.
|
||||
idx_a[BOTTOM] = idx_last ++;
|
||||
volume.push_geometry(a.x, a.y, bottom_z, 0., 0., -1.);
|
||||
|
|
@ -852,13 +865,15 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
volume.push_geometry(a2.x, a2.y, middle_z, -xy_right_normal.x, -xy_right_normal.y, -xy_right_normal.z);
|
||||
idx_a[RIGHT] = idx_last ++;
|
||||
volume.push_geometry(a1.x, a1.y, middle_z, xy_right_normal.x, xy_right_normal.y, xy_right_normal.z);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
idx_a[BOTTOM] = idx_prev[BOTTOM];
|
||||
}
|
||||
|
||||
if (ii == 0) {
|
||||
if (is_first) {
|
||||
// Start of the 1st line segment.
|
||||
width_initial = width;
|
||||
bottom_z_initial = bottom_z;
|
||||
memcpy(idx_initial, idx_a, sizeof(int) * 4);
|
||||
} else {
|
||||
// Continuing a previous segment.
|
||||
|
|
@ -866,43 +881,54 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
double v_dot = dot(v_prev, v);
|
||||
bool sharp = v_dot < 0.707; // sin(45 degrees)
|
||||
if (sharp) {
|
||||
// Allocate new left / right points for the start of this segment as these points will receive their own normals to indicate a sharp turn.
|
||||
idx_a[RIGHT] = idx_last ++;
|
||||
volume.push_geometry(a1.x, a1.y, middle_z, xy_right_normal.x, xy_right_normal.y, xy_right_normal.z);
|
||||
idx_a[LEFT ] = idx_last ++;
|
||||
volume.push_geometry(a2.x, a2.y, middle_z, -xy_right_normal.x, -xy_right_normal.y, -xy_right_normal.z);
|
||||
if (!bottom_z_different)
|
||||
{
|
||||
// Allocate new left / right points for the start of this segment as these points will receive their own normals to indicate a sharp turn.
|
||||
idx_a[RIGHT] = idx_last++;
|
||||
volume.push_geometry(a1.x, a1.y, middle_z, xy_right_normal.x, xy_right_normal.y, xy_right_normal.z);
|
||||
idx_a[LEFT] = idx_last++;
|
||||
volume.push_geometry(a2.x, a2.y, middle_z, -xy_right_normal.x, -xy_right_normal.y, -xy_right_normal.z);
|
||||
}
|
||||
}
|
||||
if (v_dot > 0.9) {
|
||||
// The two successive segments are nearly collinear.
|
||||
idx_a[LEFT ] = idx_prev[LEFT];
|
||||
idx_a[RIGHT] = idx_prev[RIGHT];
|
||||
} else if (! sharp) {
|
||||
// Create a sharp corner with an overshot and average the left / right normals.
|
||||
// At the crease angle of 45 degrees, the overshot at the corner will be less than (1-1/cos(PI/8)) = 8.2% over an arc.
|
||||
Pointf intersection;
|
||||
Geometry::ray_ray_intersection(b1_prev, v_prev, a1, v, intersection);
|
||||
a1 = intersection;
|
||||
a2 = 2. * a - intersection;
|
||||
assert(length(a1.vector_to(a)) < width);
|
||||
assert(length(a2.vector_to(a)) < width);
|
||||
float *n_left_prev = volume.vertices_and_normals_interleaved.data() + idx_prev[LEFT ] * 6;
|
||||
float *p_left_prev = n_left_prev + 3;
|
||||
float *n_right_prev = volume.vertices_and_normals_interleaved.data() + idx_prev[RIGHT] * 6;
|
||||
float *p_right_prev = n_right_prev + 3;
|
||||
p_left_prev [0] = float(a2.x);
|
||||
p_left_prev [1] = float(a2.y);
|
||||
p_right_prev[0] = float(a1.x);
|
||||
p_right_prev[1] = float(a1.y);
|
||||
xy_right_normal.x += n_right_prev[0];
|
||||
xy_right_normal.y += n_right_prev[1];
|
||||
xy_right_normal.scale(1. / length(xy_right_normal));
|
||||
n_left_prev [0] = float(-xy_right_normal.x);
|
||||
n_left_prev [1] = float(-xy_right_normal.y);
|
||||
n_right_prev[0] = float( xy_right_normal.x);
|
||||
n_right_prev[1] = float( xy_right_normal.y);
|
||||
idx_a[LEFT ] = idx_prev[LEFT ];
|
||||
idx_a[RIGHT] = idx_prev[RIGHT];
|
||||
} else if (cross(v_prev, v) > 0.) {
|
||||
if (!bottom_z_different)
|
||||
{
|
||||
// The two successive segments are nearly collinear.
|
||||
idx_a[LEFT ] = idx_prev[LEFT];
|
||||
idx_a[RIGHT] = idx_prev[RIGHT];
|
||||
}
|
||||
}
|
||||
else if (!sharp) {
|
||||
if (!bottom_z_different)
|
||||
{
|
||||
// Create a sharp corner with an overshot and average the left / right normals.
|
||||
// At the crease angle of 45 degrees, the overshot at the corner will be less than (1-1/cos(PI/8)) = 8.2% over an arc.
|
||||
Pointf intersection;
|
||||
Geometry::ray_ray_intersection(b1_prev, v_prev, a1, v, intersection);
|
||||
a1 = intersection;
|
||||
a2 = 2. * a - intersection;
|
||||
assert(length(a1.vector_to(a)) < width);
|
||||
assert(length(a2.vector_to(a)) < width);
|
||||
float *n_left_prev = volume.vertices_and_normals_interleaved.data() + idx_prev[LEFT ] * 6;
|
||||
float *p_left_prev = n_left_prev + 3;
|
||||
float *n_right_prev = volume.vertices_and_normals_interleaved.data() + idx_prev[RIGHT] * 6;
|
||||
float *p_right_prev = n_right_prev + 3;
|
||||
p_left_prev [0] = float(a2.x);
|
||||
p_left_prev [1] = float(a2.y);
|
||||
p_right_prev[0] = float(a1.x);
|
||||
p_right_prev[1] = float(a1.y);
|
||||
xy_right_normal.x += n_right_prev[0];
|
||||
xy_right_normal.y += n_right_prev[1];
|
||||
xy_right_normal.scale(1. / length(xy_right_normal));
|
||||
n_left_prev [0] = float(-xy_right_normal.x);
|
||||
n_left_prev [1] = float(-xy_right_normal.y);
|
||||
n_right_prev[0] = float( xy_right_normal.x);
|
||||
n_right_prev[1] = float( xy_right_normal.y);
|
||||
idx_a[LEFT ] = idx_prev[LEFT ];
|
||||
idx_a[RIGHT] = idx_prev[RIGHT];
|
||||
}
|
||||
}
|
||||
else if (cross(v_prev, v) > 0.) {
|
||||
// Right turn. Fill in the right turn wedge.
|
||||
volume.push_triangle(idx_prev[RIGHT], idx_a [RIGHT], idx_prev[TOP] );
|
||||
volume.push_triangle(idx_prev[RIGHT], idx_prev[BOTTOM], idx_a [RIGHT] );
|
||||
|
|
@ -911,18 +937,21 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
volume.push_triangle(idx_prev[LEFT], idx_prev[TOP], idx_a [LEFT] );
|
||||
volume.push_triangle(idx_prev[LEFT], idx_a [LEFT], idx_prev[BOTTOM]);
|
||||
}
|
||||
if (ii == lines.size()) {
|
||||
if (! sharp) {
|
||||
// Closing a loop with smooth transition. Unify the closing left / right vertices.
|
||||
memcpy(volume.vertices_and_normals_interleaved.data() + idx_initial[LEFT ] * 6, volume.vertices_and_normals_interleaved.data() + idx_prev[LEFT ] * 6, sizeof(float) * 6);
|
||||
memcpy(volume.vertices_and_normals_interleaved.data() + idx_initial[RIGHT] * 6, volume.vertices_and_normals_interleaved.data() + idx_prev[RIGHT] * 6, sizeof(float) * 6);
|
||||
volume.vertices_and_normals_interleaved.erase(volume.vertices_and_normals_interleaved.end() - 12, volume.vertices_and_normals_interleaved.end());
|
||||
// Replace the left / right vertex indices to point to the start of the loop.
|
||||
for (size_t u = volume.quad_indices.size() - 16; u < volume.quad_indices.size(); ++ u) {
|
||||
if (volume.quad_indices[u] == idx_prev[LEFT])
|
||||
volume.quad_indices[u] = idx_initial[LEFT];
|
||||
else if (volume.quad_indices[u] == idx_prev[RIGHT])
|
||||
volume.quad_indices[u] = idx_initial[RIGHT];
|
||||
if (is_closing) {
|
||||
if (!sharp) {
|
||||
if (!bottom_z_different)
|
||||
{
|
||||
// Closing a loop with smooth transition. Unify the closing left / right vertices.
|
||||
memcpy(volume.vertices_and_normals_interleaved.data() + idx_initial[LEFT ] * 6, volume.vertices_and_normals_interleaved.data() + idx_prev[LEFT ] * 6, sizeof(float) * 6);
|
||||
memcpy(volume.vertices_and_normals_interleaved.data() + idx_initial[RIGHT] * 6, volume.vertices_and_normals_interleaved.data() + idx_prev[RIGHT] * 6, sizeof(float) * 6);
|
||||
volume.vertices_and_normals_interleaved.erase(volume.vertices_and_normals_interleaved.end() - 12, volume.vertices_and_normals_interleaved.end());
|
||||
// Replace the left / right vertex indices to point to the start of the loop.
|
||||
for (size_t u = volume.quad_indices.size() - 16; u < volume.quad_indices.size(); ++ u) {
|
||||
if (volume.quad_indices[u] == idx_prev[LEFT])
|
||||
volume.quad_indices[u] = idx_initial[LEFT];
|
||||
else if (volume.quad_indices[u] == idx_prev[RIGHT])
|
||||
volume.quad_indices[u] = idx_initial[RIGHT];
|
||||
}
|
||||
}
|
||||
}
|
||||
// This is the last iteration, only required to solve the transition.
|
||||
|
|
@ -931,13 +960,14 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
}
|
||||
|
||||
// Only new allocate top / bottom vertices, if not closing a loop.
|
||||
if (closed && ii + 1 == lines.size()) {
|
||||
if (is_closing) {
|
||||
idx_b[TOP] = idx_initial[TOP];
|
||||
} else {
|
||||
idx_b[TOP] = idx_last ++;
|
||||
volume.push_geometry(b.x, b.y, top_z , 0., 0., 1.);
|
||||
}
|
||||
if (closed && ii + 1 == lines.size() && width == width_initial) {
|
||||
|
||||
if (is_closing && (width == width_initial) && (bottom_z == bottom_z_initial)) {
|
||||
idx_b[BOTTOM] = idx_initial[BOTTOM];
|
||||
} else {
|
||||
idx_b[BOTTOM] = idx_last ++;
|
||||
|
|
@ -949,22 +979,26 @@ static void thick_lines_to_indexed_vertex_array(
|
|||
idx_b[RIGHT ] = idx_last ++;
|
||||
volume.push_geometry(b1.x, b1.y, middle_z, xy_right_normal.x, xy_right_normal.y, xy_right_normal.z);
|
||||
|
||||
prev_line = line;
|
||||
memcpy(idx_prev, idx_b, 4 * sizeof(int));
|
||||
bottom_z_prev = bottom_z;
|
||||
b1_prev = b1;
|
||||
b2_prev = b2;
|
||||
v_prev = v;
|
||||
v_prev = v;
|
||||
|
||||
if (bottom_z_different)
|
||||
{
|
||||
// Found a change of the layer thickness -> Add a cap at the beginning of this segment.
|
||||
volume.push_quad(idx_a[BOTTOM], idx_a[RIGHT], idx_a[TOP], idx_a[LEFT]);
|
||||
}
|
||||
|
||||
if (! closed) {
|
||||
// Terminate open paths with caps.
|
||||
if (i == 0)
|
||||
if (is_first && !bottom_z_different)
|
||||
volume.push_quad(idx_a[BOTTOM], idx_a[RIGHT], idx_a[TOP], idx_a[LEFT]);
|
||||
// We don't use 'else' because both cases are true if we have only one line.
|
||||
if (i + 1 == lines.size())
|
||||
if (is_last && !bottom_z_different)
|
||||
volume.push_quad(idx_b[BOTTOM], idx_b[LEFT], idx_b[TOP], idx_b[RIGHT]);
|
||||
}
|
||||
|
||||
|
||||
// Add quads for a straight hollow tube-like segment.
|
||||
// bottom-right face
|
||||
volume.push_quad(idx_a[BOTTOM], idx_b[BOTTOM], idx_b[RIGHT], idx_a[RIGHT]);
|
||||
|
|
|
|||
|
|
@ -297,7 +297,7 @@ const std::vector<std::string>& Preset::filament_options()
|
|||
static std::vector<std::string> s_opts {
|
||||
"filament_colour", "filament_diameter", "filament_type", "filament_soluble", "filament_notes", "filament_max_volumetric_speed",
|
||||
"extrusion_multiplier", "filament_density", "filament_cost", "filament_loading_speed", "filament_unloading_speed", "filament_toolchange_delay",
|
||||
"filament_cooling_time", "filament_ramming_parameters", "temperature", "first_layer_temperature", "bed_temperature",
|
||||
"filament_ramming_parameters", "temperature", "first_layer_temperature", "bed_temperature",
|
||||
"first_layer_bed_temperature", "fan_always_on", "cooling", "min_fan_speed", "max_fan_speed", "bridge_fan_speed", "disable_fan_first_layers",
|
||||
"fan_below_layer_time", "slowdown_below_layer_time", "min_print_speed", "start_filament_gcode", "end_filament_gcode","compatible_printers",
|
||||
"compatible_printers_condition", "inherits"
|
||||
|
|
|
|||
|
|
@ -1288,7 +1288,6 @@ void TabFilament::build()
|
|||
optgroup->append_single_option_line("filament_loading_speed");
|
||||
optgroup->append_single_option_line("filament_unloading_speed");
|
||||
optgroup->append_single_option_line("filament_toolchange_delay");
|
||||
optgroup->append_single_option_line("filament_cooling_time");
|
||||
line = { _(L("Ramming")), "" };
|
||||
line.widget = [this](wxWindow* parent){
|
||||
auto ramming_dialog_btn = new wxButton(parent, wxID_ANY, _(L("Ramming settings"))+"\u2026", wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
|
||||
|
|
|
|||
|
|
@ -85,8 +85,12 @@ namespace Slic3r {
|
|||
|
||||
template<class T>
|
||||
struct ClassTraits {
|
||||
// Name of a Perl alias of a C++ class type, owned by Perl, reference counted.
|
||||
static const char* name;
|
||||
static const char* name_ref;
|
||||
// Name of a Perl alias of a C++ class type, owned by the C++ code.
|
||||
// The references shall be enumerated at the end of XS.pm, where the desctructor is undefined with sub DESTROY {},
|
||||
// so Perl will never delete the object instance.
|
||||
static const char* name_ref;
|
||||
};
|
||||
|
||||
// use this for typedefs for which the forward prototype
|
||||
|
|
@ -99,11 +103,16 @@ struct ClassTraits {
|
|||
class cname; \
|
||||
__REGISTER_CLASS(cname, perlname);
|
||||
|
||||
// Return Perl alias to a C++ class name.
|
||||
template<class T>
|
||||
const char* perl_class_name(const T*) { return ClassTraits<T>::name; }
|
||||
// Return Perl alias to a C++ class name, suffixed with ::Ref.
|
||||
// Such a C++ class instance will not be destroyed by Perl, the instance destruction is left to the C++ code.
|
||||
template<class T>
|
||||
const char* perl_class_name_ref(const T*) { return ClassTraits<T>::name_ref; }
|
||||
|
||||
// Mark the Perl SV (Scalar Value) as owning a "blessed" pointer to an object reference.
|
||||
// Perl will never release the C++ instance.
|
||||
template<class T>
|
||||
SV* perl_to_SV_ref(T &t) {
|
||||
SV* sv = newSV(0);
|
||||
|
|
@ -111,6 +120,8 @@ SV* perl_to_SV_ref(T &t) {
|
|||
return sv;
|
||||
}
|
||||
|
||||
// Mark the Perl SV (Scalar Value) as owning a "blessed" pointer to an object instance.
|
||||
// Perl will own the C++ instance, therefore it will also release it.
|
||||
template<class T>
|
||||
SV* perl_to_SV_clone_ref(const T &t) {
|
||||
SV* sv = newSV(0);
|
||||
|
|
@ -118,6 +129,8 @@ SV* perl_to_SV_clone_ref(const T &t) {
|
|||
return sv;
|
||||
}
|
||||
|
||||
// Reference wrapper to provide a C++ instance to Perl while keeping Perl from destroying the instance.
|
||||
// The instance is created temporarily by XS.cpp just to provide Perl with a CLASS name and a object instance pointer.
|
||||
template <class T>
|
||||
class Ref {
|
||||
T* val;
|
||||
|
|
@ -125,10 +138,15 @@ public:
|
|||
Ref() : val(NULL) {}
|
||||
Ref(T* t) : val(t) {}
|
||||
Ref(const T* t) : val(const_cast<T*>(t)) {}
|
||||
// Called by XS.cpp to convert the referenced object instance to a Perl SV, before it is blessed with the name
|
||||
// returned by CLASS()
|
||||
operator T*() const { return val; }
|
||||
// Name to bless the Perl SV with. The name ends with a "::Ref" suffix to keep Perl from destroying the object instance.
|
||||
static const char* CLASS() { return ClassTraits<T>::name_ref; }
|
||||
};
|
||||
|
||||
|
||||
// Wrapper to clone a C++ object instance before passing it to Perl for ownership.
|
||||
// This wrapper instance is created temporarily by XS.cpp to provide Perl with a CLASS name and a object instance pointer.
|
||||
template <class T>
|
||||
class Clone {
|
||||
T* val;
|
||||
|
|
@ -136,7 +154,11 @@ public:
|
|||
Clone() : val(NULL) {}
|
||||
Clone(T* t) : val(new T(*t)) {}
|
||||
Clone(const T& t) : val(new T(t)) {}
|
||||
// Called by XS.cpp to convert the cloned object instance to a Perl SV, before it is blessed with the name
|
||||
// returned by CLASS()
|
||||
operator T*() const { return val; }
|
||||
// Name to bless the Perl SV with. If there is a destructor registered in the XSP file for this class, then Perl will
|
||||
// call this destructor when the reference counter of this SV drops to zero.
|
||||
static const char* CLASS() { return ClassTraits<T>::name; }
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue