Blender  V3.3
BPy_FrsMaterial.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
7 #include "BPy_FrsMaterial.h"
8 
9 #include "BPy_Convert.h"
10 
11 #ifdef __cplusplus
12 extern "C" {
13 #endif
14 
15 #include "BLI_hash_mm2a.h"
16 
17 using namespace Freestyle;
18 
20 
21 //-------------------MODULE INITIALIZATION--------------------------------
22 int FrsMaterial_Init(PyObject *module)
23 {
24  if (module == nullptr) {
25  return -1;
26  }
27 
28  if (PyType_Ready(&FrsMaterial_Type) < 0) {
29  return -1;
30  }
31  Py_INCREF(&FrsMaterial_Type);
32  PyModule_AddObject(module, "Material", (PyObject *)&FrsMaterial_Type);
33 
35 
36  return 0;
37 }
38 
39 //------------------------INSTANCE METHODS ----------------------------------
40 
42  FrsMaterial_doc,
43  "Class defining a material.\n"
44  "\n"
45  ".. method:: __init__()\n"
46  " __init__(brother)\n"
47  " __init__(line, diffuse, ambient, specular, emission, shininess, priority)\n"
48  "\n"
49  " Creates a :class:`FrsMaterial` using either default constructor,\n"
50  " copy constructor, or an overloaded constructor\n"
51  "\n"
52  " :arg brother: A Material object to be used as a copy constructor.\n"
53  " :type brother: :class:`Material`\n"
54  " :arg line: The line color.\n"
55  " :type line: :class:`mathutils.Vector`, list or tuple of 4 float values\n"
56  " :arg diffuse: The diffuse color.\n"
57  " :type diffuse: :class:`mathutils.Vector`, list or tuple of 4 float values\n"
58  " :arg ambient: The ambient color.\n"
59  " :type ambient: :class:`mathutils.Vector`, list or tuple of 4 float values\n"
60  " :arg specular: The specular color.\n"
61  " :type specular: :class:`mathutils.Vector`, list or tuple of 4 float values\n"
62  " :arg emission: The emissive color.\n"
63  " :type emission: :class:`mathutils.Vector`, list or tuple of 4 float values\n"
64  " :arg shininess: The shininess coefficient.\n"
65  " :type shininess: float\n"
66  " :arg priority: The line color priority.\n"
67  " :type priority: int");
68 
69 static int FrsMaterial_init(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds)
70 {
71  static const char *kwlist_1[] = {"brother", nullptr};
72  static const char *kwlist_2[] = {
73  "line", "diffuse", "ambient", "specular", "emission", "shininess", "priority", nullptr};
74  PyObject *brother = nullptr;
75  float line[4], diffuse[4], ambient[4], specular[4], emission[4], shininess;
76  int priority;
77 
78  if (PyArg_ParseTupleAndKeywords(
79  args, kwds, "|O!", (char **)kwlist_1, &FrsMaterial_Type, &brother)) {
80  if (!brother) {
81  self->m = new FrsMaterial();
82  }
83  else {
84  FrsMaterial *m = ((BPy_FrsMaterial *)brother)->m;
85  if (!m) {
86  PyErr_SetString(PyExc_RuntimeError, "invalid Material object");
87  return -1;
88  }
89  self->m = new FrsMaterial(*m);
90  }
91  }
92  else if ((void)PyErr_Clear(),
93  PyArg_ParseTupleAndKeywords(args,
94  kwds,
95  "O&O&O&O&O&fi",
96  (char **)kwlist_2,
97  convert_v4,
98  line,
99  convert_v4,
100  diffuse,
101  convert_v4,
102  ambient,
103  convert_v4,
104  specular,
105  convert_v4,
106  emission,
107  &shininess,
108  &priority)) {
109  self->m = new FrsMaterial(line, diffuse, ambient, specular, emission, shininess, priority);
110  }
111  else {
112  PyErr_SetString(PyExc_TypeError, "invalid argument(s)");
113  return -1;
114  }
115  return 0;
116 }
117 
119 {
120  delete self->m;
121  Py_TYPE(self)->tp_free((PyObject *)self);
122 }
123 
124 static PyObject *FrsMaterial_repr(BPy_FrsMaterial *self)
125 {
126  return PyUnicode_FromFormat("Material - address: %p", self->m);
127 }
128 
129 /*----------------------mathutils callbacks ----------------------------*/
130 
131 /* subtype */
132 #define MATHUTILS_SUBTYPE_DIFFUSE 1
133 #define MATHUTILS_SUBTYPE_SPECULAR 2
134 #define MATHUTILS_SUBTYPE_AMBIENT 3
135 #define MATHUTILS_SUBTYPE_EMISSION 4
136 #define MATHUTILS_SUBTYPE_LINE 5
137 
139 {
140  if (!BPy_FrsMaterial_Check(bmo->cb_user)) {
141  return -1;
142  }
143  return 0;
144 }
145 
146 static int FrsMaterial_mathutils_get(BaseMathObject *bmo, int subtype)
147 {
148  BPy_FrsMaterial *self = (BPy_FrsMaterial *)bmo->cb_user;
149  switch (subtype) {
151  bmo->data[0] = self->m->lineR();
152  bmo->data[1] = self->m->lineG();
153  bmo->data[2] = self->m->lineB();
154  bmo->data[3] = self->m->lineA();
155  break;
157  bmo->data[0] = self->m->diffuseR();
158  bmo->data[1] = self->m->diffuseG();
159  bmo->data[2] = self->m->diffuseB();
160  bmo->data[3] = self->m->diffuseA();
161  break;
163  bmo->data[0] = self->m->specularR();
164  bmo->data[1] = self->m->specularG();
165  bmo->data[2] = self->m->specularB();
166  bmo->data[3] = self->m->specularA();
167  break;
169  bmo->data[0] = self->m->ambientR();
170  bmo->data[1] = self->m->ambientG();
171  bmo->data[2] = self->m->ambientB();
172  bmo->data[3] = self->m->ambientA();
173  break;
175  bmo->data[0] = self->m->emissionR();
176  bmo->data[1] = self->m->emissionG();
177  bmo->data[2] = self->m->emissionB();
178  bmo->data[3] = self->m->emissionA();
179  break;
180  default:
181  return -1;
182  }
183  return 0;
184 }
185 
186 static int FrsMaterial_mathutils_set(BaseMathObject *bmo, int subtype)
187 {
188  BPy_FrsMaterial *self = (BPy_FrsMaterial *)bmo->cb_user;
189  switch (subtype) {
191  self->m->setLine(bmo->data[0], bmo->data[1], bmo->data[2], bmo->data[3]);
192  break;
194  self->m->setDiffuse(bmo->data[0], bmo->data[1], bmo->data[2], bmo->data[3]);
195  break;
197  self->m->setSpecular(bmo->data[0], bmo->data[1], bmo->data[2], bmo->data[3]);
198  break;
200  self->m->setAmbient(bmo->data[0], bmo->data[1], bmo->data[2], bmo->data[3]);
201  break;
203  self->m->setEmission(bmo->data[0], bmo->data[1], bmo->data[2], bmo->data[3]);
204  break;
205  default:
206  return -1;
207  }
208  return 0;
209 }
210 
211 static int FrsMaterial_mathutils_get_index(BaseMathObject *bmo, int subtype, int index)
212 {
213  BPy_FrsMaterial *self = (BPy_FrsMaterial *)bmo->cb_user;
214  switch (subtype) {
215  case MATHUTILS_SUBTYPE_LINE: {
216  const float *color = self->m->line();
217  bmo->data[index] = color[index];
218  } break;
220  const float *color = self->m->diffuse();
221  bmo->data[index] = color[index];
222  } break;
224  const float *color = self->m->specular();
225  bmo->data[index] = color[index];
226  } break;
228  const float *color = self->m->ambient();
229  bmo->data[index] = color[index];
230  } break;
232  const float *color = self->m->emission();
233  bmo->data[index] = color[index];
234  } break;
235  default:
236  return -1;
237  }
238  return 0;
239 }
240 
241 static int FrsMaterial_mathutils_set_index(BaseMathObject *bmo, int subtype, int index)
242 {
243  BPy_FrsMaterial *self = (BPy_FrsMaterial *)bmo->cb_user;
244  float color[4];
245  switch (subtype) {
247  copy_v4_v4(color, self->m->line());
248  color[index] = bmo->data[index];
249  self->m->setLine(color[0], color[1], color[2], color[3]);
250  break;
252  copy_v4_v4(color, self->m->diffuse());
253  color[index] = bmo->data[index];
254  self->m->setDiffuse(color[0], color[1], color[2], color[3]);
255  break;
257  copy_v4_v4(color, self->m->specular());
258  color[index] = bmo->data[index];
259  self->m->setSpecular(color[0], color[1], color[2], color[3]);
260  break;
262  copy_v4_v4(color, self->m->ambient());
263  color[index] = bmo->data[index];
264  self->m->setAmbient(color[0], color[1], color[2], color[3]);
265  break;
267  copy_v4_v4(color, self->m->emission());
268  color[index] = bmo->data[index];
269  self->m->setEmission(color[0], color[1], color[2], color[3]);
270  break;
271  default:
272  return -1;
273  }
274  return 0;
275 }
276 
283 };
284 
285 static unsigned char FrsMaterial_mathutils_cb_index = -1;
286 
288 {
290 }
291 
292 /*----------------------FrsMaterial get/setters ----------------------------*/
293 
294 PyDoc_STRVAR(FrsMaterial_line_doc,
295  "RGBA components of the line color of the material.\n"
296  "\n"
297  ":type: :class:`mathutils.Vector`");
298 
299 static PyObject *FrsMaterial_line_get(BPy_FrsMaterial *self, void *UNUSED(closure))
300 {
303 }
304 
305 static int FrsMaterial_line_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
306 {
307  float color[4];
308  if (mathutils_array_parse(color, 4, 4, value, "value must be a 4-dimensional vector") == -1) {
309  return -1;
310  }
311  self->m->setLine(color[0], color[1], color[2], color[3]);
312  return 0;
313 }
314 
315 PyDoc_STRVAR(FrsMaterial_diffuse_doc,
316  "RGBA components of the diffuse color of the material.\n"
317  "\n"
318  ":type: :class:`mathutils.Vector`");
319 
320 static PyObject *FrsMaterial_diffuse_get(BPy_FrsMaterial *self, void *UNUSED(closure))
321 {
324 }
325 
326 static int FrsMaterial_diffuse_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
327 {
328  float color[4];
329  if (mathutils_array_parse(color, 4, 4, value, "value must be a 4-dimensional vector") == -1) {
330  return -1;
331  }
332  self->m->setDiffuse(color[0], color[1], color[2], color[3]);
333  return 0;
334 }
335 
336 PyDoc_STRVAR(FrsMaterial_specular_doc,
337  "RGBA components of the specular color of the material.\n"
338  "\n"
339  ":type: :class:`mathutils.Vector`");
340 
341 static PyObject *FrsMaterial_specular_get(BPy_FrsMaterial *self, void *UNUSED(closure))
342 {
345 }
346 
347 static int FrsMaterial_specular_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
348 {
349  float color[4];
350  if (mathutils_array_parse(color, 4, 4, value, "value must be a 4-dimensional vector") == -1) {
351  return -1;
352  }
353  self->m->setSpecular(color[0], color[1], color[2], color[3]);
354  return 0;
355 }
356 
357 PyDoc_STRVAR(FrsMaterial_ambient_doc,
358  "RGBA components of the ambient color of the material.\n"
359  "\n"
360  ":type: :class:`mathutils.Color`");
361 
362 static PyObject *FrsMaterial_ambient_get(BPy_FrsMaterial *self, void *UNUSED(closure))
363 {
366 }
367 
368 static int FrsMaterial_ambient_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
369 {
370  float color[4];
371  if (mathutils_array_parse(color, 4, 4, value, "value must be a 4-dimensional vector") == -1) {
372  return -1;
373  }
374  self->m->setAmbient(color[0], color[1], color[2], color[3]);
375  return 0;
376 }
377 
378 PyDoc_STRVAR(FrsMaterial_emission_doc,
379  "RGBA components of the emissive color of the material.\n"
380  "\n"
381  ":type: :class:`mathutils.Color`");
382 
383 static PyObject *FrsMaterial_emission_get(BPy_FrsMaterial *self, void *UNUSED(closure))
384 {
387 }
388 
389 static int FrsMaterial_emission_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
390 {
391  float color[4];
392  if (mathutils_array_parse(color, 4, 4, value, "value must be a 4-dimensional vector") == -1) {
393  return -1;
394  }
395  self->m->setEmission(color[0], color[1], color[2], color[3]);
396  return 0;
397 }
398 
399 PyDoc_STRVAR(FrsMaterial_shininess_doc,
400  "Shininess coefficient of the material.\n"
401  "\n"
402  ":type: float");
403 
404 static PyObject *FrsMaterial_shininess_get(BPy_FrsMaterial *self, void *UNUSED(closure))
405 {
406  return PyFloat_FromDouble(self->m->shininess());
407 }
408 
409 static int FrsMaterial_shininess_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
410 {
411  float scalar;
412  if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) {
413  /* parsed item not a number */
414  PyErr_SetString(PyExc_TypeError, "value must be a number");
415  return -1;
416  }
417  self->m->setShininess(scalar);
418  return 0;
419 }
420 
421 PyDoc_STRVAR(FrsMaterial_priority_doc,
422  "Line color priority of the material.\n"
423  "\n"
424  ":type: int");
425 
426 static PyObject *FrsMaterial_priority_get(BPy_FrsMaterial *self, void *UNUSED(closure))
427 {
428  return PyLong_FromLong(self->m->priority());
429 }
430 
431 static int FrsMaterial_priority_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
432 {
433  int scalar;
434  if ((scalar = PyLong_AsLong(value)) == -1 && PyErr_Occurred()) {
435  PyErr_SetString(PyExc_TypeError, "value must be an integer");
436  return -1;
437  }
438  self->m->setPriority(scalar);
439  return 0;
440 }
441 
442 static PyGetSetDef BPy_FrsMaterial_getseters[] = {
443  {"line",
444  (getter)FrsMaterial_line_get,
445  (setter)FrsMaterial_line_set,
446  FrsMaterial_line_doc,
447  nullptr},
448  {"diffuse",
449  (getter)FrsMaterial_diffuse_get,
450  (setter)FrsMaterial_diffuse_set,
451  FrsMaterial_diffuse_doc,
452  nullptr},
453  {"specular",
454  (getter)FrsMaterial_specular_get,
455  (setter)FrsMaterial_specular_set,
456  FrsMaterial_specular_doc,
457  nullptr},
458  {"ambient",
459  (getter)FrsMaterial_ambient_get,
460  (setter)FrsMaterial_ambient_set,
461  FrsMaterial_ambient_doc,
462  nullptr},
463  {"emission",
464  (getter)FrsMaterial_emission_get,
465  (setter)FrsMaterial_emission_set,
466  FrsMaterial_emission_doc,
467  nullptr},
468  {"shininess",
471  FrsMaterial_shininess_doc,
472  nullptr},
473  {"priority",
474  (getter)FrsMaterial_priority_get,
475  (setter)FrsMaterial_priority_set,
476  FrsMaterial_priority_doc,
477  nullptr},
478  {nullptr, nullptr, nullptr, nullptr, nullptr} /* Sentinel */
479 };
480 
481 static PyObject *BPy_FrsMaterial_richcmpr(PyObject *objectA,
482  PyObject *objectB,
483  int comparison_type)
484 {
485  const BPy_FrsMaterial *matA = nullptr, *matB = nullptr;
486  bool result = false;
487 
488  if (!BPy_FrsMaterial_Check(objectA) || !BPy_FrsMaterial_Check(objectB)) {
489  if (comparison_type == Py_NE) {
490  Py_RETURN_TRUE;
491  }
492 
493  Py_RETURN_FALSE;
494  }
495 
496  matA = (BPy_FrsMaterial *)objectA;
497  matB = (BPy_FrsMaterial *)objectB;
498 
499  switch (comparison_type) {
500  case Py_NE:
501  result = (*matA->m) != (*matB->m);
502  break;
503  case Py_EQ:
504  result = (*matA->m) == (*matB->m);
505  break;
506  default:
507  PyErr_SetString(PyExc_TypeError, "Material does not support this comparison type");
508  return nullptr;
509  }
510 
511  if (result == true) {
512  Py_RETURN_TRUE;
513  }
514 
515  Py_RETURN_FALSE;
516 }
517 
518 static Py_hash_t FrsMaterial_hash(PyObject *self)
519 {
520  return (Py_uhash_t)BLI_hash_mm2((const unsigned char *)self, sizeof(*self), 0);
521 }
522 /*-----------------------BPy_FrsMaterial type definition ------------------------------*/
523 
524 PyTypeObject FrsMaterial_Type = {
525  PyVarObject_HEAD_INIT(nullptr, 0) "Material", /* tp_name */
526  sizeof(BPy_FrsMaterial), /* tp_basicsize */
527  0, /* tp_itemsize */
528  (destructor)FrsMaterial_dealloc, /* tp_dealloc */
529  0, /* tp_vectorcall_offset */
530  nullptr, /* tp_getattr */
531  nullptr, /* tp_setattr */
532  nullptr, /* tp_reserved */
533  (reprfunc)FrsMaterial_repr, /* tp_repr */
534  nullptr, /* tp_as_number */
535  nullptr, /* tp_as_sequence */
536  nullptr, /* tp_as_mapping */
537  (hashfunc)FrsMaterial_hash, /* tp_hash */
538  nullptr, /* tp_call */
539  nullptr, /* tp_str */
540  nullptr, /* tp_getattro */
541  nullptr, /* tp_setattro */
542  nullptr, /* tp_as_buffer */
543  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
544  FrsMaterial_doc, /* tp_doc */
545  nullptr, /* tp_traverse */
546  nullptr, /* tp_clear */
547  (richcmpfunc)BPy_FrsMaterial_richcmpr, /* tp_richcompare */
548  0, /* tp_weaklistoffset */
549  nullptr, /* tp_iter */
550  nullptr, /* tp_iternext */
551  nullptr, /* tp_methods */
552  nullptr, /* tp_members */
553  BPy_FrsMaterial_getseters, /* tp_getset */
554  nullptr, /* tp_base */
555  nullptr, /* tp_dict */
556  nullptr, /* tp_descr_get */
557  nullptr, /* tp_descr_set */
558  0, /* tp_dictoffset */
559  (initproc)FrsMaterial_init, /* tp_init */
560  nullptr, /* tp_alloc */
561  PyType_GenericNew, /* tp_new */
562 };
563 
565 
566 #ifdef __cplusplus
567 }
568 #endif
uint32_t BLI_hash_mm2(const unsigned char *data, size_t len, uint32_t seed)
Definition: hash_mm2a.c:99
MINLINE void copy_v4_v4(float r[4], const float a[4])
#define UNUSED(x)
int convert_v4(PyObject *obj, void *v)
void FrsMaterial_mathutils_register_callback()
int FrsMaterial_Init(PyObject *module)
#define MATHUTILS_SUBTYPE_DIFFUSE
static PyGetSetDef BPy_FrsMaterial_getseters[]
static PyObject * FrsMaterial_priority_get(BPy_FrsMaterial *self, void *UNUSED(closure))
static int FrsMaterial_line_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
static PyObject * FrsMaterial_diffuse_get(BPy_FrsMaterial *self, void *UNUSED(closure))
static PyObject * FrsMaterial_ambient_get(BPy_FrsMaterial *self, void *UNUSED(closure))
static void FrsMaterial_dealloc(BPy_FrsMaterial *self)
static int FrsMaterial_shininess_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
static int FrsMaterial_priority_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
PyDoc_STRVAR(FrsMaterial_doc, "Class defining a material.\n" "\n" ".. method:: __init__()\n" " __init__(brother)\n" " __init__(line, diffuse, ambient, specular, emission, shininess, priority)\n" "\n" " Creates a :class:`FrsMaterial` using either default constructor,\n" " copy constructor, or an overloaded constructor\n" "\n" " :arg brother: A Material object to be used as a copy constructor.\n" " :type brother: :class:`Material`\n" " :arg line: The line color.\n" " :type line: :class:`mathutils.Vector`, list or tuple of 4 float values\n" " :arg diffuse: The diffuse color.\n" " :type diffuse: :class:`mathutils.Vector`, list or tuple of 4 float values\n" " :arg ambient: The ambient color.\n" " :type ambient: :class:`mathutils.Vector`, list or tuple of 4 float values\n" " :arg specular: The specular color.\n" " :type specular: :class:`mathutils.Vector`, list or tuple of 4 float values\n" " :arg emission: The emissive color.\n" " :type emission: :class:`mathutils.Vector`, list or tuple of 4 float values\n" " :arg shininess: The shininess coefficient.\n" " :type shininess: float\n" " :arg priority: The line color priority.\n" " :type priority: int")
static int FrsMaterial_mathutils_get_index(BaseMathObject *bmo, int subtype, int index)
static PyObject * FrsMaterial_specular_get(BPy_FrsMaterial *self, void *UNUSED(closure))
static int FrsMaterial_init(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds)
#define MATHUTILS_SUBTYPE_EMISSION
#define MATHUTILS_SUBTYPE_LINE
static Mathutils_Callback FrsMaterial_mathutils_cb
PyTypeObject FrsMaterial_Type
static int FrsMaterial_mathutils_set(BaseMathObject *bmo, int subtype)
#define MATHUTILS_SUBTYPE_SPECULAR
#define MATHUTILS_SUBTYPE_AMBIENT
static unsigned char FrsMaterial_mathutils_cb_index
static PyObject * BPy_FrsMaterial_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type)
static int FrsMaterial_diffuse_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
static int FrsMaterial_mathutils_get(BaseMathObject *bmo, int subtype)
static int FrsMaterial_emission_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
static PyObject * FrsMaterial_repr(BPy_FrsMaterial *self)
static int FrsMaterial_mathutils_set_index(BaseMathObject *bmo, int subtype, int index)
static int FrsMaterial_ambient_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
static PyObject * FrsMaterial_shininess_get(BPy_FrsMaterial *self, void *UNUSED(closure))
static int FrsMaterial_mathutils_check(BaseMathObject *bmo)
static Py_hash_t FrsMaterial_hash(PyObject *self)
static PyObject * FrsMaterial_emission_get(BPy_FrsMaterial *self, void *UNUSED(closure))
static int FrsMaterial_specular_set(BPy_FrsMaterial *self, PyObject *value, void *UNUSED(closure))
static PyObject * FrsMaterial_line_get(BPy_FrsMaterial *self, void *UNUSED(closure))
#define BPy_FrsMaterial_Check(v)
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a color
PyObject * self
Definition: bpy_driver.c:165
int mathutils_array_parse(float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix)
Definition: mathutils.c:98
uchar Mathutils_RegisterCallback(Mathutils_Callback *cb)
Definition: mathutils.c:551
PyObject * Vector_CreatePyObject_cb(PyObject *cb_user, int vec_num, uchar cb_type, uchar cb_subtype)
inherits from class Rep
Definition: AppCanvas.cpp:18
static const pxr::TfToken specular("specular", pxr::TfToken::Immortal)
static struct PyModuleDef module
Definition: python.cpp:972
PyObject_HEAD Freestyle::FrsMaterial * m