← Back to branch summary

~ubuntu-branches/ubuntu/utopic/slic3r/utopic

« back to all changes in this revision

Viewing changes to xs/xsp/my.map

  • Committer: Package Import Robot
  • Author(s): Chow Loong Jin
  • Date: 2014-06-17 01:27:26 UTC
  • Revision ID: package-import@ubuntu.com-20140617012726-2wrs4zdo251nr4vg
Tags: upstream-1.1.4+dfsg
Import upstream version 1.1.4+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
xs/xsp/my.map
 
1
coordf_t T_NV
 
2
 
 
3
std::vector<Points::size_type>  T_STD_VECTOR_INT
 
4
std::vector<size_t>  T_STD_VECTOR_INT
 
5
 
 
6
t_config_option_key T_STD_STRING
 
7
t_model_material_id T_STD_STRING
 
8
t_layer_height_ranges   T_LAYER_HEIGHT_RANGES
 
9
 
 
10
 
 
11
BoundingBox*               O_OBJECT_SLIC3R
 
12
Ref<BoundingBox>           O_OBJECT_SLIC3R_T
 
13
Clone<BoundingBox>         O_OBJECT_SLIC3R_T
 
14
 
 
15
BoundingBoxf3*             O_OBJECT_SLIC3R
 
16
Ref<BoundingBoxf3>         O_OBJECT_SLIC3R_T
 
17
Clone<BoundingBoxf3>       O_OBJECT_SLIC3R_T
 
18
 
 
19
DynamicPrintConfig*        O_OBJECT_SLIC3R
 
20
Ref<DynamicPrintConfig>    O_OBJECT_SLIC3R_T
 
21
PrintObjectConfig*         O_OBJECT_SLIC3R
 
22
PrintRegionConfig*         O_OBJECT_SLIC3R
 
23
PrintConfig*               O_OBJECT_SLIC3R
 
24
FullPrintConfig*           O_OBJECT_SLIC3R
 
25
ZTable*                    O_OBJECT
 
26
 
 
27
TriangleMesh*              O_OBJECT_SLIC3R
 
28
Ref<TriangleMesh>          O_OBJECT_SLIC3R_T
 
29
Clone<TriangleMesh>        O_OBJECT_SLIC3R_T
 
30
 
 
31
Point*                     O_OBJECT_SLIC3R
 
32
Ref<Point>                 O_OBJECT_SLIC3R_T
 
33
Clone<Point>               O_OBJECT_SLIC3R_T
 
34
 
 
35
Pointf*                    O_OBJECT_SLIC3R
 
36
Ref<Pointf>                O_OBJECT_SLIC3R_T
 
37
Clone<Pointf>              O_OBJECT_SLIC3R_T
 
38
 
 
39
Pointf3*                   O_OBJECT_SLIC3R
 
40
Ref<Pointf3>               O_OBJECT_SLIC3R_T
 
41
Clone<Pointf3>             O_OBJECT_SLIC3R_T
 
42
 
 
43
Line*                      O_OBJECT_SLIC3R
 
44
Ref<Line>                  O_OBJECT_SLIC3R_T
 
45
Clone<Line>                O_OBJECT_SLIC3R_T
 
46
 
 
47
Polyline*                  O_OBJECT_SLIC3R
 
48
Ref<Polyline>              O_OBJECT_SLIC3R_T
 
49
Clone<Polyline>            O_OBJECT_SLIC3R_T
 
50
 
 
51
PolylineCollection*        O_OBJECT_SLIC3R
 
52
Ref<PolylineCollection>    O_OBJECT_SLIC3R_T
 
53
Clone<PolylineCollection>  O_OBJECT_SLIC3R_T
 
54
 
 
55
Polygon*                   O_OBJECT_SLIC3R
 
56
Ref<Polygon>               O_OBJECT_SLIC3R_T
 
57
Clone<Polygon>             O_OBJECT_SLIC3R_T
 
58
 
 
59
ExPolygon*                 O_OBJECT_SLIC3R
 
