%module{Slic3r::XS};

%{
#include <myinit.h>
#include "TriangleMesh.hpp"
%}

%name{Slic3r::TriangleMesh} class TriangleMesh {
    TriangleMesh();
    ~TriangleMesh();
    TriangleMesh* clone()
        %code{% const char* CLASS = "Slic3r::TriangleMesh"; RETVAL = new TriangleMesh(*THIS); %};
    void ReadSTLFile(char* input_file);
    void write_ascii(char* output_file);
    void write_binary(char* output_file);
    void ReadFromPerl(SV* vertices, SV* facets);
    void repair();
    void WriteOBJFile(char* output_file);
    void scale(float factor);
    void scale_xyz(std::vector<double> versor)
        %code{% THIS->scale(versor); %};
    void translate(float x, float y, float z);
    void align_to_origin();
    void rotate(double angle, Point* center);
    TriangleMeshPtrs split();
    void merge(TriangleMesh* mesh);
    ExPolygons horizontal_projection()
        %code{% THIS->horizontal_projection(RETVAL); %};
    BoundingBoxf3* bounding_box()
        %code{%
            const char* CLASS = "Slic3r::Geometry::BoundingBoxf3";
            RETVAL = new BoundingBoxf3();
            THIS->bounding_box(RETVAL);
        %};
    int facets_count()
        %code{% RETVAL = THIS->stl.stats.number_of_facets; %};
%{

SV*
TriangleMesh::stats()
    CODE:
        HV* hv = newHV();
        (void)hv_stores( hv, "number_of_facets",    newSViv(THIS->stl.stats.number_of_facets) );
        (void)hv_stores( hv, "number_of_parts",     newSViv(THIS->stl.stats.number_of_parts) );
        (void)hv_stores( hv, "volume",              newSVnv(THIS->stl.stats.volume) );
        (void)hv_stores( hv, "degenerate_facets",   newSViv(THIS->stl.stats.degenerate_facets) );
        (void)hv_stores( hv, "edges_fixed",         newSViv(THIS->stl.stats.edges_fixed) );
        (void)hv_stores( hv, "facets_removed",      newSViv(THIS->stl.stats.facets_removed) );
        (void)hv_stores( hv, "facets_added",        newSViv(THIS->stl.stats.facets_added) );
        (void)hv_stores( hv, "facets_reversed",     newSViv(THIS->stl.stats.facets_reversed) );
        (void)hv_stores( hv, "backwards_edges",     newSViv(THIS->stl.stats.backwards_edges) );
        (void)hv_stores( hv, "normals_fixed",       newSViv(THIS->stl.stats.normals_fixed) );
        RETVAL = (SV*)newRV_noinc((SV*)hv);
    OUTPUT:
        RETVAL

SV*
TriangleMesh::vertices()
    CODE:
        if (!THIS->repaired) CONFESS("vertices() requires repair()");
        
        if (THIS->stl.v_shared == NULL)
            stl_generate_shared_vertices(&(THIS->stl));
        
        // vertices
        AV* vertices = newAV();
        av_extend(vertices, THIS->stl.stats.shared_vertices);
        for (int i = 0; i < THIS->stl.stats.shared_vertices; i++) {
            AV* vertex = newAV();
            av_store(vertices, i, newRV_noinc((SV*)vertex));
            av_extend(vertex, 2);
            av_store(vertex, 0, newSVnv(THIS->stl.v_shared[i].x));
            av_store(vertex, 1, newSVnv(THIS->stl.v_shared[i].y));
            av_store(vertex, 2, newSVnv(THIS->stl.v_shared[i].z));
        }
        
        RETVAL = newRV_noinc((SV*)vertices);
    OUTPUT:
        RETVAL

SV*
TriangleMesh::facets()
    CODE:
        if (!THIS->repaired) CONFESS("facets() requires repair()");
        
        if (THIS->stl.v_shared == NULL)
            stl_generate_shared_vertices(&(THIS->stl));
        
        // facets
        AV* facets = newAV();
        av_extend(facets, THIS->stl.stats.number_of_facets);
        for (int i = 0; i < THIS->stl.stats.number_of_facets; i++) {
            AV* facet = newAV();
            av_store(facets, i, newRV_noinc((SV*)facet));
            av_extend(facet, 2);
            av_store(facet, 0, newSVnv(THIS->stl.v_indices[i].vertex[0]));
            av_store(facet, 1, newSVnv(THIS->stl.v_indices[i].vertex[1]));
            av_store(facet, 2, newSVnv(THIS->stl.v_indices[i].vertex[2]));
        }
        
        RETVAL = newRV_noinc((SV*)facets);
    OUTPUT:
        RETVAL

SV*
TriangleMesh::normals()
    CODE:
        if (!THIS->repaired) CONFESS("normals() requires repair()");
        
        // normals
        AV* normals = newAV();
        av_extend(normals, THIS->stl.stats.number_of_facets);
        for (int i = 0; i < THIS->stl.stats.number_of_facets; i++) {
            AV* facet = newAV();
            av_store(normals, i, newRV_noinc((SV*)facet));
            av_extend(facet, 2);
            av_store(facet, 0, newSVnv(THIS->stl.facet_start[i].normal.x));
            av_store(facet, 1, newSVnv(THIS->stl.facet_start[i].normal.y));
            av_store(facet, 2, newSVnv(THIS->stl.facet_start[i].normal.z));
        }
        
        RETVAL = newRV_noinc((SV*)normals);
    OUTPUT:
        RETVAL

SV*
TriangleMesh::size()
    CODE:
        AV* size = newAV();
        av_extend(size, 2);
        av_store(size, 0, newSVnv(THIS->stl.stats.size.x));
        av_store(size, 1, newSVnv(THIS->stl.stats.size.y));
        av_store(size, 2, newSVnv(THIS->stl.stats.size.z));
        RETVAL = newRV_noinc((SV*)size);
    OUTPUT:
        RETVAL

SV*
TriangleMesh::slice(z)
    std::vector<double>* z
    CODE:
        // convert doubles to floats
        std::vector<float> z_f(z->begin(), z->end());
        delete z;
        
        std::vector<ExPolygons> layers;
        TriangleMeshSlicer mslicer(THIS);
        mslicer.slice(z_f, &layers);
        
        AV* layers_av = newAV();
        av_extend(layers_av, layers.size()-1);
        for (unsigned int i = 0; i < layers.size(); i++) {
            AV* expolygons_av = newAV();
            av_extend(expolygons_av, layers[i].size()-1);
            unsigned int j = 0;
            for (ExPolygons::iterator it = layers[i].begin(); it != layers[i].end(); ++it) {
                av_store(expolygons_av, j++, (*it).to_SV_clone_ref());
            }
            av_store(layers_av, i, newRV_noinc((SV*)expolygons_av));
        }
        RETVAL = (SV*)newRV_noinc((SV*)layers_av);
    OUTPUT:
        RETVAL

void
TriangleMesh::cut(z, upper, lower)
    float           z;
    TriangleMesh*   upper;
    TriangleMesh*   lower;
    CODE:
        TriangleMeshSlicer mslicer(THIS);
        mslicer.cut(z, upper, lower);

std::vector<double>
TriangleMesh::bb3()
    CODE:
        RETVAL.push_back(THIS->stl.stats.min.x);
        RETVAL.push_back(THIS->stl.stats.min.y);
        RETVAL.push_back(THIS->stl.stats.max.x);
        RETVAL.push_back(THIS->stl.stats.max.y);
        RETVAL.push_back(THIS->stl.stats.min.z);
        RETVAL.push_back(THIS->stl.stats.max.z);
    OUTPUT:
        RETVAL

Polygon*
TriangleMesh::convex_hull()
    PREINIT:
        const char* CLASS = "Slic3r::Polygon";
    CODE:
        RETVAL = new Polygon ();
        THIS->convex_hull(RETVAL);
    OUTPUT:
        RETVAL

%}
};

%package{Slic3r::TriangleMesh};

%{
PROTOTYPES: DISABLE

std::string
hello_world()
  CODE:
    RETVAL = "Hello world!";
  OUTPUT:
    RETVAL
%}