fake-bpy-module 20231205__py3-none-any.whl → 20231207__py3-none-any.whl

freestyle/utils/ContextFunctions/__init__.pyi

@@ -0,0 +1,127 @@
+import sys
+import typing
+import freestyle.types
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def get_border() -> typing.Tuple:
+    ''' Returns the border.
+
+    :rtype: typing.Tuple
+    :return: A tuple of 4 numbers (xmin, ymin, xmax, ymax).
+    '''
+
+    ...
+
+
+def get_canvas_height() -> int:
+    ''' Returns the canvas height.
+
+    :rtype: int
+    :return: The canvas height.
+    '''
+
+    ...
+
+
+def get_canvas_width() -> int:
+    ''' Returns the canvas width.
+
+    :rtype: int
+    :return: The canvas width.
+    '''
+
+    ...
+
+
+def get_selected_fedge() -> 'freestyle.types.FEdge':
+    ''' Returns the selected FEdge.
+
+    :rtype: 'freestyle.types.FEdge'
+    :return: The selected FEdge.
+    '''
+
+    ...
+
+
+def get_time_stamp() -> int:
+    ''' Returns the system time stamp.
+
+    :rtype: int
+    :return: The system time stamp.
+    '''
+
+    ...
+
+
+def load_map(file_name: str,
+             map_name: str,
+             num_levels: int = 4,
+             sigma: float = 1.0):
+    ''' Loads an image map for further reading.
+
+    :param file_name: The name of the image file.
+    :type file_name: str
+    :param map_name: The name that will be used to access this image.
+    :type map_name: str
+    :param num_levels: The number of levels in the map pyramid (default = 4). If num_levels == 0, the complete pyramid is built.
+    :type num_levels: int
+    :param sigma: The sigma value of the gaussian function.
+    :type sigma: float
+    '''
+
+    ...
+
+
+def read_complete_view_map_pixel(level: int, x: int, y: int) -> float:
+    ''' Reads a pixel in the complete view map.
+
+    :param level: The level of the pyramid in which we wish to read the pixel.
+    :type level: int
+    :param x: The x coordinate of the pixel we wish to read. The origin is in the lower-left corner.
+    :type x: int
+    :param y: The y coordinate of the pixel we wish to read. The origin is in the lower-left corner.
+    :type y: int
+    :rtype: float
+    :return: The floating-point value stored for that pixel.
+    '''
+
+    ...
+
+
+def read_directional_view_map_pixel(orientation: int, level: int, x: int,
+                                    y: int) -> float:
+    ''' Reads a pixel in one of the oriented view map images.
+
+    :param orientation: The number telling which orientation we want to check.
+    :type orientation: int
+    :param level: The level of the pyramid in which we wish to read the pixel.
+    :type level: int
+    :param x: The x coordinate of the pixel we wish to read. The origin is in the lower-left corner.
+    :type x: int
+    :param y: The y coordinate of the pixel we wish to read. The origin is in the lower-left corner.
+    :type y: int
+    :rtype: float
+    :return: The floating-point value stored for that pixel.
+    '''
+
+    ...
+
+
+def read_map_pixel(map_name: str, level: int, x: int, y: int) -> float:
+    ''' Reads a pixel in a user-defined map.
+
+    :param map_name: The name of the map.
+    :type map_name: str
+    :param level: The level of the pyramid in which we wish to read the pixel.
+    :type level: int
+    :param x: The x coordinate of the pixel we wish to read. The origin is in the lower-left corner.
+    :type x: int
+    :param y: The y coordinate of the pixel we wish to read. The origin is in the lower-left corner.
+    :type y: int
+    :rtype: float
+    :return: The floating-point value stored for that pixel.
+    '''
+
+    ...

freestyle/utils/__init__.pyi