60
Ref<ExPolygon>             O_OBJECT_SLIC3R_T
 
61
Clone<ExPolygon>           O_OBJECT_SLIC3R_T
 
62
 
 
63
ExPolygonCollection*       O_OBJECT_SLIC3R
 
64
Ref<ExPolygonCollection>   O_OBJECT_SLIC3R_T
 
65
Clone<ExPolygonCollection> O_OBJECT_SLIC3R_T
 
66
 
 
67
ExtrusionEntityCollection*              O_OBJECT_SLIC3R
 
68
Ref<ExtrusionEntityCollection>          O_OBJECT_SLIC3R_T
 
69
Clone<ExtrusionEntityCollection>        O_OBJECT_SLIC3R_T
 
70
 
 
71
ExtrusionPath*             O_OBJECT_SLIC3R
 
72
Ref<ExtrusionPath>         O_OBJECT_SLIC3R_T
 
73
Clone<ExtrusionPath>       O_OBJECT_SLIC3R_T
 
74
 
 
75
ExtrusionLoop*             O_OBJECT_SLIC3R
 
76
Ref<ExtrusionLoop>         O_OBJECT_SLIC3R_T
 
77
Clone<ExtrusionLoop>       O_OBJECT_SLIC3R_T
 
78
 
 
79
Flow*                      O_OBJECT_SLIC3R
 
80
Ref<Flow>                  O_OBJECT_SLIC3R_T
 
81
Clone<Flow>                O_OBJECT_SLIC3R_T
 
82
 
 
83
PrintState*                O_OBJECT_SLIC3R
 
84
 
 
85
Surface*                   O_OBJECT_SLIC3R
 
86
Ref<Surface>               O_OBJECT_SLIC3R_T
 
87
Clone<Surface>             O_OBJECT_SLIC3R_T
 
88
 
 
89
SurfaceCollection*         O_OBJECT_SLIC3R
 
90
 
 
91
Extruder*                  O_OBJECT_SLIC3R
 
92
 
 
93
Model*                     O_OBJECT_SLIC3R
 
94
Ref<Model>                 O_OBJECT_SLIC3R_T
 
95
Clone<Model>               O_OBJECT_SLIC3R_T
 
96
 
 
97
ModelMaterial*             O_OBJECT_SLIC3R
 
98
Ref<ModelMaterial>         O_OBJECT_SLIC3R_T
 
99
Clone<ModelMaterial>       O_OBJECT_SLIC3R_T
 
100
 
 
101
ModelObject*               O_OBJECT_SLIC3R
 
102
Ref<ModelObject>           O_OBJECT_SLIC3R_T
 
103
Clone<ModelObject>         O_OBJECT_SLIC3R_T
 
104
 
 
105
ModelVolume*               O_OBJECT_SLIC3R
 
106
Ref<ModelVolume>           O_OBJECT_SLIC3R_T
 
107
Clone<ModelVolume>         O_OBJECT_SLIC3R_T
 
108
 
 
109
ModelInstance*             O_OBJECT_SLIC3R
 
110
Ref<ModelInstance>         O_OBJECT_SLIC3R_T
 
111
Clone<ModelInstance>       O_OBJECT_SLIC3R_T
 
112
 
 
113
 
 
114
ExtrusionLoopRole     T_UV
 
115
ExtrusionRole     T_UV
 
116
FlowRole     T_UV
 
117
PrintStep     T_UV
 
118
SurfaceType     T_UV
 
119
ClipperLib::JoinType            T_UV
 
120
ClipperLib::PolyFillType                T_UV
 
121
 
 
122
# we return these types whenever we want the items to be cloned
 
123
Points          T_ARRAYREF
 
124
Pointfs         T_ARRAYREF
 
125
Lines           T_ARRAYREF
 
126
Polygons        T_ARRAYREF
 
127
Polylines       T_ARRAYREF
 
128
ExPolygons      T_ARRAYREF
 
129
ExtrusionPaths  T_ARRAYREF
 
130
Surfaces        T_ARRAYREF
 
