PrusaSlicer-NonPlainar/xs/xsp/Model.xsp

%module{Slic3r::XS};

%{
#include <xsinit.h>
#include "libslic3r/Model.hpp"
#include "libslic3r/PrintConfig.hpp"
#include "libslic3r/Slicing.hpp"
#include "libslic3r/Format/AMF.hpp"
#include "libslic3r/Format/OBJ.hpp"
#include "libslic3r/Format/PRUS.hpp"
#include "libslic3r/Format/STL.hpp"
%}

%name{Slic3r::Model} class Model {
    Model();
    ~Model();

    Clone<Model> clone()
        %code%{ RETVAL = THIS; %};
    
    %name{_add_object} Ref<ModelObject> add_object();
    Ref<ModelObject> _add_object_clone(ModelObject* other, bool copy_volumes = true)
        %code%{ RETVAL = THIS->add_object(*other, copy_volumes); %};
    void delete_object(size_t idx);
    void clear_objects();
    size_t objects_count()
        %code%{ RETVAL = THIS->objects.size(); %};
    Ref<ModelObject> get_object(int idx)
        %code%{ RETVAL = THIS->objects.at(idx); %};

    Ref<ModelMaterial> get_material(t_model_material_id material_id)
        %code%{
            RETVAL = THIS->get_material(material_id);
            if (RETVAL == NULL) {
                XSRETURN_UNDEF;
            }
        %};

    %name{add_material} Ref<ModelMaterial> add_material(t_model_material_id material_id);
    Ref<ModelMaterial> add_material_clone(t_model_material_id material_id, ModelMaterial* other)
        %code%{ RETVAL = THIS->add_material(material_id, *other); %};
    bool has_material(t_model_material_id material_id) const
        %code%{
            RETVAL = (THIS->get_material(material_id) != NULL);
        %};
    void delete_material(t_model_material_id material_id);
    void clear_materials();

    std::vector<std::string> material_names() const
        %code%{
            for (ModelMaterialMap::iterator i = THIS->materials.begin();
                i != THIS->materials.end(); ++i)
            {
                RETVAL.push_back(i->first);
            }
        %};

    size_t material_count() const
        %code%{ RETVAL = THIS->materials.size(); %};

    bool has_objects_with_no_instances();
    bool add_default_instances();
    Clone<BoundingBoxf3> bounding_box();
    void center_instances_around_point(Pointf* point)
        %code%{ THIS->center_instances_around_point(*point); %};
    void align_instances_to_origin();
    void translate(double x, double y, double z);
    Clone<TriangleMesh> mesh();
    Clone<TriangleMesh> raw_mesh();

    ModelObjectPtrs* objects()
        %code%{ RETVAL = &THIS->objects; %};
    
    bool arrange_objects(double dist, BoundingBoxf* bb = NULL);
    void duplicate(unsigned int copies_num, double dist, BoundingBoxf* bb = NULL);
    void duplicate_objects(unsigned int copies_num, double dist, BoundingBoxf* bb = NULL);
    void duplicate_objects_grid(unsigned int x, unsigned int y, double dist);

    bool store_stl(char *path, bool binary)
        %code%{ TriangleMesh mesh = THIS->mesh(); RETVAL = Slic3r::store_stl(path, &mesh, binary); %};
    bool store_amf(char *path)
        %code%{ RETVAL = Slic3r::store_amf(path, THIS); %};

%{

Model*
load_stl(CLASS, path, object_name)
    char*           CLASS;
    char*           path;
    char*           object_name;
    CODE:
        RETVAL = new Model();
        if (! load_stl(path, RETVAL, object_name)) {
            delete RETVAL;
            RETVAL = NULL;
        }
    OUTPUT:
        RETVAL

Model*
load_obj(CLASS, path, object_name)
    char*           CLASS;
    char*           path;
    char*           object_name;
    CODE:
        RETVAL = new Model();
        if (! load_obj(path, RETVAL, object_name)) {
            delete RETVAL;
            RETVAL = NULL;
        }
    OUTPUT:
        RETVAL

Model*
load_amf(CLASS, path)
    char*           CLASS;
    char*           path;
    CODE:
        RETVAL = new Model();
        if (! load_amf(path, RETVAL)) {
            delete RETVAL;
            RETVAL = NULL;
        }
    OUTPUT:
        RETVAL

Model*
load_prus(CLASS, path)
    char*           CLASS;
    char*           path;
    CODE:
#ifdef SLIC3R_PRUS
        RETVAL = new Model();
        if (! load_prus(path, RETVAL)) {
            delete RETVAL;
            RETVAL = NULL;
        }
#else
        RETVAL = nullptr;
#endif
    OUTPUT:
        RETVAL

%}

};