@@ -0,0 +1,246 @@
+import sys
+import typing
+import bpy.types
+import freestyle.types
+
+from . import ContextFunctions
+
+GenericType = typing.TypeVar("GenericType")
+
+
+class BoundingBox:
+    ''' Object representing a bounding box consisting out of 2 2D vectors
+    '''
+
+    def inside(self, other):
+        ''' True if self inside other, False otherwise
+
+        '''
+        ...
+
+
+class StrokeCollector:
+    ''' Collects and Stores stroke objects
+    '''
+
+    def shade(self, stroke):
+        ''' 
+
+        '''
+        ...
+
+
+def angle_x_normal(i):
+    ''' unsigned angle between a Point's normal and the X axis, in radians
+
+    '''
+
+    ...
+
+
+def bound(lower, x, higher):
+    ''' Returns x bounded by a maximum and minimum value. Equivalent to: return min(max(x, lower), higher)
+
+    '''
+
+    ...
+
+
+def bounding_box(stroke):
+    ''' Returns the maximum and minimum coordinates (the bounding box) of the stroke's vertices
+
+    '''
+
+    ...
+
+
+def curvature_from_stroke_vertex(svert):
+    ''' The 3D curvature of an stroke vertex' underlying geometry The result is None or in the range [-inf, inf]
+
+    '''
+
+    ...
+
+
+def find_matching_vertex(id, it):
+    ''' Finds the matching vertex, or returns None.
+
+    '''
+
+    ...
+
+
+def getCurrentScene() -> 'bpy.types.Scene':
+    ''' Returns the current scene.
+
+    :rtype: 'bpy.types.Scene'
+    :return: The current scene.
+    '''
+
+    ...
+
+
+def get_chain_length(ve, orientation):
+    ''' Returns the 2d length of a given ViewEdge.
+
+    '''
+
+    ...
+
+
+def get_object_name(stroke):
+    ''' Returns the name of the object that this stroke is drawn on.
+
+    '''
+
+    ...
+
+
+def get_strokes():
+    ''' Get all strokes that are currently available
+
+    '''
+
+    ...
+
+
+def get_test_stroke():
+    ''' Returns a static stroke object for testing
+
+    '''
+
+    ...
+
+
+def integrate(func: 'freestyle.types.UnaryFunction0D',
+              it: 'freestyle.types.Interface0DIterator',
+              it_end: 'freestyle.types.Interface0DIterator',
+              integration_type: 'freestyle.types.IntegrationType'
+              ) -> typing.Union[int, float]:
+    ''' Returns a single value from a set of values evaluated at each 0D element of this 1D element.
+
+    :param func: The UnaryFunction0D used to compute a value at each Interface0D.
+    :type func: 'freestyle.types.UnaryFunction0D'
+    :param it: The Interface0DIterator used to iterate over the 0D elements of this 1D element. The integration will occur over the 0D elements starting from the one pointed by it.
+    :type it: 'freestyle.types.Interface0DIterator'
+    :param it_end: The Interface0DIterator pointing the end of the 0D elements of the 1D element.
+    :type it_end: 'freestyle.types.Interface0DIterator'
+    :param integration_type: The integration method used to compute a single value from a set of values.
+    :type integration_type: 'freestyle.types.IntegrationType'
+    :rtype: typing.Union[int, float]
+    :return: The single value obtained for the 1D element. The return value type is float if func is of the `UnaryFunction0DDouble` or `UnaryFunction0DFloat` type, and int if func is of the `UnaryFunction0DUnsigned` type.
+    '''
+
+    ...
+
+
+def is_poly_clockwise(stroke):
+    ''' True if the stroke is orientated in a clockwise way, False otherwise
+
+    '''
+
+    ...
+
+
+def iter_distance_along_stroke(stroke):
+    ''' Yields the absolute distance along the stroke up to the current vertex.
+
+    '''
+
+    ...
+
+
+def iter_distance_from_camera(stroke, range_min, range_max, normfac):
+    ''' Yields the distance to the camera relative to the maximum possible distance for every stroke vertex, constrained by given minimum and maximum values.
+
+    '''
+
+    ...
+
+
+def iter_distance_from_object(stroke, location, range_min, range_max, normfac):
+    ''' yields the distance to the given object relative to the maximum possible distance for every stroke vertex, constrained by given minimum and maximum values.
+
+    '''
+
+    ...
+
+
+def iter_material_value(stroke, func, attribute):
+    ''' Yields a specific material attribute from the vertex' underlying material.
+
+    '''
+
+    ...
+
+
+def iter_t2d_along_stroke(stroke):
+    ''' Yields the progress along the stroke.
+
+    '''
+
+    ...
+
+
+def material_from_fedge(fe):
+    ''' get the diffuse RGBA color from an FEdge
+
+    '''
+
+    ...
+
+
+def normal_at_I0D(i):
+    ''' Normal at an Interface0D object. In contrast to Normal2DF0D this function uses the actual data instead of underlying Fedge objects.
+
+    '''
+
+    ...
+
+
+def pairwise(iterable, types={}):
+    ''' Yields a tuple containing the previous and current object
+
+    '''
+
+    ...
+
+
+def rgb_to_bw(r, g, b):
+    ''' Method to convert rgb to a bw intensity value.
+
+    '''
+
+    ...
+
+
+def simplify(points, tolerance):
+    ''' Simplifies a set of points
+
+    '''
+
+    ...
+
+
+def stroke_curvature(it):
+    ''' Compute the 2D curvature at the stroke vertex pointed by the iterator 'it'. K = 1 / R where R is the radius of the circle going through the current vertex and its neighbors
+
+    '''
+
+    ...
+
+
+def stroke_normal(stroke):
+    ''' Compute the 2D normal at the stroke vertex pointed by the iterator 'it'. It is noted that Normal2DF0D computes normals based on underlying FEdges instead, which is inappropriate for strokes when they have already been modified by stroke geometry modifiers. The returned normals are dynamic: they update when the vertex position (and therefore the vertex normal) changes. for use in geometry modifiers it is advised to cast this generator function to a tuple or list
+
+    '''
+
+    ...
+
+
+def tripplewise(iterable):
+    ''' Yields a tuple containing the current object and its immediate neighbors
+
+    '''
+
+    ...

