fake-bpy-module 20240327__py3-none-any.whl → 20240330__py3-none-any.whl

freestyle/shaders/__init__.pyi

@@ -7,11 +7,10 @@ GenericType = typing.TypeVar("GenericType")
 class BackboneStretcherShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `BackboneStretcherShader`[Geometry shader]"""
 
-    def __init__(self, amount: float = 2.0):
+    def __init__(self, amount=2.0):
         """Builds a BackboneStretcherShader object.
 
         :param amount: The stretching amount value.
-        :type amount: float
         """
         ...
 
@@ -27,13 +26,12 @@ class BackboneStretcherShader:
 class BezierCurveShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `BezierCurveShader`[Geometry shader]"""
 
-    def __init__(self, error: float = 4.0):
+    def __init__(self, error=4.0):
         """Builds a BezierCurveShader object.
 
                 :param error: The error we're allowing for the approximation. This
         error is the max distance allowed between the new curve and the
         original geometry.
-                :type error: float
         """
         ...
 
@@ -71,8 +69,8 @@ class CalligraphicShader:
 
     def __init__(
         self,
-        thickness_min: float,
-        thickness_max: float,
+        thickness_min,
+        thickness_max,
         orientation: typing.Union[typing.Sequence[float], mathutils.Vector],
         clamp: bool,
     ):
@@ -80,9 +78,7 @@ class CalligraphicShader:
 
                 :param thickness_min: The minimum thickness in the direction
         perpendicular to the main direction.
-                :type thickness_min: float
                 :param thickness_max: The maximum thickness in the main direction.
-                :type thickness_max: float
                 :param orientation: The 2D vector giving the main direction.
                 :type orientation: typing.Union[typing.Sequence[float], mathutils.Vector]
                 :param clamp: If true, the strokes are drawn in black when the stroke
@@ -107,13 +103,11 @@ class CalligraphicShader:
 class ColorNoiseShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ColorNoiseShader`[Color shader]"""
 
-    def __init__(self, amplitude: float, period: float):
+    def __init__(self, amplitude, period):
         """Builds a ColorNoiseShader object.
 
         :param amplitude: The amplitude of the noise signal.
-        :type amplitude: float
         :param period: The period of the noise signal.
-        :type period: float
         """
         ...
 
@@ -128,17 +122,13 @@ class ColorNoiseShader:
 class ConstantColorShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ConstantColorShader`[Color shader]"""
 
-    def __init__(self, red: float, green: float, blue: float, alpha: float = 1.0):
+    def __init__(self, red, green, blue, alpha=1.0):
         """Builds a ConstantColorShader object.
 
         :param red: The red component.
-        :type red: float
         :param green: The green component.
-        :type green: float
         :param blue: The blue component.
-        :type blue: float
         :param alpha: The alpha value.
-        :type alpha: float
         """
         ...
 
@@ -153,11 +143,10 @@ class ConstantColorShader:
 class ConstantThicknessShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ConstantThicknessShader`[Thickness shader]"""
 
-    def __init__(self, thickness: float):
+    def __init__(self, thickness):
         """Builds a ConstantThicknessShader object.
 
         :param thickness: The thickness that must be assigned to the stroke.
-        :type thickness: float
         """
         ...
 
