Blender V5.3
BPy_Convert.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BPy_Convert.h"
10
11#include "BPy_BBox.h"
12#include "BPy_FrsMaterial.h"
13#include "BPy_Id.h"
14#include "BPy_IntegrationType.h"
15#include "BPy_Interface0D.h"
16#include "BPy_Interface1D.h"
17#include "BPy_MediumType.h"
18#include "BPy_Nature.h"
19#include "BPy_SShape.h"
20#include "BPy_StrokeAttribute.h"
21#include "BPy_ViewShape.h"
34
45
46#include "../stroke/StrokeRep.h"
47
48using namespace Freestyle;
49using namespace Freestyle::Geometry;
50
52
53//==============================
54// C++ => Python
55//==============================
56
57PyObject *PyBool_from_bool(bool b)
58{
59 return PyBool_FromLong(b ? 1 : 0);
60}
61
62PyObject *PyLong_subtype_new(PyTypeObject *ty, long value)
63{
64 BLI_assert(ty->tp_basicsize == sizeof(PyLongObject));
65 PyLongObject *result = PyObject_NewVar(PyLongObject, ty, 1);
66 PyLongObject *value_py = (PyLongObject *)PyLong_FromLong(value);
67 memcpy(&result->long_value, &value_py->long_value, sizeof(result->long_value));
68 Py_DECREF(value_py);
69 return (PyObject *)result;
70}
71
72void PyLong_subtype_add_to_dict(PyObject *dict, PyTypeObject *ty, const char *attr, long value)
73{
74 PyObject *result = PyLong_subtype_new(ty, value);
75 PyDict_SetItemString(dict, attr, result);
76 /* Owned by the dictionary. */
77 Py_DECREF(result);
78}
79
80PyObject *Vector_from_Vec2f(Vec2f &vec)
81{
82 float vec_data[2]; // because vec->_coord is protected
83 vec_data[0] = vec.x();
84 vec_data[1] = vec.y();
85 return blender::Vector_CreatePyObject(vec_data, 2, nullptr);
86}
87
88PyObject *Vector_from_Vec3f(Vec3f &vec)
89{
90 float vec_data[3]; // because vec->_coord is protected
91 vec_data[0] = vec.x();
92 vec_data[1] = vec.y();
93 vec_data[2] = vec.z();
94 return blender::Vector_CreatePyObject(vec_data, 3, nullptr);
95}
96
97PyObject *Vector_from_Vec3r(Vec3r &vec)
98{
99 float vec_data[3]; // because vec->_coord is protected
100 vec_data[0] = vec.x();
101 vec_data[1] = vec.y();
102 vec_data[2] = vec.z();
103 return blender::Vector_CreatePyObject(vec_data, 3, nullptr);
104}
105
106PyObject *BPy_Id_from_Id(Id &id)
107{
108 PyObject *py_id = Id_Type.tp_new(&Id_Type, nullptr, nullptr);
109 ((BPy_Id *)py_id)->id = new Id(id.getFirst(), id.getSecond());
110 return py_id;
111}
112
114{
115 if (typeid(if0D) == typeid(CurvePoint)) {
116 return BPy_CurvePoint_from_CurvePoint(dynamic_cast<CurvePoint &>(if0D));
117 }
118 if (typeid(if0D) == typeid(StrokeVertex)) {
119 return BPy_StrokeVertex_from_StrokeVertex(dynamic_cast<StrokeVertex &>(if0D));
120 }
121 if (typeid(if0D) == typeid(SVertex)) {
122 return BPy_SVertex_from_SVertex(dynamic_cast<SVertex &>(if0D));
123 }
124 if (typeid(if0D) == typeid(ViewVertex)) {
125 return BPy_ViewVertex_from_ViewVertex(dynamic_cast<ViewVertex &>(if0D));
126 }
127 if (typeid(if0D) == typeid(NonTVertex)) {
128 return BPy_NonTVertex_from_NonTVertex(dynamic_cast<NonTVertex &>(if0D));
129 }
130 if (typeid(if0D) == typeid(TVertex)) {
131 return BPy_TVertex_from_TVertex(dynamic_cast<TVertex &>(if0D));
132 }
133 if (typeid(if0D) == typeid(Interface0D)) {
135 }
136 string msg("unexpected type: " + if0D.getExactTypeName());
137 PyErr_SetString(PyExc_TypeError, msg.c_str());
138 return nullptr;
139}
140
142{
143 if (typeid(if1D) == typeid(ViewEdge)) {
144 return BPy_ViewEdge_from_ViewEdge(dynamic_cast<ViewEdge &>(if1D));
145 }
146 if (typeid(if1D) == typeid(Chain)) {
147 return BPy_Chain_from_Chain(dynamic_cast<Chain &>(if1D));
148 }
149 if (typeid(if1D) == typeid(Stroke)) {
150 return BPy_Stroke_from_Stroke(dynamic_cast<Stroke &>(if1D));
151 }
152 if (typeid(if1D) == typeid(FEdgeSharp)) {
153 return BPy_FEdgeSharp_from_FEdgeSharp(dynamic_cast<FEdgeSharp &>(if1D));
154 }
155 if (typeid(if1D) == typeid(FEdgeSmooth)) {
156 return BPy_FEdgeSmooth_from_FEdgeSmooth(dynamic_cast<FEdgeSmooth &>(if1D));
157 }
158 if (typeid(if1D) == typeid(FEdge)) {
159 return BPy_FEdge_from_FEdge(dynamic_cast<FEdge &>(if1D));
160 }
161 if (typeid(if1D) == typeid(Interface1D)) {
163 }
164 string msg("unexpected type: " + if1D.getExactTypeName());
165 PyErr_SetString(PyExc_TypeError, msg.c_str());
166 return nullptr;
167}
168
170{
171 if (typeid(fe) == typeid(FEdgeSharp)) {
172 return BPy_FEdgeSharp_from_FEdgeSharp(dynamic_cast<FEdgeSharp &>(fe));
173 }
174 if (typeid(fe) == typeid(FEdgeSmooth)) {
175 return BPy_FEdgeSmooth_from_FEdgeSmooth(dynamic_cast<FEdgeSmooth &>(fe));
176 }
177 if (typeid(fe) == typeid(FEdge)) {
178 return BPy_FEdge_from_FEdge(fe);
179 }
180 string msg("unexpected type: " + fe.getExactTypeName());
181 PyErr_SetString(PyExc_TypeError, msg.c_str());
182 return nullptr;
183}
184
186{
187 if (typeid(vv) == typeid(NonTVertex)) {
188 return BPy_NonTVertex_from_NonTVertex(dynamic_cast<NonTVertex &>(vv));
189 }
190 if (typeid(vv) == typeid(TVertex)) {
191 return BPy_TVertex_from_TVertex(dynamic_cast<TVertex &>(vv));
192 }
193 if (typeid(vv) == typeid(ViewVertex)) {
195 }
196 string msg("unexpected type: " + vv.getExactTypeName());
197 PyErr_SetString(PyExc_TypeError, msg.c_str());
198 return nullptr;
199}
200
202{
203 PyObject *py_if0D = Interface0D_Type.tp_new(&Interface0D_Type, nullptr, nullptr);
204 ((BPy_Interface0D *)py_if0D)->if0D = &if0D;
205 ((BPy_Interface0D *)py_if0D)->borrowed = true;
206 return py_if0D;
207}
208
210{
211 PyObject *py_if1D = Interface1D_Type.tp_new(&Interface1D_Type, nullptr, nullptr);
212 ((BPy_Interface1D *)py_if1D)->if1D = &if1D;
213 ((BPy_Interface1D *)py_if1D)->borrowed = true;
214 return py_if1D;
215}
216
218{
219 PyObject *py_sv = SVertex_Type.tp_new(&SVertex_Type, nullptr, nullptr);
220 ((BPy_SVertex *)py_sv)->sv = &sv;
221 ((BPy_SVertex *)py_sv)->py_if0D.if0D = ((BPy_SVertex *)py_sv)->sv;
222 ((BPy_SVertex *)py_sv)->py_if0D.borrowed = true;
223 return py_sv;
224}
225
227{
228 PyObject *py_fe = FEdgeSharp_Type.tp_new(&FEdgeSharp_Type, nullptr, nullptr);
229 ((BPy_FEdgeSharp *)py_fe)->fes = &fes;
230 ((BPy_FEdgeSharp *)py_fe)->py_fe.fe = ((BPy_FEdgeSharp *)py_fe)->fes;
231 ((BPy_FEdgeSharp *)py_fe)->py_fe.py_if1D.if1D = ((BPy_FEdgeSharp *)py_fe)->fes;
232 ((BPy_FEdgeSharp *)py_fe)->py_fe.py_if1D.borrowed = true;
233 return py_fe;
234}
235
237{
238 PyObject *py_fe = FEdgeSmooth_Type.tp_new(&FEdgeSmooth_Type, nullptr, nullptr);
239 ((BPy_FEdgeSmooth *)py_fe)->fes = &fes;
240 ((BPy_FEdgeSmooth *)py_fe)->py_fe.fe = ((BPy_FEdgeSmooth *)py_fe)->fes;
241 ((BPy_FEdgeSmooth *)py_fe)->py_fe.py_if1D.if1D = ((BPy_FEdgeSmooth *)py_fe)->fes;
242 ((BPy_FEdgeSmooth *)py_fe)->py_fe.py_if1D.borrowed = true;
243 return py_fe;
244}
245
247{
248 PyObject *py_fe = FEdge_Type.tp_new(&FEdge_Type, nullptr, nullptr);
249 ((BPy_FEdge *)py_fe)->fe = &fe;
250 ((BPy_FEdge *)py_fe)->py_if1D.if1D = ((BPy_FEdge *)py_fe)->fe;
251 ((BPy_FEdge *)py_fe)->py_if1D.borrowed = true;
252 return py_fe;
253}
254
255PyObject *BPy_Nature_from_Nature(ushort n)
256{
257 PyObject *args = PyTuple_New(1);
258 PyTuple_SET_ITEM(args, 0, PyLong_FromLong(n));
259 PyObject *py_n = Nature_Type.tp_new(&Nature_Type, args, nullptr);
260 Py_DECREF(args);
261 return py_n;
262}
263
265{
266 PyObject *py_s = Stroke_Type.tp_new(&Stroke_Type, nullptr, nullptr);
267 ((BPy_Stroke *)py_s)->s = &s;
268 ((BPy_Stroke *)py_s)->py_if1D.if1D = ((BPy_Stroke *)py_s)->s;
269 ((BPy_Stroke *)py_s)->py_if1D.borrowed = true;
270 return py_s;
271}
272
274{
275 PyObject *py_sa = StrokeAttribute_Type.tp_new(&StrokeAttribute_Type, nullptr, nullptr);
276 ((BPy_StrokeAttribute *)py_sa)->sa = &sa;
277 ((BPy_StrokeAttribute *)py_sa)->borrowed = true;
278 return py_sa;
279}
280
282{
283 PyObject *args = PyTuple_New(1);
284 PyTuple_SET_ITEM(args, 0, PyLong_FromLong(n));
285 PyObject *py_mt = MediumType_Type.tp_new(&MediumType_Type, args, nullptr);
286 Py_DECREF(args);
287 return py_mt;
288}
289
291{
292 PyObject *py_sv = StrokeVertex_Type.tp_new(&StrokeVertex_Type, nullptr, nullptr);
293 ((BPy_StrokeVertex *)py_sv)->sv = &sv;
294 ((BPy_StrokeVertex *)py_sv)->py_cp.cp = ((BPy_StrokeVertex *)py_sv)->sv;
295 ((BPy_StrokeVertex *)py_sv)->py_cp.py_if0D.if0D = ((BPy_StrokeVertex *)py_sv)->sv;
296 ((BPy_StrokeVertex *)py_sv)->py_cp.py_if0D.borrowed = true;
297 return py_sv;
298}
299
301{
302 PyObject *py_vv = ViewVertex_Type.tp_new(&ViewVertex_Type, nullptr, nullptr);
303 ((BPy_ViewVertex *)py_vv)->vv = &vv;
304 ((BPy_ViewVertex *)py_vv)->py_if0D.if0D = ((BPy_ViewVertex *)py_vv)->vv;
305 ((BPy_ViewVertex *)py_vv)->py_if0D.borrowed = true;
306 return py_vv;
307}
308
310{
311 PyObject *py_ntv = NonTVertex_Type.tp_new(&NonTVertex_Type, nullptr, nullptr);
312 ((BPy_NonTVertex *)py_ntv)->ntv = &ntv;
313 ((BPy_NonTVertex *)py_ntv)->py_vv.vv = ((BPy_NonTVertex *)py_ntv)->ntv;
314 ((BPy_NonTVertex *)py_ntv)->py_vv.py_if0D.if0D = ((BPy_NonTVertex *)py_ntv)->ntv;
315 ((BPy_NonTVertex *)py_ntv)->py_vv.py_if0D.borrowed = true;
316 return py_ntv;
317}
318
320{
321 PyObject *py_tv = TVertex_Type.tp_new(&TVertex_Type, nullptr, nullptr);
322 ((BPy_TVertex *)py_tv)->tv = &tv;
323 ((BPy_TVertex *)py_tv)->py_vv.vv = ((BPy_TVertex *)py_tv)->tv;
324 ((BPy_TVertex *)py_tv)->py_vv.py_if0D.if0D = ((BPy_TVertex *)py_tv)->tv;
325 ((BPy_TVertex *)py_tv)->py_vv.py_if0D.borrowed = true;
326 return py_tv;
327}
328
329PyObject *BPy_BBox_from_BBox(const BBox<Vec3r> &bb)
330{
331 PyObject *py_bb = BBox_Type.tp_new(&BBox_Type, nullptr, nullptr);
332 ((BPy_BBox *)py_bb)->bb = new BBox<Vec3r>(bb);
333 return py_bb;
334}
335
337{
338 PyObject *py_ve = ViewEdge_Type.tp_new(&ViewEdge_Type, nullptr, nullptr);
339 ((BPy_ViewEdge *)py_ve)->ve = &ve;
340 ((BPy_ViewEdge *)py_ve)->py_if1D.if1D = ((BPy_ViewEdge *)py_ve)->ve;
341 ((BPy_ViewEdge *)py_ve)->py_if1D.borrowed = true;
342 return py_ve;
343}
344
346{
347 PyObject *py_c = Chain_Type.tp_new(&Chain_Type, nullptr, nullptr);
348 ((BPy_Chain *)py_c)->c = &c;
349 ((BPy_Chain *)py_c)->py_c.c = ((BPy_Chain *)py_c)->c;
350 ((BPy_Chain *)py_c)->py_c.py_if1D.if1D = ((BPy_Chain *)py_c)->c;
351 ((BPy_Chain *)py_c)->py_c.py_if1D.borrowed = true;
352 return py_c;
353}
354
356{
357 PyObject *py_ss = SShape_Type.tp_new(&SShape_Type, nullptr, nullptr);
358 ((BPy_SShape *)py_ss)->ss = &ss;
359 ((BPy_SShape *)py_ss)->borrowed = true;
360 return py_ss;
361}
362
364{
365 PyObject *py_vs = ViewShape_Type.tp_new(&ViewShape_Type, nullptr, nullptr);
366 ((BPy_ViewShape *)py_vs)->vs = &vs;
367 ((BPy_ViewShape *)py_vs)->borrowed = true;
368 ((BPy_ViewShape *)py_vs)->py_ss = nullptr;
369 return py_vs;
370}
371
373{
374 PyObject *py_m = FrsMaterial_Type.tp_new(&FrsMaterial_Type, nullptr, nullptr);
375 ((BPy_FrsMaterial *)py_m)->m = new FrsMaterial(m);
376 return py_m;
377}
378
380{
381 PyObject *args = PyTuple_New(1);
382 PyTuple_SET_ITEM(args, 0, PyLong_FromLong(i));
383 PyObject *py_it = IntegrationType_Type.tp_new(&IntegrationType_Type, args, nullptr);
384 Py_DECREF(args);
385 return py_it;
386}
387
389{
390 PyObject *py_cp = CurvePoint_Type.tp_new(&CurvePoint_Type, nullptr, nullptr);
391 // CurvePointIterator::operator*() returns a reference of a class data
392 // member whose value is mutable upon iteration over different CurvePoints.
393 // It is likely that such a mutable reference is passed to this function,
394 // so that a new allocated CurvePoint instance is created here to avoid
395 // nasty bugs (cf. #41464).
396 ((BPy_CurvePoint *)py_cp)->cp = new CurvePoint(cp);
397 ((BPy_CurvePoint *)py_cp)->py_if0D.if0D = ((BPy_CurvePoint *)py_cp)->cp;
398 ((BPy_CurvePoint *)py_cp)->py_if0D.borrowed = false;
399 return py_cp;
400}
401
403{
404 PyObject *py_dve = PyTuple_New(2);
406 py_dve, BPy_ViewEdge_from_ViewEdge(*(dve.first)), PyBool_from_bool(dve.second));
407 return py_dve;
408}
409
410//==============================
411// Iterators
412//==============================
413
415{
416 PyObject *py_a_it = AdjacencyIterator_Type.tp_new(&AdjacencyIterator_Type, nullptr, nullptr);
417 ((BPy_AdjacencyIterator *)py_a_it)->a_it = new AdjacencyIterator(a_it);
418 ((BPy_AdjacencyIterator *)py_a_it)->py_it.it = ((BPy_AdjacencyIterator *)py_a_it)->a_it;
419 ((BPy_AdjacencyIterator *)py_a_it)->at_start = true;
420 return py_a_it;
421}
422
424 bool reversed)
425{
426 PyObject *py_if0D_it = Interface0DIterator_Type.tp_new(
427 &Interface0DIterator_Type, nullptr, nullptr);
428 ((BPy_Interface0DIterator *)py_if0D_it)->if0D_it = new Interface0DIterator(if0D_it);
429 ((BPy_Interface0DIterator *)py_if0D_it)->py_it.it =
430 ((BPy_Interface0DIterator *)py_if0D_it)->if0D_it;
431 ((BPy_Interface0DIterator *)py_if0D_it)->at_start = true;
432 ((BPy_Interface0DIterator *)py_if0D_it)->reversed = reversed;
433 return py_if0D_it;
434}
435
437{
438 PyObject *py_cp_it = CurvePointIterator_Type.tp_new(&CurvePointIterator_Type, nullptr, nullptr);
439 ((BPy_CurvePointIterator *)py_cp_it)->cp_it = new CurveInternal::CurvePointIterator(cp_it);
440 ((BPy_CurvePointIterator *)py_cp_it)->py_it.it = ((BPy_CurvePointIterator *)py_cp_it)->cp_it;
441 return py_cp_it;
442}
443
445 StrokeInternal::StrokeVertexIterator &sv_it, bool reversed)
446{
447 PyObject *py_sv_it = StrokeVertexIterator_Type.tp_new(
448 &StrokeVertexIterator_Type, nullptr, nullptr);
449 ((BPy_StrokeVertexIterator *)py_sv_it)->sv_it = new StrokeInternal::StrokeVertexIterator(sv_it);
450 ((BPy_StrokeVertexIterator *)py_sv_it)->py_it.it = ((BPy_StrokeVertexIterator *)py_sv_it)->sv_it;
451 ((BPy_StrokeVertexIterator *)py_sv_it)->at_start = true;
452 ((BPy_StrokeVertexIterator *)py_sv_it)->reversed = reversed;
453 return py_sv_it;
454}
455
457{
458 PyObject *py_sv_it = SVertexIterator_Type.tp_new(&SVertexIterator_Type, nullptr, nullptr);
459 ((BPy_SVertexIterator *)py_sv_it)->sv_it = new ViewEdgeInternal::SVertexIterator(sv_it);
460 ((BPy_SVertexIterator *)py_sv_it)->py_it.it = ((BPy_SVertexIterator *)py_sv_it)->sv_it;
461 return py_sv_it;
462}
463
466{
467 PyObject *py_ove_it = orientedViewEdgeIterator_Type.tp_new(
468 &orientedViewEdgeIterator_Type, nullptr, nullptr);
469 ((BPy_orientedViewEdgeIterator *)py_ove_it)->ove_it =
471 ((BPy_orientedViewEdgeIterator *)py_ove_it)->py_it.it =
472 ((BPy_orientedViewEdgeIterator *)py_ove_it)->ove_it;
473 ((BPy_orientedViewEdgeIterator *)py_ove_it)->at_start = true;
474 ((BPy_orientedViewEdgeIterator *)py_ove_it)->reversed = reversed;
475 return py_ove_it;
476}
477
479{
480 PyObject *py_ve_it = ViewEdgeIterator_Type.tp_new(&ViewEdgeIterator_Type, nullptr, nullptr);
481 ((BPy_ViewEdgeIterator *)py_ve_it)->ve_it = new ViewEdgeInternal::ViewEdgeIterator(ve_it);
482 ((BPy_ViewEdgeIterator *)py_ve_it)->py_it.it = ((BPy_ViewEdgeIterator *)py_ve_it)->ve_it;
483 return py_ve_it;
484}
485
487{
488 PyObject *py_c_it = ChainingIterator_Type.tp_new(&ChainingIterator_Type, nullptr, nullptr);
489 ((BPy_ChainingIterator *)py_c_it)->c_it = new ChainingIterator(c_it);
490 ((BPy_ChainingIterator *)py_c_it)->py_ve_it.py_it.it = ((BPy_ChainingIterator *)py_c_it)->c_it;
491 return py_c_it;
492}
493
495{
496 PyObject *py_cp_it = ChainPredicateIterator_Type.tp_new(
497 &ChainPredicateIterator_Type, nullptr, nullptr);
498 ((BPy_ChainPredicateIterator *)py_cp_it)->cp_it = new ChainPredicateIterator(cp_it);
499 ((BPy_ChainPredicateIterator *)py_cp_it)->py_c_it.py_ve_it.py_it.it =
500 ((BPy_ChainPredicateIterator *)py_cp_it)->cp_it;
501 return py_cp_it;
502}
503
505{
506 PyObject *py_cs_it = ChainSilhouetteIterator_Type.tp_new(
507 &ChainSilhouetteIterator_Type, nullptr, nullptr);
508 ((BPy_ChainSilhouetteIterator *)py_cs_it)->cs_it = new ChainSilhouetteIterator(cs_it);
509 ((BPy_ChainSilhouetteIterator *)py_cs_it)->py_c_it.py_ve_it.py_it.it =
510 ((BPy_ChainSilhouetteIterator *)py_cs_it)->cs_it;
511 return py_cs_it;
512}
513
514//==============================
515// Python => C++
516//==============================
517
518bool bool_from_PyBool(PyObject *b)
519{
520 return PyObject_IsTrue(b) != 0;
521}
522
524{
525 return static_cast<IntegrationType>(PyLong_AsLong(obj));
526}
527
529{
530 return static_cast<Stroke::MediumType>(PyLong_AsLong(obj));
531}
532
534{
535 return static_cast<Nature::EdgeNature>(PyLong_AsLong(obj));
536}
537
538bool Vec2f_ptr_from_PyObject(PyObject *obj, Vec2f &vec)
539{
540 if (Vec2f_ptr_from_Vector(obj, vec)) {
541 return true;
542 }
543 if (Vec2f_ptr_from_PyList(obj, vec)) {
544 return true;
545 }
546 if (Vec2f_ptr_from_PyTuple(obj, vec)) {
547 return true;
548 }
549 return false;
550}
551
552bool Vec3f_ptr_from_PyObject(PyObject *obj, Vec3f &vec)
553{
554 if (Vec3f_ptr_from_Vector(obj, vec)) {
555 return true;
556 }
557 if (Vec3f_ptr_from_Color(obj, vec)) {
558 return true;
559 }
560 if (Vec3f_ptr_from_PyList(obj, vec)) {
561 return true;
562 }
563 if (Vec3f_ptr_from_PyTuple(obj, vec)) {
564 return true;
565 }
566 return false;
567}
568
569bool Vec3r_ptr_from_PyObject(PyObject *obj, Vec3r &vec)
570{
571 if (Vec3r_ptr_from_Vector(obj, vec)) {
572 return true;
573 }
574 if (Vec3r_ptr_from_Color(obj, vec)) {
575 return true;
576 }
577 if (Vec3r_ptr_from_PyList(obj, vec)) {
578 return true;
579 }
580 if (Vec3r_ptr_from_PyTuple(obj, vec)) {
581 return true;
582 }
583 return false;
584}
585
586bool Vec2f_ptr_from_Vector(PyObject *obj, Vec2f &vec)
587{
588 using namespace blender;
589 if (!VectorObject_Check(obj) || ((VectorObject *)obj)->vec_num != 2) {
590 return false;
591 }
593 return false;
594 }
595 vec[0] = ((VectorObject *)obj)->vec[0];
596 vec[1] = ((VectorObject *)obj)->vec[1];
597 return true;
598}
599
600bool Vec3f_ptr_from_Vector(PyObject *obj, Vec3f &vec)
601{
602 using namespace blender;
603 if (!VectorObject_Check(obj) || ((VectorObject *)obj)->vec_num != 3) {
604 return false;
605 }
607 return false;
608 }
609 vec[0] = ((VectorObject *)obj)->vec[0];
610 vec[1] = ((VectorObject *)obj)->vec[1];
611 vec[2] = ((VectorObject *)obj)->vec[2];
612 return true;
613}
614
615bool Vec3r_ptr_from_Vector(PyObject *obj, Vec3r &vec)
616{
617 using namespace blender;
618 if (!VectorObject_Check(obj) || ((VectorObject *)obj)->vec_num != 3) {
619 return false;
620 }
622 return false;
623 }
624 vec[0] = ((VectorObject *)obj)->vec[0];
625 vec[1] = ((VectorObject *)obj)->vec[1];
626 vec[2] = ((VectorObject *)obj)->vec[2];
627 return true;
628}
629
630bool Vec3f_ptr_from_Color(PyObject *obj, Vec3f &vec)
631{
632 using namespace blender;
633 if (!ColorObject_Check(obj)) {
634 return false;
635 }
637 return false;
638 }
639 vec[0] = ((ColorObject *)obj)->col[0];
640 vec[1] = ((ColorObject *)obj)->col[1];
641 vec[2] = ((ColorObject *)obj)->col[2];
642 return true;
643}
644
645bool Vec3r_ptr_from_Color(PyObject *obj, Vec3r &vec)
646{
647 using namespace blender;
648 if (!ColorObject_Check(obj)) {
649 return false;
650 }
652 return false;
653 }
654 vec[0] = ((ColorObject *)obj)->col[0];
655 vec[1] = ((ColorObject *)obj)->col[1];
656 vec[2] = ((ColorObject *)obj)->col[2];
657 return true;
658}
659
660static bool float_array_from_PyList(PyObject *obj, float *v, int n)
661{
662 for (int i = 0; i < n; i++) {
663 v[i] = PyFloat_AsDouble(PyList_GET_ITEM(obj, i));
664 if (v[i] == -1.0f && PyErr_Occurred()) {
665 PyErr_SetString(PyExc_TypeError, "list elements must be a number");
666 return false;
667 }
668 }
669 return true;
670}
671
672bool Vec2f_ptr_from_PyList(PyObject *obj, Vec2f &vec)
673{
674 float v[2];
675
676 if (!PyList_Check(obj) || PyList_GET_SIZE(obj) != 2) {
677 return false;
678 }
679 if (!float_array_from_PyList(obj, v, 2)) {
680 return false;
681 }
682 vec[0] = v[0];
683 vec[1] = v[1];
684 return true;
685}
686
687bool Vec3f_ptr_from_PyList(PyObject *obj, Vec3f &vec)
688{
689 float v[3];
690
691 if (!PyList_Check(obj) || PyList_GET_SIZE(obj) != 3) {
692 return false;
693 }
694 if (!float_array_from_PyList(obj, v, 3)) {
695 return false;
696 }
697 vec[0] = v[0];
698 vec[1] = v[1];
699 vec[2] = v[2];
700 return true;
701}
702
703bool Vec3r_ptr_from_PyList(PyObject *obj, Vec3r &vec)
704{
705 float v[3];
706
707 if (!PyList_Check(obj) || PyList_GET_SIZE(obj) != 3) {
708 return false;
709 }
710 if (!float_array_from_PyList(obj, v, 3)) {
711 return false;
712 }
713 vec[0] = v[0];
714 vec[1] = v[1];
715 vec[2] = v[2];
716 return true;
717}
718
719static bool float_array_from_PyTuple(PyObject *obj, float *v, int n)
720{
721 for (int i = 0; i < n; i++) {
722 v[i] = PyFloat_AsDouble(PyTuple_GET_ITEM(obj, i));
723 if (v[i] == -1.0f && PyErr_Occurred()) {
724 PyErr_SetString(PyExc_TypeError, "tuple elements must be a number");
725 return false;
726 }
727 }
728 return true;
729}
730
731bool Vec2f_ptr_from_PyTuple(PyObject *obj, Vec2f &vec)
732{
733 float v[2];
734
735 if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 2) {
736 return false;
737 }
738 if (!float_array_from_PyTuple(obj, v, 2)) {
739 return false;
740 }
741 vec[0] = v[0];
742 vec[1] = v[1];
743 return true;
744}
745
746bool Vec3f_ptr_from_PyTuple(PyObject *obj, Vec3f &vec)
747{
748 float v[3];
749
750 if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 3) {
751 return false;
752 }
753 if (!float_array_from_PyTuple(obj, v, 3)) {
754 return false;
755 }
756 vec[0] = v[0];
757 vec[1] = v[1];
758 vec[2] = v[2];
759 return true;
760}
761
762bool Vec3r_ptr_from_PyTuple(PyObject *obj, Vec3r &vec)
763{
764 float v[3];
765
766 if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 3) {
767 return false;
768 }
769 if (!float_array_from_PyTuple(obj, v, 3)) {
770 return false;
771 }
772 vec[0] = v[0];
773 vec[1] = v[1];
774 vec[2] = v[2];
775 return true;
776}
777
778// helpers for argument parsing
779
780bool float_array_from_PyObject(PyObject *obj, float *v, int n)
781{
782 using namespace blender;
783 if (VectorObject_Check(obj) && ((VectorObject *)obj)->vec_num == n) {
785 return false;
786 }
787 for (int i = 0; i < n; i++) {
788 v[i] = ((VectorObject *)obj)->vec[i];
789 }
790 return true;
791 }
792 if (ColorObject_Check(obj) && n == 3) {
794 return false;
795 }
796 for (int i = 0; i < n; i++) {
797 v[i] = ((ColorObject *)obj)->col[i];
798 }
799 return true;
800 }
801 if (PyList_Check(obj) && PyList_GET_SIZE(obj) == n) {
802 return float_array_from_PyList(obj, v, n);
803 }
804 if (PyTuple_Check(obj) && PyTuple_GET_SIZE(obj) == n) {
805 return float_array_from_PyTuple(obj, v, n);
806 }
807 return false;
808}
809
810int convert_v4(PyObject *obj, void *v)
811{
812 return blender::mathutils_array_parse((float *)v, 4, 4, obj, "Error parsing 4D vector");
813}
814
815int convert_v3(PyObject *obj, void *v)
816{
817 return blender::mathutils_array_parse((float *)v, 3, 3, obj, "Error parsing 3D vector");
818}
819
820int convert_v2(PyObject *obj, void *v)
821{
822 return blender::mathutils_array_parse((float *)v, 2, 2, obj, "Error parsing 2D vector");
823}
824
PyTypeObject AdjacencyIterator_Type
PyTypeObject BBox_Type
Definition BPy_BBox.cpp:65
PyTypeObject ChainPredicateIterator_Type
PyTypeObject ChainSilhouetteIterator_Type
PyTypeObject Chain_Type
PyTypeObject ChainingIterator_Type
PyObject * BPy_NonTVertex_from_NonTVertex(NonTVertex &ntv)
bool Vec3r_ptr_from_Vector(PyObject *obj, Vec3r &vec)
bool Vec3r_ptr_from_Color(PyObject *obj, Vec3r &vec)
bool Vec2f_ptr_from_Vector(PyObject *obj, Vec2f &vec)
PyObject * BPy_CurvePointIterator_from_CurvePointIterator(CurveInternal::CurvePointIterator &cp_it)
PyObject * BPy_StrokeVertexIterator_from_StrokeVertexIterator(StrokeInternal::StrokeVertexIterator &sv_it, bool reversed)
PyObject * Vector_from_Vec3r(Vec3r &vec)
bool Vec3r_ptr_from_PyList(PyObject *obj, Vec3r &vec)
bool Vec3r_ptr_from_PyTuple(PyObject *obj, Vec3r &vec)
PyObject * BPy_Interface0DIterator_from_Interface0DIterator(Interface0DIterator &if0D_it, bool reversed)
PyObject * BPy_Id_from_Id(Id &id)
PyObject * BPy_StrokeAttribute_from_StrokeAttribute(StrokeAttribute &sa)
bool bool_from_PyBool(PyObject *b)
void PyLong_subtype_add_to_dict(PyObject *dict, PyTypeObject *ty, const char *attr, long value)
PyObject * BPy_ChainPredicateIterator_from_ChainPredicateIterator(ChainPredicateIterator &cp_it)
PyObject * BPy_SVertexIterator_from_SVertexIterator(ViewEdgeInternal::SVertexIterator &sv_it)
bool Vec2f_ptr_from_PyTuple(PyObject *obj, Vec2f &vec)
PyObject * BPy_StrokeVertex_from_StrokeVertex(StrokeVertex &sv)
PyObject * PyLong_subtype_new(PyTypeObject *ty, long value)
bool Vec3f_ptr_from_PyObject(PyObject *obj, Vec3f &vec)
PyObject * BPy_Interface0D_from_Interface0D(Interface0D &if0D)
PyObject * BPy_SShape_from_SShape(SShape &ss)
bool Vec3f_ptr_from_Color(PyObject *obj, Vec3f &vec)
PyObject * BPy_ViewVertex_from_ViewVertex(ViewVertex &vv)
PyObject * BPy_Chain_from_Chain(Chain &c)
PyObject * Any_BPy_Interface1D_from_Interface1D(Interface1D &if1D)
bool Vec2f_ptr_from_PyObject(PyObject *obj, Vec2f &vec)
PyObject * BPy_MediumType_from_MediumType(Stroke::MediumType n)
bool float_array_from_PyObject(PyObject *obj, float *v, int n)
bool Vec3f_ptr_from_PyTuple(PyObject *obj, Vec3f &vec)
PyObject * Any_BPy_FEdge_from_FEdge(FEdge &fe)
Nature::EdgeNature EdgeNature_from_BPy_Nature(PyObject *obj)
PyObject * BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ViewVertexInternal::orientedViewEdgeIterator &ove_it, bool reversed)
PyObject * BPy_FEdgeSmooth_from_FEdgeSmooth(FEdgeSmooth &fes)
PyObject * BPy_FEdgeSharp_from_FEdgeSharp(FEdgeSharp &fes)
bool Vec3f_ptr_from_PyList(PyObject *obj, Vec3f &vec)
PyObject * BPy_Nature_from_Nature(ushort n)
PyObject * BPy_directedViewEdge_from_directedViewEdge(ViewVertex::directedViewEdge &dve)
PyObject * BPy_ViewEdgeIterator_from_ViewEdgeIterator(ViewEdgeInternal::ViewEdgeIterator &ve_it)
PyObject * BPy_Stroke_from_Stroke(Stroke &s)
PyObject * BPy_ChainingIterator_from_ChainingIterator(ChainingIterator &c_it)
PyObject * BPy_CurvePoint_from_CurvePoint(CurvePoint &cp)
PyObject * BPy_ChainSilhouetteIterator_from_ChainSilhouetteIterator(ChainSilhouetteIterator &cs_it)
PyObject * BPy_FEdge_from_FEdge(FEdge &fe)
PyObject * BPy_AdjacencyIterator_from_AdjacencyIterator(AdjacencyIterator &a_it)
int convert_v4(PyObject *obj, void *v)
IntegrationType IntegrationType_from_BPy_IntegrationType(PyObject *obj)
PyObject * BPy_SVertex_from_SVertex(SVertex &sv)
Stroke::MediumType MediumType_from_BPy_MediumType(PyObject *obj)
PyObject * Vector_from_Vec3f(Vec3f &vec)
PyObject * Any_BPy_ViewVertex_from_ViewVertex(ViewVertex &vv)
static bool float_array_from_PyList(PyObject *obj, float *v, int n)
PyObject * BPy_ViewEdge_from_ViewEdge(ViewEdge &ve)
PyObject * Vector_from_Vec2f(Vec2f &vec)
int convert_v3(PyObject *obj, void *v)
PyObject * BPy_IntegrationType_from_IntegrationType(IntegrationType i)
PyObject * BPy_TVertex_from_TVertex(TVertex &tv)
PyObject * PyBool_from_bool(bool b)
bool Vec2f_ptr_from_PyList(PyObject *obj, Vec2f &vec)
PyObject * BPy_ViewShape_from_ViewShape(ViewShape &vs)
PyObject * BPy_Interface1D_from_Interface1D(Interface1D &if1D)
PyObject * BPy_BBox_from_BBox(const BBox< Vec3r > &bb)
bool Vec3f_ptr_from_Vector(PyObject *obj, Vec3f &vec)
bool Vec3r_ptr_from_PyObject(PyObject *obj, Vec3r &vec)
static bool float_array_from_PyTuple(PyObject *obj, float *v, int n)
PyObject * BPy_FrsMaterial_from_FrsMaterial(const FrsMaterial &m)
int convert_v2(PyObject *obj, void *v)
PyObject * Any_BPy_Interface0D_from_Interface0D(Interface0D &if0D)
PyTypeObject CurvePointIterator_Type
PyTypeObject CurvePoint_Type
PyTypeObject FEdgeSharp_Type
PyTypeObject FEdgeSmooth_Type
PyTypeObject FEdge_Type
PyTypeObject FrsMaterial_Type
PyTypeObject Id_Type
Definition BPy_Id.cpp:176
PyTypeObject IntegrationType_Type
PyTypeObject Interface0DIterator_Type
PyTypeObject Interface0D_Type
PyTypeObject Interface1D_Type
PyTypeObject MediumType_Type
PyTypeObject Nature_Type
PyTypeObject NonTVertex_Type
PyTypeObject SShape_Type
PyTypeObject SVertexIterator_Type
PyTypeObject SVertex_Type
PyTypeObject StrokeAttribute_Type
PyTypeObject StrokeVertexIterator_Type
PyTypeObject StrokeVertex_Type
PyTypeObject Stroke_Type
PyTypeObject TVertex_Type
PyTypeObject ViewEdgeIterator_Type
PyTypeObject ViewEdge_Type
PyTypeObject ViewShape_Type
PyTypeObject ViewVertex_Type
PyTypeObject orientedViewEdgeIterator_Type
Class to define the representation of a stroke (for display purpose).
#define BLI_assert(a)
ChainPredicateIterator(bool iRestrictToSelection=true, bool iRestrictToUnvisited=true, ViewEdge *begin=nullptr, bool orientation=true)
ChainSilhouetteIterator(bool iRestrictToSelection=true, ViewEdge *begin=nullptr, bool orientation=true)
ChainingIterator(bool iRestrictToSelection=true, bool iRestrictToUnvisited=true, ViewEdge *begin=nullptr, bool orientation=true)
virtual string getExactTypeName() const
Definition Silhouette.h:464
Interface0DIterator(Interface0DIteratorNested *it=nullptr)
virtual string getExactTypeName() const
Definition Interface0D.h:50
virtual string getExactTypeName() const
value_type x() const
Definition VecMat.h:292
value_type y() const
Definition VecMat.h:302
value_type x() const
Definition VecMat.h:489
value_type z() const
Definition VecMat.h:509
value_type y() const
Definition VecMat.h:499
pair< ViewEdge *, bool > directedViewEdge
Definition ViewMap.h:263
virtual string getExactTypeName() const
Definition ViewMap.h:256
#define BaseMath_ReadCallback(_self)
Definition mathutils.hh:147
#define ColorObject_Check(v)
#define VectorObject_Check(v)
VecMat::Vec3< float > Vec3f
Definition Geom.h:28
VecMat::Vec2< float > Vec2f
Definition Geom.h:22
VecMat::Vec3< real > Vec3r
Definition Geom.h:30
ushort EdgeNature
Definition Nature.h:36
inherits from class Rep
Definition AppCanvas.cpp:20
BMesh Iterators.
ATTR_WARN_UNUSED_RESULT const BMVert * v
PyObject * Vector_CreatePyObject(const float *vec, const int vec_num, PyTypeObject *base_type)
int mathutils_array_parse(float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix)
Definition mathutils.cc:97
#define PyTuple_SET_ITEMS(op_arg,...)