131
 
 
132
# we return these types whenever we want the items to be returned
 
133
# by reference and marked ::Ref because they're contained in another
 
134
# Perl object
 
135
Polygons*       T_ARRAYREF_PTR
 
136
ModelObjectPtrs* T_PTR_ARRAYREF_PTR
 
137
ModelVolumePtrs* T_PTR_ARRAYREF_PTR
 
138
ModelInstancePtrs*   T_PTR_ARRAYREF_PTR
 
139
 
 
140
# we return these types whenever we want the items to be returned
 
141
# by reference and not marked ::Ref because they're newly allocated
 
142
# and not referenced by any Perl object
 
143
TriangleMeshPtrs T_PTR_ARRAYREF
 
144
 
 
145
 
 
146
INPUT
 
147
 
 
148
O_OBJECT_SLIC3R
 
149
    if( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) ) {
 
150
        if ( sv_isa($arg, perl_class_name($var) ) ||  sv_isa($arg, perl_class_name_ref($var) )) {
 
151
              $var = ($type)SvIV((SV*)SvRV( $arg ));
 
152
        } else {
 
153
              croak(\"$var is not of type %s (got %s)\", perl_class_name($var), HvNAME(SvSTASH(SvRV($arg))));
 
154
              XSRETURN_UNDEF;
 
155
        }
 
156
    } else {
 
157
        warn( \"${Package}::$func_name() -- $var is not a blessed SV reference\" );
 
158
        XSRETURN_UNDEF;
 
159
    }
 
160
 
 
161
T_ARRAYREF
 
162
    if (SvROK($arg) && SvTYPE(SvRV($arg)) == SVt_PVAV) {
 
163
        AV* av = (AV*)SvRV($arg);
 
164
        const unsigned int len = av_len(av)+1;
 
165
        $type* tmp = new $type(len);
 
166
        for (unsigned int i = 0; i < len; i++) {
 
167
            SV** elem = av_fetch(av, i, 0);
 
168
            (*tmp)[i].from_SV_check(*elem);
 
169
        }
 
170
        $var = *tmp;
 
171
            delete tmp;
 
172
    } else
 
173
        Perl_croak(aTHX_ \"%s: %s is not an array reference\",
 
174
                     ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
 
175
                     \"$var\");
 
176
 
 
177
T_LAYER_HEIGHT_RANGES
 
178
    {
 
179
        if (!SvROK($arg) || SvTYPE(SvRV($arg)) != SVt_PVAV) {
 
180
            Perl_croak(aTHX_ \"%s: %s is not an array reference\",
 
181
                     ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
 
182
                     \"$var\");
 
183
        }
 
184
 
 
185
        AV* av = (AV*)SvRV($arg);
 
186
        const unsigned int len = av_len(av)+1;
 
187
        t_layer_height_ranges tmp_ranges;
 
188
        for (unsigned int i = 0; i < len; i++) {
 
189
            SV* elem = *av_fetch(av, i, 0);
 
190
            if (!SvROK(elem) || SvTYPE(SvRV(elem)) != SVt_PVAV) {
 
191
                Perl_croak(
 
192
                    aTHX_ \"%s: %s contains something that is not an array reference\",
 
193
                        ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
 
194
                        \"$var\");
 
195
            }
 
196
 
 
197
            AV* elemAV = (AV*)SvRV(elem);
 
198
            if (av_len(elemAV) + 1 != 3) {
 
199
                Perl_croak(
 
200
                    aTHX_ \"%s: %s contains an array that isn't 3 elements long\",
 
201
                        ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
 
202
                        \"$var\");
 
203
            }
 
204
 
 
205
            coordf_t vals[3];
 
206
            for (unsigned int j = 0; j < 3; ++j) {
 
207
                SV *elem_elem = *av_fetch(elemAV, j, 0);
 
208
                if (!SvNOK(elem_elem)) {
 
209
                    Perl_croak(
 
210
                        aTHX_ \"%s: layer ranges and heights must be numbers\",
 
211
                            ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]});
 
212
                }
 
213
 
 
214
                vals[j] = SvNV(elem_elem);
 
215
            }
 
216
 
 
217
            tmp_ranges[t_layer_height_range(vals[0], vals[1])] = vals[2];
 
218
        }
 
219
 
 
220
        $var = tmp_ranges;
 
221
    }
 
222
 
 
223
 
 
224
OUTPUT
 
225
# return object from pointer
 
226
O_OBJECT_SLIC3R
 
227
        sv_setref_pv( $arg, perl_class_name($var), (void*)$var );
 
228
 
 
229
# return value handled by template class
 
230
O_OBJECT_SLIC3R_T
 
231
        sv_setref_pv( $arg, $type\::CLASS(), (void*)$var );
 
232
 
 
233
 
 
234
T_ARRAYREF
 
235
        AV* av = newAV();
 
236
        $arg = newRV_noinc((SV*)av);
 
237
        sv_2mortal($arg);
 
238
        av_extend(av, $var.size()-1);
 
239
        int i = 0;
 
240
    for (${type}::const_iterator it = $var.begin(); it != $var.end(); ++it) {
 
241
        av_store(av, i++, perl_to_SV_clone_ref(*it));
 
242
        }
 
243
        $var.clear();
 
244
 
 
245
T_ARRAYREF_PTR
 
246
    AV* av = newAV();
 
247
        $arg = newRV_noinc((SV*)av);
 
248
        sv_2mortal($arg);
 
249
        av_extend(av, $var->size()-1);
 
250
        int i = 0;
 
251
    for (${ my $t = $type; $t =~ s/\*$//; \$t }::iterator it = $var->begin(); it != $var->end(); ++it) {
 
252
        av_store(av, i++, perl_to_SV_ref(*it));
 
253
        }
 
254
 
 
255
T_PTR_ARRAYREF_PTR
 
256
    AV* av = newAV();
 
257
    $arg = newRV_noinc((SV*)av);
 
258
    sv_2mortal($arg);
 
259
    av_extend(av, $var->size()-1);
 
260
    int i = 0;
 
261
    for (${ my $t = $type; $t =~ s/\*$//; \$t }::iterator it = $var->begin(); it != $var->end(); ++it) {
 
262
        av_store(av, i++, perl_to_SV_ref(**it));
 
263
    }
 
264
 
 
265
T_PTR_ARRAYREF
 
266
    AV* av = newAV();
 
267
        $arg = newRV_noinc((SV*)av);
 
268
        sv_2mortal($arg);
 
269
        av_extend(av, $var.size()-1);
 
270
        int i = 0;
 
271
    for (${type}::iterator it = $var.begin(); it != $var.end(); ++it) {
 
272
        av_store(av, i++, (*it)->to_SV());
 
273
        }
 
274
 
 
275
T_LAYER_HEIGHT_RANGES
 
276
    AV* av = newAV();
 
277
    $arg = newRV_noinc((SV*)av);
 
278
    sv_2mortal($arg);
 
279
    av_extend(av, $var.size() - 1);
 
280
    // map is sorted, so we can just copy it in order
 
281
    int i = 0;
 
282
    for (${type}::iterator it = $var.begin(); it != $var.end(); ++it) {
 
283
        const coordf_t range_values[] = {
 
284
                it->first.first,    // key's first = minz
 
285
                it->first.second,   // key's second = maxz
 
286
                it->second,         // value = height
 
287
            };
 
288
 
 
289
        AV *rangeAV = newAV();
 
290
        SV *rangeAV_ref = newRV_noinc((SV*)rangeAV);
 
291
        sv_2mortal(rangeAV_ref);
 
292
        av_extend(rangeAV, 2);
 
293
        for (int j = 0; j < 3; ++j) {
 
294
            SV *val = sv_newmortal();
 
295
            sv_setnv(val, range_values[j]);
 
296
            av_store(rangeAV, j, val);
 
297
        }
 
298
 
 
299
        av_store(av, i++, (SV*)rangeAV_ref);
 
300
    }