%name{Slic3r::Model::Material} class ModelMaterial {
    Ref<Model> model()
        %code%{ RETVAL = THIS->get_model(); %};

    Ref<DynamicPrintConfig> config()
        %code%{ RETVAL = &THIS->config; %};
    
    std::string get_attribute(std::string name)
        %code%{ if (THIS->attributes.find(name) != THIS->attributes.end()) RETVAL = THIS->attributes[name]; %};
    
    void set_attribute(std::string name, std::string value)
        %code%{ THIS->attributes[name] = value; %};

%{

SV*
ModelMaterial::attributes()
    CODE:
        HV* hv = newHV();
        for (t_model_material_attributes::const_iterator attr = THIS->attributes.begin(); attr != THIS->attributes.end(); ++attr) {
            (void)hv_store( hv, attr->first.c_str(), attr->first.length(), newSVpv(attr->second.c_str(), attr->second.length()), 0 );
        }
        RETVAL = (SV*)newRV_noinc((SV*)hv);
    OUTPUT:
        RETVAL
%}

};


%name{Slic3r::Model::Object} class ModelObject {
    ModelVolumePtrs* volumes()
        %code%{ RETVAL = &THIS->volumes; %};

    ModelInstancePtrs* instances()
        %code%{ RETVAL = &THIS->instances; %};
    
    void invalidate_bounding_box();
    void update_bounding_box();
    Clone<TriangleMesh> mesh();
    Clone<TriangleMesh> raw_mesh();
    Clone<BoundingBoxf3> raw_bounding_box();
    Clone<BoundingBoxf3> instance_bounding_box(int idx);

    Ref<BoundingBoxf3> _bounding_box(BoundingBoxf3* new_bbox = NULL)
        %code{%
            if (NULL != new_bbox) {
                THIS->_bounding_box = *new_bbox;
                THIS->_bounding_box_valid = true;
            }
            
            if (!THIS->_bounding_box_valid) {
                XSRETURN_UNDEF;
            }

            RETVAL = &THIS->_bounding_box;
        %};
    Clone<BoundingBoxf3> bounding_box();

    %name{_add_volume} Ref<ModelVolume> add_volume(TriangleMesh* mesh)
        %code%{ RETVAL = THIS->add_volume(*mesh); %};
    Ref<ModelVolume> _add_volume_clone(ModelVolume* other)
        %code%{ RETVAL = THIS->add_volume(*other); %};

    void delete_volume(size_t idx);
    void clear_volumes();
    int volumes_count()
        %code%{ RETVAL = THIS->volumes.size(); %};
    Ref<ModelVolume> get_volume(int idx)
        %code%{ RETVAL = THIS->volumes.at(idx); %};
    bool move_volume_up(int idx)
        %code%{ 
            if (idx > 0 && idx < int(THIS->volumes.size())) {
                std::swap(THIS->volumes[idx-1], THIS->volumes[idx]);
                RETVAL = true;
            } else
                RETVAL = false;
        %};
    bool move_volume_down(int idx)
        %code%{ 
            if (idx >= 0 && idx + 1 < int(THIS->volumes.size())) {
                std::swap(THIS->volumes[idx+1], THIS->volumes[idx]);
                RETVAL = true;
            } else
                RETVAL = false;
        %};

    %name{_add_instance} Ref<ModelInstance> add_instance();
    Ref<ModelInstance> _add_instance_clone(ModelInstance* other)
        %code%{ RETVAL = THIS->add_instance(*other); %};
    void delete_last_instance();
    void clear_instances();
    int instances_count()
        %code%{ RETVAL = THIS->instances.size(); %};

    std::string name()
        %code%{ RETVAL = THIS->name; %};
    void set_name(std::string value)
        %code%{ THIS->name = value; %};
    std::string input_file()
        %code%{ RETVAL = THIS->input_file; %};
    void set_input_file(std::string value)
        %code%{ THIS->input_file = value; %};
    Ref<DynamicPrintConfig> config()
        %code%{ RETVAL = &THIS->config; %};

    Ref<Model> model()
        %code%{ RETVAL = THIS->get_model(); %};

    t_layer_height_ranges layer_height_ranges()
        %code%{ RETVAL = THIS->layer_height_ranges; %};
    void set_layer_height_ranges(t_layer_height_ranges ranges)
        %code%{ THIS->layer_height_ranges = ranges; %};

    std::vector<double> layer_height_profile() 
        %code%{ RETVAL = THIS->layer_height_profile_valid ? THIS->layer_height_profile : std::vector<double>(); %};
    void set_layer_height_profile(std::vector<double> profile)
        %code%{ THIS->layer_height_profile = profile; THIS->layer_height_profile_valid = true; %};

    Ref<Pointf3> origin_translation()
        %code%{ RETVAL = &THIS->origin_translation; %};
    void set_origin_translation(Pointf3* point)
        %code%{ THIS->origin_translation = *point; %};
    
    bool needed_repair() const;
    int materials_count() const;
    int facets_count();
    void center_around_origin();
    void translate(double x, double y, double z);
    void scale_xyz(Pointf3* versor)
        %code{% THIS->scale(*versor); %};
    void rotate(float angle, Axis axis);
    void mirror(Axis axis);
    
    Model* cut(double z)
        %code%{
            RETVAL = new Model();
            THIS->cut(z, RETVAL);
        %};

    ModelObjectPtrs* split_object()
        %code%{
            RETVAL = new ModelObjectPtrs();  // leak?
            THIS->split(RETVAL);
        %};
};


