tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: force wrapping all uses of PyDoc_STRVAR 

Without this, minor edits can re-indent the whole doc-string at a
different level, causing diffs to be unnecessary noisy.
This commit is contained in:
Campbell Barton 2024-01-25 10:22:16 +11:00
parent 0ea0573349
commit 7436b578dd
213 changed files with 8505 additions and 6231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
source/blender/freestyle/intern/python/BPy_BBox.cpp
View File

@ -35,12 +35,14 @@ int BBox_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(BBox_doc,
"Class for representing a bounding box.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
PyDoc_STRVAR(
/* Wrap. */
BBox_doc,
"Class for representing a bounding box.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
static int BBox_init(BPy_BBox *self, PyObject *args, PyObject *kwds)
{

16
source/blender/freestyle/intern/python/BPy_BinaryPredicate0D.cpp
View File

@ -37,7 +37,9 @@ int BinaryPredicate0D_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char BinaryPredicate0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
BinaryPredicate0D___doc__,
"Base class for binary predicates working on :class:`Interface0D`\n"
"objects. A BinaryPredicate0D is typically an ordering relation\n"
"between two Interface0D objects. The predicate evaluates a relation\n"
@ -58,7 +60,7 @@ static char BinaryPredicate0D___doc__[] =
" :arg inter2: The second Interface0D object.\n"
" :type inter2: :class:`Interface0D`\n"
" :return: True or false.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int BinaryPredicate0D___init__(BPy_BinaryPredicate0D *self, PyObject *args, PyObject *kwds)
{
@ -112,10 +114,12 @@ static PyObject *BinaryPredicate0D___call__(BPy_BinaryPredicate0D *self,
/*----------------------BinaryPredicate0D get/setters ----------------------------*/
PyDoc_STRVAR(BinaryPredicate0D_name_doc,
"The name of the binary 0D predicate.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
BinaryPredicate0D_name_doc,
"The name of the binary 0D predicate.\n"
"\n"
":type: str");
static PyObject *BinaryPredicate0D_name_get(BPy_BinaryPredicate0D *self, void * /*closure*/)
{

16
source/blender/freestyle/intern/python/BPy_BinaryPredicate1D.cpp
View File

@ -73,7 +73,9 @@ int BinaryPredicate1D_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char BinaryPredicate1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
BinaryPredicate1D___doc__,
"Base class for binary predicates working on :class:`Interface1D`\n"
"objects. A BinaryPredicate1D is typically an ordering relation\n"
"between two Interface1D objects. The predicate evaluates a relation\n"
@ -94,7 +96,7 @@ static char BinaryPredicate1D___doc__[] =
" :arg inter2: The second Interface1D object.\n"
" :type inter2: :class:`Interface1D`\n"
" :return: True or false.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int BinaryPredicate1D___init__(BPy_BinaryPredicate1D *self, PyObject *args, PyObject *kwds)
{
@ -147,10 +149,12 @@ static PyObject *BinaryPredicate1D___call__(BPy_BinaryPredicate1D *self,
/*----------------------BinaryPredicate0D get/setters ----------------------------*/
PyDoc_STRVAR(BinaryPredicate1D_name_doc,
"The name of the binary 1D predicate.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
BinaryPredicate1D_name_doc,
"The name of the binary 1D predicate.\n"
"\n"
":type: str");
static PyObject *BinaryPredicate1D_name_get(BPy_BinaryPredicate1D *self, void * /*closure*/)
{

60
source/blender/freestyle/intern/python/BPy_ContextFunctions.cpp
View File

@ -23,52 +23,60 @@ extern "C" {
//------------------------ MODULE FUNCTIONS ----------------------------------
static char ContextFunctions_get_time_stamp___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_get_time_stamp___doc__,
".. function:: get_time_stamp()\n"
"\n"
" Returns the system time stamp.\n"
"\n"
" :return: The system time stamp.\n"
" :rtype: int\n";
" :rtype: int\n");
static PyObject *ContextFunctions_get_time_stamp(PyObject * /*self*/)
{
return PyLong_FromLong(ContextFunctions::GetTimeStampCF());
}
static char ContextFunctions_get_canvas_width___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_get_canvas_width___doc__,
".. method:: get_canvas_width()\n"
"\n"
" Returns the canvas width.\n"
"\n"
" :return: The canvas width.\n"
" :rtype: int\n";
" :rtype: int\n");
static PyObject *ContextFunctions_get_canvas_width(PyObject * /*self*/)
{
return PyLong_FromLong(ContextFunctions::GetCanvasWidthCF());
}
static char ContextFunctions_get_canvas_height___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_get_canvas_height___doc__,
".. method:: get_canvas_height()\n"
"\n"
" Returns the canvas height.\n"
"\n"
" :return: The canvas height.\n"
" :rtype: int\n";
" :rtype: int\n");
static PyObject *ContextFunctions_get_canvas_height(PyObject * /*self*/)
{
return PyLong_FromLong(ContextFunctions::GetCanvasHeightCF());
}
static char ContextFunctions_get_border___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_get_border___doc__,
".. method:: get_border()\n"
"\n"
" Returns the border.\n"
"\n"
" :return: A tuple of 4 numbers (xmin, ymin, xmax, ymax).\n"
" :rtype: tuple\n";
" :rtype: tuple\n");
static PyObject *ContextFunctions_get_border(PyObject * /*self*/)
{
@ -82,7 +90,9 @@ static PyObject *ContextFunctions_get_border(PyObject * /*self*/)
return v;
}
static char ContextFunctions_load_map___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_load_map___doc__,
".. function:: load_map(file_name, map_name, num_levels=4, sigma=1.0)\n"
"\n"
" Loads an image map for further reading.\n"
@ -96,7 +106,7 @@ static char ContextFunctions_load_map___doc__[] =
" built.\n"
" :type num_levels: int\n"
" :arg sigma: The sigma value of the gaussian function.\n"
" :type sigma: float\n";
" :type sigma: float\n");
static PyObject *ContextFunctions_load_map(PyObject * /*self*/, PyObject *args, PyObject *kwds)
{
@ -114,7 +124,9 @@ static PyObject *ContextFunctions_load_map(PyObject * /*self*/, PyObject *args,
Py_RETURN_NONE;
}
static char ContextFunctions_read_map_pixel___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_read_map_pixel___doc__,
".. function:: read_map_pixel(map_name, level, x, y)\n"
"\n"
" Reads a pixel in a user-defined map.\n"
@ -131,7 +143,7 @@ static char ContextFunctions_read_map_pixel___doc__[] =
" is in the lower-left corner.\n"
" :type y: int\n"
" :return: The floating-point value stored for that pixel.\n"
" :rtype: float\n";
" :rtype: float\n");
static PyObject *ContextFunctions_read_map_pixel(PyObject * /*self*/,
PyObject *args,
@ -149,7 +161,9 @@ static PyObject *ContextFunctions_read_map_pixel(PyObject * /*self*/,
return PyFloat_FromDouble(ContextFunctions::ReadMapPixelCF(mapName, level, x, y));
}
static char ContextFunctions_read_complete_view_map_pixel___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_read_complete_view_map_pixel___doc__,
".. function:: read_complete_view_map_pixel(level, x, y)\n"
"\n"
" Reads a pixel in the complete view map.\n"
@ -164,7 +178,7 @@ static char ContextFunctions_read_complete_view_map_pixel___doc__[] =
" is in the lower-left corner.\n"
" :type y: int\n"
" :return: The floating-point value stored for that pixel.\n"
" :rtype: float\n";
" :rtype: float\n");
static PyObject *ContextFunctions_read_complete_view_map_pixel(PyObject * /*self*/,
PyObject *args,
@ -180,7 +194,9 @@ static PyObject *ContextFunctions_read_complete_view_map_pixel(PyObject * /*self
return PyFloat_FromDouble(ContextFunctions::ReadCompleteViewMapPixelCF(level, x, y));
}
static char ContextFunctions_read_directional_view_map_pixel___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_read_directional_view_map_pixel___doc__,
".. function:: read_directional_view_map_pixel(orientation, level, x, y)\n"
"\n"
" Reads a pixel in one of the oriented view map images.\n"
@ -198,7 +214,7 @@ static char ContextFunctions_read_directional_view_map_pixel___doc__[] =
" is in the lower-left corner.\n"
" :type y: int\n"
" :return: The floating-point value stored for that pixel.\n"
" :rtype: float\n";
" :rtype: float\n");
static PyObject *ContextFunctions_read_directional_view_map_pixel(PyObject * /*self*/,
PyObject *args,
@ -217,13 +233,15 @@ static PyObject *ContextFunctions_read_directional_view_map_pixel(PyObject * /*s
ContextFunctions::ReadDirectionalViewMapPixelCF(orientation, level, x, y));
}
static char ContextFunctions_get_selected_fedge___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ContextFunctions_get_selected_fedge___doc__,
".. function:: get_selected_fedge()\n"
"\n"
" Returns the selected FEdge.\n"
"\n"
" :return: The selected FEdge.\n"
" :rtype: :class:`FEdge`\n";
" :rtype: :class:`FEdge`\n");
static PyObject *ContextFunctions_get_selected_fedge(PyObject * /*self*/)
{
@ -236,7 +254,11 @@ static PyObject *ContextFunctions_get_selected_fedge(PyObject * /*self*/)
/*-----------------------ContextFunctions module docstring-------------------------------*/
static char module_docstring[] = "The Blender Freestyle.ContextFunctions submodule\n\n";
PyDoc_STRVAR(
/* Wrap. */
module_docstring,
"The Blender Freestyle.ContextFunctions submodule\n"
"\n");
/*-----------------------ContextFunctions module functions definitions-------------------*/

30
source/blender/freestyle/intern/python/BPy_Freestyle.cpp
View File

@ -53,13 +53,15 @@ extern "C" {
//------------------------ MODULE FUNCTIONS ----------------------------------
static char Freestyle_getCurrentScene___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
Freestyle_getCurrentScene___doc__,
".. function:: getCurrentScene()\n"
"\n"
" Returns the current scene.\n"
"\n"
" :return: The current scene.\n"
" :rtype: :class:`bpy.types.Scene`\n";
" :rtype: :class:`bpy.types.Scene`\n");
static PyObject *Freestyle_getCurrentScene(PyObject * /*self*/)
{
@ -138,7 +140,9 @@ static int ramp_blend_type(const char *type)
#include "BKE_material.h" /* ramp_blend() */
static char Freestyle_blendRamp___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
Freestyle_blendRamp___doc__,
".. function:: blendRamp(type, color1, fac, color2)\n"
"\n"
" Blend two colors according to a ramp blend type.\n"
@ -152,7 +156,7 @@ static char Freestyle_blendRamp___doc__[] =
" :arg color2: 1st color.\n"
" :type color2: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
" :return: Blended color in RGB format.\n"
" :rtype: :class:`mathutils.Vector`\n";
" :rtype: :class:`mathutils.Vector`\n");
static PyObject *Freestyle_blendRamp(PyObject * /*self*/, PyObject *args)
{
@ -191,7 +195,9 @@ static PyObject *Freestyle_blendRamp(PyObject * /*self*/, PyObject *args)
return Vector_CreatePyObject(a, 3, nullptr);
}
static char Freestyle_evaluateColorRamp___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
Freestyle_evaluateColorRamp___doc__,
".. function:: evaluateColorRamp(ramp, in)\n"
"\n"
" Evaluate a color ramp at a point in the interval 0 to 1.\n"
@ -201,7 +207,7 @@ static char Freestyle_evaluateColorRamp___doc__[] =
" :arg in: Value in the interval 0 to 1.\n"
" :type in: float\n"
" :return: color in RGBA format.\n"
" :rtype: :class:`mathutils.Vector`\n";
" :rtype: :class:`mathutils.Vector`\n");
static PyObject *Freestyle_evaluateColorRamp(PyObject * /*self*/, PyObject *args)
{
@ -226,7 +232,9 @@ static PyObject *Freestyle_evaluateColorRamp(PyObject * /*self*/, PyObject *args
#include "DNA_color_types.h"
static char Freestyle_evaluateCurveMappingF___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
Freestyle_evaluateCurveMappingF___doc__,
".. function:: evaluateCurveMappingF(cumap, cur, value)\n"
"\n"
" Evaluate a curve mapping at a point in the interval 0 to 1.\n"
@ -238,7 +246,7 @@ static char Freestyle_evaluateCurveMappingF___doc__[] =
" :arg value: Input value in the interval 0 to 1.\n"
" :type value: float\n"
" :return: Mapped output value.\n"
" :rtype: float\n";
" :rtype: float\n");
static PyObject *Freestyle_evaluateCurveMappingF(PyObject * /*self*/, PyObject *args)
{
@ -270,7 +278,9 @@ static PyObject *Freestyle_evaluateCurveMappingF(PyObject * /*self*/, PyObject *
/*-----------------------Freestyle module docstring----------------------------*/
static char module_docstring[] =
PyDoc_STRVAR(
/* Force wrapped line. */
module_docstring,
"This module provides classes for defining line drawing rules (such as\n"
"predicates, functions, chaining iterators, and stroke shaders), as well\n"
"as helper functions for style module writing.\n"
@ -492,7 +502,7 @@ static char module_docstring[] =
"- :class:`IntegrationType`\n"
"- :class:`MediumType`\n"
"- :class:`Nature`\n"
"\n";
"\n");
/*-----------------------Freestyle module method def---------------------------*/

71
source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp
View File

@ -43,6 +43,7 @@ int FrsMaterial_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_doc,
"Class defining a material.\n"
"\n"
@ -302,10 +303,12 @@ void FrsMaterial_mathutils_register_callback()
/*----------------------FrsMaterial get/setters ----------------------------*/
PyDoc_STRVAR(FrsMaterial_line_doc,
"RGBA components of the line color of the material.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_line_doc,
"RGBA components of the line color of the material.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *FrsMaterial_line_get(BPy_FrsMaterial *self, void * /*closure*/)
{
@ -323,10 +326,12 @@ static int FrsMaterial_line_set(BPy_FrsMaterial *self, PyObject *value, void * /
return 0;
}
PyDoc_STRVAR(FrsMaterial_diffuse_doc,
"RGBA components of the diffuse color of the material.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_diffuse_doc,
"RGBA components of the diffuse color of the material.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *FrsMaterial_diffuse_get(BPy_FrsMaterial *self, void * /*closure*/)
{
@ -344,10 +349,12 @@ static int FrsMaterial_diffuse_set(BPy_FrsMaterial *self, PyObject *value, void
return 0;
}
PyDoc_STRVAR(FrsMaterial_specular_doc,
"RGBA components of the specular color of the material.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_specular_doc,
"RGBA components of the specular color of the material.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *FrsMaterial_specular_get(BPy_FrsMaterial *self, void * /*closure*/)
{
@ -365,10 +372,12 @@ static int FrsMaterial_specular_set(BPy_FrsMaterial *self, PyObject *value, void
return 0;
}
PyDoc_STRVAR(FrsMaterial_ambient_doc,
"RGBA components of the ambient color of the material.\n"
"\n"
":type: :class:`mathutils.Color`");
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_ambient_doc,
"RGBA components of the ambient color of the material.\n"
"\n"
":type: :class:`mathutils.Color`");
static PyObject *FrsMaterial_ambient_get(BPy_FrsMaterial *self, void * /*closure*/)
{
@ -386,10 +395,12 @@ static int FrsMaterial_ambient_set(BPy_FrsMaterial *self, PyObject *value, void
return 0;
}
PyDoc_STRVAR(FrsMaterial_emission_doc,
"RGBA components of the emissive color of the material.\n"
"\n"
":type: :class:`mathutils.Color`");
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_emission_doc,
"RGBA components of the emissive color of the material.\n"
"\n"
":type: :class:`mathutils.Color`");
static PyObject *FrsMaterial_emission_get(BPy_FrsMaterial *self, void * /*closure*/)
{
@ -407,10 +418,12 @@ static int FrsMaterial_emission_set(BPy_FrsMaterial *self, PyObject *value, void
return 0;
}
PyDoc_STRVAR(FrsMaterial_shininess_doc,
"Shininess coefficient of the material.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_shininess_doc,
"Shininess coefficient of the material.\n"
"\n"
":type: float");
static PyObject *FrsMaterial_shininess_get(BPy_FrsMaterial *self, void * /*closure*/)
{
@ -429,10 +442,12 @@ static int FrsMaterial_shininess_set(BPy_FrsMaterial *self, PyObject *value, voi
return 0;
}
PyDoc_STRVAR(FrsMaterial_priority_doc,
"Line color priority of the material.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
FrsMaterial_priority_doc,
"Line color priority of the material.\n"
"\n"
":type: int");
static PyObject *FrsMaterial_priority_get(BPy_FrsMaterial *self, void * /*closure*/)
{

180
source/blender/freestyle/intern/python/BPy_FrsNoise.cpp
View File

@ -41,17 +41,19 @@ int FrsNoise_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(FrsNoise_doc,
"Class to provide Perlin noise functionalities.\n"
"\n"
".. method:: __init__(seed = -1)\n"
"\n"
" Builds a Noise object. Seed is an optional argument. The seed value is used\n"
" as a seed for random number generation if it is equal to or greater than zero;\n"
" otherwise, time is used as a seed.\n"
"\n"
" :arg seed: Seed for random number generation.\n"
" :type seed: int");
PyDoc_STRVAR(
/* Wrap. */
FrsNoise_doc,
"Class to provide Perlin noise functionalities.\n"
"\n"
".. method:: __init__(seed = -1)\n"
"\n"
" Builds a Noise object. Seed is an optional argument. The seed value is used\n"
" as a seed for random number generation if it is equal to or greater than zero;\n"
" otherwise, time is used as a seed.\n"
"\n"
" :arg seed: Seed for random number generation.\n"
" :type seed: int");
static int FrsNoise_init(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
{
@ -78,21 +80,23 @@ static PyObject *FrsNoise_repr(BPy_FrsNoise *self)
return PyUnicode_FromFormat("Noise - address: %p", self->n);
}
PyDoc_STRVAR(FrsNoise_turbulence1_doc,
".. method:: turbulence1(v, freq, amp, oct=4)\n"
"\n"
" Returns a noise value for a 1D element.\n"
"\n"
" :arg v: One-dimensional sample point.\n"
" :type v: float\n"
" :arg freq: Noise frequency.\n"
" :type freq: float\n"
" :arg amp: Amplitude.\n"
" :type amp: float\n"
" :arg oct: Number of octaves.\n"
" :type oct: int\n"
" :return: A noise value.\n"
" :rtype: float");
PyDoc_STRVAR(
/* Wrap. */
FrsNoise_turbulence1_doc,
".. method:: turbulence1(v, freq, amp, oct=4)\n"
"\n"
" Returns a noise value for a 1D element.\n"
"\n"
" :arg v: One-dimensional sample point.\n"
" :type v: float\n"
" :arg freq: Noise frequency.\n"
" :type freq: float\n"
" :arg amp: Amplitude.\n"
" :type amp: float\n"
" :arg oct: Number of octaves.\n"
" :type oct: int\n"
" :return: A noise value.\n"
" :rtype: float");
static PyObject *FrsNoise_drand(BPy_FrsNoise * /*self*/, PyObject *args, PyObject *kwds)
{
@ -133,21 +137,23 @@ static PyObject *FrsNoise_turbulence1(BPy_FrsNoise *self, PyObject *args, PyObje
return PyFloat_FromDouble(self->n->turbulence1(f1, f2, f3, i));
}
PyDoc_STRVAR(FrsNoise_turbulence2_doc,
".. method:: turbulence2(v, freq, amp, oct=4)\n"
"\n"
" Returns a noise value for a 2D element.\n"
"\n"
" :arg v: Two-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n"
" :arg freq: Noise frequency.\n"
" :type freq: float\n"
" :arg amp: Amplitude.\n"
" :type amp: float\n"
" :arg oct: Number of octaves.\n"
" :type oct: int\n"
" :return: A noise value.\n"
" :rtype: float");
PyDoc_STRVAR(
/* Wrap. */
FrsNoise_turbulence2_doc,
".. method:: turbulence2(v, freq, amp, oct=4)\n"
"\n"
" Returns a noise value for a 2D element.\n"
"\n"
" :arg v: Two-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n"
" :arg freq: Noise frequency.\n"
" :type freq: float\n"
" :arg amp: Amplitude.\n"
" :type amp: float\n"
" :arg oct: Number of octaves.\n"
" :type oct: int\n"
" :return: A noise value.\n"
" :rtype: float");
static PyObject *FrsNoise_turbulence2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
{
@ -169,21 +175,23 @@ static PyObject *FrsNoise_turbulence2(BPy_FrsNoise *self, PyObject *args, PyObje
return PyFloat_FromDouble(t);
}
PyDoc_STRVAR(FrsNoise_turbulence3_doc,
".. method:: turbulence3(v, freq, amp, oct=4)\n"
"\n"
" Returns a noise value for a 3D element.\n"
"\n"
" :arg v: Three-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
" :arg freq: Noise frequency.\n"
" :type freq: float\n"
" :arg amp: Amplitude.\n"
" :type amp: float\n"
" :arg oct: Number of octaves.\n"
" :type oct: int\n"
" :return: A noise value.\n"
" :rtype: float");
PyDoc_STRVAR(
/* Wrap. */
FrsNoise_turbulence3_doc,
".. method:: turbulence3(v, freq, amp, oct=4)\n"
"\n"
" Returns a noise value for a 3D element.\n"
"\n"
" :arg v: Three-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
" :arg freq: Noise frequency.\n"
" :type freq: float\n"
" :arg amp: Amplitude.\n"
" :type amp: float\n"
" :arg oct: Number of octaves.\n"
" :type oct: int\n"
" :return: A noise value.\n"
" :rtype: float");
static PyObject *FrsNoise_turbulence3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
{
@ -205,15 +213,17 @@ static PyObject *FrsNoise_turbulence3(BPy_FrsNoise *self, PyObject *args, PyObje
return PyFloat_FromDouble(t);
}
PyDoc_STRVAR(FrsNoise_smoothNoise1_doc,
".. method:: smoothNoise1(v)\n"
"\n"
" Returns a smooth noise value for a 1D element.\n"
"\n"
" :arg v: One-dimensional sample point.\n"
" :type v: float\n"
" :return: A smooth noise value.\n"
" :rtype: float");
PyDoc_STRVAR(
/* Wrap. */
FrsNoise_smoothNoise1_doc,
".. method:: smoothNoise1(v)\n"
"\n"
" Returns a smooth noise value for a 1D element.\n"
"\n"
" :arg v: One-dimensional sample point.\n"
" :type v: float\n"
" :return: A smooth noise value.\n"
" :rtype: float");
static PyObject *FrsNoise_smoothNoise1(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
{
@ -226,15 +236,17 @@ static PyObject *FrsNoise_smoothNoise1(BPy_FrsNoise *self, PyObject *args, PyObj
return PyFloat_FromDouble(self->n->smoothNoise1(f));
}
PyDoc_STRVAR(FrsNoise_smoothNoise2_doc,
".. method:: smoothNoise2(v)\n"
"\n"
" Returns a smooth noise value for a 2D element.\n"
"\n"
" :arg v: Two-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n"
" :return: A smooth noise value.\n"
" :rtype: float");
PyDoc_STRVAR(
/* Wrap. */
FrsNoise_smoothNoise2_doc,
".. method:: smoothNoise2(v)\n"
"\n"
" Returns a smooth noise value for a 2D element.\n"
"\n"
" :arg v: Two-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n"
" :return: A smooth noise value.\n"
" :rtype: float");
static PyObject *FrsNoise_smoothNoise2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
{
@ -254,15 +266,17 @@ static PyObject *FrsNoise_smoothNoise2(BPy_FrsNoise *self, PyObject *args, PyObj
return PyFloat_FromDouble(t);
}
PyDoc_STRVAR(FrsNoise_smoothNoise3_doc,
".. method:: smoothNoise3(v)\n"
"\n"
" Returns a smooth noise value for a 3D element.\n"
"\n"
" :arg v: Three-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
" :return: A smooth noise value.\n"
" :rtype: float");
PyDoc_STRVAR(
/* Wrap. */
FrsNoise_smoothNoise3_doc,
".. method:: smoothNoise3(v)\n"
"\n"
" Returns a smooth noise value for a 3D element.\n"
"\n"
" :arg v: Three-dimensional sample point.\n"
" :type v: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"
" :return: A smooth noise value.\n"
" :rtype: float");
static PyObject *FrsNoise_smoothNoise3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
{

21
source/blender/freestyle/intern/python/BPy_Id.cpp
View File

@ -37,6 +37,7 @@ int Id_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(
/* Wrap. */
Id_doc,
"Class for representing an object Id.\n"
"\n"
@ -107,10 +108,12 @@ static PyObject *Id_RichCompare(BPy_Id *o1, BPy_Id *o2, int opid)
/*----------------------Id get/setters ----------------------------*/
PyDoc_STRVAR(Id_first_doc,
"The first number constituting the Id.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
Id_first_doc,
"The first number constituting the Id.\n"
"\n"
":type: int");
static PyObject *Id_first_get(BPy_Id *self, void * /*closure*/)
{
@ -128,10 +131,12 @@ static int Id_first_set(BPy_Id *self, PyObject *value, void * /*closure*/)
return 0;
}
PyDoc_STRVAR(Id_second_doc,
"The second number constituting the Id.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
Id_second_doc,
"The second number constituting the Id.\n"
"\n"
":type: int");
static PyObject *Id_second_get(BPy_Id *self, void * /*closure*/)
{

92
source/blender/freestyle/intern/python/BPy_IntegrationType.cpp
View File

@ -26,30 +26,32 @@ using namespace Freestyle;
//------------------------ MODULE FUNCTIONS ----------------------------------
PyDoc_STRVAR(Integrator_integrate_doc,
".. function:: integrate(func, it, it_end, integration_type)\n"
"\n"
" Returns a single value from a set of values evaluated at each 0D\n"
" element of this 1D element.\n"
"\n"
" :arg func: The UnaryFunction0D used to compute a value at each\n"
" Interface0D.\n"
" :type func: :class:`UnaryFunction0D`\n"
" :arg it: The Interface0DIterator used to iterate over the 0D\n"
" elements of this 1D element. The integration will occur over\n"
" the 0D elements starting from the one pointed by it.\n"
" :type it: :class:`Interface0DIterator`\n"
" :arg it_end: The Interface0DIterator pointing the end of the 0D\n"
" elements of the 1D element.\n"
" :type it_end: :class:`Interface0DIterator`\n"
" :arg integration_type: The integration method used to compute a\n"
" single value from a set of values.\n"
" :type integration_type: :class:`IntegrationType`\n"
" :return: The single value obtained for the 1D element. The return\n"
" value type is float if func is of the :class:`UnaryFunction0DDouble`\n"
" or :class:`UnaryFunction0DFloat` type, and int if func is of the\n"
" :class:`UnaryFunction0DUnsigned` type.\n"
" :rtype: int or float");
PyDoc_STRVAR(
/* Wrap. */
Integrator_integrate_doc,
".. function:: integrate(func, it, it_end, integration_type)\n"
"\n"
" Returns a single value from a set of values evaluated at each 0D\n"
" element of this 1D element.\n"
"\n"
" :arg func: The UnaryFunction0D used to compute a value at each\n"
" Interface0D.\n"
" :type func: :class:`UnaryFunction0D`\n"
" :arg it: The Interface0DIterator used to iterate over the 0D\n"
" elements of this 1D element. The integration will occur over\n"
" the 0D elements starting from the one pointed by it.\n"
" :type it: :class:`Interface0DIterator`\n"
" :arg it_end: The Interface0DIterator pointing the end of the 0D\n"
" elements of the 1D element.\n"
" :type it_end: :class:`Interface0DIterator`\n"
" :arg integration_type: The integration method used to compute a\n"
" single value from a set of values.\n"
" :type integration_type: :class:`IntegrationType`\n"
" :return: The single value obtained for the 1D element. The return\n"
" value type is float if func is of the :class:`UnaryFunction0DDouble`\n"
" or :class:`UnaryFunction0DFloat` type, and int if func is of the\n"
" :class:`UnaryFunction0DUnsigned` type.\n"
" :rtype: int or float");
static PyObject *Integrator_integrate(PyObject * /*self*/, PyObject *args, PyObject *kwds)
{
@ -99,7 +101,11 @@ static PyObject *Integrator_integrate(PyObject * /*self*/, PyObject *args, PyObj
/*-----------------------Integrator module docstring---------------------------------------*/
PyDoc_STRVAR(module_docstring, "The Blender Freestyle.Integrator submodule\n\n");
PyDoc_STRVAR(
/* Wrap. */
module_docstring,
"The Blender Freestyle.Integrator submodule\n"
"\n");
/*-----------------------Integrator module functions definitions---------------------------*/
@ -127,23 +133,25 @@ static PyModuleDef module_definition = {
/*-----------------------BPy_IntegrationType type definition ------------------------------*/
PyDoc_STRVAR(IntegrationType_doc,
"Class hierarchy: int > :class:`IntegrationType`\n"
"\n"
"Different integration methods that can be invoked to integrate into a\n"
"single value the set of values obtained from each 0D element of an 1D\n"
"element:\n"
"\n"
"* IntegrationType.MEAN: The value computed for the 1D element is the\n"
" mean of the values obtained for the 0D elements.\n"
"* IntegrationType.MIN: The value computed for the 1D element is the\n"
" minimum of the values obtained for the 0D elements.\n"
"* IntegrationType.MAX: The value computed for the 1D element is the\n"
" maximum of the values obtained for the 0D elements.\n"
"* IntegrationType.FIRST: The value computed for the 1D element is the\n"
" first of the values obtained for the 0D elements.\n"
"* IntegrationType.LAST: The value computed for the 1D element is the\n"
" last of the values obtained for the 0D elements.");
PyDoc_STRVAR(
/* Wrap. */
IntegrationType_doc,
"Class hierarchy: int > :class:`IntegrationType`\n"
"\n"
"Different integration methods that can be invoked to integrate into a\n"
"single value the set of values obtained from each 0D element of an 1D\n"
"element:\n"
"\n"
"* IntegrationType.MEAN: The value computed for the 1D element is the\n"
" mean of the values obtained for the 0D elements.\n"
"* IntegrationType.MIN: The value computed for the 1D element is the\n"
" minimum of the values obtained for the 0D elements.\n"
"* IntegrationType.MAX: The value computed for the 1D element is the\n"
" maximum of the values obtained for the 0D elements.\n"
"* IntegrationType.FIRST: The value computed for the 1D element is the\n"
" first of the values obtained for the 0D elements.\n"
"* IntegrationType.LAST: The value computed for the 1D element is the\n"
" last of the values obtained for the 0D elements.");
PyTypeObject IntegrationType_Type = {
/*ob_base*/ PyVarObject_HEAD_INIT(nullptr, 0)

116
source/blender/freestyle/intern/python/BPy_Interface0D.cpp
View File

@ -83,12 +83,14 @@ int Interface0D_Init(PyObject *module)
/*----------------------Interface1D methods ----------------------------*/
PyDoc_STRVAR(Interface0D_doc,
"Base class for any 0D element.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_doc,
"Base class for any 0D element.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
static int Interface0D_init(BPy_Interface0D *self, PyObject *args, PyObject *kwds)
{
@ -116,16 +118,18 @@ static PyObject *Interface0D_repr(BPy_Interface0D *self)
"type: %s - address: %p", self->if0D->getExactTypeName().c_str(), self->if0D);
}
PyDoc_STRVAR(Interface0D_get_fedge_doc,
".. method:: get_fedge(inter)\n"
"\n"
" Returns the FEdge that lies between this 0D element and the 0D\n"
" element given as the argument.\n"
"\n"
" :arg inter: A 0D element.\n"
" :type inter: :class:`Interface0D`\n"
" :return: The FEdge lying between the two 0D elements.\n"
" :rtype: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_get_fedge_doc,
".. method:: get_fedge(inter)\n"
"\n"
" Returns the FEdge that lies between this 0D element and the 0D\n"
" element given as the argument.\n"
"\n"
" :arg inter: A 0D element.\n"
" :type inter: :class:`Interface0D`\n"
" :return: The FEdge lying between the two 0D elements.\n"
" :rtype: :class:`FEdge`");
static PyObject *Interface0D_get_fedge(BPy_Interface0D *self, PyObject *args, PyObject *kwds)
{
@ -156,20 +160,24 @@ static PyMethodDef BPy_Interface0D_methods[] = {
/*----------------------Interface1D get/setters ----------------------------*/
PyDoc_STRVAR(Interface0D_name_doc,
"The string of the name of this 0D element.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_name_doc,
"The string of the name of this 0D element.\n"
"\n"
":type: str");
static PyObject *Interface0D_name_get(BPy_Interface0D *self, void * /*closure*/)
{
return PyUnicode_FromString(Py_TYPE(self)->tp_name);
}
PyDoc_STRVAR(Interface0D_point_3d_doc,
"The 3D point of this 0D element.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_point_3d_doc,
"The 3D point of this 0D element.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *Interface0D_point_3d_get(BPy_Interface0D *self, void * /*closure*/)
{
@ -180,10 +188,12 @@ static PyObject *Interface0D_point_3d_get(BPy_Interface0D *self, void * /*closur
return Vector_from_Vec3f(p);
}
PyDoc_STRVAR(Interface0D_projected_x_doc,
"The X coordinate of the projected 3D point of this 0D element.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_projected_x_doc,
"The X coordinate of the projected 3D point of this 0D element.\n"
"\n"
":type: float");
static PyObject *Interface0D_projected_x_get(BPy_Interface0D *self, void * /*closure*/)
{
@ -194,10 +204,12 @@ static PyObject *Interface0D_projected_x_get(BPy_Interface0D *self, void * /*clo
return PyFloat_FromDouble(x);
}
PyDoc_STRVAR(Interface0D_projected_y_doc,
"The Y coordinate of the projected 3D point of this 0D element.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_projected_y_doc,
"The Y coordinate of the projected 3D point of this 0D element.\n"
"\n"
":type: float");
static PyObject *Interface0D_projected_y_get(BPy_Interface0D *self, void * /*closure*/)
{
@ -208,10 +220,12 @@ static PyObject *Interface0D_projected_y_get(BPy_Interface0D *self, void * /*clo
return PyFloat_FromDouble(y);
}
PyDoc_STRVAR(Interface0D_projected_z_doc,
"The Z coordinate of the projected 3D point of this 0D element.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_projected_z_doc,
"The Z coordinate of the projected 3D point of this 0D element.\n"
"\n"
":type: float");
static PyObject *Interface0D_projected_z_get(BPy_Interface0D *self, void * /*closure*/)
{
@ -222,10 +236,12 @@ static PyObject *Interface0D_projected_z_get(BPy_Interface0D *self, void * /*clo
return PyFloat_FromDouble(z);
}
PyDoc_STRVAR(Interface0D_point_2d_doc,
"The 2D point of this 0D element.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_point_2d_doc,
"The 2D point of this 0D element.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *Interface0D_point_2d_get(BPy_Interface0D *self, void * /*closure*/)
{
@ -236,10 +252,12 @@ static PyObject *Interface0D_point_2d_get(BPy_Interface0D *self, void * /*closur
return Vector_from_Vec2f(p);
}
PyDoc_STRVAR(Interface0D_id_doc,
"The Id of this 0D element.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_id_doc,
"The Id of this 0D element.\n"
"\n"
":type: :class:`Id`");
static PyObject *Interface0D_id_get(BPy_Interface0D *self, void * /*closure*/)
{
@ -250,10 +268,12 @@ static PyObject *Interface0D_id_get(BPy_Interface0D *self, void * /*closure*/)
return BPy_Id_from_Id(id); // return a copy
}
PyDoc_STRVAR(Interface0D_nature_doc,
"The nature of this 0D element.\n"
"\n"
":type: :class:`Nature`");
PyDoc_STRVAR(
/* Wrap. */
Interface0D_nature_doc,
"The nature of this 0D element.\n"
"\n"
":type: :class:`Nature`");
static PyObject *Interface0D_nature_get(BPy_Interface0D *self, void * /*closure*/)
{

156
source/blender/freestyle/intern/python/BPy_Interface1D.cpp
View File

@ -94,12 +94,14 @@ int Interface1D_Init(PyObject *module)
/*----------------------Interface1D methods ----------------------------*/
PyDoc_STRVAR(Interface1D_doc,
"Base class for any 1D element.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_doc,
"Base class for any 1D element.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
static int Interface1D_init(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
{
@ -127,14 +129,16 @@ static PyObject *Interface1D_repr(BPy_Interface1D *self)
"type: %s - address: %p", self->if1D->getExactTypeName().c_str(), self->if1D);
}
PyDoc_STRVAR(Interface1D_vertices_begin_doc,
".. method:: vertices_begin()\n"
"\n"
" Returns an iterator over the Interface1D vertices, pointing to the\n"
" first vertex.\n"
"\n"
" :return: An Interface0DIterator pointing to the first vertex.\n"
" :rtype: :class:`Interface0DIterator`");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_vertices_begin_doc,
".. method:: vertices_begin()\n"
"\n"
" Returns an iterator over the Interface1D vertices, pointing to the\n"
" first vertex.\n"
"\n"
" :return: An Interface0DIterator pointing to the first vertex.\n"
" :rtype: :class:`Interface0DIterator`");
static PyObject *Interface1D_vertices_begin(BPy_Interface1D *self)
{
@ -142,14 +146,16 @@ static PyObject *Interface1D_vertices_begin(BPy_Interface1D *self)
return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, false);
}
PyDoc_STRVAR(Interface1D_vertices_end_doc,
".. method:: vertices_end()\n"
"\n"
" Returns an iterator over the Interface1D vertices, pointing after\n"
" the last vertex.\n"
"\n"
" :return: An Interface0DIterator pointing after the last vertex.\n"
" :rtype: :class:`Interface0DIterator`");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_vertices_end_doc,
".. method:: vertices_end()\n"
"\n"
" Returns an iterator over the Interface1D vertices, pointing after\n"
" the last vertex.\n"
"\n"
" :return: An Interface0DIterator pointing after the last vertex.\n"
" :rtype: :class:`Interface0DIterator`");
static PyObject *Interface1D_vertices_end(BPy_Interface1D *self)
{
@ -157,19 +163,21 @@ static PyObject *Interface1D_vertices_end(BPy_Interface1D *self)
return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, true);
}
PyDoc_STRVAR(Interface1D_points_begin_doc,
".. method:: points_begin(t=0.0)\n"
"\n"
" Returns an iterator over the Interface1D points, pointing to the\n"
" first point. The difference with vertices_begin() is that here we can\n"
" iterate over points of the 1D element at a any given sampling.\n"
" Indeed, for each iteration, a virtual point is created.\n"
"\n"
" :arg t: A sampling with which we want to iterate over points of\n"
" this 1D element.\n"
" :type t: float\n"
" :return: An Interface0DIterator pointing to the first point.\n"
" :rtype: :class:`Interface0DIterator`");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_points_begin_doc,
".. method:: points_begin(t=0.0)\n"
"\n"
" Returns an iterator over the Interface1D points, pointing to the\n"
" first point. The difference with vertices_begin() is that here we can\n"
" iterate over points of the 1D element at a any given sampling.\n"
" Indeed, for each iteration, a virtual point is created.\n"
"\n"
" :arg t: A sampling with which we want to iterate over points of\n"
" this 1D element.\n"
" :type t: float\n"
" :return: An Interface0DIterator pointing to the first point.\n"
" :rtype: :class:`Interface0DIterator`");
static PyObject *Interface1D_points_begin(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
{
@ -183,19 +191,21 @@ static PyObject *Interface1D_points_begin(BPy_Interface1D *self, PyObject *args,
return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, false);
}
PyDoc_STRVAR(Interface1D_points_end_doc,
".. method:: points_end(t=0.0)\n"
"\n"
" Returns an iterator over the Interface1D points, pointing after the\n"
" last point. The difference with vertices_end() is that here we can\n"
" iterate over points of the 1D element at a given sampling. Indeed,\n"
" for each iteration, a virtual point is created.\n"
"\n"
" :arg t: A sampling with which we want to iterate over points of\n"
" this 1D element.\n"
" :type t: float\n"
" :return: An Interface0DIterator pointing after the last point.\n"
" :rtype: :class:`Interface0DIterator`");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_points_end_doc,
".. method:: points_end(t=0.0)\n"
"\n"
" Returns an iterator over the Interface1D points, pointing after the\n"
" last point. The difference with vertices_end() is that here we can\n"
" iterate over points of the 1D element at a given sampling. Indeed,\n"
" for each iteration, a virtual point is created.\n"
"\n"
" :arg t: A sampling with which we want to iterate over points of\n"
" this 1D element.\n"
" :type t: float\n"
" :return: An Interface0DIterator pointing after the last point.\n"
" :rtype: :class:`Interface0DIterator`");
static PyObject *Interface1D_points_end(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
{
@ -231,20 +241,24 @@ static PyMethodDef BPy_Interface1D_methods[] = {
/*----------------------Interface1D get/setters ----------------------------*/
PyDoc_STRVAR(Interface1D_name_doc,
"The string of the name of the 1D element.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_name_doc,
"The string of the name of the 1D element.\n"
"\n"
":type: str");
static PyObject *Interface1D_name_get(BPy_Interface1D *self, void * /*closure*/)
{
return PyUnicode_FromString(Py_TYPE(self)->tp_name);
}
PyDoc_STRVAR(Interface1D_id_doc,
"The Id of this Interface1D.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_id_doc,
"The Id of this Interface1D.\n"
"\n"
":type: :class:`Id`");
static PyObject *Interface1D_id_get(BPy_Interface1D *self, void * /*closure*/)
{
@ -255,10 +269,12 @@ static PyObject *Interface1D_id_get(BPy_Interface1D *self, void * /*closure*/)
return BPy_Id_from_Id(id); // return a copy
}
PyDoc_STRVAR(Interface1D_nature_doc,
"The nature of this Interface1D.\n"
"\n"
":type: :class:`Nature`");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_nature_doc,
"The nature of this Interface1D.\n"
"\n"
":type: :class:`Nature`");
static PyObject *Interface1D_nature_get(BPy_Interface1D *self, void * /*closure*/)
{
@ -269,10 +285,12 @@ static PyObject *Interface1D_nature_get(BPy_Interface1D *self, void * /*closure*
return BPy_Nature_from_Nature(nature);
}
PyDoc_STRVAR(Interface1D_length_2d_doc,
"The 2D length of this Interface1D.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_length_2d_doc,
"The 2D length of this Interface1D.\n"
"\n"
":type: float");
static PyObject *Interface1D_length_2d_get(BPy_Interface1D *self, void * /*closure*/)
{
@ -283,10 +301,12 @@ static PyObject *Interface1D_length_2d_get(BPy_Interface1D *self, void * /*closu
return PyFloat_FromDouble(double(length));
}
PyDoc_STRVAR(Interface1D_time_stamp_doc,
"The time stamp of the 1D element, mainly used for selection.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
Interface1D_time_stamp_doc,
"The time stamp of the 1D element, mainly used for selection.\n"
"\n"
":type: int");
static PyObject *Interface1D_time_stamp_get(BPy_Interface1D *self, void * /*closure*/)
{

64
source/blender/freestyle/intern/python/BPy_Iterator.cpp
View File

@ -107,12 +107,14 @@ int Iterator_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(Iterator_doc,
"Base class to define iterators.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
PyDoc_STRVAR(
/* Wrap. */
Iterator_doc,
"Base class to define iterators.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
static int Iterator_init(BPy_Iterator *self, PyObject *args, PyObject *kwds)
{
@ -136,10 +138,12 @@ static PyObject *Iterator_repr(BPy_Iterator *self)
return PyUnicode_FromFormat("type: %s - address: %p", Py_TYPE(self)->tp_name, self->it);
}
PyDoc_STRVAR(Iterator_increment_doc,
".. method:: increment()\n"
"\n"
" Makes the iterator point the next element.");
PyDoc_STRVAR(
/* Wrap. */
Iterator_increment_doc,
".. method:: increment()\n"
"\n"
" Makes the iterator point the next element.");
static PyObject *Iterator_increment(BPy_Iterator *self)
{
@ -151,10 +155,12 @@ static PyObject *Iterator_increment(BPy_Iterator *self)
Py_RETURN_NONE;
}
PyDoc_STRVAR(Iterator_decrement_doc,
".. method:: decrement()\n"
"\n"
" Makes the iterator point the previous element.");
PyDoc_STRVAR(
/* Wrap. */
Iterator_decrement_doc,
".. method:: decrement()\n"
"\n"
" Makes the iterator point the previous element.");
static PyObject *Iterator_decrement(BPy_Iterator *self)
{
@ -174,30 +180,36 @@ static PyMethodDef BPy_Iterator_methods[] = {
/*----------------------Iterator get/setters ----------------------------*/
PyDoc_STRVAR(Iterator_name_doc,
"The string of the name of this iterator.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
Iterator_name_doc,
"The string of the name of this iterator.\n"
"\n"
":type: str");
static PyObject *Iterator_name_get(BPy_Iterator *self, void * /*closure*/)
{
return PyUnicode_FromString(Py_TYPE(self)->tp_name);
}
PyDoc_STRVAR(Iterator_is_begin_doc,
"True if the iterator points to the first element.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
Iterator_is_begin_doc,
"True if the iterator points to the first element.\n"
"\n"
":type: bool");
static PyObject *Iterator_is_begin_get(BPy_Iterator *self, void * /*closure*/)
{
return PyBool_from_bool(self->it->isBegin());
}
PyDoc_STRVAR(Iterator_is_end_doc,
"True if the iterator points to the last element.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
Iterator_is_end_doc,
"True if the iterator points to the last element.\n"
"\n"
":type: bool");
static PyObject *Iterator_is_end_get(BPy_Iterator *self, void * /*closure*/)
{

20
source/blender/freestyle/intern/python/BPy_MediumType.cpp
View File

@ -20,15 +20,17 @@ using namespace Freestyle;
/*-----------------------BPy_MediumType type definition ------------------------------*/
PyDoc_STRVAR(MediumType_doc,
"Class hierarchy: int > :class:`MediumType`\n"
"\n"
"The different blending modes available to simulate the interaction\n"
"media-medium:\n"
"\n"
"* Stroke.DRY_MEDIUM: To simulate a dry medium such as Pencil or Charcoal.\n"
"* Stroke.HUMID_MEDIUM: To simulate ink painting (color subtraction blending).\n"
"* Stroke.OPAQUE_MEDIUM: To simulate an opaque medium (oil, spray...).");
PyDoc_STRVAR(
/* Wrap. */
MediumType_doc,
"Class hierarchy: int > :class:`MediumType`\n"
"\n"
"The different blending modes available to simulate the interaction\n"
"media-medium:\n"
"\n"
"* Stroke.DRY_MEDIUM: To simulate a dry medium such as Pencil or Charcoal.\n"
"* Stroke.HUMID_MEDIUM: To simulate ink painting (color subtraction blending).\n"
"* Stroke.OPAQUE_MEDIUM: To simulate an opaque medium (oil, spray...).");
PyTypeObject MediumType_Type = {
/*ob_base*/ PyVarObject_HEAD_INIT(nullptr, 0)

54
source/blender/freestyle/intern/python/BPy_Nature.cpp
View File

@ -65,32 +65,34 @@ static PyNumberMethods nature_as_number = {
/*-----------------------BPy_Nature doc-string -----------------------------------*/
PyDoc_STRVAR(Nature_doc,
"Class hierarchy: int > :class:`Nature`\n"
"\n"
"Different possible natures of 0D and 1D elements of the ViewMap.\n"
"\n"
"Vertex natures:\n"
"\n"
"* Nature.POINT: True for any 0D element.\n"
"* Nature.S_VERTEX: True for SVertex.\n"
"* Nature.VIEW_VERTEX: True for ViewVertex.\n"
"* Nature.NON_T_VERTEX: True for NonTVertex.\n"
"* Nature.T_VERTEX: True for TVertex.\n"
"* Nature.CUSP: True for CUSP.\n"
"\n"
"Edge natures:\n"
"\n"
"* Nature.NO_FEATURE: True for non feature edges (always false for 1D\n"
" elements of the ViewMap).\n"
"* Nature.SILHOUETTE: True for silhouettes.\n"
"* Nature.BORDER: True for borders.\n"
"* Nature.CREASE: True for creases.\n"
"* Nature.RIDGE: True for ridges.\n"
"* Nature.VALLEY: True for valleys.\n"
"* Nature.SUGGESTIVE_CONTOUR: True for suggestive contours.\n"
"* Nature.MATERIAL_BOUNDARY: True for edges at material boundaries.\n"
"* Nature.EDGE_MARK: True for edges having user-defined edge marks.");
PyDoc_STRVAR(
/* Wrap. */
Nature_doc,
"Class hierarchy: int > :class:`Nature`\n"
"\n"
"Different possible natures of 0D and 1D elements of the ViewMap.\n"
"\n"
"Vertex natures:\n"
"\n"
"* Nature.POINT: True for any 0D element.\n"
"* Nature.S_VERTEX: True for SVertex.\n"
"* Nature.VIEW_VERTEX: True for ViewVertex.\n"
"* Nature.NON_T_VERTEX: True for NonTVertex.\n"
"* Nature.T_VERTEX: True for TVertex.\n"
"* Nature.CUSP: True for CUSP.\n"
"\n"
"Edge natures:\n"
"\n"
"* Nature.NO_FEATURE: True for non feature edges (always false for 1D\n"
" elements of the ViewMap).\n"
"* Nature.SILHOUETTE: True for silhouettes.\n"
"* Nature.BORDER: True for borders.\n"
"* Nature.CREASE: True for creases.\n"
"* Nature.RIDGE: True for ridges.\n"
"* Nature.VALLEY: True for valleys.\n"
"* Nature.SUGGESTIVE_CONTOUR: True for suggestive contours.\n"
"* Nature.MATERIAL_BOUNDARY: True for edges at material boundaries.\n"
"* Nature.EDGE_MARK: True for edges having user-defined edge marks.");
/*-----------------------BPy_Nature type definition ------------------------------*/

353
source/blender/freestyle/intern/python/BPy_Operators.cpp
View File

@ -48,25 +48,29 @@ int Operators_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(Operators_doc,
"Class defining the operators used in a style module. There are five\n"
"types of operators: Selection, chaining, splitting, sorting and\n"
"creation. All these operators are user controlled through functors,\n"
"predicates and shaders that are taken as arguments.");
PyDoc_STRVAR(
/* Wrap. */
Operators_doc,
"Class defining the operators used in a style module. There are five\n"
"types of operators: Selection, chaining, splitting, sorting and\n"
"creation. All these operators are user controlled through functors,\n"
"predicates and shaders that are taken as arguments.");
static void Operators_dealloc(BPy_Operators *self)
{
Py_TYPE(self)->tp_free((PyObject *)self);
}
PyDoc_STRVAR(Operators_select_doc,
".. staticmethod:: select(pred)\n"
"\n"
" Selects the ViewEdges of the ViewMap verifying a specified\n"
" condition.\n"
"\n"
" :arg pred: The predicate expressing this condition.\n"
" :type pred: :class:`UnaryPredicate1D`");
PyDoc_STRVAR(
/* Wrap. */
Operators_select_doc,
".. staticmethod:: select(pred)\n"
"\n"
" Selects the ViewEdges of the ViewMap verifying a specified\n"
" condition.\n"
"\n"
" :arg pred: The predicate expressing this condition.\n"
" :type pred: :class:`UnaryPredicate1D`");
static PyObject *Operators_select(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
{
@ -92,27 +96,29 @@ static PyObject *Operators_select(BPy_Operators * /*self*/, PyObject *args, PyOb
Py_RETURN_NONE;
}
PyDoc_STRVAR(Operators_chain_doc,
".. staticmethod:: chain(it, pred, modifier)\n"
" chain(it, pred)\n"
"\n"
" Builds a set of chains from the current set of ViewEdges. Each\n"
" ViewEdge of the current list starts a new chain. The chaining\n"
" operator then iterates over the ViewEdges of the ViewMap using the\n"
" user specified iterator. This operator only iterates using the\n"
" increment operator and is therefore unidirectional.\n"
"\n"
" :arg it: The iterator on the ViewEdges of the ViewMap. It contains\n"
" the chaining rule.\n"
" :type it: :class:`ViewEdgeIterator`\n"
" :arg pred: The predicate on the ViewEdge that expresses the\n"
" stopping condition.\n"
" :type pred: :class:`UnaryPredicate1D`\n"
" :arg modifier: A function that takes a ViewEdge as argument and\n"
" that is used to modify the processed ViewEdge state (the\n"
" timestamp incrementation is a typical illustration of such a modifier).\n"
" If this argument is not given, the time stamp is automatically managed.\n"
" :type modifier: :class:`UnaryFunction1DVoid`\n");
PyDoc_STRVAR(
/* Wrap. */
Operators_chain_doc,
".. staticmethod:: chain(it, pred, modifier)\n"
" chain(it, pred)\n"
"\n"
" Builds a set of chains from the current set of ViewEdges. Each\n"
" ViewEdge of the current list starts a new chain. The chaining\n"
" operator then iterates over the ViewEdges of the ViewMap using the\n"
" user specified iterator. This operator only iterates using the\n"
" increment operator and is therefore unidirectional.\n"
"\n"
" :arg it: The iterator on the ViewEdges of the ViewMap. It contains\n"
" the chaining rule.\n"
" :type it: :class:`ViewEdgeIterator`\n"
" :arg pred: The predicate on the ViewEdge that expresses the\n"
" stopping condition.\n"
" :type pred: :class:`UnaryPredicate1D`\n"
" :arg modifier: A function that takes a ViewEdge as argument and\n"
" that is used to modify the processed ViewEdge state (the\n"
" timestamp incrementation is a typical illustration of such a modifier).\n"
" If this argument is not given, the time stamp is automatically managed.\n"
" :type modifier: :class:`UnaryFunction1DVoid`\n");
static PyObject *Operators_chain(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
{
@ -171,29 +177,31 @@ static PyObject *Operators_chain(BPy_Operators * /*self*/, PyObject *args, PyObj
Py_RETURN_NONE;
}
PyDoc_STRVAR(Operators_bidirectional_chain_doc,
".. staticmethod:: bidirectional_chain(it, pred)\n"
" bidirectional_chain(it)\n"
"\n"
" Builds a set of chains from the current set of ViewEdges. Each\n"
" ViewEdge of the current list potentially starts a new chain. The\n"
" chaining operator then iterates over the ViewEdges of the ViewMap\n"
" using the user specified iterator. This operator iterates both using\n"
" the increment and decrement operators and is therefore bidirectional.\n"
" This operator works with a ChainingIterator which contains the\n"
" chaining rules. It is this last one which can be told to chain only\n"
" edges that belong to the selection or not to process twice a ViewEdge\n"
" during the chaining. Each time a ViewEdge is added to a chain, its\n"
" chaining time stamp is incremented. This allows you to keep track of\n"
" the number of chains to which a ViewEdge belongs to.\n"
"\n"
" :arg it: The ChainingIterator on the ViewEdges of the ViewMap. It\n"
" contains the chaining rule.\n"
" :type it: :class:`ChainingIterator`\n"
" :arg pred: The predicate on the ViewEdge that expresses the stopping condition.\n"
" This parameter is optional, you make not want to pass a stopping criterion\n"
" when the stopping criterion is already contained in the iterator definition.\n"
" :type pred: :class:`UnaryPredicate1D`\n");
PyDoc_STRVAR(
/* Wrap. */
Operators_bidirectional_chain_doc,
".. staticmethod:: bidirectional_chain(it, pred)\n"
" bidirectional_chain(it)\n"
"\n"
" Builds a set of chains from the current set of ViewEdges. Each\n"
" ViewEdge of the current list potentially starts a new chain. The\n"
" chaining operator then iterates over the ViewEdges of the ViewMap\n"
" using the user specified iterator. This operator iterates both using\n"
" the increment and decrement operators and is therefore bidirectional.\n"
" This operator works with a ChainingIterator which contains the\n"
" chaining rules. It is this last one which can be told to chain only\n"
" edges that belong to the selection or not to process twice a ViewEdge\n"
" during the chaining. Each time a ViewEdge is added to a chain, its\n"
" chaining time stamp is incremented. This allows you to keep track of\n"
" the number of chains to which a ViewEdge belongs to.\n"
"\n"
" :arg it: The ChainingIterator on the ViewEdges of the ViewMap. It\n"
" contains the chaining rule.\n"
" :type it: :class:`ChainingIterator`\n"
" :arg pred: The predicate on the ViewEdge that expresses the stopping condition.\n"
" This parameter is optional, you make not want to pass a stopping criterion\n"
" when the stopping criterion is already contained in the iterator definition.\n"
" :type pred: :class:`UnaryPredicate1D`\n");
static PyObject *Operators_bidirectional_chain(BPy_Operators * /*self*/,
PyObject *args,
@ -246,36 +254,38 @@ static PyObject *Operators_bidirectional_chain(BPy_Operators * /*self*/,
Py_RETURN_NONE;
}
PyDoc_STRVAR(Operators_sequential_split_doc,
".. staticmethod:: sequential_split(starting_pred, stopping_pred, sampling=0.0)\n"
" sequential_split(pred, sampling=0.0)\n"
"\n"
" Splits each chain of the current set of chains in a sequential way.\n"
" The points of each chain are processed (with a specified sampling)\n"
" sequentially. The first point of the initial chain is the\n"
" first point of one of the resulting chains. The splitting ends when\n"
" no more chain can start.\n"
"\n"
" .. tip::\n"
"\n"
" By specifying a starting and stopping predicate allows\n"
" the chains to overlap rather than chains partitioning.\n"
"\n"
" :arg starting_pred: The predicate on a point that expresses the\n"
" starting condition. Each time this condition is verified, a new chain begins\n"
" :type starting_pred: :class:`UnaryPredicate0D`\n"
" :arg stopping_pred: The predicate on a point that expresses the\n"
" stopping condition. The chain ends as soon as this predicate is verified.\n"
" :type stopping_pred: :class:`UnaryPredicate0D`\n"
" :arg pred: The predicate on a point that expresses the splitting condition.\n"
" Each time the condition is verified, the chain is split into two chains.\n"
" The resulting set of chains is a partition of the initial chain\n"
" :type pred: :class:`UnaryPredicate0D`\n"
" :arg sampling: The resolution used to sample the chain for the\n"
" predicates evaluation. (The chain is not actually resampled;\n"
" a virtual point only progresses along the curve using this\n"
" resolution.)\n"
" :type sampling: float\n");
PyDoc_STRVAR(
/* Wrap. */
Operators_sequential_split_doc,
".. staticmethod:: sequential_split(starting_pred, stopping_pred, sampling=0.0)\n"
" sequential_split(pred, sampling=0.0)\n"
"\n"
" Splits each chain of the current set of chains in a sequential way.\n"
" The points of each chain are processed (with a specified sampling)\n"
" sequentially. The first point of the initial chain is the\n"
" first point of one of the resulting chains. The splitting ends when\n"
" no more chain can start.\n"
"\n"
" .. tip::\n"
"\n"
" By specifying a starting and stopping predicate allows\n"
" the chains to overlap rather than chains partitioning.\n"
"\n"
" :arg starting_pred: The predicate on a point that expresses the\n"
" starting condition. Each time this condition is verified, a new chain begins\n"
" :type starting_pred: :class:`UnaryPredicate0D`\n"
" :arg stopping_pred: The predicate on a point that expresses the\n"
" stopping condition. The chain ends as soon as this predicate is verified.\n"
" :type stopping_pred: :class:`UnaryPredicate0D`\n"
" :arg pred: The predicate on a point that expresses the splitting condition.\n"
" Each time the condition is verified, the chain is split into two chains.\n"
" The resulting set of chains is a partition of the initial chain\n"
" :type pred: :class:`UnaryPredicate0D`\n"
" :arg sampling: The resolution used to sample the chain for the\n"
" predicates evaluation. (The chain is not actually resampled;\n"
" a virtual point only progresses along the curve using this\n"
" resolution.)\n"
" :type sampling: float\n");
static PyObject *Operators_sequential_split(BPy_Operators * /*self*/,
PyObject *args,
@ -344,6 +354,7 @@ static PyObject *Operators_sequential_split(BPy_Operators * /*self*/,
}
PyDoc_STRVAR(
/* Wrap. */
Operators_recursive_split_doc,
".. staticmethod:: recursive_split(func, pred_1d, sampling=0.0)\n"
" recursive_split(func, pred_0d, pred_1d, sampling=0.0)\n"
@ -470,14 +481,16 @@ static PyObject *Operators_recursive_split(BPy_Operators * /*self*/,
Py_RETURN_NONE;
}
PyDoc_STRVAR(Operators_sort_doc,
".. staticmethod:: sort(pred)\n"
"\n"
" Sorts the current set of chains (or viewedges) according to the\n"
" comparison predicate given as argument.\n"
"\n"
" :arg pred: The binary predicate used for the comparison.\n"
" :type pred: :class:`BinaryPredicate1D`");
PyDoc_STRVAR(
/* Wrap. */
Operators_sort_doc,
".. staticmethod:: sort(pred)\n"
"\n"
" Sorts the current set of chains (or viewedges) according to the\n"
" comparison predicate given as argument.\n"
"\n"
" :arg pred: The binary predicate used for the comparison.\n"
" :type pred: :class:`BinaryPredicate1D`");
static PyObject *Operators_sort(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
{
@ -503,17 +516,19 @@ static PyObject *Operators_sort(BPy_Operators * /*self*/, PyObject *args, PyObje
Py_RETURN_NONE;
}
PyDoc_STRVAR(Operators_create_doc,
".. staticmethod:: create(pred, shaders)\n"
"\n"
" Creates and shades the strokes from the current set of chains. A\n"
" predicate can be specified to make a selection pass on the chains.\n"
"\n"
" :arg pred: The predicate that a chain must verify in order to be\n"
" transform as a stroke.\n"
" :type pred: :class:`UnaryPredicate1D`\n"
" :arg shaders: The list of shaders used to shade the strokes.\n"
" :type shaders: list of :class:`StrokeShader` objects");
PyDoc_STRVAR(
/* Wrap. */
Operators_create_doc,
".. staticmethod:: create(pred, shaders)\n"
"\n"
" Creates and shades the strokes from the current set of chains. A\n"
" predicate can be specified to make a selection pass on the chains.\n"
"\n"
" :arg pred: The predicate that a chain must verify in order to be\n"
" transform as a stroke.\n"
" :type pred: :class:`UnaryPredicate1D`\n"
" :arg shaders: The list of shaders used to shade the strokes.\n"
" :type shaders: list of :class:`StrokeShader` objects");
static PyObject *Operators_create(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
{
@ -559,14 +574,16 @@ static PyObject *Operators_create(BPy_Operators * /*self*/, PyObject *args, PyOb
Py_RETURN_NONE;
}
PyDoc_STRVAR(Operators_reset_doc,
".. staticmethod:: reset(delete_strokes=True)\n"
"\n"
" Resets the line stylization process to the initial state. The results of\n"
" stroke creation are accumulated if **delete_strokes** is set to False.\n"
"\n"
" :arg delete_strokes: Delete the strokes that are currently stored.\n"
" :type delete_strokes: bool\n");
PyDoc_STRVAR(
/* Wrap. */
Operators_reset_doc,
".. staticmethod:: reset(delete_strokes=True)\n"
"\n"
" Resets the line stylization process to the initial state. The results of\n"
" stroke creation are accumulated if **delete_strokes** is set to False.\n"
"\n"
" :arg delete_strokes: Delete the strokes that are currently stored.\n"
" :type delete_strokes: bool\n");
static PyObject *Operators_reset(BPy_Operators * /*self*/, PyObject *args, PyObject *kwds)
{
@ -583,15 +600,17 @@ static PyObject *Operators_reset(BPy_Operators * /*self*/, PyObject *args, PyObj
Py_RETURN_NONE;
}
PyDoc_STRVAR(Operators_get_viewedge_from_index_doc,
".. staticmethod:: get_viewedge_from_index(i)\n"
"\n"
" Returns the ViewEdge at the index in the current set of ViewEdges.\n"
"\n"
" :arg i: index (0 <= i < Operators.get_view_edges_size()).\n"
" :type i: int\n"
" :return: The ViewEdge object.\n"
" :rtype: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
Operators_get_viewedge_from_index_doc,
".. staticmethod:: get_viewedge_from_index(i)\n"
"\n"
" Returns the ViewEdge at the index in the current set of ViewEdges.\n"
"\n"
" :arg i: index (0 <= i < Operators.get_view_edges_size()).\n"
" :type i: int\n"
" :return: The ViewEdge object.\n"
" :rtype: :class:`ViewEdge`");
static PyObject *Operators_get_viewedge_from_index(BPy_Operators * /*self*/,
PyObject *args,
@ -610,15 +629,17 @@ static PyObject *Operators_get_viewedge_from_index(BPy_Operators * /*self*/,
return BPy_ViewEdge_from_ViewEdge(*(Operators::getViewEdgeFromIndex(i)));
}
PyDoc_STRVAR(Operators_get_chain_from_index_doc,
".. staticmethod:: get_chain_from_index(i)\n"
"\n"
" Returns the Chain at the index in the current set of Chains.\n"
"\n"
" :arg i: index (0 <= i < Operators.get_chains_size()).\n"
" :type i: int\n"
" :return: The Chain object.\n"
" :rtype: :class:`Chain`");
PyDoc_STRVAR(
/* Wrap. */
Operators_get_chain_from_index_doc,
".. staticmethod:: get_chain_from_index(i)\n"
"\n"
" Returns the Chain at the index in the current set of Chains.\n"
"\n"
" :arg i: index (0 <= i < Operators.get_chains_size()).\n"
" :type i: int\n"
" :return: The Chain object.\n"
" :rtype: :class:`Chain`");
static PyObject *Operators_get_chain_from_index(BPy_Operators * /*self*/,
PyObject *args,
@ -637,15 +658,17 @@ static PyObject *Operators_get_chain_from_index(BPy_Operators * /*self*/,
return BPy_Chain_from_Chain(*(Operators::getChainFromIndex(i)));
}
PyDoc_STRVAR(Operators_get_stroke_from_index_doc,
".. staticmethod:: get_stroke_from_index(i)\n"
"\n"
" Returns the Stroke at the index in the current set of Strokes.\n"
"\n"
" :arg i: index (0 <= i < Operators.get_strokes_size()).\n"
" :type i: int\n"
" :return: The Stroke object.\n"
" :rtype: :class:`Stroke`");
PyDoc_STRVAR(
/* Wrap. */
Operators_get_stroke_from_index_doc,
".. staticmethod:: get_stroke_from_index(i)\n"
"\n"
" Returns the Stroke at the index in the current set of Strokes.\n"
"\n"
" :arg i: index (0 <= i < Operators.get_strokes_size()).\n"
" :type i: int\n"
" :return: The Stroke object.\n"
" :rtype: :class:`Stroke`");
static PyObject *Operators_get_stroke_from_index(BPy_Operators * /*self*/,
PyObject *args,
@ -664,39 +687,45 @@ static PyObject *Operators_get_stroke_from_index(BPy_Operators * /*self*/,
return BPy_Stroke_from_Stroke(*(Operators::getStrokeFromIndex(i)));
}
PyDoc_STRVAR(Operators_get_view_edges_size_doc,
".. staticmethod:: get_view_edges_size()\n"
"\n"
" Returns the number of ViewEdges.\n"
"\n"
" :return: The number of ViewEdges.\n"
" :rtype: int");
PyDoc_STRVAR(
/* Wrap. */
Operators_get_view_edges_size_doc,
".. staticmethod:: get_view_edges_size()\n"
"\n"
" Returns the number of ViewEdges.\n"
"\n"
" :return: The number of ViewEdges.\n"
" :rtype: int");
static PyObject *Operators_get_view_edges_size(BPy_Operators * /*self*/)
{
return PyLong_FromLong(Operators::getViewEdgesSize());
}
PyDoc_STRVAR(Operators_get_chains_size_doc,
".. staticmethod:: get_chains_size()\n"
"\n"
" Returns the number of Chains.\n"
"\n"
" :return: The number of Chains.\n"
" :rtype: int");
PyDoc_STRVAR(
/* Wrap. */
Operators_get_chains_size_doc,
".. staticmethod:: get_chains_size()\n"
"\n"
" Returns the number of Chains.\n"
"\n"
" :return: The number of Chains.\n"
" :rtype: int");
static PyObject *Operators_get_chains_size(BPy_Operators * /*self*/)
{
return PyLong_FromLong(Operators::getChainsSize());
}
PyDoc_STRVAR(Operators_get_strokes_size_doc,
".. staticmethod:: get_strokes_size()\n"
"\n"
" Returns the number of Strokes.\n"
"\n"
" :return: The number of Strokes.\n"
" :rtype: int");
PyDoc_STRVAR(
/* Wrap. */
Operators_get_strokes_size_doc,
".. staticmethod:: get_strokes_size()\n"
"\n"
" Returns the number of Strokes.\n"
"\n"
" :return: The number of Strokes.\n"
" :rtype: int");
static PyObject *Operators_get_strokes_size(BPy_Operators * /*self*/)
{

79
source/blender/freestyle/intern/python/BPy_SShape.cpp
View File

@ -43,6 +43,7 @@ int SShape_Init(PyObject *module)
/*----------------------SShape methods ----------------------------*/
PyDoc_STRVAR(
/* Wrap. */
SShape_doc,
"Class to define a feature shape. It is the gathering of feature\n"
"elements from an identified input shape.\n"
@ -106,14 +107,16 @@ static PyObject *SShape_add_edge(BPy_SShape *self, PyObject *args, PyObject *kwd
Py_RETURN_NONE;
}
PyDoc_STRVAR(SShape_add_vertex_doc,
".. method:: add_vertex(vertex)\n"
"\n"
" Adds an SVertex to the list of SVertex of this Shape. The SShape\n"
" attribute of the SVertex is also set to this SShape.\n"
"\n"
" :arg vertex: An SVertex object.\n"
" :type vertex: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
SShape_add_vertex_doc,
".. method:: add_vertex(vertex)\n"
"\n"
" Adds an SVertex to the list of SVertex of this Shape. The SShape\n"
" attribute of the SVertex is also set to this SShape.\n"
"\n"
" :arg vertex: An SVertex object.\n"
" :type vertex: :class:`SVertex`");
static PyObject *SShape_add_vertex(BPy_SShape *self, PyObject *args, PyObject *kwds)
{
@ -127,10 +130,12 @@ static PyObject *SShape_add_vertex(BPy_SShape *self, PyObject *args, PyObject *k
Py_RETURN_NONE;
}
PyDoc_STRVAR(SShape_compute_bbox_doc,
".. method:: compute_bbox()\n"
"\n"
" Compute the bbox of the SShape.");
PyDoc_STRVAR(
/* Wrap. */
SShape_compute_bbox_doc,
".. method:: compute_bbox()\n"
"\n"
" Compute the bbox of the SShape.");
static PyObject *SShape_compute_bbox(BPy_SShape *self)
{
@ -154,10 +159,12 @@ static PyMethodDef BPy_SShape_methods[] = {
/*----------------------SShape get/setters ----------------------------*/
PyDoc_STRVAR(SShape_id_doc,
"The Id of this SShape.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
SShape_id_doc,
"The Id of this SShape.\n"
"\n"
":type: :class:`Id`");
static PyObject *SShape_id_get(BPy_SShape *self, void * /*closure*/)
{
@ -175,10 +182,12 @@ static int SShape_id_set(BPy_SShape *self, PyObject *value, void * /*closure*/)
return 0;
}
PyDoc_STRVAR(SShape_name_doc,
"The name of the SShape.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
SShape_name_doc,
"The name of the SShape.\n"
"\n"
":type: str");
static PyObject *SShape_name_get(BPy_SShape *self, void * /*closure*/)
{
@ -196,10 +205,12 @@ static int SShape_name_set(BPy_SShape *self, PyObject *value, void * /*closure*/
return 0;
}
PyDoc_STRVAR(SShape_bbox_doc,
"The bounding box of the SShape.\n"
"\n"
":type: :class:`BBox`");
PyDoc_STRVAR(
/* Wrap. */
SShape_bbox_doc,
"The bounding box of the SShape.\n"
"\n"
":type: :class:`BBox`");
static PyObject *SShape_bbox_get(BPy_SShape *self, void * /*closure*/)
{
@ -217,10 +228,12 @@ static int SShape_bbox_set(BPy_SShape *self, PyObject *value, void * /*closure*/
return 0;
}
PyDoc_STRVAR(SShape_vertices_doc,
"The list of vertices constituting this SShape.\n"
"\n"
":type: List of :class:`SVertex` objects");
PyDoc_STRVAR(
/* Wrap. */
SShape_vertices_doc,
"The list of vertices constituting this SShape.\n"
"\n"
":type: List of :class:`SVertex` objects");
static PyObject *SShape_vertices_get(BPy_SShape *self, void * /*closure*/)
{
@ -237,10 +250,12 @@ static PyObject *SShape_vertices_get(BPy_SShape *self, void * /*closure*/)
return py_vertices;
}
PyDoc_STRVAR(SShape_edges_doc,
"The list of edges constituting this SShape.\n"
"\n"
":type: List of :class:`FEdge` objects");
PyDoc_STRVAR(
/* Wrap. */
SShape_edges_doc,
"The list of edges constituting this SShape.\n"
"\n"
":type: List of :class:`FEdge` objects");
static PyObject *SShape_edges_get(BPy_SShape *self, void * /*closure*/)
{

310
source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
View File

@ -37,40 +37,42 @@ int StrokeAttribute_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(StrokeAttribute_doc,
"Class to define a set of attributes associated with a :class:`StrokeVertex`.\n"
"The attribute set stores the color, alpha and thickness values for a Stroke\n"
"Vertex.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(red, green, blue, alpha, thickness_right, thickness_left)\n"
" __init__(attribute1, attribute2, t)\n"
"\n"
" Creates a :class:`StrokeAttribute` object using either a default constructor,\n"
" copy constructor, overloaded constructor, or and interpolation constructor\n"
" to interpolate between two :class:`StrokeAttribute` objects.\n"
"\n"
" :arg brother: A StrokeAttribute object to be used as a copy constructor.\n"
" :type brother: :class:`StrokeAttribute`\n"
" :arg red: Red component of a stroke color.\n"
" :type red: float\n"
" :arg green: Green component of a stroke color.\n"
" :type green: float\n"
" :arg blue: Blue component of a stroke color.\n"
" :type blue: float\n"
" :arg alpha: Alpha component of a stroke color.\n"
" :type alpha: float\n"
" :arg thickness_right: Stroke thickness on the right.\n"
" :type thickness_right: float\n"
" :arg thickness_left: Stroke thickness on the left.\n"
" :type thickness_left: float\n"
" :arg attribute1: The first StrokeAttribute object.\n"
" :type attribute1: :class:`StrokeAttribute`\n"
" :arg attribute2: The second StrokeAttribute object.\n"
" :type attribute2: :class:`StrokeAttribute`\n"
" :arg t: The interpolation parameter (0 <= t <= 1).\n"
" :type t: float\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_doc,
"Class to define a set of attributes associated with a :class:`StrokeVertex`.\n"
"The attribute set stores the color, alpha and thickness values for a Stroke\n"
"Vertex.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(red, green, blue, alpha, thickness_right, thickness_left)\n"
" __init__(attribute1, attribute2, t)\n"
"\n"
" Creates a :class:`StrokeAttribute` object using either a default constructor,\n"
" copy constructor, overloaded constructor, or and interpolation constructor\n"
" to interpolate between two :class:`StrokeAttribute` objects.\n"
"\n"
" :arg brother: A StrokeAttribute object to be used as a copy constructor.\n"
" :type brother: :class:`StrokeAttribute`\n"
" :arg red: Red component of a stroke color.\n"
" :type red: float\n"
" :arg green: Green component of a stroke color.\n"
" :type green: float\n"
" :arg blue: Blue component of a stroke color.\n"
" :type blue: float\n"
" :arg alpha: Alpha component of a stroke color.\n"
" :type alpha: float\n"
" :arg thickness_right: Stroke thickness on the right.\n"
" :type thickness_right: float\n"
" :arg thickness_left: Stroke thickness on the left.\n"
" :type thickness_left: float\n"
" :arg attribute1: The first StrokeAttribute object.\n"
" :type attribute1: :class:`StrokeAttribute`\n"
" :arg attribute2: The second StrokeAttribute object.\n"
" :type attribute2: :class:`StrokeAttribute`\n"
" :arg t: The interpolation parameter (0 <= t <= 1).\n"
" :type t: float\n");
static int StrokeAttribute_init(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
{
@ -145,15 +147,17 @@ static PyObject *StrokeAttribute_repr(BPy_StrokeAttribute *self)
return PyUnicode_FromString(repr.str().c_str());
}
PyDoc_STRVAR(StrokeAttribute_get_attribute_real_doc,
".. method:: get_attribute_real(name)\n"
"\n"
" Returns an attribute of float type.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: The attribute value.\n"
" :rtype: float\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_get_attribute_real_doc,
".. method:: get_attribute_real(name)\n"
"\n"
" Returns an attribute of float type.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: The attribute value.\n"
" :rtype: float\n");
static PyObject *StrokeAttribute_get_attribute_real(BPy_StrokeAttribute *self,
PyObject *args,
@ -169,15 +173,17 @@ static PyObject *StrokeAttribute_get_attribute_real(BPy_StrokeAttribute *self,
return PyFloat_FromDouble(a);
}
PyDoc_STRVAR(StrokeAttribute_get_attribute_vec2_doc,
".. method:: get_attribute_vec2(name)\n"
"\n"
" Returns an attribute of two-dimensional vector type.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: The attribute value.\n"
" :rtype: :class:`mathutils.Vector`\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_get_attribute_vec2_doc,
".. method:: get_attribute_vec2(name)\n"
"\n"
" Returns an attribute of two-dimensional vector type.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: The attribute value.\n"
" :rtype: :class:`mathutils.Vector`\n");
static PyObject *StrokeAttribute_get_attribute_vec2(BPy_StrokeAttribute *self,
PyObject *args,
@ -193,15 +199,17 @@ static PyObject *StrokeAttribute_get_attribute_vec2(BPy_StrokeAttribute *self,
return Vector_from_Vec2f(a);
}
PyDoc_STRVAR(StrokeAttribute_get_attribute_vec3_doc,
".. method:: get_attribute_vec3(name)\n"
"\n"
" Returns an attribute of three-dimensional vector type.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: The attribute value.\n"
" :rtype: :class:`mathutils.Vector`\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_get_attribute_vec3_doc,
".. method:: get_attribute_vec3(name)\n"
"\n"
" Returns an attribute of three-dimensional vector type.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: The attribute value.\n"
" :rtype: :class:`mathutils.Vector`\n");
static PyObject *StrokeAttribute_get_attribute_vec3(BPy_StrokeAttribute *self,
PyObject *args,
@ -217,15 +225,17 @@ static PyObject *StrokeAttribute_get_attribute_vec3(BPy_StrokeAttribute *self,
return Vector_from_Vec3f(a);
}
PyDoc_STRVAR(StrokeAttribute_has_attribute_real_doc,
".. method:: has_attribute_real(name)\n"
"\n"
" Checks whether the attribute name of float type is available.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: True if the attribute is available.\n"
" :rtype: bool\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_has_attribute_real_doc,
".. method:: has_attribute_real(name)\n"
"\n"
" Checks whether the attribute name of float type is available.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: True if the attribute is available.\n"
" :rtype: bool\n");
static PyObject *StrokeAttribute_has_attribute_real(BPy_StrokeAttribute *self,
PyObject *args,
@ -240,16 +250,18 @@ static PyObject *StrokeAttribute_has_attribute_real(BPy_StrokeAttribute *self,
return PyBool_from_bool(self->sa->isAttributeAvailableReal(attr));
}
PyDoc_STRVAR(StrokeAttribute_has_attribute_vec2_doc,
".. method:: has_attribute_vec2(name)\n"
"\n"
" Checks whether the attribute name of two-dimensional vector type\n"
" is available.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: True if the attribute is available.\n"
" :rtype: bool\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_has_attribute_vec2_doc,
".. method:: has_attribute_vec2(name)\n"
"\n"
" Checks whether the attribute name of two-dimensional vector type\n"
" is available.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: True if the attribute is available.\n"
" :rtype: bool\n");
static PyObject *StrokeAttribute_has_attribute_vec2(BPy_StrokeAttribute *self,
PyObject *args,
@ -264,16 +276,18 @@ static PyObject *StrokeAttribute_has_attribute_vec2(BPy_StrokeAttribute *self,
return PyBool_from_bool(self->sa->isAttributeAvailableVec2f(attr));
}
PyDoc_STRVAR(StrokeAttribute_has_attribute_vec3_doc,
".. method:: has_attribute_vec3(name)\n"
"\n"
" Checks whether the attribute name of three-dimensional vector\n"
" type is available.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: True if the attribute is available.\n"
" :rtype: bool\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_has_attribute_vec3_doc,
".. method:: has_attribute_vec3(name)\n"
"\n"
" Checks whether the attribute name of three-dimensional vector\n"
" type is available.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :return: True if the attribute is available.\n"
" :rtype: bool\n");
static PyObject *StrokeAttribute_has_attribute_vec3(BPy_StrokeAttribute *self,
PyObject *args,
@ -288,17 +302,19 @@ static PyObject *StrokeAttribute_has_attribute_vec3(BPy_StrokeAttribute *self,
return PyBool_from_bool(self->sa->isAttributeAvailableVec3f(attr));
}
PyDoc_STRVAR(StrokeAttribute_set_attribute_real_doc,
".. method:: set_attribute_real(name, value)\n"
"\n"
" Adds a user-defined attribute of float type. If there is no\n"
" attribute of the given name, it is added. Otherwise, the new value\n"
" replaces the old one.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :arg value: The attribute value.\n"
" :type value: float\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_set_attribute_real_doc,
".. method:: set_attribute_real(name, value)\n"
"\n"
" Adds a user-defined attribute of float type. If there is no\n"
" attribute of the given name, it is added. Otherwise, the new value\n"
" replaces the old one.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :arg value: The attribute value.\n"
" :type value: float\n");
static PyObject *StrokeAttribute_set_attribute_real(BPy_StrokeAttribute *self,
PyObject *args,
@ -315,17 +331,19 @@ static PyObject *StrokeAttribute_set_attribute_real(BPy_StrokeAttribute *self,
Py_RETURN_NONE;
}
PyDoc_STRVAR(StrokeAttribute_set_attribute_vec2_doc,
".. method:: set_attribute_vec2(name, value)\n"
"\n"
" Adds a user-defined attribute of two-dimensional vector type. If\n"
" there is no attribute of the given name, it is added. Otherwise,\n"
" the new value replaces the old one.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :arg value: The attribute value.\n"
" :type value: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_set_attribute_vec2_doc,
".. method:: set_attribute_vec2(name, value)\n"
"\n"
" Adds a user-defined attribute of two-dimensional vector type. If\n"
" there is no attribute of the given name, it is added. Otherwise,\n"
" the new value replaces the old one.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :arg value: The attribute value.\n"
" :type value: :class:`mathutils.Vector`, list or tuple of 2 real numbers\n");
static PyObject *StrokeAttribute_set_attribute_vec2(BPy_StrokeAttribute *self,
PyObject *args,
@ -348,17 +366,19 @@ static PyObject *StrokeAttribute_set_attribute_vec2(BPy_StrokeAttribute *self,
Py_RETURN_NONE;
}
PyDoc_STRVAR(StrokeAttribute_set_attribute_vec3_doc,
".. method:: set_attribute_vec3(name, value)\n"
"\n"
" Adds a user-defined attribute of three-dimensional vector type.\n"
" If there is no attribute of the given name, it is added.\n"
" Otherwise, the new value replaces the old one.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :arg value: The attribute value.\n"
" :type value: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_set_attribute_vec3_doc,
".. method:: set_attribute_vec3(name, value)\n"
"\n"
" Adds a user-defined attribute of three-dimensional vector type.\n"
" If there is no attribute of the given name, it is added.\n"
" Otherwise, the new value replaces the old one.\n"
"\n"
" :arg name: The name of the attribute.\n"
" :type name: str\n"
" :arg value: The attribute value.\n"
" :type value: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n");
static PyObject *StrokeAttribute_set_attribute_vec3(BPy_StrokeAttribute *self,
PyObject *args,
@ -547,10 +567,12 @@ void StrokeAttribute_mathutils_register_callback()
/*----------------------StrokeAttribute get/setters ----------------------------*/
PyDoc_STRVAR(StrokeAttribute_alpha_doc,
"Alpha component of the stroke color.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_alpha_doc,
"Alpha component of the stroke color.\n"
"\n"
":type: float");
static PyObject *StrokeAttribute_alpha_get(BPy_StrokeAttribute *self, void * /*closure*/)
{
@ -571,10 +593,12 @@ static int StrokeAttribute_alpha_set(BPy_StrokeAttribute *self,
return 0;
}
PyDoc_STRVAR(StrokeAttribute_color_doc,
"RGB components of the stroke color.\n"
"\n"
":type: :class:`mathutils.Color`");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_color_doc,
"RGB components of the stroke color.\n"
"\n"
":type: :class:`mathutils.Color`");
static PyObject *StrokeAttribute_color_get(BPy_StrokeAttribute *self, void * /*closure*/)
{
@ -594,12 +618,14 @@ static int StrokeAttribute_color_set(BPy_StrokeAttribute *self,
return 0;
}
PyDoc_STRVAR(StrokeAttribute_thickness_doc,
"Right and left components of the stroke thickness.\n"
"The right (left) component is the thickness on the right (left) of the vertex\n"
"when following the stroke.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_thickness_doc,
"Right and left components of the stroke thickness.\n"
"The right (left) component is the thickness on the right (left) of the vertex\n"
"when following the stroke.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *StrokeAttribute_thickness_get(BPy_StrokeAttribute *self, void * /*closure*/)
{
@ -619,10 +645,12 @@ static int StrokeAttribute_thickness_set(BPy_StrokeAttribute *self,
return 0;
}
PyDoc_STRVAR(StrokeAttribute_visible_doc,
"The visibility flag. True if the StrokeVertex is visible.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
StrokeAttribute_visible_doc,
"The visibility flag. True if the StrokeVertex is visible.\n"
"\n"
":type: bool");
static PyObject *StrokeAttribute_visible_get(BPy_StrokeAttribute *self, void * /*closure*/)
{

22
source/blender/freestyle/intern/python/BPy_StrokeShader.cpp
View File

@ -167,7 +167,9 @@ int StrokeShader_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char StrokeShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
StrokeShader___doc__,
"Base class for stroke shaders. Any stroke shader must inherit from\n"
"this class and overload the shade() method. A StrokeShader is\n"
"designed to modify stroke attributes such as thickness, color,\n"
@ -184,7 +186,7 @@ static char StrokeShader___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int StrokeShader___init__(BPy_StrokeShader *self, PyObject *args, PyObject *kwds)
{
@ -209,13 +211,15 @@ static PyObject *StrokeShader___repr__(BPy_StrokeShader *self)
return PyUnicode_FromFormat("type: %s - address: %p", Py_TYPE(self)->tp_name, self->ss);
}
static char StrokeShader_shade___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
StrokeShader_shade___doc__,
".. method:: shade(stroke)\n"
"\n"
" The shading method. Must be overloaded by inherited classes.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`Stroke`\n";
" :type stroke: :class:`Stroke`\n");
static PyObject *StrokeShader_shade(BPy_StrokeShader *self, PyObject *args, PyObject *kwds)
{
@ -250,10 +254,12 @@ static PyMethodDef BPy_StrokeShader_methods[] = {
/*----------------------StrokeShader get/setters ----------------------------*/
PyDoc_STRVAR(StrokeShader_name_doc,
"The name of the stroke shader.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
StrokeShader_name_doc,
"The name of the stroke shader.\n"
"\n"
":type: str");
static PyObject *StrokeShader_name_get(BPy_StrokeShader *self, void * /*closure*/)
{

16
source/blender/freestyle/intern/python/BPy_UnaryFunction0D.cpp
View File

@ -56,7 +56,9 @@ int UnaryFunction0D_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0D___doc__,
"Base class for Unary Functions (functors) working on\n"
":class:`Interface0DIterator`. A unary function will be used by\n"
"invoking __call__() on an Interface0DIterator. In Python, several\n"
@ -74,7 +76,7 @@ static char UnaryFunction0D___doc__[] =
"* :class:`UnaryFunction0DVec2f`\n"
"* :class:`UnaryFunction0DVec3f`\n"
"* :class:`UnaryFunction0DVectorViewShape`\n"
"* :class:`UnaryFunction0DViewShape`\n";
"* :class:`UnaryFunction0DViewShape`\n");
static void UnaryFunction0D___dealloc__(BPy_UnaryFunction0D *self)
{
@ -88,10 +90,12 @@ static PyObject *UnaryFunction0D___repr__(BPy_UnaryFunction0D * /*self*/)
/*----------------------UnaryFunction0D get/setters ----------------------------*/
PyDoc_STRVAR(UnaryFunction0D_name_doc,
"The name of the unary 0D function.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0D_name_doc,
"The name of the unary 0D function.\n"
"\n"
":type: str");
static PyObject *UnaryFunction0D_name_get(BPy_UnaryFunction0D *self, void * /*closure*/)
{

16
source/blender/freestyle/intern/python/BPy_UnaryFunction1D.cpp
View File

@ -52,7 +52,9 @@ int UnaryFunction1D_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction1D___doc__,
"Base class for Unary Functions (functors) working on\n"
":class:`Interface1D`. A unary function will be used by invoking\n"
"__call__() on an Interface1D. In Python, several different subclasses\n"
@ -68,7 +70,7 @@ static char UnaryFunction1D___doc__[] =
"* :class:`UnaryFunction1DVec2f`\n"
"* :class:`UnaryFunction1DVec3f`\n"
"* :class:`UnaryFunction1DVectorViewShape`\n"
"* :class:`UnaryFunction1DVoid`\n";
"* :class:`UnaryFunction1DVoid`\n");
static void UnaryFunction1D___dealloc__(BPy_UnaryFunction1D *self)
{
@ -82,10 +84,12 @@ static PyObject *UnaryFunction1D___repr__(BPy_UnaryFunction1D * /*self*/)
/*----------------------UnaryFunction1D get/setters ----------------------------*/
PyDoc_STRVAR(UnaryFunction1D_name_doc,
"The name of the unary 1D function.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction1D_name_doc,
"The name of the unary 1D function.\n"
"\n"
":type: str");
static PyObject *UnaryFunction1D_name_get(BPy_UnaryFunction1D *self, void * /*closure*/)
{

16
source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp
View File

@ -51,7 +51,9 @@ int UnaryPredicate0D_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryPredicate0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryPredicate0D___doc__,
"Base class for unary predicates that work on\n"
":class:`Interface0DIterator`. A UnaryPredicate0D is a functor that\n"
"evaluates a condition on an Interface0DIterator and returns true or\n"
@ -71,7 +73,7 @@ static char UnaryPredicate0D___doc__[] =
" which we wish to evaluate the predicate.\n"
" :type it: :class:`Interface0DIterator`\n"
" :return: True if the condition is satisfied, false otherwise.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int UnaryPredicate0D___init__(BPy_UnaryPredicate0D *self, PyObject *args, PyObject *kwds)
{
@ -132,10 +134,12 @@ static PyObject *UnaryPredicate0D___call__(BPy_UnaryPredicate0D *self,
/*----------------------UnaryPredicate0D get/setters ----------------------------*/
PyDoc_STRVAR(UnaryPredicate0D_name_doc,
"The name of the unary 0D predicate.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
UnaryPredicate0D_name_doc,
"The name of the unary 0D predicate.\n"
"\n"
":type: str");
static PyObject *UnaryPredicate0D_name_get(BPy_UnaryPredicate0D *self, void * /*closure*/)
{

16
source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp
View File

@ -110,7 +110,9 @@ int UnaryPredicate1D_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryPredicate1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryPredicate1D___doc__,
"Base class for unary predicates that work on :class:`Interface1D`. A\n"
"UnaryPredicate1D is a functor that evaluates a condition on a\n"
"Interface1D and returns true or false depending on whether this\n"
@ -129,7 +131,7 @@ static char UnaryPredicate1D___doc__[] =
" :arg inter: The Interface1D on which we wish to evaluate the predicate.\n"
" :type inter: :class:`Interface1D`\n"
" :return: True if the condition is satisfied, false otherwise.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int UnaryPredicate1D___init__(BPy_UnaryPredicate1D *self, PyObject *args, PyObject *kwds)
{
@ -189,10 +191,12 @@ static PyObject *UnaryPredicate1D___call__(BPy_UnaryPredicate1D *self,
/*----------------------UnaryPredicate1D get/setters ----------------------------*/
PyDoc_STRVAR(UnaryPredicate1D_name_doc,
"The name of the unary 1D predicate.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
UnaryPredicate1D_name_doc,
"The name of the unary 1D predicate.\n"
"\n"
":type: str");
static PyObject *UnaryPredicate1D_name_get(BPy_UnaryPredicate1D *self, void * /*closure*/)
{

72
source/blender/freestyle/intern/python/BPy_ViewMap.cpp
View File

@ -39,12 +39,14 @@ int ViewMap_Init(PyObject *module)
/*----------------------ViewMap methods----------------------------*/
PyDoc_STRVAR(ViewMap_doc,
"Class defining the ViewMap.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
PyDoc_STRVAR(
/* Wrap. */
ViewMap_doc,
"Class defining the ViewMap.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
static int ViewMap_init(BPy_ViewMap *self, PyObject *args, PyObject *kwds)
{
@ -68,17 +70,19 @@ static PyObject *ViewMap_repr(BPy_ViewMap *self)
return PyUnicode_FromFormat("ViewMap - address: %p", self->vm);
}
PyDoc_STRVAR(ViewMap_get_closest_viewedge_doc,
".. method:: get_closest_viewedge(x, y)\n"
"\n"
" Gets the ViewEdge nearest to the 2D point specified as arguments.\n"
"\n"
" :arg x: X coordinate of a 2D point.\n"
" :type x: float\n"
" :arg y: Y coordinate of a 2D point.\n"
" :type y: float\n"
" :return: The ViewEdge nearest to the specified 2D point.\n"
" :rtype: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
ViewMap_get_closest_viewedge_doc,
".. method:: get_closest_viewedge(x, y)\n"
"\n"
" Gets the ViewEdge nearest to the 2D point specified as arguments.\n"
"\n"
" :arg x: X coordinate of a 2D point.\n"
" :type x: float\n"
" :arg y: Y coordinate of a 2D point.\n"
" :type y: float\n"
" :return: The ViewEdge nearest to the specified 2D point.\n"
" :rtype: :class:`ViewEdge`");
static PyObject *ViewMap_get_closest_viewedge(BPy_ViewMap *self, PyObject *args, PyObject *kwds)
{
@ -95,17 +99,19 @@ static PyObject *ViewMap_get_closest_viewedge(BPy_ViewMap *self, PyObject *args,
Py_RETURN_NONE;
}
PyDoc_STRVAR(ViewMap_get_closest_fedge_doc,
".. method:: get_closest_fedge(x, y)\n"
"\n"
" Gets the FEdge nearest to the 2D point specified as arguments.\n"
"\n"
" :arg x: X coordinate of a 2D point.\n"
" :type x: float\n"
" :arg y: Y coordinate of a 2D point.\n"
" :type y: float\n"
" :return: The FEdge nearest to the specified 2D point.\n"
" :rtype: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
ViewMap_get_closest_fedge_doc,
".. method:: get_closest_fedge(x, y)\n"
"\n"
" Gets the FEdge nearest to the 2D point specified as arguments.\n"
"\n"
" :arg x: X coordinate of a 2D point.\n"
" :type x: float\n"
" :arg y: Y coordinate of a 2D point.\n"
" :type y: float\n"
" :return: The FEdge nearest to the specified 2D point.\n"
" :rtype: :class:`FEdge`");
static PyObject *ViewMap_get_closest_fedge(BPy_ViewMap *self, PyObject *args, PyObject *kwds)
{
@ -138,10 +144,12 @@ static PyMethodDef BPy_ViewMap_methods[] = {
/*----------------------ViewMap get/setters ----------------------------*/
PyDoc_STRVAR(ViewMap_scene_bbox_doc,
"The 3D bounding box of the scene.\n"
"\n"
":type: :class:`BBox`");
PyDoc_STRVAR(
/* Wrap. */
ViewMap_scene_bbox_doc,
"The 3D bounding box of the scene.\n"
"\n"
":type: :class:`BBox`");
static PyObject *ViewMap_scene_bbox_get(BPy_ViewMap *self, void * /*closure*/)
{

124
source/blender/freestyle/intern/python/BPy_ViewShape.cpp
View File

@ -42,21 +42,23 @@ int ViewShape_Init(PyObject *module)
/*----------------------ViewShape methods ----------------------------*/
PyDoc_STRVAR(ViewShape_doc,
"Class gathering the elements of the ViewMap (i.e., :class:`ViewVertex`\n"
"and :class:`ViewEdge`) that are issued from the same input shape.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(sshape)\n"
"\n"
" Builds a :class:`ViewShape` using the default constructor,\n"
" copy constructor, or from a :class:`SShape`.\n"
"\n"
" :arg brother: A ViewShape object.\n"
" :type brother: :class:`ViewShape`\n"
" :arg sshape: An SShape object.\n"
" :type sshape: :class:`SShape`");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_doc,
"Class gathering the elements of the ViewMap (i.e., :class:`ViewVertex`\n"
"and :class:`ViewEdge`) that are issued from the same input shape.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(sshape)\n"
"\n"
" Builds a :class:`ViewShape` using the default constructor,\n"
" copy constructor, or from a :class:`SShape`.\n"
"\n"
" :arg brother: A ViewShape object.\n"
" :type brother: :class:`ViewShape`\n"
" :arg sshape: An SShape object.\n"
" :type sshape: :class:`SShape`");
static int ViewShape_init(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
{
@ -107,13 +109,15 @@ static PyObject *ViewShape_repr(BPy_ViewShape *self)
return PyUnicode_FromFormat("ViewShape - address: %p", self->vs);
}
PyDoc_STRVAR(ViewShape_add_edge_doc,
".. method:: add_edge(edge)\n"
"\n"
" Adds a ViewEdge to the list of ViewEdge objects.\n"
"\n"
" :arg edge: A ViewEdge object.\n"
" :type edge: :class:`ViewEdge`\n");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_add_edge_doc,
".. method:: add_edge(edge)\n"
"\n"
" Adds a ViewEdge to the list of ViewEdge objects.\n"
"\n"
" :arg edge: A ViewEdge object.\n"
" :type edge: :class:`ViewEdge`\n");
static PyObject *ViewShape_add_edge(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
{
@ -127,13 +131,15 @@ static PyObject *ViewShape_add_edge(BPy_ViewShape *self, PyObject *args, PyObjec
Py_RETURN_NONE;
}
PyDoc_STRVAR(ViewShape_add_vertex_doc,
".. method:: add_vertex(vertex)\n"
"\n"
" Adds a ViewVertex to the list of the ViewVertex objects.\n"
"\n"
" :arg vertex: A ViewVertex object.\n"
" :type vertex: :class:`ViewVertex`");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_add_vertex_doc,
".. method:: add_vertex(vertex)\n"
"\n"
" Adds a ViewVertex to the list of the ViewVertex objects.\n"
"\n"
" :arg vertex: A ViewVertex object.\n"
" :type vertex: :class:`ViewVertex`");
static PyObject *ViewShape_add_vertex(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
{
@ -163,10 +169,12 @@ static PyMethodDef BPy_ViewShape_methods[] = {
/*----------------------ViewShape get/setters ----------------------------*/
PyDoc_STRVAR(ViewShape_sshape_doc,
"The SShape on top of which this ViewShape is built.\n"
"\n"
":type: :class:`SShape`");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_sshape_doc,
"The SShape on top of which this ViewShape is built.\n"
"\n"
":type: :class:`SShape`");
static PyObject *ViewShape_sshape_get(BPy_ViewShape *self, void * /*closure*/)
{
@ -195,10 +203,12 @@ static int ViewShape_sshape_set(BPy_ViewShape *self, PyObject *value, void * /*c
return 0;
}
PyDoc_STRVAR(ViewShape_vertices_doc,
"The list of ViewVertex objects contained in this ViewShape.\n"
"\n"
":type: List of :class:`ViewVertex` objects");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_vertices_doc,
"The list of ViewVertex objects contained in this ViewShape.\n"
"\n"
":type: List of :class:`ViewVertex` objects");
static PyObject *ViewShape_vertices_get(BPy_ViewShape *self, void * /*closure*/)
{
@ -238,10 +248,12 @@ static int ViewShape_vertices_set(BPy_ViewShape *self, PyObject *value, void * /
return 0;
}
PyDoc_STRVAR(ViewShape_edges_doc,
"The list of ViewEdge objects contained in this ViewShape.\n"
"\n"
":type: List of :class:`ViewEdge` objects");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_edges_doc,
"The list of ViewEdge objects contained in this ViewShape.\n"
"\n"
":type: List of :class:`ViewEdge` objects");
static PyObject *ViewShape_edges_get(BPy_ViewShape *self, void * /*closure*/)
{
@ -281,30 +293,36 @@ static int ViewShape_edges_set(BPy_ViewShape *self, PyObject *value, void * /*cl
return 0;
}
PyDoc_STRVAR(ViewShape_name_doc,
"The name of the ViewShape.\n"
"\n"
":type: str");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_name_doc,
"The name of the ViewShape.\n"
"\n"
":type: str");
static PyObject *ViewShape_name_get(BPy_ViewShape *self, void * /*closure*/)
{
return PyUnicode_FromString(self->vs->getName().c_str());
}
PyDoc_STRVAR(ViewShape_library_path_doc,
"The library path of the ViewShape.\n"
"\n"
":type: str, or None if the ViewShape is not part of a library");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_library_path_doc,
"The library path of the ViewShape.\n"
"\n"
":type: str, or None if the ViewShape is not part of a library");
static PyObject *ViewShape_library_path_get(BPy_ViewShape *self, void * /*closure*/)
{
return PyUnicode_FromString(self->vs->getLibraryPath().c_str());
}
PyDoc_STRVAR(ViewShape_id_doc,
"The Id of this ViewShape.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
ViewShape_id_doc,
"The Id of this ViewShape.\n"
"\n"
":type: :class:`Id`");
static PyObject *ViewShape_id_get(BPy_ViewShape *self, void * /*closure*/)
{

6
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_FalseBP1D.cpp
View File

@ -18,7 +18,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char FalseBP1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
FalseBP1D___doc__,
"Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > :class:`FalseBP1D`\n"
"\n"
".. method:: __call__(inter1, inter2)\n"
@ -30,7 +32,7 @@ static char FalseBP1D___doc__[] =
" :arg inter2: The second Interface1D object.\n"
" :type inter2: :class:`freestyle.types.Interface1D`\n"
" :return: False.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int FalseBP1D___init__(BPy_FalseBP1D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_Length2DBP1D.cpp
View File

@ -18,7 +18,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char Length2DBP1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
Length2DBP1D___doc__,
"Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > :class:`Length2DBP1D`\n"
"\n"
".. method:: __call__(inter1, inter2)\n"
@ -31,7 +33,7 @@ static char Length2DBP1D___doc__[] =
" :arg inter2: The second Interface1D object.\n"
" :type inter2: :class:`freestyle.types.Interface1D`\n"
" :return: True or false.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int Length2DBP1D___init__(BPy_Length2DBP1D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_SameShapeIdBP1D.cpp
View File

@ -18,7 +18,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char SameShapeIdBP1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
SameShapeIdBP1D___doc__,
"Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > :class:`SameShapeIdBP1D`\n"
"\n"
".. method:: __call__(inter1, inter2)\n"
@ -30,7 +32,7 @@ static char SameShapeIdBP1D___doc__[] =
" :arg inter2: The second Interface1D object.\n"
" :type inter2: :class:`freestyle.types.Interface1D`\n"
" :return: True or false.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int SameShapeIdBP1D___init__(BPy_SameShapeIdBP1D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_TrueBP1D.cpp
View File

@ -18,7 +18,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char TrueBP1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
TrueBP1D___doc__,
"Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > :class:`TrueBP1D`\n"
"\n"
".. method:: __call__(inter1, inter2)\n"
@ -30,7 +32,7 @@ static char TrueBP1D___doc__[] =
" :arg inter2: The second Interface1D object.\n"
" :type inter2: :class:`freestyle.types.Interface1D`\n"
" :return: True.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int TrueBP1D___init__(BPy_TrueBP1D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_ViewMapGradientNormBP1D.cpp
View File

@ -23,7 +23,9 @@ using namespace Freestyle;
// ViewMapGradientNormBP1D(int level, IntegrationType iType=MEAN, float sampling=2.0)
static char ViewMapGradientNormBP1D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ViewMapGradientNormBP1D___doc__,
"Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > "
":class:`ViewMapGradientNormBP1D`\n"
"\n"
@ -53,7 +55,7 @@ static char ViewMapGradientNormBP1D___doc__[] =
" :arg inter2: The second Interface1D object.\n"
" :type inter2: :class:`freestyle.types.Interface1D`\n"
" :return: True or false.\n"
" :rtype: bool\n";
" :rtype: bool\n");
static int ViewMapGradientNormBP1D___init__(BPy_ViewMapGradientNormBP1D *self,
PyObject *args,

114
source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp
View File

@ -21,41 +21,43 @@ using namespace Freestyle;
/*----------------------CurvePoint methods----------------------------*/
PyDoc_STRVAR(CurvePoint_doc,
"Class hierarchy: :class:`Interface0D` > :class:`CurvePoint`\n"
"\n"
"Class to represent a point of a curve. A CurvePoint can be any point\n"
"of a 1D curve (it doesn't have to be a vertex of the curve). Any\n"
":class:`Interface1D` is built upon ViewEdges, themselves built upon\n"
"FEdges. Therefore, a curve is basically a polyline made of a list of\n"
":class:`SVertex` objects. Thus, a CurvePoint is built by linearly\n"
"interpolating two :class:`SVertex` instances. CurvePoint can be used\n"
"as virtual points while querying 0D information along a curve at a\n"
"given resolution.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex, t2d)\n"
" __init__(first_point, second_point, t2d)\n"
"\n"
" Builds a CurvePoint using the default constructor, copy constructor,\n"
" or one of the overloaded constructors. The over loaded constructors\n"
" can either take two :class:`SVertex` or two :class:`CurvePoint`\n"
" objects and an interpolation parameter\n"
"\n"
" :arg brother: A CurvePoint object.\n"
" :type brother: :class:`CurvePoint`\n"
" :arg first_vertex: The first SVertex.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex.\n"
" :type second_vertex: :class:`SVertex`\n"
" :arg first_point: The first CurvePoint.\n"
" :type first_point: :class:`CurvePoint`\n"
" :arg second_point: The second CurvePoint.\n"
" :type second_point: :class:`CurvePoint`\n"
" :arg t2d: A 2D interpolation parameter used to linearly interpolate\n"
" first_vertex and second_vertex or first_point and second_point.\n"
" :type t2d: float\n");
PyDoc_STRVAR(
/* Wrap. */
CurvePoint_doc,
"Class hierarchy: :class:`Interface0D` > :class:`CurvePoint`\n"
"\n"
"Class to represent a point of a curve. A CurvePoint can be any point\n"
"of a 1D curve (it doesn't have to be a vertex of the curve). Any\n"
":class:`Interface1D` is built upon ViewEdges, themselves built upon\n"
"FEdges. Therefore, a curve is basically a polyline made of a list of\n"
":class:`SVertex` objects. Thus, a CurvePoint is built by linearly\n"
"interpolating two :class:`SVertex` instances. CurvePoint can be used\n"
"as virtual points while querying 0D information along a curve at a\n"
"given resolution.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex, t2d)\n"
" __init__(first_point, second_point, t2d)\n"
"\n"
" Builds a CurvePoint using the default constructor, copy constructor,\n"
" or one of the overloaded constructors. The over loaded constructors\n"
" can either take two :class:`SVertex` or two :class:`CurvePoint`\n"
" objects and an interpolation parameter\n"
"\n"
" :arg brother: A CurvePoint object.\n"
" :type brother: :class:`CurvePoint`\n"
" :arg first_vertex: The first SVertex.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex.\n"
" :type second_vertex: :class:`SVertex`\n"
" :arg first_point: The first CurvePoint.\n"
" :type first_point: :class:`CurvePoint`\n"
" :arg second_point: The second CurvePoint.\n"
" :type second_point: :class:`CurvePoint`\n"
" :arg t2d: A 2D interpolation parameter used to linearly interpolate\n"
" first_vertex and second_vertex or first_point and second_point.\n"
" :type t2d: float\n");
static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds)
{
@ -122,10 +124,12 @@ static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds)
/*----------------------CurvePoint get/setters ----------------------------*/
PyDoc_STRVAR(CurvePoint_first_svertex_doc,
"The first SVertex upon which the CurvePoint is built.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
CurvePoint_first_svertex_doc,
"The first SVertex upon which the CurvePoint is built.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *CurvePoint_first_svertex_get(BPy_CurvePoint *self, void * /*closure*/)
{
@ -146,10 +150,12 @@ static int CurvePoint_first_svertex_set(BPy_CurvePoint *self, PyObject *value, v
return 0;
}
PyDoc_STRVAR(CurvePoint_second_svertex_doc,
"The second SVertex upon which the CurvePoint is built.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
CurvePoint_second_svertex_doc,
"The second SVertex upon which the CurvePoint is built.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *CurvePoint_second_svertex_get(BPy_CurvePoint *self, void * /*closure*/)
{
@ -170,11 +176,13 @@ static int CurvePoint_second_svertex_set(BPy_CurvePoint *self, PyObject *value,
return 0;
}
PyDoc_STRVAR(CurvePoint_fedge_doc,
"Gets the FEdge for the two SVertices that given CurvePoints consists out of.\n"
"A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).\n"
"\n"
":type: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
CurvePoint_fedge_doc,
"Gets the FEdge for the two SVertices that given CurvePoints consists out of.\n"
"A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).\n"
"\n"
":type: :class:`FEdge`");
static PyObject *CurvePoint_fedge_get(BPy_CurvePoint *self, void * /*closure*/)
{
@ -187,10 +195,12 @@ static PyObject *CurvePoint_fedge_get(BPy_CurvePoint *self, void * /*closure*/)
Py_RETURN_NONE;
}
PyDoc_STRVAR(CurvePoint_t2d_doc,
"The 2D interpolation parameter.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
CurvePoint_t2d_doc,
"The 2D interpolation parameter.\n"
"\n"
":type: float");
static PyObject *CurvePoint_t2d_get(BPy_CurvePoint *self, void * /*closure*/)
{

166
source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp
View File

@ -24,25 +24,27 @@ using namespace Freestyle;
/*----------------------SVertex methods ----------------------------*/
PyDoc_STRVAR(SVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`SVertex`\n"
"\n"
"Class to define a vertex of the embedding.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(point_3d, id)\n"
"\n"
" Builds a :class:`SVertex` using the default constructor,\n"
" copy constructor or the overloaded constructor which builds"
" a :class:`SVertex` from 3D coordinates and an Id.\n"
"\n"
" :arg brother: A SVertex object.\n"
" :type brother: :class:`SVertex`\n"
" :arg point_3d: A three-dimensional vector.\n"
" :type point_3d: :class:`mathutils.Vector`\n"
" :arg id: An Id object.\n"
" :type id: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
SVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`SVertex`\n"
"\n"
"Class to define a vertex of the embedding.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(point_3d, id)\n"
"\n"
" Builds a :class:`SVertex` using the default constructor,\n"
" copy constructor or the overloaded constructor which builds"
" a :class:`SVertex` from 3D coordinates and an Id.\n"
"\n"
" :arg brother: A SVertex object.\n"
" :type brother: :class:`SVertex`\n"
" :arg point_3d: A three-dimensional vector.\n"
" :type point_3d: :class:`mathutils.Vector`\n"
" :arg id: An Id object.\n"
" :type id: :class:`Id`");
static int SVertex_init(BPy_SVertex *self, PyObject *args, PyObject *kwds)
{
@ -75,14 +77,16 @@ static int SVertex_init(BPy_SVertex *self, PyObject *args, PyObject *kwds)
return 0;
}
PyDoc_STRVAR(SVertex_add_normal_doc,
".. method:: add_normal(normal)\n"
"\n"
" Adds a normal to the SVertex's set of normals. If the same normal\n"
" is already in the set, nothing changes.\n"
"\n"
" :arg normal: A three-dimensional vector.\n"
" :type normal: :class:`mathutils.Vector`, list or tuple of 3 real numbers");
PyDoc_STRVAR(
/* Wrap. */
SVertex_add_normal_doc,
".. method:: add_normal(normal)\n"
"\n"
" Adds a normal to the SVertex's set of normals. If the same normal\n"
" is already in the set, nothing changes.\n"
"\n"
" :arg normal: A three-dimensional vector.\n"
" :type normal: :class:`mathutils.Vector`, list or tuple of 3 real numbers");
static PyObject *SVertex_add_normal(BPy_SVertex *self, PyObject *args, PyObject *kwds)
{
@ -102,13 +106,15 @@ static PyObject *SVertex_add_normal(BPy_SVertex *self, PyObject *args, PyObject
Py_RETURN_NONE;
}
PyDoc_STRVAR(SVertex_add_fedge_doc,
".. method:: add_fedge(fedge)\n"
"\n"
" Add an FEdge to the list of edges emanating from this SVertex.\n"
"\n"
" :arg fedge: An FEdge.\n"
" :type fedge: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
SVertex_add_fedge_doc,
".. method:: add_fedge(fedge)\n"
"\n"
" Add an FEdge to the list of edges emanating from this SVertex.\n"
"\n"
" :arg fedge: An FEdge.\n"
" :type fedge: :class:`FEdge`");
static PyObject *SVertex_add_fedge(BPy_SVertex *self, PyObject *args, PyObject *kwds)
{
@ -269,10 +275,12 @@ void SVertex_mathutils_register_callback()
/*----------------------SVertex get/setters ----------------------------*/
PyDoc_STRVAR(SVertex_point_3d_doc,
"The 3D coordinates of the SVertex.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
SVertex_point_3d_doc,
"The 3D coordinates of the SVertex.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *SVertex_point_3d_get(BPy_SVertex *self, void * /*closure*/)
{
@ -291,10 +299,12 @@ static int SVertex_point_3d_set(BPy_SVertex *self, PyObject *value, void * /*clo
return 0;
}
PyDoc_STRVAR(SVertex_point_2d_doc,
"The projected 3D coordinates of the SVertex.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
SVertex_point_2d_doc,
"The projected 3D coordinates of the SVertex.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *SVertex_point_2d_get(BPy_SVertex *self, void * /*closure*/)
{
@ -313,10 +323,12 @@ static int SVertex_point_2d_set(BPy_SVertex *self, PyObject *value, void * /*clo
return 0;
}
PyDoc_STRVAR(SVertex_id_doc,
"The Id of this SVertex.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
SVertex_id_doc,
"The Id of this SVertex.\n"
"\n"
":type: :class:`Id`");
static PyObject *SVertex_id_get(BPy_SVertex *self, void * /*closure*/)
{
@ -334,12 +346,14 @@ static int SVertex_id_set(BPy_SVertex *self, PyObject *value, void * /*closure*/
return 0;
}
PyDoc_STRVAR(SVertex_normals_doc,
"The normals for this Vertex as a list. In a sharp surface, an SVertex\n"
"has exactly one normal. In a smooth surface, an SVertex can have any\n"
"number of normals.\n"
"\n"
":type: list of :class:`mathutils.Vector` objects");
PyDoc_STRVAR(
/* Wrap. */
SVertex_normals_doc,
"The normals for this Vertex as a list. In a sharp surface, an SVertex\n"
"has exactly one normal. In a smooth surface, an SVertex can have any\n"
"number of normals.\n"
"\n"
":type: list of :class:`mathutils.Vector` objects");
static PyObject *SVertex_normals_get(BPy_SVertex *self, void * /*closure*/)
{
@ -356,21 +370,25 @@ static PyObject *SVertex_normals_get(BPy_SVertex *self, void * /*closure*/)
return py_normals;
}
PyDoc_STRVAR(SVertex_normals_size_doc,
"The number of different normals for this SVertex.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
SVertex_normals_size_doc,
"The number of different normals for this SVertex.\n"
"\n"
":type: int");
static PyObject *SVertex_normals_size_get(BPy_SVertex *self, void * /*closure*/)
{
return PyLong_FromLong(self->sv->normalsSize());
}
PyDoc_STRVAR(SVertex_viewvertex_doc,
"If this SVertex is also a ViewVertex, this property refers to the\n"
"ViewVertex, and None otherwise.\n"
"\n"
":type: :class:`ViewVertex`");
PyDoc_STRVAR(
/* Wrap. */
SVertex_viewvertex_doc,
"If this SVertex is also a ViewVertex, this property refers to the\n"
"ViewVertex, and None otherwise.\n"
"\n"
":type: :class:`ViewVertex`");
static PyObject *SVertex_viewvertex_get(BPy_SVertex *self, void * /*closure*/)
{
@ -381,18 +399,20 @@ static PyObject *SVertex_viewvertex_get(BPy_SVertex *self, void * /*closure*/)
Py_RETURN_NONE;
}
PyDoc_STRVAR(SVertex_curvatures_doc,
"Curvature information expressed in the form of a seven-element tuple\n"
"(K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n"
"representing the first (maximum) and second (minimum) principal\n"
"curvatures at this SVertex, respectively; e1 and e2 are\n"
"three-dimensional vectors representing the first and second principal\n"
"directions, i.e. the directions of the normal plane where the\n"
"curvature takes its maximum and minimum values, respectively; and Kr,\n"
"er and dKr are the radial curvature, radial direction, and the\n"
"derivative of the radial curvature at this SVertex, respectively.\n"
"\n"
":type: tuple");
PyDoc_STRVAR(
/* Wrap. */
SVertex_curvatures_doc,
"Curvature information expressed in the form of a seven-element tuple\n"
"(K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n"
"representing the first (maximum) and second (minimum) principal\n"
"curvatures at this SVertex, respectively; e1 and e2 are\n"
"three-dimensional vectors representing the first and second principal\n"
"directions, i.e. the directions of the normal plane where the\n"
"curvature takes its maximum and minimum values, respectively; and Kr,\n"
"er and dKr are the radial curvature, radial direction, and the\n"
"derivative of the radial curvature at this SVertex, respectively.\n"
"\n"
":type: tuple");
static PyObject *SVertex_curvatures_get(BPy_SVertex *self, void * /*closure*/)
{

100
source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp
View File

@ -22,18 +22,20 @@ using namespace Freestyle;
/*----------------------ViewVertex methods----------------------------*/
PyDoc_STRVAR(ViewVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex`\n"
"\n"
"Class to define a view vertex. A view vertex is a feature vertex\n"
"corresponding to a point of the image graph, where the characteristics\n"
"of an edge (e.g., nature and visibility) might change. A\n"
":class:`ViewVertex` can be of two kinds: A :class:`TVertex` when it\n"
"corresponds to the intersection between two ViewEdges or a\n"
":class:`NonTVertex` when it corresponds to a vertex of the initial\n"
"input mesh (it is the case for vertices such as corners for example).\n"
"Thus, this class can be specialized into two classes, the\n"
":class:`TVertex` class and the :class:`NonTVertex` class.");
PyDoc_STRVAR(
/* Wrap. */
ViewVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex`\n"
"\n"
"Class to define a view vertex. A view vertex is a feature vertex\n"
"corresponding to a point of the image graph, where the characteristics\n"
"of an edge (e.g., nature and visibility) might change. A\n"
":class:`ViewVertex` can be of two kinds: A :class:`TVertex` when it\n"
"corresponds to the intersection between two ViewEdges or a\n"
":class:`NonTVertex` when it corresponds to a vertex of the initial\n"
"input mesh (it is the case for vertices such as corners for example).\n"
"Thus, this class can be specialized into two classes, the\n"
":class:`TVertex` class and the :class:`NonTVertex` class.");
static int ViewVertex_init(BPy_ViewVertex * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
{
@ -41,17 +43,19 @@ static int ViewVertex_init(BPy_ViewVertex * /*self*/, PyObject * /*args*/, PyObj
return -1;
}
PyDoc_STRVAR(ViewVertex_edges_begin_doc,
".. method:: edges_begin()\n"
"\n"
" Returns an iterator over the ViewEdges that goes to or comes from\n"
" this ViewVertex pointing to the first ViewEdge of the list. The\n"
" orientedViewEdgeIterator allows to iterate in CCW order over these\n"
" ViewEdges and to get the orientation for each ViewEdge\n"
" (incoming/outgoing).\n"
"\n"
" :return: An orientedViewEdgeIterator pointing to the first ViewEdge.\n"
" :rtype: :class:`orientedViewEdgeIterator`");
PyDoc_STRVAR(
/* Wrap. */
ViewVertex_edges_begin_doc,
".. method:: edges_begin()\n"
"\n"
" Returns an iterator over the ViewEdges that goes to or comes from\n"
" this ViewVertex pointing to the first ViewEdge of the list. The\n"
" orientedViewEdgeIterator allows to iterate in CCW order over these\n"
" ViewEdges and to get the orientation for each ViewEdge\n"
" (incoming/outgoing).\n"
"\n"
" :return: An orientedViewEdgeIterator pointing to the first ViewEdge.\n"
" :rtype: :class:`orientedViewEdgeIterator`");
static PyObject *ViewVertex_edges_begin(BPy_ViewVertex *self)
{
@ -59,14 +63,16 @@ static PyObject *ViewVertex_edges_begin(BPy_ViewVertex *self)
return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, false);
}
PyDoc_STRVAR(ViewVertex_edges_end_doc,
".. method:: edges_end()\n"
"\n"
" Returns an orientedViewEdgeIterator over the ViewEdges around this\n"
" ViewVertex, pointing after the last ViewEdge.\n"
"\n"
" :return: An orientedViewEdgeIterator pointing after the last ViewEdge.\n"
" :rtype: :class:`orientedViewEdgeIterator`");
PyDoc_STRVAR(
/* Wrap. */
ViewVertex_edges_end_doc,
".. method:: edges_end()\n"
"\n"
" Returns an orientedViewEdgeIterator over the ViewEdges around this\n"
" ViewVertex, pointing after the last ViewEdge.\n"
"\n"
" :return: An orientedViewEdgeIterator pointing after the last ViewEdge.\n"
" :rtype: :class:`orientedViewEdgeIterator`");
static PyObject *ViewVertex_edges_end(BPy_ViewVertex * /*self*/)
{
@ -79,16 +85,18 @@ static PyObject *ViewVertex_edges_end(BPy_ViewVertex * /*self*/)
#endif
}
PyDoc_STRVAR(ViewVertex_edges_iterator_doc,
".. method:: edges_iterator(edge)\n"
"\n"
" Returns an orientedViewEdgeIterator pointing to the ViewEdge given\n"
" as argument.\n"
"\n"
" :arg edge: A ViewEdge object.\n"
" :type edge: :class:`ViewEdge`\n"
" :return: An orientedViewEdgeIterator pointing to the given ViewEdge.\n"
" :rtype: :class:`orientedViewEdgeIterator`");
PyDoc_STRVAR(
/* Wrap. */
ViewVertex_edges_iterator_doc,
".. method:: edges_iterator(edge)\n"
"\n"
" Returns an orientedViewEdgeIterator pointing to the ViewEdge given\n"
" as argument.\n"
"\n"
" :arg edge: A ViewEdge object.\n"
" :type edge: :class:`ViewEdge`\n"
" :return: An orientedViewEdgeIterator pointing to the given ViewEdge.\n"
" :rtype: :class:`orientedViewEdgeIterator`");
static PyObject *ViewVertex_edges_iterator(BPy_ViewVertex *self, PyObject *args, PyObject *kwds)
{
@ -115,10 +123,12 @@ static PyMethodDef BPy_ViewVertex_methods[] = {
/*----------------------ViewVertex get/setters ----------------------------*/
PyDoc_STRVAR(ViewVertex_nature_doc,
"The nature of this ViewVertex.\n"
"\n"
":type: :class:`Nature`");
PyDoc_STRVAR(
/* Wrap. */
ViewVertex_nature_doc,
"The nature of this ViewVertex.\n"
"\n"
":type: :class:`Nature`");
static PyObject *ViewVertex_nature_get(BPy_ViewVertex *self, void * /*closure*/)
{

53
source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp
View File

@ -24,6 +24,7 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(
/* Wrap. */
StrokeVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`CurvePoint` > :class:`StrokeVertex`\n"
"\n"
@ -220,10 +221,12 @@ void StrokeVertex_mathutils_register_callback()
/*----------------------StrokeVertex get/setters ----------------------------*/
PyDoc_STRVAR(StrokeVertex_attribute_doc,
"StrokeAttribute for this StrokeVertex.\n"
"\n"
":type: :class:`StrokeAttribute`");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertex_attribute_doc,
"StrokeAttribute for this StrokeVertex.\n"
"\n"
":type: :class:`StrokeAttribute`");
static PyObject *StrokeVertex_attribute_get(BPy_StrokeVertex *self, void * /*closure*/)
{
@ -240,10 +243,12 @@ static int StrokeVertex_attribute_set(BPy_StrokeVertex *self, PyObject *value, v
return 0;
}
PyDoc_STRVAR(StrokeVertex_curvilinear_abscissa_doc,
"Curvilinear abscissa of this StrokeVertex in the Stroke.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertex_curvilinear_abscissa_doc,
"Curvilinear abscissa of this StrokeVertex in the Stroke.\n"
"\n"
":type: float");
static PyObject *StrokeVertex_curvilinear_abscissa_get(BPy_StrokeVertex *self, void * /*closure*/)
{
@ -264,10 +269,12 @@ static int StrokeVertex_curvilinear_abscissa_set(BPy_StrokeVertex *self,
return 0;
}
PyDoc_STRVAR(StrokeVertex_point_doc,
"2D point coordinates.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertex_point_doc,
"2D point coordinates.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *StrokeVertex_point_get(BPy_StrokeVertex *self, void * /*closure*/)
{
@ -285,11 +292,13 @@ static int StrokeVertex_point_set(BPy_StrokeVertex *self, PyObject *value, void
return 0;
}
PyDoc_STRVAR(StrokeVertex_stroke_length_doc,
"Stroke length (it is only a value retained by the StrokeVertex,\n"
"and it won't change the real stroke length).\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertex_stroke_length_doc,
"Stroke length (it is only a value retained by the StrokeVertex,\n"
"and it won't change the real stroke length).\n"
"\n"
":type: float");
static PyObject *StrokeVertex_stroke_length_get(BPy_StrokeVertex *self, void * /*closure*/)
{
@ -310,10 +319,12 @@ static int StrokeVertex_stroke_length_set(BPy_StrokeVertex *self,
return 0;
}
PyDoc_STRVAR(StrokeVertex_u_doc,
"Curvilinear abscissa of this StrokeVertex in the Stroke.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertex_u_doc,
"Curvilinear abscissa of this StrokeVertex in the Stroke.\n"
"\n"
":type: float");
static PyObject *StrokeVertex_u_get(BPy_StrokeVertex *self, void * /*closure*/)
{

11
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp
View File

@ -22,6 +22,7 @@ using namespace Freestyle;
/*----------------------NonTVertex methods ----------------------------*/
PyDoc_STRVAR(
/* Wrap. */
NonTVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`NonTVertex`\n"
"\n"
@ -60,10 +61,12 @@ static int NonTVertex_init(BPy_NonTVertex *self, PyObject *args, PyObject *kwds)
/*----------------------NonTVertex get/setters ----------------------------*/
PyDoc_STRVAR(NonTVertex_svertex_doc,
"The SVertex on top of which this NonTVertex is built.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
NonTVertex_svertex_doc,
"The SVertex on top of which this NonTVertex is built.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *NonTVertex_svertex_get(BPy_NonTVertex *self, void * /*closure*/)
{

100
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
View File

@ -24,18 +24,20 @@ using namespace Freestyle;
/*----------------------TVertex methods ----------------------------*/
PyDoc_STRVAR(TVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`TVertex`\n"
"\n"
"Class to define a T vertex, i.e. an intersection between two edges.\n"
"It points towards two SVertex and four ViewEdges. Among the\n"
"ViewEdges, two are front and the other two are back. Basically a\n"
"front edge hides part of a back edge. So, among the back edges, one\n"
"is of invisibility N and the other of invisibility N+1.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
PyDoc_STRVAR(
/* Wrap. */
TVertex_doc,
"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`TVertex`\n"
"\n"
"Class to define a T vertex, i.e. an intersection between two edges.\n"
"It points towards two SVertex and four ViewEdges. Among the\n"
"ViewEdges, two are front and the other two are back. Basically a\n"
"front edge hides part of a back edge. So, among the back edges, one\n"
"is of invisibility N and the other of invisibility N+1.\n"
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.");
/* NOTE: No copy constructor in Python because the C++ copy constructor is 'protected'. */
@ -53,15 +55,17 @@ static int TVertex_init(BPy_TVertex *self, PyObject *args, PyObject *kwds)
return 0;
}
PyDoc_STRVAR(TVertex_get_svertex_doc,
".. method:: get_svertex(fedge)\n"
"\n"
" Returns the SVertex (among the 2) belonging to the given FEdge.\n"
"\n"
" :arg fedge: An FEdge object.\n"
" :type fedge: :class:`FEdge`\n"
" :return: The SVertex belonging to the given FEdge.\n"
" :rtype: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
TVertex_get_svertex_doc,
".. method:: get_svertex(fedge)\n"
"\n"
" Returns the SVertex (among the 2) belonging to the given FEdge.\n"
"\n"
" :arg fedge: An FEdge object.\n"
" :type fedge: :class:`FEdge`\n"
" :return: The SVertex belonging to the given FEdge.\n"
" :rtype: :class:`SVertex`");
static PyObject *TVertex_get_svertex(BPy_TVertex *self, PyObject *args, PyObject *kwds)
{
@ -78,17 +82,19 @@ static PyObject *TVertex_get_svertex(BPy_TVertex *self, PyObject *args, PyObject
Py_RETURN_NONE;
}
PyDoc_STRVAR(TVertex_get_mate_doc,
".. method:: get_mate(viewedge)\n"
"\n"
" Returns the mate edge of the ViewEdge given as argument. If the\n"
" ViewEdge is frontEdgeA, frontEdgeB is returned. If the ViewEdge is\n"
" frontEdgeB, frontEdgeA is returned. Same for back edges.\n"
"\n"
" :arg viewedge: A ViewEdge object.\n"
" :type viewedge: :class:`ViewEdge`\n"
" :return: The mate edge of the given ViewEdge.\n"
" :rtype: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
TVertex_get_mate_doc,
".. method:: get_mate(viewedge)\n"
"\n"
" Returns the mate edge of the ViewEdge given as argument. If the\n"
" ViewEdge is frontEdgeA, frontEdgeB is returned. If the ViewEdge is\n"
" frontEdgeB, frontEdgeA is returned. Same for back edges.\n"
"\n"
" :arg viewedge: A ViewEdge object.\n"
" :type viewedge: :class:`ViewEdge`\n"
" :return: The mate edge of the given ViewEdge.\n"
" :rtype: :class:`ViewEdge`");
static PyObject *TVertex_get_mate(BPy_TVertex *self, PyObject *args, PyObject *kwds)
{
@ -119,10 +125,12 @@ static PyMethodDef BPy_TVertex_methods[] = {
/*----------------------TVertex get/setters ----------------------------*/
PyDoc_STRVAR(TVertex_front_svertex_doc,
"The SVertex that is closer to the viewpoint.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
TVertex_front_svertex_doc,
"The SVertex that is closer to the viewpoint.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *TVertex_front_svertex_get(BPy_TVertex *self, void * /*closure*/)
{
@ -143,10 +151,12 @@ static int TVertex_front_svertex_set(BPy_TVertex *self, PyObject *value, void *
return 0;
}
PyDoc_STRVAR(TVertex_back_svertex_doc,
"The SVertex that is further away from the viewpoint.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
TVertex_back_svertex_doc,
"The SVertex that is further away from the viewpoint.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *TVertex_back_svertex_get(BPy_TVertex *self, void * /*closure*/)
{
@ -167,10 +177,12 @@ static int TVertex_back_svertex_set(BPy_TVertex *self, PyObject *value, void * /
return 0;
}
PyDoc_STRVAR(TVertex_id_doc,
"The Id of this TVertex.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
TVertex_id_doc,
"The Id of this TVertex.\n"
"\n"
":type: :class:`Id`");
static PyObject *TVertex_id_get(BPy_TVertex *self, void * /*closure*/)
{

136
source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp
View File

@ -24,31 +24,33 @@ using namespace Freestyle;
/*----------------------FEdge methods ----------------------------*/
PyDoc_STRVAR(FEdge_doc,
"Class hierarchy: :class:`Interface1D` > :class:`FEdge`\n"
"\n"
"Base Class for feature edges. This FEdge can represent a silhouette,\n"
"a crease, a ridge/valley, a border or a suggestive contour. For\n"
"silhouettes, the FEdge is oriented so that the visible face lies on\n"
"the left of the edge. For borders, the FEdge is oriented so that the\n"
"face lies on the left of the edge. An FEdge can represent an initial\n"
"edge of the mesh or runs across a face of the initial mesh depending\n"
"on the smoothness or sharpness of the mesh. This class is specialized\n"
"into a smooth and a sharp version since their properties slightly vary\n"
"from one to the other.\n"
"\n"
".. method:: FEdge()\n"
" FEdge(brother)\n"
"\n"
" Builds an :class:`FEdge` using the default constructor,\n"
" copy constructor, or between two :class:`SVertex` objects.\n"
"\n"
" :arg brother: An FEdge object.\n"
" :type brother: :class:`FEdge`\n"
" :arg first_vertex: The first SVertex.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex.\n"
" :type second_vertex: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_doc,
"Class hierarchy: :class:`Interface1D` > :class:`FEdge`\n"
"\n"
"Base Class for feature edges. This FEdge can represent a silhouette,\n"
"a crease, a ridge/valley, a border or a suggestive contour. For\n"
"silhouettes, the FEdge is oriented so that the visible face lies on\n"
"the left of the edge. For borders, the FEdge is oriented so that the\n"
"face lies on the left of the edge. An FEdge can represent an initial\n"
"edge of the mesh or runs across a face of the initial mesh depending\n"
"on the smoothness or sharpness of the mesh. This class is specialized\n"
"into a smooth and a sharp version since their properties slightly vary\n"
"from one to the other.\n"
"\n"
".. method:: FEdge()\n"
" FEdge(brother)\n"
"\n"
" Builds an :class:`FEdge` using the default constructor,\n"
" copy constructor, or between two :class:`SVertex` objects.\n"
"\n"
" :arg brother: An FEdge object.\n"
" :type brother: :class:`FEdge`\n"
" :arg first_vertex: The first SVertex.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex.\n"
" :type second_vertex: :class:`SVertex`");
static int FEdge_init(BPy_FEdge *self, PyObject *args, PyObject *kwds)
{
@ -117,10 +119,12 @@ static PySequenceMethods BPy_FEdge_as_sequence = {
/*----------------------FEdge get/setters ----------------------------*/
PyDoc_STRVAR(FEdge_first_svertex_doc,
"The first SVertex constituting this FEdge.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_first_svertex_doc,
"The first SVertex constituting this FEdge.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *FEdge_first_svertex_get(BPy_FEdge *self, void * /*closure*/)
{
@ -141,10 +145,12 @@ static int FEdge_first_svertex_set(BPy_FEdge *self, PyObject *value, void * /*cl
return 0;
}
PyDoc_STRVAR(FEdge_second_svertex_doc,
"The second SVertex constituting this FEdge.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_second_svertex_doc,
"The second SVertex constituting this FEdge.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *FEdge_second_svertex_get(BPy_FEdge *self, void * /*closure*/)
{
@ -165,11 +171,13 @@ static int FEdge_second_svertex_set(BPy_FEdge *self, PyObject *value, void * /*c
return 0;
}
PyDoc_STRVAR(FEdge_next_fedge_doc,
"The FEdge following this one in the ViewEdge. The value is None if\n"
"this FEdge is the last of the ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_next_fedge_doc,
"The FEdge following this one in the ViewEdge. The value is None if\n"
"this FEdge is the last of the ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
static PyObject *FEdge_next_fedge_get(BPy_FEdge *self, void * /*closure*/)
{
@ -190,11 +198,13 @@ static int FEdge_next_fedge_set(BPy_FEdge *self, PyObject *value, void * /*closu
return 0;
}
PyDoc_STRVAR(FEdge_previous_fedge_doc,
"The FEdge preceding this one in the ViewEdge. The value is None if\n"
"this FEdge is the first one of the ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_previous_fedge_doc,
"The FEdge preceding this one in the ViewEdge. The value is None if\n"
"this FEdge is the first one of the ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
static PyObject *FEdge_previous_fedge_get(BPy_FEdge *self, void * /*closure*/)
{
@ -215,10 +225,12 @@ static int FEdge_previous_fedge_set(BPy_FEdge *self, PyObject *value, void * /*c
return 0;
}
PyDoc_STRVAR(FEdge_viewedge_doc,
"The ViewEdge to which this FEdge belongs to.\n"
"\n"
":type: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_viewedge_doc,
"The ViewEdge to which this FEdge belongs to.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *FEdge_viewedge_get(BPy_FEdge *self, void * /*closure*/)
{
@ -239,10 +251,12 @@ static int FEdge_viewedge_set(BPy_FEdge *self, PyObject *value, void * /*closure
return 0;
}
PyDoc_STRVAR(FEdge_is_smooth_doc,
"True if this FEdge is a smooth FEdge.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
FEdge_is_smooth_doc,
"True if this FEdge is a smooth FEdge.\n"
"\n"
":type: bool");
static PyObject *FEdge_is_smooth_get(BPy_FEdge *self, void * /*closure*/)
{
@ -259,10 +273,12 @@ static int FEdge_is_smooth_set(BPy_FEdge *self, PyObject *value, void * /*closur
return 0;
}
PyDoc_STRVAR(FEdge_id_doc,
"The Id of this FEdge.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_id_doc,
"The Id of this FEdge.\n"
"\n"
":type: :class:`Id`");
static PyObject *FEdge_id_get(BPy_FEdge *self, void * /*closure*/)
{
@ -280,10 +296,12 @@ static int FEdge_id_set(BPy_FEdge *self, PyObject *value, void * /*closure*/)
return 0;
}
PyDoc_STRVAR(FEdge_nature_doc,
"The nature of this FEdge.\n"
"\n"
":type: :class:`Nature`");
PyDoc_STRVAR(
/* Wrap. */
FEdge_nature_doc,
"The nature of this FEdge.\n"
"\n"
":type: :class:`Nature`");
static PyObject *FEdge_nature_get(BPy_FEdge *self, void * /*closure*/)
{

90
source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp
View File

@ -23,24 +23,26 @@ using namespace Freestyle;
/*----------------------CurvePoint methods ----------------------------*/
PyDoc_STRVAR(FrsCurve_doc,
"Class hierarchy: :class:`Interface1D` > :class:`Curve`\n"
"\n"
"Base class for curves made of CurvePoints. :class:`SVertex` is the\n"
"type of the initial curve vertices. A :class:`Chain` is a\n"
"specialization of a Curve.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(id)\n"
"\n"
" Builds a :class:`FrsCurve` using a default constructor,\n"
" copy constructor or from an :class:`Id`.\n"
"\n"
" :arg brother: A Curve object.\n"
" :type brother: :class:`Curve`\n"
" :arg id: An Id object.\n"
" :type id: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
FrsCurve_doc,
"Class hierarchy: :class:`Interface1D` > :class:`Curve`\n"
"\n"
"Base class for curves made of CurvePoints. :class:`SVertex` is the\n"
"type of the initial curve vertices. A :class:`Chain` is a\n"
"specialization of a Curve.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(id)\n"
"\n"
" Builds a :class:`FrsCurve` using a default constructor,\n"
" copy constructor or from an :class:`Id`.\n"
"\n"
" :arg brother: A Curve object.\n"
" :type brother: :class:`Curve`\n"
" :arg id: An Id object.\n"
" :type id: :class:`Id`");
static int FrsCurve_init(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
{
@ -70,13 +72,15 @@ static int FrsCurve_init(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
return 0;
}
PyDoc_STRVAR(FrsCurve_push_vertex_back_doc,
".. method:: push_vertex_back(vertex)\n"
"\n"
" Adds a single vertex at the end of the Curve.\n"
"\n"
" :arg vertex: A vertex object.\n"
" :type vertex: :class:`SVertex` or :class:`CurvePoint`");
PyDoc_STRVAR(
/* Wrap. */
FrsCurve_push_vertex_back_doc,
".. method:: push_vertex_back(vertex)\n"
"\n"
" Adds a single vertex at the end of the Curve.\n"
"\n"
" :arg vertex: A vertex object.\n"
" :type vertex: :class:`SVertex` or :class:`CurvePoint`");
static PyObject *FrsCurve_push_vertex_back(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
{
@ -100,13 +104,15 @@ static PyObject *FrsCurve_push_vertex_back(BPy_FrsCurve *self, PyObject *args, P
Py_RETURN_NONE;
}
PyDoc_STRVAR(FrsCurve_push_vertex_front_doc,
".. method:: push_vertex_front(vertex)\n"
"\n"
" Adds a single vertex at the front of the Curve.\n"
"\n"
" :arg vertex: A vertex object.\n"
" :type vertex: :class:`SVertex` or :class:`CurvePoint`");
PyDoc_STRVAR(
/* Wrap. */
FrsCurve_push_vertex_front_doc,
".. method:: push_vertex_front(vertex)\n"
"\n"
" Adds a single vertex at the front of the Curve.\n"
"\n"
" :arg vertex: A vertex object.\n"
" :type vertex: :class:`SVertex` or :class:`CurvePoint`");
static PyObject *FrsCurve_push_vertex_front(BPy_FrsCurve *self, PyObject *args, PyObject *kwds)
{
@ -144,20 +150,24 @@ static PyMethodDef BPy_FrsCurve_methods[] = {
/*----------------------CurvePoint get/setters ----------------------------*/
PyDoc_STRVAR(FrsCurve_is_empty_doc,
"True if the Curve doesn't have any Vertex yet.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
FrsCurve_is_empty_doc,
"True if the Curve doesn't have any Vertex yet.\n"
"\n"
":type: bool");
static PyObject *FrsCurve_is_empty_get(BPy_FrsCurve *self, void * /*closure*/)
{
return PyBool_from_bool(self->c->empty());
}
PyDoc_STRVAR(FrsCurve_segments_size_doc,
"The number of segments in the polyline constituting the Curve.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
FrsCurve_segments_size_doc,
"The number of segments in the polyline constituting the Curve.\n"
"\n"
":type: int");
static PyObject *FrsCurve_segments_size_get(BPy_FrsCurve *self, void * /*closure*/)
{

280
source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp
View File

@ -33,18 +33,20 @@ using namespace Freestyle;
// pb: - need to be able to switch representation: InputVertexIterator <=> position
// - is it even used ? not even in SWIG version
PyDoc_STRVAR(Stroke_doc,
"Class hierarchy: :class:`Interface1D` > :class:`Stroke`\n"
"\n"
"Class to define a stroke. A stroke is made of a set of 2D vertices\n"
"(:class:`StrokeVertex`), regularly spaced out. This set of vertices\n"
"defines the stroke's backbone geometry. Each of these stroke vertices\n"
"defines the stroke's shape and appearance at this vertex position.\n"
"\n"
".. method:: Stroke()\n"
" Stroke(brother)\n"
"\n"
" Creates a :class:`Stroke` using the default constructor or copy constructor\n");
PyDoc_STRVAR(
/* Wrap. */
Stroke_doc,
"Class hierarchy: :class:`Interface1D` > :class:`Stroke`\n"
"\n"
"Class to define a stroke. A stroke is made of a set of 2D vertices\n"
"(:class:`StrokeVertex`), regularly spaced out. This set of vertices\n"
"defines the stroke's backbone geometry. Each of these stroke vertices\n"
"defines the stroke's shape and appearance at this vertex position.\n"
"\n"
".. method:: Stroke()\n"
" Stroke(brother)\n"
"\n"
" Creates a :class:`Stroke` using the default constructor or copy constructor\n");
static int Stroke_init(BPy_Stroke *self, PyObject *args, PyObject *kwds)
{
@ -88,20 +90,22 @@ static PyObject *Stroke_sq_item(BPy_Stroke *self, Py_ssize_t keynum)
return BPy_StrokeVertex_from_StrokeVertex(self->s->strokeVerticeAt(keynum));
}
PyDoc_STRVAR(Stroke_compute_sampling_doc,
".. method:: compute_sampling(n)\n"
"\n"
" Compute the sampling needed to get N vertices. If the\n"
" specified number of vertices is less than the actual number of\n"
" vertices, the actual sampling value is returned. (To remove Vertices,\n"
" use the RemoveVertex() method of this class.)\n"
"\n"
" :arg n: The number of stroke vertices we eventually want\n"
" in our Stroke.\n"
" :type n: int\n"
" :return: The sampling that must be used in the Resample(float)\n"
" method.\n"
" :rtype: float");
PyDoc_STRVAR(
/* Wrap. */
Stroke_compute_sampling_doc,
".. method:: compute_sampling(n)\n"
"\n"
" Compute the sampling needed to get N vertices. If the\n"
" specified number of vertices is less than the actual number of\n"
" vertices, the actual sampling value is returned. (To remove Vertices,\n"
" use the RemoveVertex() method of this class.)\n"
"\n"
" :arg n: The number of stroke vertices we eventually want\n"
" in our Stroke.\n"
" :type n: int\n"
" :return: The sampling that must be used in the Resample(float)\n"
" method.\n"
" :rtype: float");
static PyObject *Stroke_compute_sampling(BPy_Stroke *self, PyObject *args, PyObject *kwds)
{
@ -114,21 +118,23 @@ static PyObject *Stroke_compute_sampling(BPy_Stroke *self, PyObject *args, PyObj
return PyFloat_FromDouble(self->s->ComputeSampling(i));
}
PyDoc_STRVAR(Stroke_resample_doc,
".. method:: resample(n)\n"
" resample(sampling)\n"
"\n"
" Resamples the stroke so using one of two methods with the goal\n"
" of creating a stroke with fewer points and the same shape.\n"
"\n"
" :arg n: Resamples the stroke so that it eventually has N points. That means\n"
" it is going to add N-vertices_size, where vertices_size is the\n"
" number of points we already have. If vertices_size >= N, no\n"
" resampling is done.\n"
" :type n: int\n"
" :arg sampling: Resamples the stroke with a given sampling value. If the\n"
" sampling is smaller than the actual sampling value, no resampling is done.\n"
" :type sampling: float");
PyDoc_STRVAR(
/* Wrap. */
Stroke_resample_doc,
".. method:: resample(n)\n"
" resample(sampling)\n"
"\n"
" Resamples the stroke so using one of two methods with the goal\n"
" of creating a stroke with fewer points and the same shape.\n"
"\n"
" :arg n: Resamples the stroke so that it eventually has N points. That means\n"
" it is going to add N-vertices_size, where vertices_size is the\n"
" number of points we already have. If vertices_size >= N, no\n"
" resampling is done.\n"
" :type n: int\n"
" :arg sampling: Resamples the stroke with a given sampling value. If the\n"
" sampling is smaller than the actual sampling value, no resampling is done.\n"
" :type sampling: float");
static PyObject *Stroke_resample(BPy_Stroke *self, PyObject *args, PyObject *kwds)
{
@ -158,18 +164,20 @@ static PyObject *Stroke_resample(BPy_Stroke *self, PyObject *args, PyObject *kwd
Py_RETURN_NONE;
}
PyDoc_STRVAR(Stroke_insert_vertex_doc,
".. method:: insert_vertex(vertex, next)\n"
"\n"
" Inserts the StrokeVertex given as argument into the Stroke before the\n"
" point specified by next. The length and curvilinear abscissa are\n"
" updated consequently.\n"
"\n"
" :arg vertex: The StrokeVertex to insert in the Stroke.\n"
" :type vertex: :class:`StrokeVertex`\n"
" :arg next: A StrokeVertexIterator pointing to the StrokeVertex\n"
" before which vertex must be inserted.\n"
" :type next: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
Stroke_insert_vertex_doc,
".. method:: insert_vertex(vertex, next)\n"
"\n"
" Inserts the StrokeVertex given as argument into the Stroke before the\n"
" point specified by next. The length and curvilinear abscissa are\n"
" updated consequently.\n"
"\n"
" :arg vertex: The StrokeVertex to insert in the Stroke.\n"
" :type vertex: :class:`StrokeVertex`\n"
" :arg next: A StrokeVertexIterator pointing to the StrokeVertex\n"
" before which vertex must be inserted.\n"
" :type next: :class:`StrokeVertexIterator`");
static PyObject *Stroke_insert_vertex(BPy_Stroke *self, PyObject *args, PyObject *kwds)
{
@ -197,14 +205,16 @@ static PyObject *Stroke_insert_vertex(BPy_Stroke *self, PyObject *args, PyObject
Py_RETURN_NONE;
}
PyDoc_STRVAR(Stroke_remove_vertex_doc,
".. method:: remove_vertex(vertex)\n"
"\n"
" Removes the StrokeVertex given as argument from the Stroke. The length\n"
" and curvilinear abscissa are updated consequently.\n"
"\n"
" :arg vertex: the StrokeVertex to remove from the Stroke.\n"
" :type vertex: :class:`StrokeVertex`");
PyDoc_STRVAR(
/* Wrap. */
Stroke_remove_vertex_doc,
".. method:: remove_vertex(vertex)\n"
"\n"
" Removes the StrokeVertex given as argument from the Stroke. The length\n"
" and curvilinear abscissa are updated consequently.\n"
"\n"
" :arg vertex: the StrokeVertex to remove from the Stroke.\n"
" :type vertex: :class:`StrokeVertex`");
static PyObject *Stroke_remove_vertex(BPy_Stroke *self, PyObject *args, PyObject *kwds)
{
@ -225,10 +235,12 @@ static PyObject *Stroke_remove_vertex(BPy_Stroke *self, PyObject *args, PyObject
Py_RETURN_NONE;
}
PyDoc_STRVAR(Stroke_remove_all_vertices_doc,
".. method:: remove_all_vertices()\n"
"\n"
" Removes all vertices from the Stroke.");
PyDoc_STRVAR(
/* Wrap. */
Stroke_remove_all_vertices_doc,
".. method:: remove_all_vertices()\n"
"\n"
" Removes all vertices from the Stroke.");
static PyObject *Stroke_remove_all_vertices(BPy_Stroke *self)
{
@ -236,10 +248,12 @@ static PyObject *Stroke_remove_all_vertices(BPy_Stroke *self)
Py_RETURN_NONE;
}
PyDoc_STRVAR(Stroke_update_length_doc,
".. method:: update_length()\n"
"\n"
" Updates the 2D length of the Stroke.");
PyDoc_STRVAR(
/* Wrap. */
Stroke_update_length_doc,
".. method:: update_length()\n"
"\n"
" Updates the 2D length of the Stroke.");
static PyObject *Stroke_update_length(BPy_Stroke *self)
{
@ -247,18 +261,20 @@ static PyObject *Stroke_update_length(BPy_Stroke *self)
Py_RETURN_NONE;
}
PyDoc_STRVAR(Stroke_stroke_vertices_begin_doc,
".. method:: stroke_vertices_begin(t=0.0)\n"
"\n"
" Returns a StrokeVertexIterator pointing on the first StrokeVertex of\n"
" the Stroke. One can specify a sampling value to re-sample the Stroke\n"
" on the fly if needed.\n"
"\n"
" :arg t: The resampling value with which we want our Stroke to be\n"
" resampled. If 0 is specified, no resampling is done.\n"
" :type t: float\n"
" :return: A StrokeVertexIterator pointing on the first StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
Stroke_stroke_vertices_begin_doc,
".. method:: stroke_vertices_begin(t=0.0)\n"
"\n"
" Returns a StrokeVertexIterator pointing on the first StrokeVertex of\n"
" the Stroke. One can specify a sampling value to re-sample the Stroke\n"
" on the fly if needed.\n"
"\n"
" :arg t: The resampling value with which we want our Stroke to be\n"
" resampled. If 0 is specified, no resampling is done.\n"
" :type t: float\n"
" :return: A StrokeVertexIterator pointing on the first StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
static PyObject *Stroke_stroke_vertices_begin(BPy_Stroke *self, PyObject *args, PyObject *kwds)
{
@ -272,14 +288,16 @@ static PyObject *Stroke_stroke_vertices_begin(BPy_Stroke *self, PyObject *args,
return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, false);
}
PyDoc_STRVAR(Stroke_stroke_vertices_end_doc,
".. method:: stroke_vertices_end()\n"
"\n"
" Returns a StrokeVertexIterator pointing after the last StrokeVertex\n"
" of the Stroke.\n"
"\n"
" :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
Stroke_stroke_vertices_end_doc,
".. method:: stroke_vertices_end()\n"
"\n"
" Returns a StrokeVertexIterator pointing after the last StrokeVertex\n"
" of the Stroke.\n"
"\n"
" :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
static PyObject *Stroke_stroke_vertices_end(BPy_Stroke *self)
{
@ -287,14 +305,16 @@ static PyObject *Stroke_stroke_vertices_end(BPy_Stroke *self)
return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, true);
}
PyDoc_STRVAR(Stroke_reversed_doc,
".. method:: __reversed__()\n"
"\n"
" Returns a StrokeVertexIterator iterating over the vertices of the Stroke\n"
" in the reversed order (from the last to the first).\n"
"\n"
" :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
Stroke_reversed_doc,
".. method:: __reversed__()\n"
"\n"
" Returns a StrokeVertexIterator iterating over the vertices of the Stroke\n"
" in the reversed order (from the last to the first).\n"
"\n"
" :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
static PyObject *Stroke_reversed(BPy_Stroke *self)
{
@ -302,13 +322,15 @@ static PyObject *Stroke_reversed(BPy_Stroke *self)
return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, true);
}
PyDoc_STRVAR(Stroke_stroke_vertices_size_doc,
".. method:: stroke_vertices_size()\n"
"\n"
" Returns the number of StrokeVertex constituting the Stroke.\n"
"\n"
" :return: The number of stroke vertices.\n"
" :rtype: int");
PyDoc_STRVAR(
/* Wrap. */
Stroke_stroke_vertices_size_doc,
".. method:: stroke_vertices_size()\n"
"\n"
" Returns the number of StrokeVertex constituting the Stroke.\n"
"\n"
" :return: The number of stroke vertices.\n"
" :rtype: int");
static PyObject *Stroke_stroke_vertices_size(BPy_Stroke *self)
{
@ -352,10 +374,12 @@ static PyMethodDef BPy_Stroke_methods[] = {
/*----------------------Stroke get/setters ----------------------------*/
PyDoc_STRVAR(Stroke_medium_type_doc,
"The MediumType used for this Stroke.\n"
"\n"
":type: :class:`MediumType`");
PyDoc_STRVAR(
/* Wrap. */
Stroke_medium_type_doc,
"The MediumType used for this Stroke.\n"
"\n"
":type: :class:`MediumType`");
static PyObject *Stroke_medium_type_get(BPy_Stroke *self, void * /*closure*/)
{
@ -372,10 +396,12 @@ static int Stroke_medium_type_set(BPy_Stroke *self, PyObject *value, void * /*cl
return 0;
}
PyDoc_STRVAR(Stroke_texture_id_doc,
"The ID of the texture used to simulate th marks system for this Stroke.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
Stroke_texture_id_doc,
"The ID of the texture used to simulate th marks system for this Stroke.\n"
"\n"
":type: int");
static PyObject *Stroke_texture_id_get(BPy_Stroke *self, void * /*closure*/)
{
@ -392,10 +418,12 @@ static int Stroke_texture_id_set(BPy_Stroke *self, PyObject *value, void * /*clo
return 0;
}
PyDoc_STRVAR(Stroke_tips_doc,
"True if this Stroke uses a texture with tips, and false otherwise.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
Stroke_tips_doc,
"True if this Stroke uses a texture with tips, and false otherwise.\n"
"\n"
":type: bool");
static PyObject *Stroke_tips_get(BPy_Stroke *self, void * /*closure*/)
{
@ -411,10 +439,12 @@ static int Stroke_tips_set(BPy_Stroke *self, PyObject *value, void * /*closure*/
return 0;
}
PyDoc_STRVAR(Stroke_length_2d_doc,
"The 2D length of the Stroke.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
Stroke_length_2d_doc,
"The 2D length of the Stroke.\n"
"\n"
":type: float");
static PyObject *Stroke_length_2d_get(BPy_Stroke *self, void * /*closure*/)
{
@ -433,10 +463,12 @@ static int Stroke_length_2d_set(BPy_Stroke *self, PyObject *value, void * /*clos
return 0;
}
PyDoc_STRVAR(Stroke_id_doc,
"The Id of this Stroke.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
Stroke_id_doc,
"The Id of this Stroke.\n"
"\n"
":type: :class:`Id`");
static PyObject *Stroke_id_get(BPy_Stroke *self, void * /*closure*/)
{

123
source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
View File

@ -27,6 +27,7 @@ using namespace Freestyle;
/*----------------------ViewEdge methods ----------------------------*/
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_doc,
"Class hierarchy: :class:`Interface1D` > :class:`ViewEdge`\n"
"\n"
@ -61,10 +62,12 @@ static int ViewEdge_init(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
return 0;
}
PyDoc_STRVAR(ViewEdge_update_fedges_doc,
".. method:: update_fedges()\n"
"\n"
" Sets Viewedge to this for all embedded fedges.\n");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_update_fedges_doc,
".. method:: update_fedges()\n"
"\n"
" Sets Viewedge to this for all embedded fedges.\n");
static PyObject *ViewEdge_update_fedges(BPy_ViewEdge *self)
{
@ -82,10 +85,12 @@ static PyMethodDef BPy_ViewEdge_methods[] = {
/*----------------------ViewEdge get/setters ----------------------------*/
PyDoc_STRVAR(ViewEdge_first_viewvertex_doc,
"The first ViewVertex.\n"
"\n"
":type: :class:`ViewVertex`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_first_viewvertex_doc,
"The first ViewVertex.\n"
"\n"
":type: :class:`ViewVertex`");
static PyObject *ViewEdge_first_viewvertex_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -105,10 +110,12 @@ static int ViewEdge_first_viewvertex_set(BPy_ViewEdge *self, PyObject *value, vo
return 0;
}
PyDoc_STRVAR(ViewEdge_last_viewvertex_doc,
"The second ViewVertex.\n"
"\n"
":type: :class:`ViewVertex`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_last_viewvertex_doc,
"The second ViewVertex.\n"
"\n"
":type: :class:`ViewVertex`");
static PyObject *ViewEdge_last_viewvertex_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -128,10 +135,12 @@ static int ViewEdge_last_viewvertex_set(BPy_ViewEdge *self, PyObject *value, voi
return 0;
}
PyDoc_STRVAR(ViewEdge_first_fedge_doc,
"The first FEdge that constitutes this ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_first_fedge_doc,
"The first FEdge that constitutes this ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
static PyObject *ViewEdge_first_fedge_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -151,10 +160,12 @@ static int ViewEdge_first_fedge_set(BPy_ViewEdge *self, PyObject *value, void *
return 0;
}
PyDoc_STRVAR(ViewEdge_last_fedge_doc,
"The last FEdge that constitutes this ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_last_fedge_doc,
"The last FEdge that constitutes this ViewEdge.\n"
"\n"
":type: :class:`FEdge`");
static PyObject *ViewEdge_last_fedge_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -174,10 +185,12 @@ static int ViewEdge_last_fedge_set(BPy_ViewEdge *self, PyObject *value, void * /
return 0;
}
PyDoc_STRVAR(ViewEdge_viewshape_doc,
"The ViewShape to which this ViewEdge belongs to.\n"
"\n"
":type: :class:`ViewShape`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_viewshape_doc,
"The ViewShape to which this ViewEdge belongs to.\n"
"\n"
":type: :class:`ViewShape`");
static PyObject *ViewEdge_viewshape_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -197,11 +210,13 @@ static int ViewEdge_viewshape_set(BPy_ViewEdge *self, PyObject *value, void * /*
return 0;
}
PyDoc_STRVAR(ViewEdge_occludee_doc,
"The shape that is occluded by the ViewShape to which this ViewEdge\n"
"belongs to. If no object is occluded, this property is set to None.\n"
"\n"
":type: :class:`ViewShape`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_occludee_doc,
"The shape that is occluded by the ViewShape to which this ViewEdge\n"
"belongs to. If no object is occluded, this property is set to None.\n"
"\n"
":type: :class:`ViewShape`");
static PyObject *ViewEdge_occludee_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -221,20 +236,24 @@ static int ViewEdge_occludee_set(BPy_ViewEdge *self, PyObject *value, void * /*c
return 0;
}
PyDoc_STRVAR(ViewEdge_is_closed_doc,
"True if this ViewEdge forms a closed loop.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_is_closed_doc,
"True if this ViewEdge forms a closed loop.\n"
"\n"
":type: bool");
static PyObject *ViewEdge_is_closed_get(BPy_ViewEdge *self, void * /*closure*/)
{
return PyBool_from_bool(self->ve->isClosed());
}
PyDoc_STRVAR(ViewEdge_id_doc,
"The Id of this ViewEdge.\n"
"\n"
":type: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_id_doc,
"The Id of this ViewEdge.\n"
"\n"
":type: :class:`Id`");
static PyObject *ViewEdge_id_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -252,10 +271,12 @@ static int ViewEdge_id_set(BPy_ViewEdge *self, PyObject *value, void * /*closure
return 0;
}
PyDoc_STRVAR(ViewEdge_nature_doc,
"The nature of this ViewEdge.\n"
"\n"
":type: :class:`Nature`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_nature_doc,
"The nature of this ViewEdge.\n"
"\n"
":type: :class:`Nature`");
static PyObject *ViewEdge_nature_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -272,10 +293,12 @@ static int ViewEdge_nature_set(BPy_ViewEdge *self, PyObject *value, void * /*clo
return 0;
}
PyDoc_STRVAR(ViewEdge_qi_doc,
"The quantitative invisibility.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_qi_doc,
"The quantitative invisibility.\n"
"\n"
":type: int");
static PyObject *ViewEdge_qi_get(BPy_ViewEdge *self, void * /*closure*/)
{
@ -293,10 +316,12 @@ static int ViewEdge_qi_set(BPy_ViewEdge *self, PyObject *value, void * /*closure
return 0;
}
PyDoc_STRVAR(ViewEdge_chaining_time_stamp_doc,
"The time stamp of this ViewEdge.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
ViewEdge_chaining_time_stamp_doc,
"The time stamp of this ViewEdge.\n"
"\n"
":type: int");
static PyObject *ViewEdge_chaining_time_stamp_get(BPy_ViewEdge *self, void * /*closure*/)
{

82
source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.cpp
View File

@ -22,24 +22,26 @@ using namespace Freestyle;
/*----------------------Chain methods ----------------------------*/
PyDoc_STRVAR(Chain_doc,
"Class hierarchy: :class:`Interface1D` > :class:`Curve` > :class:`Chain`\n"
"\n"
"Class to represent a 1D elements issued from the chaining process. A\n"
"Chain is the last step before the :class:`Stroke` and is used in the\n"
"Splitting and Creation processes.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(id)\n"
"\n"
" Builds a :class:`Chain` using the default constructor,\n"
" copy constructor or from an :class:`Id`.\n"
"\n"
" :arg brother: A Chain object.\n"
" :type brother: :class:`Chain`\n"
" :arg id: An Id object.\n"
" :type id: :class:`Id`");
PyDoc_STRVAR(
/* Wrap. */
Chain_doc,
"Class hierarchy: :class:`Interface1D` > :class:`Curve` > :class:`Chain`\n"
"\n"
"Class to represent a 1D elements issued from the chaining process. A\n"
"Chain is the last step before the :class:`Stroke` and is used in the\n"
"Splitting and Creation processes.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(id)\n"
"\n"
" Builds a :class:`Chain` using the default constructor,\n"
" copy constructor or from an :class:`Id`.\n"
"\n"
" :arg brother: A Chain object.\n"
" :type brother: :class:`Chain`\n"
" :arg id: An Id object.\n"
" :type id: :class:`Id`");
static int Chain_init(BPy_Chain *self, PyObject *args, PyObject *kwds)
{
@ -70,16 +72,18 @@ static int Chain_init(BPy_Chain *self, PyObject *args, PyObject *kwds)
return 0;
}
PyDoc_STRVAR(Chain_push_viewedge_back_doc,
".. method:: push_viewedge_back(viewedge, orientation)\n"
"\n"
" Adds a ViewEdge at the end of the Chain.\n"
"\n"
" :arg viewedge: The ViewEdge that must be added.\n"
" :type viewedge: :class:`ViewEdge`\n"
" :arg orientation: The orientation with which the ViewEdge must be\n"
" processed.\n"
" :type orientation: bool");
PyDoc_STRVAR(
/* Wrap. */
Chain_push_viewedge_back_doc,
".. method:: push_viewedge_back(viewedge, orientation)\n"
"\n"
" Adds a ViewEdge at the end of the Chain.\n"
"\n"
" :arg viewedge: The ViewEdge that must be added.\n"
" :type viewedge: :class:`ViewEdge`\n"
" :arg orientation: The orientation with which the ViewEdge must be\n"
" processed.\n"
" :type orientation: bool");
static PyObject *Chain_push_viewedge_back(BPy_Chain *self, PyObject *args, PyObject *kwds)
{
@ -97,16 +101,18 @@ static PyObject *Chain_push_viewedge_back(BPy_Chain *self, PyObject *args, PyObj
Py_RETURN_NONE;
}
PyDoc_STRVAR(Chain_push_viewedge_front_doc,
".. method:: push_viewedge_front(viewedge, orientation)\n"
"\n"
" Adds a ViewEdge at the beginning of the Chain.\n"
"\n"
" :arg viewedge: The ViewEdge that must be added.\n"
" :type viewedge: :class:`ViewEdge`\n"
" :arg orientation: The orientation with which the ViewEdge must be\n"
" processed.\n"
" :type orientation: bool");
PyDoc_STRVAR(
/* Wrap. */
Chain_push_viewedge_front_doc,
".. method:: push_viewedge_front(viewedge, orientation)\n"
"\n"
" Adds a ViewEdge at the beginning of the Chain.\n"
"\n"
" :arg viewedge: The ViewEdge that must be added.\n"
" :type viewedge: :class:`ViewEdge`\n"
" :arg orientation: The orientation with which the ViewEdge must be\n"
" processed.\n"
" :type orientation: bool");
static PyObject *Chain_push_viewedge_front(BPy_Chain *self, PyObject *args, PyObject *kwds)
{

140
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp
View File

@ -23,29 +23,31 @@ using namespace Freestyle;
/*----------------------FEdgeSharp methods ----------------------------*/
PyDoc_STRVAR(FEdgeSharp_doc,
"Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSharp`\n"
"\n"
"Class defining a sharp FEdge. A Sharp FEdge corresponds to an initial\n"
"edge of the input mesh. It can be a silhouette, a crease or a border.\n"
"If it is a crease edge, then it is bordered by two faces of the mesh.\n"
"Face a lies on its right whereas Face b lies on its left. If it is a\n"
"border edge, then it doesn't have any face on its right, and thus Face\n"
"a is None.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex)\n"
"\n"
" Builds an :class:`FEdgeSharp` using the default constructor,\n"
" copy constructor, or between two :class:`SVertex` objects.\n"
"\n"
" :arg brother: An FEdgeSharp object.\n"
" :type brother: :class:`FEdgeSharp`\n"
" :arg first_vertex: The first SVertex object.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex object.\n"
" :type second_vertex: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_doc,
"Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSharp`\n"
"\n"
"Class defining a sharp FEdge. A Sharp FEdge corresponds to an initial\n"
"edge of the input mesh. It can be a silhouette, a crease or a border.\n"
"If it is a crease edge, then it is bordered by two faces of the mesh.\n"
"Face a lies on its right whereas Face b lies on its left. If it is a\n"
"border edge, then it doesn't have any face on its right, and thus Face\n"
"a is None.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex)\n"
"\n"
" Builds an :class:`FEdgeSharp` using the default constructor,\n"
" copy constructor, or between two :class:`SVertex` objects.\n"
"\n"
" :arg brother: An FEdgeSharp object.\n"
" :type brother: :class:`FEdgeSharp`\n"
" :arg first_vertex: The first SVertex object.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex object.\n"
" :type second_vertex: :class:`SVertex`");
static int FEdgeSharp_init(BPy_FEdgeSharp *self, PyObject *args, PyObject *kwds)
{
@ -194,11 +196,13 @@ void FEdgeSharp_mathutils_register_callback()
/*----------------------FEdgeSharp get/setters ----------------------------*/
PyDoc_STRVAR(FEdgeSharp_normal_right_doc,
"The normal to the face lying on the right of the FEdge. If this FEdge\n"
"is a border, it has no Face on its right and therefore no normal.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_normal_right_doc,
"The normal to the face lying on the right of the FEdge. If this FEdge\n"
"is a border, it has no Face on its right and therefore no normal.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *FEdgeSharp_normal_right_get(BPy_FEdgeSharp *self, void * /*closure*/)
{
@ -217,10 +221,12 @@ static int FEdgeSharp_normal_right_set(BPy_FEdgeSharp *self, PyObject *value, vo
return 0;
}
PyDoc_STRVAR(FEdgeSharp_normal_left_doc,
"The normal to the face lying on the left of the FEdge.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_normal_left_doc,
"The normal to the face lying on the left of the FEdge.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *FEdgeSharp_normal_left_get(BPy_FEdgeSharp *self, void * /*closure*/)
{
@ -239,12 +245,14 @@ static int FEdgeSharp_normal_left_set(BPy_FEdgeSharp *self, PyObject *value, voi
return 0;
}
PyDoc_STRVAR(FEdgeSharp_material_index_right_doc,
"The index of the material of the face lying on the right of the FEdge.\n"
"If this FEdge is a border, it has no Face on its right and therefore\n"
"no material.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_material_index_right_doc,
"The index of the material of the face lying on the right of the FEdge.\n"
"If this FEdge is a border, it has no Face on its right and therefore\n"
"no material.\n"
"\n"
":type: int");
static PyObject *FEdgeSharp_material_index_right_get(BPy_FEdgeSharp *self, void * /*closure*/)
{
@ -263,10 +271,12 @@ static int FEdgeSharp_material_index_right_set(BPy_FEdgeSharp *self,
return 0;
}
PyDoc_STRVAR(FEdgeSharp_material_index_left_doc,
"The index of the material of the face lying on the left of the FEdge.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_material_index_left_doc,
"The index of the material of the face lying on the left of the FEdge.\n"
"\n"
":type: int");
static PyObject *FEdgeSharp_material_index_left_get(BPy_FEdgeSharp *self, void * /*closure*/)
{
@ -285,33 +295,39 @@ static int FEdgeSharp_material_index_left_set(BPy_FEdgeSharp *self,
return 0;
}
PyDoc_STRVAR(FEdgeSharp_material_right_doc,
"The material of the face lying on the right of the FEdge. If this FEdge\n"
"is a border, it has no Face on its right and therefore no material.\n"
"\n"
":type: :class:`Material`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_material_right_doc,
"The material of the face lying on the right of the FEdge. If this FEdge\n"
"is a border, it has no Face on its right and therefore no material.\n"
"\n"
":type: :class:`Material`");
static PyObject *FEdgeSharp_material_right_get(BPy_FEdgeSharp *self, void * /*closure*/)
{
return BPy_FrsMaterial_from_FrsMaterial(self->fes->aFrsMaterial());
}
PyDoc_STRVAR(FEdgeSharp_material_left_doc,
"The material of the face lying on the left of the FEdge.\n"
"\n"
":type: :class:`Material`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_material_left_doc,
"The material of the face lying on the left of the FEdge.\n"
"\n"
":type: :class:`Material`");
static PyObject *FEdgeSharp_material_left_get(BPy_FEdgeSharp *self, void * /*closure*/)
{
return BPy_FrsMaterial_from_FrsMaterial(self->fes->bFrsMaterial());
}
PyDoc_STRVAR(FEdgeSharp_face_mark_right_doc,
"The face mark of the face lying on the right of the FEdge. If this FEdge\n"
"is a border, it has no face on the right and thus this property is set to\n"
"false.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_face_mark_right_doc,
"The face mark of the face lying on the right of the FEdge. If this FEdge\n"
"is a border, it has no face on the right and thus this property is set to\n"
"false.\n"
"\n"
":type: bool");
static PyObject *FEdgeSharp_face_mark_right_get(BPy_FEdgeSharp *self, void * /*closure*/)
{
@ -329,10 +345,12 @@ static int FEdgeSharp_face_mark_right_set(BPy_FEdgeSharp *self,
return 0;
}
PyDoc_STRVAR(FEdgeSharp_face_mark_left_doc,
"The face mark of the face lying on the left of the FEdge.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSharp_face_mark_left_doc,
"The face mark of the face lying on the left of the FEdge.\n"
"\n"
":type: bool");
static PyObject *FEdgeSharp_face_mark_left_get(BPy_FEdgeSharp *self, void * /*closure*/)
{

82
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp
View File

@ -23,26 +23,28 @@ using namespace Freestyle;
/*----------------------FEdgeSmooth methods ----------------------------*/
PyDoc_STRVAR(FEdgeSmooth_doc,
"Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSmooth`\n"
"\n"
"Class defining a smooth edge. This kind of edge typically runs across\n"
"a face of the input mesh. It can be a silhouette, a ridge or valley,\n"
"a suggestive contour.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex)\n"
"\n"
" Builds an :class:`FEdgeSmooth` using the default constructor,\n"
" copy constructor, or between two :class:`SVertex`.\n"
"\n"
" :arg brother: An FEdgeSmooth object.\n"
" :type brother: :class:`FEdgeSmooth`\n"
" :arg first_vertex: The first SVertex object.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex object.\n"
" :type second_vertex: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSmooth_doc,
"Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSmooth`\n"
"\n"
"Class defining a smooth edge. This kind of edge typically runs across\n"
"a face of the input mesh. It can be a silhouette, a ridge or valley,\n"
"a suggestive contour.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(first_vertex, second_vertex)\n"
"\n"
" Builds an :class:`FEdgeSmooth` using the default constructor,\n"
" copy constructor, or between two :class:`SVertex`.\n"
"\n"
" :arg brother: An FEdgeSmooth object.\n"
" :type brother: :class:`FEdgeSmooth`\n"
" :arg first_vertex: The first SVertex object.\n"
" :type first_vertex: :class:`SVertex`\n"
" :arg second_vertex: The second SVertex object.\n"
" :type second_vertex: :class:`SVertex`");
static int FEdgeSmooth_init(BPy_FEdgeSmooth *self, PyObject *args, PyObject *kwds)
{
@ -137,10 +139,12 @@ void FEdgeSmooth_mathutils_register_callback()
/*----------------------FEdgeSmooth get/setters ----------------------------*/
PyDoc_STRVAR(FEdgeSmooth_normal_doc,
"The normal of the face that this FEdge is running across.\n"
"\n"
":type: :class:`mathutils.Vector`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSmooth_normal_doc,
"The normal of the face that this FEdge is running across.\n"
"\n"
":type: :class:`mathutils.Vector`");
static PyObject *FEdgeSmooth_normal_get(BPy_FEdgeSmooth *self, void * /*closure*/)
{
@ -158,10 +162,12 @@ static int FEdgeSmooth_normal_set(BPy_FEdgeSmooth *self, PyObject *value, void *
return 0;
}
PyDoc_STRVAR(FEdgeSmooth_material_index_doc,
"The index of the material of the face that this FEdge is running across.\n"
"\n"
":type: int");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSmooth_material_index_doc,
"The index of the material of the face that this FEdge is running across.\n"
"\n"
":type: int");
static PyObject *FEdgeSmooth_material_index_get(BPy_FEdgeSmooth *self, void * /*closure*/)
{
@ -180,20 +186,24 @@ static int FEdgeSmooth_material_index_set(BPy_FEdgeSmooth *self,
return 0;
}
PyDoc_STRVAR(FEdgeSmooth_material_doc,
"The material of the face that this FEdge is running across.\n"
"\n"
":type: :class:`Material`");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSmooth_material_doc,
"The material of the face that this FEdge is running across.\n"
"\n"
":type: :class:`Material`");
static PyObject *FEdgeSmooth_material_get(BPy_FEdgeSmooth *self, void * /*closure*/)
{
return BPy_FrsMaterial_from_FrsMaterial(self->fes->frs_material());
}
PyDoc_STRVAR(FEdgeSmooth_face_mark_doc,
"The face mark of the face that this FEdge is running across.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
FEdgeSmooth_face_mark_doc,
"The face mark of the face that this FEdge is running across.\n"
"\n"
":type: bool");
static PyObject *FEdgeSmooth_face_mark_get(BPy_FEdgeSmooth *self, void * /*closure*/)
{

25
source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp
View File

@ -22,6 +22,7 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(
/* Wrap. */
AdjacencyIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`AdjacencyIterator`\n"
"\n"
@ -123,10 +124,12 @@ static PyObject *AdjacencyIterator_iternext(BPy_AdjacencyIterator *self)
/*----------------------AdjacencyIterator get/setters ----------------------------*/
PyDoc_STRVAR(AdjacencyIterator_object_doc,
"The ViewEdge object currently pointed to by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
AdjacencyIterator_object_doc,
"The ViewEdge object currently pointed to by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *AdjacencyIterator_object_get(BPy_AdjacencyIterator *self, void * /*closure*/)
{
@ -141,11 +144,15 @@ static PyObject *AdjacencyIterator_object_get(BPy_AdjacencyIterator *self, void
Py_RETURN_NONE;
}
PyDoc_STRVAR(AdjacencyIterator_is_incoming_doc,
"True if the current ViewEdge is coming towards the iteration vertex, and\n"
"False otherwise.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
A
/* Wrap. */
djacencyIterator_is_incoming_doc,
"True if the current ViewEdge is coming towards the iteration vertex, and\n"
"False otherwise.\n"
"\n"
":type: bool");
static PyObject *AdjacencyIterator_is_incoming_get(BPy_AdjacencyIterator *self, void * /*closure*/)
{

1
source/blender/freestyle/intern/python/Iterator/BPy_ChainPredicateIterator.cpp
View File

@ -24,6 +24,7 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(
/* Wrap. */
ChainPredicateIterator_doc,
"Class hierarchy: :class:`freestyle.types.Iterator` >\n"

64
source/blender/freestyle/intern/python/Iterator/BPy_ChainSilhouetteIterator.cpp
View File

@ -24,37 +24,39 @@ using namespace Freestyle;
// ChainSilhouetteIterator (bool restrict_to_selection=true, ViewEdge *begin=nullptr, bool
// orientation=true) ChainSilhouetteIterator (const ChainSilhouetteIterator &brother)
PyDoc_STRVAR(ChainSilhouetteIterator_doc,
"Class hierarchy: :class:`freestyle.types.Iterator` >\n"
":class:`freestyle.types.ViewEdgeIterator` >\n"
":class:`freestyle.types.ChainingIterator` >\n"
":class:`ChainSilhouetteIterator`\n"
"\n"
"A ViewEdge Iterator used to follow ViewEdges the most naturally. For\n"
"example, it will follow visible ViewEdges of same nature. As soon, as\n"
"the nature or the visibility changes, the iteration stops (by setting\n"
"the pointed ViewEdge to 0). In the case of an iteration over a set of\n"
"ViewEdge that are both Silhouette and Crease, there will be a\n"
"precedence of the silhouette over the crease criterion.\n"
"\n"
".. method:: __init__(restrict_to_selection=True, begin=None, orientation=True)\n"
" __init__(brother)\n"
"\n"
" Builds a ChainSilhouetteIterator from the first ViewEdge used for\n"
" iteration and its orientation or the copy constructor.\n"
"\n"
" :arg restrict_to_selection: Indicates whether to force the chaining\n"
" to stay within the set of selected ViewEdges or not.\n"
" :type restrict_to_selection: bool\n"
" :arg begin: The ViewEdge from where to start the iteration.\n"
" :type begin: :class:`freestyle.types.ViewEdge` or None\n"
" :arg orientation: If true, we'll look for the next ViewEdge among\n"
" the ViewEdges that surround the ending ViewVertex of begin. If\n"
" false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n"
" :type orientation: bool\n"
" :arg brother: A ChainSilhouetteIterator object.\n"
" :type brother: :class:`ChainSilhouetteIterator`");
PyDoc_STRVAR(
/* Wrap. */
ChainSilhouetteIterator_doc,
"Class hierarchy: :class:`freestyle.types.Iterator` >\n"
":class:`freestyle.types.ViewEdgeIterator` >\n"
":class:`freestyle.types.ChainingIterator` >\n"
":class:`ChainSilhouetteIterator`\n"
"\n"
"A ViewEdge Iterator used to follow ViewEdges the most naturally. For\n"
"example, it will follow visible ViewEdges of same nature. As soon, as\n"
"the nature or the visibility changes, the iteration stops (by setting\n"
"the pointed ViewEdge to 0). In the case of an iteration over a set of\n"
"ViewEdge that are both Silhouette and Crease, there will be a\n"
"precedence of the silhouette over the crease criterion.\n"
"\n"
".. method:: __init__(restrict_to_selection=True, begin=None, orientation=True)\n"
" __init__(brother)\n"
"\n"
" Builds a ChainSilhouetteIterator from the first ViewEdge used for\n"
" iteration and its orientation or the copy constructor.\n"
"\n"
" :arg restrict_to_selection: Indicates whether to force the chaining\n"
" to stay within the set of selected ViewEdges or not.\n"
" :type restrict_to_selection: bool\n"
" :arg begin: The ViewEdge from where to start the iteration.\n"
" :type begin: :class:`freestyle.types.ViewEdge` or None\n"
" :arg orientation: If true, we'll look for the next ViewEdge among\n"
" the ViewEdges that surround the ending ViewVertex of begin. If\n"
" false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n"
" :type orientation: bool\n"
" :arg brother: A ChainSilhouetteIterator object.\n"
" :type brother: :class:`ChainSilhouetteIterator`");
static int check_begin(PyObject *obj, void *v)
{

73
source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp
View File

@ -24,6 +24,7 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(
/* Wrap. */
ChainingIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator` > :class:`ChainingIterator`\n"
"\n"
@ -112,12 +113,14 @@ static int ChainingIterator___init__(BPy_ChainingIterator *self, PyObject *args,
return 0;
}
PyDoc_STRVAR(ChainingIterator_init_doc,
".. method:: init()\n"
"\n"
" Initializes the iterator context. This method is called each\n"
" time a new chain is started. It can be used to reset some\n"
" history information that you might want to keep.");
PyDoc_STRVAR(
/* Wrap. */
ChainingIterator_init_doc,
".. method:: init()\n"
"\n"
" Initializes the iterator context. This method is called each\n"
" time a new chain is started. It can be used to reset some\n"
" history information that you might want to keep.");
static PyObject *ChainingIterator_init(BPy_ChainingIterator *self)
{
@ -129,19 +132,21 @@ static PyObject *ChainingIterator_init(BPy_ChainingIterator *self)
Py_RETURN_NONE;
}
PyDoc_STRVAR(ChainingIterator_traverse_doc,
".. method:: traverse(it)\n"
"\n"
" This method iterates over the potential next ViewEdges and returns\n"
" the one that will be followed next. Returns the next ViewEdge to\n"
" follow or None when the end of the chain is reached.\n"
"\n"
" :arg it: The iterator over the ViewEdges adjacent to the end vertex\n"
" of the current ViewEdge. The adjacency iterator reflects the\n"
" restriction rules by only iterating over the valid ViewEdges.\n"
" :type it: :class:`AdjacencyIterator`\n"
" :return: Returns the next ViewEdge to follow, or None if chaining ends.\n"
" :rtype: :class:`ViewEdge` or None");
PyDoc_STRVAR(
/* Wrap. */
ChainingIterator_traverse_doc,
".. method:: traverse(it)\n"
"\n"
" This method iterates over the potential next ViewEdges and returns\n"
" the one that will be followed next. Returns the next ViewEdge to\n"
" follow or None when the end of the chain is reached.\n"
"\n"
" :arg it: The iterator over the ViewEdges adjacent to the end vertex\n"
" of the current ViewEdge. The adjacency iterator reflects the\n"
" restriction rules by only iterating over the valid ViewEdges.\n"
" :type it: :class:`AdjacencyIterator`\n"
" :return: Returns the next ViewEdge to follow, or None if chaining ends.\n"
" :rtype: :class:`ViewEdge` or None");
static PyObject *ChainingIterator_traverse(BPy_ChainingIterator *self,
PyObject *args,
@ -176,10 +181,12 @@ static PyMethodDef BPy_ChainingIterator_methods[] = {
/*----------------------ChainingIterator get/setters ----------------------------*/
PyDoc_STRVAR(ChainingIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
ChainingIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ChainingIterator_object_get(BPy_ChainingIterator *self, void * /*closure*/)
{
@ -195,10 +202,12 @@ static PyObject *ChainingIterator_object_get(BPy_ChainingIterator *self, void *
Py_RETURN_NONE;
}
PyDoc_STRVAR(ChainingIterator_next_vertex_doc,
"The ViewVertex that is the next crossing.\n"
"\n"
":type: :class:`ViewVertex`");
PyDoc_STRVAR(
/* Wrap. */
ChainingIterator_next_vertex_doc,
"The ViewVertex that is the next crossing.\n"
"\n"
":type: :class:`ViewVertex`");
static PyObject *ChainingIterator_next_vertex_get(BPy_ChainingIterator *self, void * /*closure*/)
{
@ -210,10 +219,12 @@ static PyObject *ChainingIterator_next_vertex_get(BPy_ChainingIterator *self, vo
Py_RETURN_NONE;
}
PyDoc_STRVAR(ChainingIterator_is_incrementing_doc,
"True if the current iteration is an incrementation.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
ChainingIterator_is_incrementing_doc,
"True if the current iteration is an incrementation.\n"
"\n"
":type: bool");
static PyObject *ChainingIterator_is_incrementing_get(BPy_ChainingIterator *self,
void * /*closure*/)

72
source/blender/freestyle/intern/python/Iterator/BPy_CurvePointIterator.cpp
View File

@ -21,26 +21,28 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(CurvePointIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`CurvePointIterator`\n"
"\n"
"Class representing an iterator on a curve. Allows an iterating\n"
"outside initial vertices. A CurvePoint is instantiated and returned\n"
"through the .object attribute.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(step=0.0)\n"
"\n"
" Builds a CurvePointIterator object using either the default constructor,\n"
" copy constructor, or the overloaded constructor.\n"
"\n"
" :arg brother: A CurvePointIterator object.\n"
" :type brother: :class:`CurvePointIterator`\n"
" :arg step: A resampling resolution with which the curve is resampled.\n"
" If zero, no resampling is done (i.e., the iterator iterates over\n"
" initial vertices).\n"
" :type step: float");
PyDoc_STRVAR(
/* Wrap. */
CurvePointIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`CurvePointIterator`\n"
"\n"
"Class representing an iterator on a curve. Allows an iterating\n"
"outside initial vertices. A CurvePoint is instantiated and returned\n"
"through the .object attribute.\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
" __init__(step=0.0)\n"
"\n"
" Builds a CurvePointIterator object using either the default constructor,\n"
" copy constructor, or the overloaded constructor.\n"
"\n"
" :arg brother: A CurvePointIterator object.\n"
" :type brother: :class:`CurvePointIterator`\n"
" :arg step: A resampling resolution with which the curve is resampled.\n"
" If zero, no resampling is done (i.e., the iterator iterates over\n"
" initial vertices).\n"
" :type step: float");
static int CurvePointIterator_init(BPy_CurvePointIterator *self, PyObject *args, PyObject *kwds)
{
@ -75,10 +77,12 @@ static int CurvePointIterator_init(BPy_CurvePointIterator *self, PyObject *args,
/*----------------------CurvePointIterator get/setters ----------------------------*/
PyDoc_STRVAR(CurvePointIterator_object_doc,
"The CurvePoint object currently pointed by this iterator.\n"
"\n"
":type: :class:`CurvePoint`");
PyDoc_STRVAR(
/* Wrap. */
CurvePointIterator_object_doc,
"The CurvePoint object currently pointed by this iterator.\n"
"\n"
":type: :class:`CurvePoint`");
static PyObject *CurvePointIterator_object_get(BPy_CurvePointIterator *self, void * /*closure*/)
{
@ -89,20 +93,24 @@ static PyObject *CurvePointIterator_object_get(BPy_CurvePointIterator *self, voi
return BPy_CurvePoint_from_CurvePoint(self->cp_it->operator*());
}
PyDoc_STRVAR(CurvePointIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
CurvePointIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *CurvePointIterator_t_get(BPy_CurvePointIterator *self, void * /*closure*/)
{
return PyFloat_FromDouble(self->cp_it->t());
}
PyDoc_STRVAR(CurvePointIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
CurvePointIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *CurvePointIterator_u_get(BPy_CurvePointIterator *self, void * /*closure*/)
{

84
source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp
View File

@ -21,23 +21,25 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(Interface0DIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`Interface0DIterator`\n"
"\n"
"Class defining an iterator over Interface0D elements. An instance of\n"
"this iterator is always obtained from a 1D element.\n"
"\n"
".. method:: __init__(brother)\n"
" __init__(it)\n"
"\n"
" Construct a nested Interface0DIterator using either the copy constructor\n"
" or the constructor that takes an he argument of a Function0D.\n"
"\n"
" :arg brother: An Interface0DIterator object.\n"
" :type brother: :class:`Interface0DIterator`\n"
" :arg it: An iterator object to be nested.\n"
" :type it: :class:`SVertexIterator`, :class:`CurvePointIterator`, or\n"
" :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
Interface0DIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`Interface0DIterator`\n"
"\n"
"Class defining an iterator over Interface0D elements. An instance of\n"
"this iterator is always obtained from a 1D element.\n"
"\n"
".. method:: __init__(brother)\n"
" __init__(it)\n"
"\n"
" Construct a nested Interface0DIterator using either the copy constructor\n"
" or the constructor that takes an he argument of a Function0D.\n"
"\n"
" :arg brother: An Interface0DIterator object.\n"
" :type brother: :class:`Interface0DIterator`\n"
" :arg it: An iterator object to be nested.\n"
" :type it: :class:`SVertexIterator`, :class:`CurvePointIterator`, or\n"
" :class:`StrokeVertexIterator`");
static int convert_nested_it(PyObject *obj, void *v)
{
@ -130,13 +132,15 @@ static PyObject *Interface0DIterator_iternext(BPy_Interface0DIterator *self)
/*----------------------Interface0DIterator get/setters ----------------------------*/
PyDoc_STRVAR(Interface0DIterator_object_doc,
"The 0D object currently pointed to by this iterator. Note that the object\n"
"may be an instance of an Interface0D subclass. For example if the iterator\n"
"has been created from the `vertices_begin()` method of the :class:`Stroke`\n"
"class, the .object property refers to a :class:`StrokeVertex` object.\n"
"\n"
":type: :class:`Interface0D` or one of its subclasses.");
PyDoc_STRVAR(
/* Wrap. */
Interface0DIterator_object_doc,
"The 0D object currently pointed to by this iterator. Note that the object\n"
"may be an instance of an Interface0D subclass. For example if the iterator\n"
"has been created from the `vertices_begin()` method of the :class:`Stroke`\n"
"class, the .object property refers to a :class:`StrokeVertex` object.\n"
"\n"
":type: :class:`Interface0D` or one of its subclasses.");
static PyObject *Interface0DIterator_object_get(BPy_Interface0DIterator *self, void * /*closure*/)
{
@ -147,31 +151,37 @@ static PyObject *Interface0DIterator_object_get(BPy_Interface0DIterator *self, v
return Any_BPy_Interface0D_from_Interface0D(self->if0D_it->operator*());
}
PyDoc_STRVAR(Interface0DIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
Interface0DIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *Interface0DIterator_t_get(BPy_Interface0DIterator *self, void * /*closure*/)
{
return PyFloat_FromDouble(self->if0D_it->t());
}
PyDoc_STRVAR(Interface0DIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
Interface0DIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *Interface0DIterator_u_get(BPy_Interface0DIterator *self, void * /*closure*/)
{
return PyFloat_FromDouble(self->if0D_it->u());
}
PyDoc_STRVAR(Interface0DIterator_at_last_doc,
"True if the iterator points to the last valid element.\n"
"For its counterpart (pointing to the first valid element), use it.is_begin.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
Interface0DIterator_at_last_doc,
"True if the iterator points to the last valid element.\n"
"For its counterpart (pointing to the first valid element), use it.is_begin.\n"
"\n"
":type: bool");
static PyObject *Interface0DIterator_at_last_get(BPy_Interface0DIterator *self, void * /*closure*/)
{

31
source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp
View File

@ -23,6 +23,7 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(
/* Wrap. */
SVertexIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`SVertexIterator`\n"
"\n"
@ -98,10 +99,12 @@ static int SVertexIterator_init(BPy_SVertexIterator *self, PyObject *args, PyObj
/*----------------------SVertexIterator get/setters ----------------------------*/
PyDoc_STRVAR(SVertexIterator_object_doc,
"The SVertex object currently pointed by this iterator.\n"
"\n"
":type: :class:`SVertex`");
PyDoc_STRVAR(
/* Wrap. */
SVertexIterator_object_doc,
"The SVertex object currently pointed by this iterator.\n"
"\n"
":type: :class:`SVertex`");
static PyObject *SVertexIterator_object_get(BPy_SVertexIterator *self, void * /*closure*/)
{
@ -116,20 +119,24 @@ static PyObject *SVertexIterator_object_get(BPy_SVertexIterator *self, void * /*
Py_RETURN_NONE;
}
PyDoc_STRVAR(SVertexIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
SVertexIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *SVertexIterator_t_get(BPy_SVertexIterator *self, void * /*closure*/)
{
return PyFloat_FromDouble(self->sv_it->t());
}
PyDoc_STRVAR(SVertexIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
SVertexIterator_u_doc,
"The point parameter at the current point in the 1D element (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *SVertexIterator_u_get(BPy_SVertexIterator *self, void * /*closure*/)
{

140
source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp
View File

@ -22,29 +22,31 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(StrokeVertexIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`StrokeVertexIterator`\n"
"\n"
"Class defining an iterator designed to iterate over the\n"
":class:`StrokeVertex` of a :class:`Stroke`. An instance of a\n"
"StrokeVertexIterator can be obtained from a Stroke by calling\n"
"iter(), stroke_vertices_begin() or stroke_vertices_begin(). It is iterating\n"
"over the same vertices as an :class:`Interface0DIterator`. The difference\n"
"resides in the object access: an Interface0DIterator only allows\n"
"access to an Interface0D while one might need to access the\n"
"specialized StrokeVertex type. In this case, one should use a\n"
"StrokeVertexIterator. To call functions of the UnaryFuntion0D type,\n"
"a StrokeVertexIterator can be converted to an Interface0DIterator by\n"
"by calling Interface0DIterator(it).\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
"\n"
" Creates a :class:`StrokeVertexIterator` using either the\n"
" default constructor or the copy constructor.\n"
"\n"
" :arg brother: A StrokeVertexIterator object.\n"
" :type brother: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`StrokeVertexIterator`\n"
"\n"
"Class defining an iterator designed to iterate over the\n"
":class:`StrokeVertex` of a :class:`Stroke`. An instance of a\n"
"StrokeVertexIterator can be obtained from a Stroke by calling\n"
"iter(), stroke_vertices_begin() or stroke_vertices_begin(). It is iterating\n"
"over the same vertices as an :class:`Interface0DIterator`. The difference\n"
"resides in the object access: an Interface0DIterator only allows\n"
"access to an Interface0D while one might need to access the\n"
"specialized StrokeVertex type. In this case, one should use a\n"
"StrokeVertexIterator. To call functions of the UnaryFuntion0D type,\n"
"a StrokeVertexIterator can be converted to an Interface0DIterator by\n"
"by calling Interface0DIterator(it).\n"
"\n"
".. method:: __init__()\n"
" __init__(brother)\n"
"\n"
" Creates a :class:`StrokeVertexIterator` using either the\n"
" default constructor or the copy constructor.\n"
"\n"
" :arg brother: A StrokeVertexIterator object.\n"
" :type brother: :class:`StrokeVertexIterator`");
static int StrokeVertexIterator_init(BPy_StrokeVertexIterator *self,
PyObject *args,
@ -134,13 +136,15 @@ static PyObject *StrokeVertexIterator_iternext(BPy_StrokeVertexIterator *self)
/*----------------------StrokeVertexIterator methods ----------------------------*/
PyDoc_STRVAR(StrokeVertexIterator_incremented_doc,
".. method:: incremented()\n"
"\n"
" Returns a copy of an incremented StrokeVertexIterator.\n"
"\n"
" :return: A StrokeVertexIterator pointing the next StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_incremented_doc,
".. method:: incremented()\n"
"\n"
" Returns a copy of an incremented StrokeVertexIterator.\n"
"\n"
" :return: A StrokeVertexIterator pointing the next StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
static PyObject *StrokeVertexIterator_incremented(BPy_StrokeVertexIterator *self)
{
@ -153,13 +157,15 @@ static PyObject *StrokeVertexIterator_incremented(BPy_StrokeVertexIterator *self
return BPy_StrokeVertexIterator_from_StrokeVertexIterator(copy, self->reversed);
}
PyDoc_STRVAR(StrokeVertexIterator_decremented_doc,
".. method:: decremented()\n"
"\n"
" Returns a copy of a decremented StrokeVertexIterator.\n"
"\n"
" :return: A StrokeVertexIterator pointing the previous StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_decremented_doc,
".. method:: decremented()\n"
"\n"
" Returns a copy of a decremented StrokeVertexIterator.\n"
"\n"
" :return: A StrokeVertexIterator pointing the previous StrokeVertex.\n"
" :rtype: :class:`StrokeVertexIterator`");
static PyObject *StrokeVertexIterator_decremented(BPy_StrokeVertexIterator *self)
{
@ -172,14 +178,16 @@ static PyObject *StrokeVertexIterator_decremented(BPy_StrokeVertexIterator *self
return BPy_StrokeVertexIterator_from_StrokeVertexIterator(copy, self->reversed);
}
PyDoc_STRVAR(StrokeVertexIterator_reversed_doc,
".. method:: reversed()\n"
"\n"
" Returns a StrokeVertexIterator that traverses stroke vertices in the\n"
" reversed order.\n"
"\n"
" :return: A StrokeVertexIterator traversing stroke vertices backward.\n"
" :rtype: :class:`StrokeVertexIterator`");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_reversed_doc,
".. method:: reversed()\n"
"\n"
" Returns a StrokeVertexIterator that traverses stroke vertices in the\n"
" reversed order.\n"
"\n"
" :return: A StrokeVertexIterator traversing stroke vertices backward.\n"
" :rtype: :class:`StrokeVertexIterator`");
static PyObject *StrokeVertexIterator_reversed(BPy_StrokeVertexIterator *self)
{
@ -204,10 +212,12 @@ static PyMethodDef BPy_StrokeVertexIterator_methods[] = {
/*----------------------StrokeVertexIterator get/setters ----------------------------*/
PyDoc_STRVAR(StrokeVertexIterator_object_doc,
"The StrokeVertex object currently pointed to by this iterator.\n"
"\n"
":type: :class:`StrokeVertex`");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_object_doc,
"The StrokeVertex object currently pointed to by this iterator.\n"
"\n"
":type: :class:`StrokeVertex`");
static PyObject *StrokeVertexIterator_object_get(BPy_StrokeVertexIterator *self,
void * /*closure*/)
@ -223,31 +233,37 @@ static PyObject *StrokeVertexIterator_object_get(BPy_StrokeVertexIterator *self,
Py_RETURN_NONE;
}
PyDoc_STRVAR(StrokeVertexIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_t_doc,
"The curvilinear abscissa of the current point.\n"
"\n"
":type: float");
static PyObject *StrokeVertexIterator_t_get(BPy_StrokeVertexIterator *self, void * /*closure*/)
{
return PyFloat_FromDouble(self->sv_it->t());
}
PyDoc_STRVAR(StrokeVertexIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_u_doc,
"The point parameter at the current point in the stroke (0 <= u <= 1).\n"
"\n"
":type: float");
static PyObject *StrokeVertexIterator_u_get(BPy_StrokeVertexIterator *self, void * /*closure*/)
{
return PyFloat_FromDouble(self->sv_it->u());
}
PyDoc_STRVAR(StrokeVertexIterator_at_last_doc,
"True if the iterator points to the last valid element.\n"
"For its counterpart (pointing to the first valid element), use it.is_begin.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
StrokeVertexIterator_at_last_doc,
"True if the iterator points to the last valid element.\n"
"For its counterpart (pointing to the first valid element), use it.is_begin.\n"
"\n"
":type: bool");
static PyObject *StrokeVertexIterator_at_last_get(BPy_StrokeVertexIterator *self)
{

106
source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp
View File

@ -21,29 +21,31 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(ViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator`\n"
"\n"
"Base class for iterators over ViewEdges of the :class:`ViewMap` Graph.\n"
"Basically the increment() operator of this class should be able to\n"
"take the decision of \"where\" (on which ViewEdge) to go when pointing\n"
"on a given ViewEdge.\n"
"\n"
".. method:: __init__(begin=None, orientation=True)\n"
" __init__(brother)\n"
"\n"
" Builds a ViewEdgeIterator from a starting ViewEdge and its\n"
" orientation or the copy constructor.\n"
"\n"
" :arg begin: The ViewEdge from where to start the iteration.\n"
" :type begin: :class:`ViewEdge` or None\n"
" :arg orientation: If true, we'll look for the next ViewEdge among\n"
" the ViewEdges that surround the ending ViewVertex of begin. If\n"
" false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n"
" :type orientation: bool\n"
" :arg brother: A ViewEdgeIterator object.\n"
" :type brother: :class:`ViewEdgeIterator`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`ViewEdgeIterator`\n"
"\n"
"Base class for iterators over ViewEdges of the :class:`ViewMap` Graph.\n"
"Basically the increment() operator of this class should be able to\n"
"take the decision of \"where\" (on which ViewEdge) to go when pointing\n"
"on a given ViewEdge.\n"
"\n"
".. method:: __init__(begin=None, orientation=True)\n"
" __init__(brother)\n"
"\n"
" Builds a ViewEdgeIterator from a starting ViewEdge and its\n"
" orientation or the copy constructor.\n"
"\n"
" :arg begin: The ViewEdge from where to start the iteration.\n"
" :type begin: :class:`ViewEdge` or None\n"
" :arg orientation: If true, we'll look for the next ViewEdge among\n"
" the ViewEdges that surround the ending ViewVertex of begin. If\n"
" false, we'll search over the ViewEdges surrounding the ending\n"
" ViewVertex of begin.\n"
" :type orientation: bool\n"
" :arg brother: A ViewEdgeIterator object.\n"
" :type brother: :class:`ViewEdgeIterator`");
static int check_begin(PyObject *obj, void *v)
{
@ -82,10 +84,12 @@ static int ViewEdgeIterator_init(BPy_ViewEdgeIterator *self, PyObject *args, PyO
return 0;
}
PyDoc_STRVAR(ViewEdgeIterator_change_orientation_doc,
".. method:: change_orientation()\n"
"\n"
" Changes the current orientation.");
PyDoc_STRVAR(
/* Wrap. */
ViewEdgeIterator_change_orientation_doc,
".. method:: change_orientation()\n"
"\n"
" Changes the current orientation.");
static PyObject *ViewEdgeIterator_change_orientation(BPy_ViewEdgeIterator *self)
{
@ -103,10 +107,12 @@ static PyMethodDef BPy_ViewEdgeIterator_methods[] = {
/*----------------------ViewEdgeIterator get/setters ----------------------------*/
PyDoc_STRVAR(ViewEdgeIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdgeIterator_object_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_object_get(BPy_ViewEdgeIterator *self, void * /*closure*/)
{
@ -121,10 +127,12 @@ static PyObject *ViewEdgeIterator_object_get(BPy_ViewEdgeIterator *self, void *
Py_RETURN_NONE;
}
PyDoc_STRVAR(ViewEdgeIterator_current_edge_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdgeIterator_current_edge_doc,
"The ViewEdge object currently pointed by this iterator.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_current_edge_get(BPy_ViewEdgeIterator *self, void * /*closure*/)
{
@ -147,14 +155,16 @@ static int ViewEdgeIterator_current_edge_set(BPy_ViewEdgeIterator *self,
return 0;
}
PyDoc_STRVAR(ViewEdgeIterator_orientation_doc,
"The orientation of the pointed ViewEdge in the iteration.\n"
"If true, the iterator looks for the next ViewEdge among those ViewEdges\n"
"that surround the ending ViewVertex of the \"begin\" ViewEdge. If false,\n"
"the iterator searches over the ViewEdges surrounding the ending ViewVertex\n"
"of the \"begin\" ViewEdge.\n"
"\n"
":type: bool");
PyDoc_STRVAR(
/* Wrap. */
ViewEdgeIterator_orientation_doc,
"The orientation of the pointed ViewEdge in the iteration.\n"
"If true, the iterator looks for the next ViewEdge among those ViewEdges\n"
"that surround the ending ViewVertex of the \"begin\" ViewEdge. If false,\n"
"the iterator searches over the ViewEdges surrounding the ending ViewVertex\n"
"of the \"begin\" ViewEdge.\n"
"\n"
":type: bool");
static PyObject *ViewEdgeIterator_orientation_get(BPy_ViewEdgeIterator *self, void * /*closure*/)
{
@ -173,10 +183,12 @@ static int ViewEdgeIterator_orientation_set(BPy_ViewEdgeIterator *self,
return 0;
}
PyDoc_STRVAR(ViewEdgeIterator_begin_doc,
"The first ViewEdge used for the iteration.\n"
"\n"
":type: :class:`ViewEdge`");
PyDoc_STRVAR(
/* Wrap. */
ViewEdgeIterator_begin_doc,
"The first ViewEdge used for the iteration.\n"
"\n"
":type: :class:`ViewEdge`");
static PyObject *ViewEdgeIterator_begin_get(BPy_ViewEdgeIterator *self, void * /*closure*/)
{

48
source/blender/freestyle/intern/python/Iterator/BPy_orientedViewEdgeIterator.cpp
View File

@ -20,22 +20,24 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
PyDoc_STRVAR(orientedViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`orientedViewEdgeIterator`\n"
"\n"
"Class representing an iterator over oriented ViewEdges around a\n"
":class:`ViewVertex`. This iterator allows a CCW iteration (in the image\n"
"plane). An instance of an orientedViewEdgeIterator can only be\n"
"obtained from a ViewVertex by calling edges_begin() or edges_end().\n"
"\n"
".. method:: __init__()\n"
" __init__(iBrother)\n"
"\n"
" Creates an :class:`orientedViewEdgeIterator` using either the\n"
" default constructor or the copy constructor.\n"
"\n"
" :arg iBrother: An orientedViewEdgeIterator object.\n"
" :type iBrother: :class:`orientedViewEdgeIterator`");
PyDoc_STRVAR(
/* Wrap. */
orientedViewEdgeIterator_doc,
"Class hierarchy: :class:`Iterator` > :class:`orientedViewEdgeIterator`\n"
"\n"
"Class representing an iterator over oriented ViewEdges around a\n"
":class:`ViewVertex`. This iterator allows a CCW iteration (in the image\n"
"plane). An instance of an orientedViewEdgeIterator can only be\n"
"obtained from a ViewVertex by calling edges_begin() or edges_end().\n"
"\n"
".. method:: __init__()\n"
" __init__(iBrother)\n"
"\n"
" Creates an :class:`orientedViewEdgeIterator` using either the\n"
" default constructor or the copy constructor.\n"
"\n"
" :arg iBrother: An orientedViewEdgeIterator object.\n"
" :type iBrother: :class:`orientedViewEdgeIterator`");
static int orientedViewEdgeIterator_init(BPy_orientedViewEdgeIterator *self,
PyObject *args,
@ -102,12 +104,14 @@ static PyObject *orientedViewEdgeIterator_iternext(BPy_orientedViewEdgeIterator
/*----------------------orientedViewEdgeIterator get/setters ----------------------------*/
PyDoc_STRVAR(orientedViewEdgeIterator_object_doc,
"The oriented ViewEdge (i.e., a tuple of the pointed ViewEdge and a boolean\n"
"value) currently pointed to by this iterator. If the boolean value is true,\n"
"the ViewEdge is incoming.\n"
"\n"
":type: (:class:`ViewEdge`, bool)");
PyDoc_STRVAR(
/* Wrap. */
orientedViewEdgeIterator_object_doc,
"The oriented ViewEdge (i.e., a tuple of the pointed ViewEdge and a boolean\n"
"value) currently pointed to by this iterator. If the boolean value is true,\n"
"the ViewEdge is incoming.\n"
"\n"
":type: (:class:`ViewEdge`, bool)");
static PyObject *orientedViewEdgeIterator_object_get(BPy_orientedViewEdgeIterator *self,
void * /*closure*/)

6
source/blender/freestyle/intern/python/StrokeShader/BPy_BackboneStretcherShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char BackboneStretcherShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
BackboneStretcherShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`BackboneStretcherShader`\n"
"\n"
"[Geometry shader]\n"
@ -38,7 +40,7 @@ static char BackboneStretcherShader___doc__[] =
" respective directions: v(1)v(0) and v(n-1)v(n).\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int BackboneStretcherShader___init__(BPy_BackboneStretcherShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_BezierCurveShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char BezierCurveShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
BezierCurveShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`BezierCurveShader`\n"
"\n"
"[Geometry shader]\n"
@ -40,7 +42,7 @@ static char BezierCurveShader___doc__[] =
" Bezier Curve approximation of the original backbone geometry.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int BezierCurveShader___init__(BPy_BezierCurveShader *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/StrokeShader/BPy_BlenderTextureShader.cpp
View File

@ -22,7 +22,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char BlenderTextureShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
BlenderTextureShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`BlenderTextureShader`\n"
"\n"
"[Texture shader]\n"
@ -42,7 +44,7 @@ static char BlenderTextureShader___doc__[] =
" simulate marks.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int BlenderTextureShader___init__(BPy_BlenderTextureShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_CalligraphicShader.cpp
View File

@ -21,7 +21,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char CalligraphicShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
CalligraphicShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`CalligraphicShader`\n"
"\n"
"[Thickness Shader]\n"
@ -51,7 +53,7 @@ static char CalligraphicShader___doc__[] =
" perpendicular to this one, and an interpolation in between.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int CalligraphicShader___init__(BPy_CalligraphicShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_ColorNoiseShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char ColorNoiseShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ColorNoiseShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`ColorNoiseShader`\n"
"\n"
"[Color shader]\n"
@ -39,7 +41,7 @@ static char ColorNoiseShader___doc__[] =
" Shader to add noise to the stroke colors.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int ColorNoiseShader___init__(BPy_ColorNoiseShader *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstantColorShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char ConstantColorShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ConstantColorShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`ConstantColorShader`\n"
"\n"
"[Color shader]\n"
@ -43,7 +45,7 @@ static char ConstantColorShader___doc__[] =
" Assigns a constant color to every vertex of the Stroke.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int ConstantColorShader___init__(BPy_ConstantColorShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstantThicknessShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char ConstantThicknessShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ConstantThicknessShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`ConstantThicknessShader`\n"
"\n"
"[Thickness shader]\n"
@ -37,7 +39,7 @@ static char ConstantThicknessShader___doc__[] =
" Assigns an absolute constant thickness to every vertex of the Stroke.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int ConstantThicknessShader___init__(BPy_ConstantThicknessShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstrainedIncreasingThicknessShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char ConstrainedIncreasingThicknessShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ConstrainedIncreasingThicknessShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > "
":class:`ConstrainedIncreasingThicknessShader`\n"
"\n"
@ -44,7 +46,7 @@ static char ConstrainedIncreasingThicknessShader___doc__[] =
" fat short lines.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int ConstrainedIncreasingThicknessShader___init__(
BPy_ConstrainedIncreasingThicknessShader *self, PyObject *args, PyObject *kwds)

6
source/blender/freestyle/intern/python/StrokeShader/BPy_GuidingLinesShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GuidingLinesShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GuidingLinesShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`GuidingLinesShader`\n"
"\n"
"[Geometry shader]\n"
@ -45,7 +47,7 @@ static char GuidingLinesShader___doc__[] =
" approximation is.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int GuidingLinesShader___init__(BPy_GuidingLinesShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_IncreasingColorShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char IncreasingColorShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
IncreasingColorShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`IncreasingColorShader`\n"
"\n"
"[Color shader]\n"
@ -54,7 +56,7 @@ static char IncreasingColorShader___doc__[] =
" between the first and the last vertex.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int IncreasingColorShader___init__(BPy_IncreasingColorShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_IncreasingThicknessShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char IncreasingThicknessShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
IncreasingThicknessShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`IncreasingThicknessShader`\n"
"\n"
"[Thickness shader]\n"
@ -43,7 +45,7 @@ static char IncreasingThicknessShader___doc__[] =
" linearly interpolated from A to B.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int IncreasingThicknessShader___init__(BPy_IncreasingThicknessShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_PolygonalizationShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char PolygonalizationShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
PolygonalizationShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`PolygonalizationShader`\n"
"\n"
"[Geometry shader]\n"
@ -44,7 +46,7 @@ static char PolygonalizationShader___doc__[] =
" error is reached.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int PolygonalizationShader___init__(BPy_PolygonalizationShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_SamplingShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char SamplingShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
SamplingShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`SamplingShader`\n"
"\n"
"[Geometry shader]\n"
@ -37,7 +39,7 @@ static char SamplingShader___doc__[] =
" Resamples the stroke.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int SamplingShader___init__(BPy_SamplingShader *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char SmoothingShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
SmoothingShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`SmoothingShader`\n"
"\n"
"[Geometry shader]\n"
@ -57,7 +59,7 @@ static char SmoothingShader___doc__[] =
" prevent the diffusion across corners.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int SmoothingShader___init__(BPy_SmoothingShader *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/StrokeShader/BPy_SpatialNoiseShader.cpp
View File

@ -21,7 +21,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char SpatialNoiseShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
SpatialNoiseShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`SpatialNoiseShader`\n"
"\n"
"[Geometry shader]\n"
@ -47,7 +49,7 @@ static char SpatialNoiseShader___doc__[] =
" more noisy.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int SpatialNoiseShader___init__(BPy_SpatialNoiseShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureStepShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char StrokeTextureStepShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
StrokeTextureStepShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`StrokeTextureStepShader`\n"
"\n"
"[Texture shader]\n"
@ -37,7 +39,7 @@ static char StrokeTextureStepShader___doc__[] =
" Assigns a spacing factor to the texture coordinates of the Stroke.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int StrokeTextureStepShader___init__(BPy_StrokeTextureStepShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_ThicknessNoiseShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char ThicknessNoiseShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ThicknessNoiseShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`ThicknessNoiseShader`\n"
"\n"
"[Thickness shader]\n"
@ -39,7 +41,7 @@ static char ThicknessNoiseShader___doc__[] =
" Adds some noise to the stroke thickness.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int ThicknessNoiseShader___init__(BPy_ThicknessNoiseShader *self,
PyObject *args,

6
source/blender/freestyle/intern/python/StrokeShader/BPy_TipRemoverShader.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char TipRemoverShader___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
TipRemoverShader___doc__,
"Class hierarchy: :class:`freestyle.types.StrokeShader` > :class:`TipRemoverShader`\n"
"\n"
"[Geometry shader]\n"
@ -38,7 +40,7 @@ static char TipRemoverShader___doc__[] =
" Removes the stroke's extremities.\n"
"\n"
" :arg stroke: A Stroke object.\n"
" :type stroke: :class:`freestyle.types.Stroke`\n";
" :type stroke: :class:`freestyle.types.Stroke`\n");
static int TipRemoverShader___init__(BPy_TipRemoverShader *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DDouble.cpp
View File

@ -109,7 +109,9 @@ int UnaryFunction0DDouble_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DDouble___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DDouble___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DDouble`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -117,7 +119,7 @@ static char UnaryFunction0DDouble___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DDouble___init__(BPy_UnaryFunction0DDouble *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DEdgeNature.cpp
View File

@ -47,7 +47,9 @@ int UnaryFunction0DEdgeNature_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DEdgeNature___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DEdgeNature___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DEdgeNature`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -55,7 +57,7 @@ static char UnaryFunction0DEdgeNature___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DEdgeNature___init__(BPy_UnaryFunction0DEdgeNature *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DFloat.cpp
View File

@ -85,7 +85,9 @@ int UnaryFunction0DFloat_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DFloat___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DFloat___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DFloat`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -93,7 +95,7 @@ static char UnaryFunction0DFloat___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DFloat___init__(BPy_UnaryFunction0DFloat *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DId.cpp
View File

@ -46,7 +46,9 @@ int UnaryFunction0DId_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DId___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DId___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DId`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -54,7 +56,7 @@ static char UnaryFunction0DId___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DId___init__(BPy_UnaryFunction0DId *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DMaterial.cpp
View File

@ -46,7 +46,9 @@ int UnaryFunction0DMaterial_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DMaterial___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DMaterial___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DMaterial`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -54,7 +56,7 @@ static char UnaryFunction0DMaterial___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DMaterial___init__(BPy_UnaryFunction0DMaterial *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DUnsigned.cpp
View File

@ -49,7 +49,9 @@ int UnaryFunction0DUnsigned_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DUnsigned___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DUnsigned___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DUnsigned`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -57,7 +59,7 @@ static char UnaryFunction0DUnsigned___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DUnsigned___init__(BPy_UnaryFunction0DUnsigned *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVec2f.cpp
View File

@ -53,7 +53,9 @@ int UnaryFunction0DVec2f_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DVec2f___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DVec2f___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DVec2f`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -61,7 +63,7 @@ static char UnaryFunction0DVec2f___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DVec2f___init__(BPy_UnaryFunction0DVec2f *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVec3f.cpp
View File

@ -46,7 +46,9 @@ int UnaryFunction0DVec3f_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DVec3f___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DVec3f___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DVec3f`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -54,7 +56,7 @@ static char UnaryFunction0DVec3f___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DVec3f___init__(BPy_UnaryFunction0DVec3f *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp
View File

@ -49,7 +49,9 @@ int UnaryFunction0DVectorViewShape_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DVectorViewShape___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DVectorViewShape___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DVectorViewShape`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -58,7 +60,7 @@ static char UnaryFunction0DVectorViewShape___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DVectorViewShape___init__(BPy_UnaryFunction0DVectorViewShape *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DViewShape.cpp
View File

@ -54,7 +54,9 @@ int UnaryFunction0DViewShape_Init(PyObject *module)
//------------------------INSTANCE METHODS ----------------------------------
static char UnaryFunction0DViewShape___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
UnaryFunction0DViewShape___doc__,
"Class hierarchy: :class:`UnaryFunction0D` > :class:`UnaryFunction0DViewShape`\n"
"\n"
"Base class for unary functions (functors) that work on\n"
@ -62,7 +64,7 @@ static char UnaryFunction0DViewShape___doc__[] =
"\n"
".. method:: __init__()\n"
"\n"
" Default constructor.\n";
" Default constructor.\n");
static int UnaryFunction0DViewShape___init__(BPy_UnaryFunction0DViewShape *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Id/BPy_ShapeIdF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char ShapeIdF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ShapeIdF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DId` > :class:`ShapeIdF0D`\n"
"\n"
@ -43,7 +45,7 @@ static char ShapeIdF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The Id of the Shape the pointed Interface0D belongs to.\n"
" :rtype: :class:`freestyle.types.Id`\n";
" :rtype: :class:`freestyle.types.Id`\n");
static int ShapeIdF0D___init__(BPy_ShapeIdF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Material/BPy_MaterialF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char MaterialF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
MaterialF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DMaterial` > :class:`MaterialF0D`\n"
"\n"
@ -46,7 +48,7 @@ static char MaterialF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The material of the object evaluated at the pointed\n"
" Interface0D.\n"
" :rtype: :class:`freestyle.types.Material`\n";
" :rtype: :class:`freestyle.types.Material`\n");
static int MaterialF0D___init__(BPy_MaterialF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Nature_EdgeNature/BPy_CurveNatureF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char CurveNatureF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
CurveNatureF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DEdgeNature` > :class:`CurveNatureF0D`\n"
"\n"
@ -37,7 +39,7 @@ static char CurveNatureF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The nature of the 1D element to which the pointed Interface0D\n"
" belongs.\n"
" :rtype: :class:`freestyle.types.Nature`\n";
" :rtype: :class:`freestyle.types.Nature`\n");
static int CurveNatureF0D___init__(BPy_CurveNatureF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_Normal2DF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char Normal2DF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
Normal2DF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DVec2f` > :class:`Normal2DF0D`\n"
"\n"
@ -39,7 +41,7 @@ static char Normal2DF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The 2D normal of the 1D element evaluated at the pointed\n"
" Interface0D.\n"
" :rtype: :class:`mathutils.Vector`\n";
" :rtype: :class:`mathutils.Vector`\n");
static int Normal2DF0D___init__(BPy_Normal2DF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_VertexOrientation2DF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char VertexOrientation2DF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
VertexOrientation2DF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DVec2f` > :class:`VertexOrientation2DF0D`\n"
"\n"
@ -39,7 +41,7 @@ static char VertexOrientation2DF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The 2D oriented tangent to the 1D element evaluated at the\n"
" pointed Interface0D.\n"
" :rtype: :class:`mathutils.Vector`\n";
" :rtype: :class:`mathutils.Vector`\n");
static int VertexOrientation2DF0D___init__(BPy_VertexOrientation2DF0D *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/BPy_VertexOrientation3DF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char VertexOrientation3DF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
VertexOrientation3DF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DVec3f` > :class:`VertexOrientation3DF0D`\n"
"\n"
@ -39,7 +41,7 @@ static char VertexOrientation3DF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The 3D oriented tangent to the 1D element evaluated at the\n"
" pointed Interface0D.\n"
" :rtype: :class:`mathutils.Vector`\n";
" :rtype: :class:`mathutils.Vector`\n");
static int VertexOrientation3DF0D___init__(BPy_VertexOrientation3DF0D *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetOccludeeF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetOccludeeF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetOccludeeF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DViewShape` > :class:`GetOccludeeF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetOccludeeF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The ViewShape occluded by the pointed Interface0D.\n"
" :rtype: :class:`freestyle.types.ViewShape`\n";
" :rtype: :class:`freestyle.types.ViewShape`\n");
static int GetOccludeeF0D___init__(BPy_GetOccludeeF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetShapeF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetShapeF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetShapeF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DViewShape` > :class:`GetShapeF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetShapeF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The ViewShape containing the pointed Interface0D.\n"
" :rtype: :class:`freestyle.types.ViewShape`\n";
" :rtype: :class:`freestyle.types.ViewShape`\n");
static int GetShapeF0D___init__(BPy_GetShapeF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_Curvature2DAngleF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char Curvature2DAngleF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
Curvature2DAngleF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`Curvature2DAngleF0D`\n"
"\n"
@ -39,7 +41,7 @@ static char Curvature2DAngleF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The 2D curvature of the 1D element evaluated at the\n"
" pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int Curvature2DAngleF0D___init__(BPy_Curvature2DAngleF0D *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_DensityF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char DensityF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
DensityF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`DensityF0D`\n"
"\n"
@ -45,7 +47,7 @@ static char DensityF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The density of the image evaluated at the pointed\n"
" Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int DensityF0D___init__(BPy_DensityF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedXF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetProjectedXF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetProjectedXF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`GetProjectedXF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetProjectedXF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The X 3D projected coordinate of the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetProjectedXF0D___init__(BPy_GetProjectedXF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedYF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetProjectedYF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetProjectedYF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`GetProjectedYF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetProjectedYF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The Y 3D projected coordinate of the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetProjectedYF0D___init__(BPy_GetProjectedYF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedZF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetProjectedZF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetProjectedZF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`GetProjectedZF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetProjectedZF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The Z 3D projected coordinate of the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetProjectedZF0D___init__(BPy_GetProjectedZF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetXF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetXF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetXF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`GetXF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetXF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The X 3D coordinate of the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetXF0D___init__(BPy_GetXF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetYF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetYF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetYF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`GetYF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetYF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The Y 3D coordinate of the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetYF0D___init__(BPy_GetYF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetZF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetZF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetZF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`GetZF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetZF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The Z 3D coordinate of the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetZF0D___init__(BPy_GetZF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_LocalAverageDepthF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char LocalAverageDepthF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
LocalAverageDepthF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`LocalAverageDepthF0D`\n"
"\n"
@ -41,7 +43,7 @@ static char LocalAverageDepthF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The average depth around the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int LocalAverageDepthF0D___init__(BPy_LocalAverageDepthF0D *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_ZDiscontinuityF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char ZDiscontinuityF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
ZDiscontinuityF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DDouble` > :class:`ZDiscontinuityF0D`\n"
"\n"
@ -41,7 +43,7 @@ static char ZDiscontinuityF0D___doc__[] =
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The normalized distance between the pointed Interface0D\n"
" and the occludee.\n"
" :rtype: float\n";
" :rtype: float\n");
static int ZDiscontinuityF0D___init__(BPy_ZDiscontinuityF0D *self, PyObject *args, PyObject *kwds)
{

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetCurvilinearAbscissaF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetCurvilinearAbscissaF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetCurvilinearAbscissaF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DFloat` > :class:`GetCurvilinearAbscissaF0D`\n"
"\n"
@ -37,7 +39,7 @@ static char GetCurvilinearAbscissaF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The curvilinear abscissa of the pointed Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetCurvilinearAbscissaF0D___init__(BPy_GetCurvilinearAbscissaF0D *self,
PyObject *args,

6
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetParameterF0D.cpp
View File

@ -20,7 +20,9 @@ using namespace Freestyle;
//------------------------INSTANCE METHODS ----------------------------------
static char GetParameterF0D___doc__[] =
PyDoc_STRVAR(
/* Wrap. */
GetParameterF0D___doc__,
"Class hierarchy: :class:`freestyle.types.UnaryFunction0D` > "
":class:`freestyle.types.UnaryFunction0DFloat` > :class:`GetParameterF0D`\n"
"\n"
@ -36,7 +38,7 @@ static char GetParameterF0D___doc__[] =
" :arg it: An Interface0DIterator object.\n"
" :type it: :class:`freestyle.types.Interface0DIterator`\n"
" :return: The parameter of an Interface0D.\n"
" :rtype: float\n";
" :rtype: float\n");
static int GetParameterF0D___init__(BPy_GetParameterF0D *self, PyObject *args, PyObject *kwds)
{

Some files were not shown because too many files have changed in this diff Show More