gpu/capabilities/__init__.pyi

@@ -0,0 +1,186 @@
+import sys
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def compute_shader_support_get() -> bool:
+    ''' Are compute shaders supported.
+
+    :rtype: bool
+    :return: True when supported, False when not supported.
+    '''
+
+    ...
+
+
+def extensions_get() -> typing.Tuple:
+    ''' Get supported extensions in the current context.
+
+    :rtype: typing.Tuple
+    :return: Extensions.
+    '''
+
+    ...
+
+
+def hdr_support_get():
+    ''' Return whether GPU backend supports High Dynamic range for viewport. :return: HDR support available. :rtype: bool
+
+    '''
+
+    ...
+
+
+def max_batch_indices_get() -> int:
+    ''' Get maximum number of vertex array indices.
+
+    :rtype: int
+    :return: Number of indices.
+    '''
+
+    ...
+
+
+def max_batch_vertices_get() -> int:
+    ''' Get maximum number of vertex array vertices.
+
+    :rtype: int
+    :return: Number of vertices.
+    '''
+
+    ...
+
+
+def max_texture_layers_get() -> int:
+    ''' Get maximum number of layers in texture.
+
+    :rtype: int
+    :return: Number of layers.
+    '''
+
+    ...
+
+
+def max_texture_size_get() -> int:
+    ''' Get estimated maximum texture size to be able to handle.
+
+    :rtype: int
+    :return: Texture size.
+    '''
+
+    ...
+
+
+def max_textures_frag_get() -> int:
+    ''' Get maximum supported texture image units used for accessing texture maps from the fragment shader.
+
+    :rtype: int
+    :return: Texture image units.
+    '''
+
+    ...
+
+
+def max_textures_geom_get() -> int:
+    ''' Get maximum supported texture image units used for accessing texture maps from the geometry shader.
+
+    :rtype: int
+    :return: Texture image units.
+    '''
+
+    ...
+
+
+def max_textures_get() -> int:
+    ''' Get maximum supported texture image units used for accessing texture maps from the vertex shader and the fragment processor.
+
+    :rtype: int
+    :return: Texture image units.
+    '''
+
+    ...
+
+
+def max_textures_vert_get() -> int:
+    ''' Get maximum supported texture image units used for accessing texture maps from the vertex shader.
+
+    :rtype: int
+    :return: Texture image units.
+    '''
+
+    ...
+
+
+def max_uniforms_frag_get() -> int:
+    ''' Get maximum number of values held in uniform variable storage for a fragment shader.
+
+    :rtype: int
+    :return: Number of values.
+    '''
+
+    ...
+
+
+def max_uniforms_vert_get() -> int:
+    ''' Get maximum number of values held in uniform variable storage for a vertex shader.
+
+    :rtype: int
+    :return: Number of values.
+    '''
+
+    ...
+
+
+def max_varying_floats_get() -> int:
+    ''' Get maximum number of varying variables used by vertex and fragment shaders.
+
+    :rtype: int
+    :return: Number of variables.
+    '''
+
+    ...
+
+
+def max_vertex_attribs_get() -> int:
+    ''' Get maximum number of vertex attributes accessible to a vertex shader.
+
+    :rtype: int
+    :return: Number of attributes.
+    '''
+
+    ...
+
+
+def max_work_group_count_get(index: int) -> int:
+    ''' Get maximum number of work groups that may be dispatched to a compute shader.
+
+    :param index: Index of the dimension.
+    :type index: int
+    :rtype: int
+    :return: Maximum number of work groups for the queried dimension.
+    '''
+
+    ...
+
+
+def max_work_group_size_get(index: int) -> int:
+    ''' Get maximum size of a work group that may be dispatched to a compute shader.
+
+    :param index: Index of the dimension.
+    :type index: int
+    :rtype: int
+    :return: Maximum size of a work group for the queried dimension.
+    '''
+
+    ...
+
+
+def shader_image_load_store_support_get() -> bool:
+    ''' Is image load/store supported.
+
+    :rtype: bool
+    :return: True when supported, False when not supported.
+    '''
+
+    ...