%name{Slic3r::Model::Volume} class ModelVolume {
    Ref<ModelObject> object()
        %code%{ RETVAL = THIS->get_object(); %};
    
    std::string name()
        %code%{ RETVAL = THIS->name; %};
    void set_name(std::string value)
        %code%{ THIS->name = value; %};
    t_model_material_id material_id();
    void set_material_id(t_model_material_id material_id)
        %code%{ THIS->material_id(material_id); %};
    Ref<ModelMaterial> material();
    
    Ref<DynamicPrintConfig> config()
        %code%{ RETVAL = &THIS->config; %};
    Ref<TriangleMesh> mesh()
        %code%{ RETVAL = &THIS->mesh; %};
    
    bool modifier()
        %code%{ RETVAL = THIS->modifier; %};
    void set_modifier(bool modifier)
        %code%{ THIS->modifier = modifier; %};
    
    ModelMaterial* assign_unique_material();
};


%name{Slic3r::Model::Instance} class ModelInstance {
    Ref<ModelObject> object()
        %code%{ RETVAL = THIS->get_object(); %};

    double rotation()
        %code%{ RETVAL = THIS->rotation; %};
    double scaling_factor()
        %code%{ RETVAL = THIS->scaling_factor; %};
    Ref<Pointf> offset()
        %code%{ RETVAL = &THIS->offset; %};

    void set_rotation(double val)
        %code%{ THIS->rotation = val; %};
    void set_scaling_factor(double val)
        %code%{ THIS->scaling_factor = val; %};
    void set_offset(Pointf *offset)
        %code%{ THIS->offset = *offset; %};
    
    void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const;
    void transform_polygon(Polygon* polygon) const;
};