25 if (module ==
nullptr) {
32 PyModule_AddObjectRef(module,
"Noise", (PyObject *)&
FrsNoise_Type);
42 "Class to provide Perlin noise functionalities.\n"
44 ".. method:: __init__(seed = -1)\n"
46 " Builds a Noise object. Seed is an optional argument. The seed value is used\n"
47 " as a seed for random number generation if it is equal to or greater than zero;\n"
48 " otherwise, time is used as a seed.\n"
50 " :param seed: Seed for random number generation.\n"
51 " :type seed: int\n");
54 static const char *kwlist[] = {
"seed",
nullptr};
57 if (!PyArg_ParseTupleAndKeywords(args,
76 Py_TYPE(self)->tp_free((PyObject *)self);
81 return PyUnicode_FromFormat(
"Noise - address: %p", self->
n);
86 FrsNoise_turbulence1_doc,
87 ".. method:: turbulence1(v, freq, amp, oct=4)\n"
89 " Returns a noise value for a 1D element.\n"
91 " :param v: One-dimensional sample point.\n"
93 " :param freq: Noise frequency.\n"
94 " :type freq: float\n"
95 " :param amp: Amplitude.\n"
97 " :param oct: Number of octaves.\n"
99 " :return: A noise value.\n"
103 static const char *kwlist[] = {
"seed",
nullptr};
105 if (!PyArg_ParseTupleAndKeywords(args,
113 PyErr_SetString(PyExc_TypeError,
"optional argument 1 must be of type int");
124 static const char *kwlist[] = {
"v",
"oct",
nullptr};
129 if (!PyArg_ParseTupleAndKeywords(args,
134 ":turbulence_smooth",
146 static const char *kwlist[] = {
"v",
"freq",
"amp",
"oct",
nullptr};
150 if (!PyArg_ParseTupleAndKeywords(args,
166 return PyFloat_FromDouble(self->
n->
turbulence1(f1, f2, f3, i));
171 FrsNoise_turbulence2_doc,
172 ".. method:: turbulence2(v, freq, amp, oct=4)\n"
174 " Returns a noise value for a 2D element.\n"
176 " :param v: Two-dimensional sample point.\n"
177 " :type v: :class:`mathutils.Vector` | tuple[float, float] | list[float]\n"
178 " :param freq: Noise frequency.\n"
179 " :type freq: float\n"
180 " :param amp: Amplitude.\n"
181 " :type amp: float\n"
182 " :param oct: Number of octaves.\n"
184 " :return: A noise value.\n"
188 static const char *kwlist[] = {
"v",
"freq",
"amp",
"oct",
nullptr};
194 if (!PyArg_ParseTupleAndKeywords(args,
211 PyErr_SetString(PyExc_TypeError,
212 "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
216 return PyFloat_FromDouble(t);
221 FrsNoise_turbulence3_doc,
222 ".. method:: turbulence3(v, freq, amp, oct=4)\n"
224 " Returns a noise value for a 3D element.\n"
226 " :param v: Three-dimensional sample point.\n"
227 " :type v: :class:`mathutils.Vector` | tuple[float, float, float] | list[float]\n"
228 " :param freq: Noise frequency.\n"
229 " :type freq: float\n"
230 " :param amp: Amplitude.\n"
231 " :type amp: float\n"
232 " :param oct: Number of octaves.\n"
234 " :return: A noise value.\n"
238 static const char *kwlist[] = {
"v",
"freq",
"amp",
"oct",
nullptr};
244 if (!PyArg_ParseTupleAndKeywords(args,
261 PyErr_SetString(PyExc_TypeError,
262 "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
266 return PyFloat_FromDouble(t);
271 FrsNoise_smoothNoise1_doc,
272 ".. method:: smoothNoise1(v)\n"
274 " Returns a smooth noise value for a 1D element.\n"
276 " :param v: One-dimensional sample point.\n"
278 " :return: A smooth noise value.\n"
282 static const char *kwlist[] = {
"v",
nullptr};
285 if (!PyArg_ParseTupleAndKeywords(args,
299 FrsNoise_smoothNoise2_doc,
300 ".. method:: smoothNoise2(v)\n"
302 " Returns a smooth noise value for a 2D element.\n"
304 " :param v: Two-dimensional sample point.\n"
305 " :type v: :class:`mathutils.Vector` | tuple[float, float] | list[float]\n"
306 " :return: A smooth noise value.\n"
310 static const char *kwlist[] = {
"v",
nullptr};
314 if (!PyArg_ParseTupleAndKeywords(args,
324 PyErr_SetString(PyExc_TypeError,
325 "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
329 return PyFloat_FromDouble(t);
334 FrsNoise_smoothNoise3_doc,
335 ".. method:: smoothNoise3(v)\n"
337 " Returns a smooth noise value for a 3D element.\n"
339 " :param v: Three-dimensional sample point.\n"
340 " :type v: :class:`mathutils.Vector` | tuple[float, float, float] | list[float]\n"
341 " :return: A smooth noise value.\n"
345 static const char *kwlist[] = {
"v",
nullptr};
349 if (!PyArg_ParseTupleAndKeywords(args,
359 PyErr_SetString(PyExc_TypeError,
360 "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
364 return PyFloat_FromDouble(t);
369# pragma clang diagnostic push
370# pragma clang diagnostic ignored "-Wcast-function-type"
372# pragma GCC diagnostic push
373# pragma GCC diagnostic ignored "-Wcast-function-type"
380 METH_VARARGS | METH_KEYWORDS,
381 FrsNoise_turbulence1_doc},
384 METH_VARARGS | METH_KEYWORDS,
385 FrsNoise_turbulence2_doc},
388 METH_VARARGS | METH_KEYWORDS,
389 FrsNoise_turbulence3_doc},
392 METH_VARARGS | METH_KEYWORDS,
393 FrsNoise_smoothNoise1_doc},
396 METH_VARARGS | METH_KEYWORDS,
397 FrsNoise_smoothNoise2_doc},
400 METH_VARARGS | METH_KEYWORDS,
401 FrsNoise_smoothNoise3_doc},
402 {
"rand", (PyCFunction)
FrsNoise_drand, METH_VARARGS | METH_KEYWORDS,
nullptr},
403 {
"turbulence_smooth",
405 METH_VARARGS | METH_KEYWORDS,
407 {
nullptr,
nullptr, 0,
nullptr},
412# pragma clang diagnostic pop
414# pragma GCC diagnostic pop
421 PyVarObject_HEAD_INIT(
nullptr, 0)
440 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
bool Vec3f_ptr_from_PyObject(PyObject *obj, Vec3f &vec)
bool Vec2f_ptr_from_PyObject(PyObject *obj, Vec2f &vec)
PyDoc_STRVAR(FalseBP1D___doc__, "Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > :class:`FalseBP1D`\n" "\n" ".. method:: __call__(inter1, inter2)\n" "\n" " Always returns false.\n" "\n" " :param inter1: The first Interface1D object.\n" " :type inter1: :class:`freestyle.types.Interface1D`\n" " :param inter2: The second Interface1D object.\n" " :type inter2: :class:`freestyle.types.Interface1D`\n" " :return: False.\n" " :rtype: bool\n")
static PyObject * FrsNoise_repr(BPy_FrsNoise *self)
static PyObject * FrsNoise_turbulence2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static void FrsNoise_dealloc(BPy_FrsNoise *self)
int FrsNoise_Init(PyObject *module)
static PyObject * FrsNoise_turbulence_smooth(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_smoothNoise3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_turbulence3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
PyTypeObject FrsNoise_Type
static PyObject * FrsNoise_drand(BPy_FrsNoise *, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_smoothNoise1(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_turbulence1(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_smoothNoise2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyMethodDef BPy_FrsNoise_methods[]
static int FrsNoise_init(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
Pseudo-random number generator.
float turbulence3(Vec3f &v, float freq, float amp, uint oct=4)
float turbulence1(float arg, float freq, float amp, uint oct=4)
float turbulence2(Vec2f &v, float freq, float amp, uint oct=4)
float smoothNoise3(Vec3f &vec)
float smoothNoise1(float arg)
float smoothNoise2(Vec2f &vec)
real turbulenceSmooth(real x, uint nbOctave=8)
static void srand48(long seedval)
VecMat::Vec3< float > Vec3f
VecMat::Vec2< float > Vec2f
Freestyle::PseudoNoise * pn
PyObject_HEAD Freestyle::Noise * n