@@ -172,15 +161,12 @@ class ConstantThicknessShader:
 class ConstrainedIncreasingThicknessShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ConstrainedIncreasingThicknessShader`[Thickness shader]"""
 
-    def __init__(self, thickness_min: float, thickness_max: float, ratio: float):
+    def __init__(self, thickness_min, thickness_max, ratio):
         """Builds a ConstrainedIncreasingThicknessShader object.
 
         :param thickness_min: The minimum thickness.
-        :type thickness_min: float
         :param thickness_max: The maximum thickness.
-        :type thickness_max: float
         :param ratio: The thickness/length ratio that we don't want to exceed.
-        :type ratio: float
         """
         ...
 
@@ -197,14 +183,13 @@ class ConstrainedIncreasingThicknessShader:
 class GuidingLinesShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `GuidingLinesShader`[Geometry shader]"""
 
-    def __init__(self, offset: float):
+    def __init__(self, offset):
         """Builds a GuidingLinesShader object.
 
                 :param offset: The line that replaces the stroke is initially in the
         middle of the initial stroke bounding box. offset is the value
         of the displacement which is applied to this line along its
         normal.
-                :type offset: float
         """
         ...
 
@@ -226,33 +211,25 @@ class IncreasingColorShader:
 
     def __init__(
         self,
-        red_min: float,
-        green_min: float,
-        blue_min: float,
-        alpha_min: float,
-        red_max: float,
-        green_max: float,
-        blue_max: float,
-        alpha_max: float,
+        red_min,
+        green_min,
+        blue_min,
+        alpha_min,
+        red_max,
+        green_max,
+        blue_max,
+        alpha_max,
     ):
         """Builds an IncreasingColorShader object.
 
         :param red_min: The first color red component.
-        :type red_min: float
         :param green_min: The first color green component.
-        :type green_min: float
         :param blue_min: The first color blue component.
-        :type blue_min: float
         :param alpha_min: The first color alpha value.
-        :type alpha_min: float
         :param red_max: The second color red component.
-        :type red_max: float
         :param green_max: The second color green component.
-        :type green_max: float
         :param blue_max: The second color blue component.
-        :type blue_max: float
         :param alpha_max: The second color alpha value.
-        :type alpha_max: float
         """
         ...
 
@@ -269,13 +246,11 @@ class IncreasingColorShader:
 class IncreasingThicknessShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `IncreasingThicknessShader`[Thickness shader]"""
 
-    def __init__(self, thickness_A: float, thickness_B: float):
+    def __init__(self, thickness_A, thickness_B):
         """Builds an IncreasingThicknessShader object.
 
         :param thickness_A: The first thickness value.
-        :type thickness_A: float
         :param thickness_B: The second thickness value.
-        :type thickness_B: float
         """
         ...
 
@@ -294,14 +269,13 @@ class IncreasingThicknessShader:
 class PolygonalizationShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `PolygonalizationShader`[Geometry shader]"""
 
-    def __init__(self, error: float):
+    def __init__(self, error):
         """Builds a PolygonalizationShader object.
 
                 :param error: The error we want our polygonal approximation to have
         with respect to the original geometry. The smaller, the closer
         the new stroke is to the original one. This error corresponds to
         the maximum distance between the new stroke and the old one.
-                :type error: float
         """
         ...
 
@@ -337,11 +311,10 @@ class RoundCapShader:
 class SamplingShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `SamplingShader`[Geometry shader]"""
 
-    def __init__(self, sampling: float):
+    def __init__(self, sampling):
         """Builds a SamplingShader object.
 
         :param sampling: The sampling to use for the stroke resampling.
-        :type sampling: float
         """
         ...
 
@@ -358,33 +331,25 @@ class SmoothingShader:
 
     def __init__(
         self,
-        num_iterations: int = 100,
-        factor_point: float = 0.1,
-        factor_curvature: float = 0.0,
-        factor_curvature_difference: float = 0.2,
-        aniso_point: float = 0.0,
-        aniso_normal: float = 0.0,
-        aniso_curvature: float = 0.0,
-        carricature_factor: float = 1.0,
+        num_iterations=100,
+        factor_point=0.1,
+        factor_curvature=0.0,
+        factor_curvature_difference=0.2,
+        aniso_point=0.0,
+        aniso_normal=0.0,
+        aniso_curvature=0.0,
+        carricature_factor=1.0,
     ):
         """Builds a SmoothingShader object.
 
         :param num_iterations: The number of iterations.
-        :type num_iterations: int
         :param factor_point: 0.1
-        :type factor_point: float
         :param factor_curvature: 0.0
-        :type factor_curvature: float
         :param factor_curvature_difference: 0.2
-        :type factor_curvature_difference: float
         :param aniso_point: 0.0
-        :type aniso_point: float
         :param aniso_normal: 0.0
-        :type aniso_normal: float
         :param aniso_curvature: 0.0
-        :type aniso_curvature: float
         :param carricature_factor: 1.0
-        :type carricature_factor: float
         """
         ...
 
@@ -402,22 +367,12 @@ class SmoothingShader:
 class SpatialNoiseShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `SpatialNoiseShader`[Geometry shader]"""
 
-    def __init__(
-        self,
-        amount: float,
-        scale: float,
-        num_octaves: int,
-        smooth: bool,
-        pure_random: bool,
-    ):
+    def __init__(self, amount, scale, num_octaves, smooth: bool, pure_random: bool):
         """Builds a SpatialNoiseShader object.
 
         :param amount: The amplitude of the noise.
-        :type amount: float
         :param scale: The noise frequency.
-        :type scale: float
         :param num_octaves: The number of octaves
-        :type num_octaves: int
         :param smooth: True if you want the noise to be smooth.
         :type smooth: bool
         :param pure_random: True if you don't want any coherence.
@@ -447,11 +402,10 @@ class SquareCapShader:
 class StrokeTextureStepShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `StrokeTextureStepShader`[Texture shader]"""
 
-    def __init__(self, step: float):
+    def __init__(self, step):
         """Builds a StrokeTextureStepShader object.
 
         :param step: The spacing along the stroke.
-        :type step: float
         """
         ...
 
@@ -466,13 +420,11 @@ class StrokeTextureStepShader:
 class ThicknessNoiseShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `ThicknessNoiseShader`[Thickness shader]"""
 
-    def __init__(self, amplitude: float, period: float):
+    def __init__(self, amplitude, period):
         """Builds a ThicknessNoiseShader object.
 
         :param amplitude: The amplitude of the noise signal.
-        :type amplitude: float
         :param period: The period of the noise signal.
-        :type period: float
         """
         ...
 
@@ -487,12 +439,11 @@ class ThicknessNoiseShader:
 class TipRemoverShader:
     """Class hierarchy: `freestyle.types.StrokeShader` > `TipRemoverShader`[Geometry shader]"""
 
-    def __init__(self, tip_length: float):
+    def __init__(self, tip_length):
         """Builds a TipRemoverShader object.
 
                 :param tip_length: The length of the piece of stroke we want to remove
         at each extremity.
-                :type tip_length: float
         """
         ...