fake-bpy-module 20240210__py3-none-any.whl → 20240326__py3-none-any.whl

mathutils/bvhtree/__init__.pyi

@@ -1,4 +1,3 @@
-import sys
 import typing
 import bmesh.types
 import bpy.types
@@ -7,12 +6,14 @@ import mathutils
 GenericType = typing.TypeVar("GenericType")
 
 class BVHTree:
+    """ """
+
     @classmethod
-    def FromBMesh(cls, bmesh: "bmesh.types.BMesh", epsilon: float = 0.0):
+    def FromBMesh(cls, bmesh: bmesh.types.BMesh, epsilon: float = 0.0):
         """BVH tree based on `BMesh` data.
 
         :param bmesh: BMesh data.
-        :type bmesh: 'bmesh.types.BMesh'
+        :type bmesh: bmesh.types.BMesh
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
         :type epsilon: float
         """
@@ -21,8 +22,8 @@ class BVHTree:
     @classmethod
     def FromObject(
         cls,
-        object: "bpy.types.Object",
-        depsgraph: "bpy.types.Depsgraph",
+        object: bpy.types.Object,
+        depsgraph: bpy.types.Depsgraph,
         deform: bool = True,
         render=False,
         cage: bool = False,
@@ -31,11 +32,12 @@ class BVHTree:
         """BVH tree based on `Object` data.
 
         :param object: Object data.
-        :type object: 'bpy.types.Object'
+        :type object: bpy.types.Object
         :param depsgraph: Depsgraph to use for evaluating the mesh.
-        :type depsgraph: 'bpy.types.Depsgraph'
+        :type depsgraph: bpy.types.Depsgraph
         :param deform: Use mesh with deformations.
         :type deform: bool
+        :param render:
         :param cage: Use modifiers cage.
         :type cage: bool
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
@@ -45,81 +47,78 @@ class BVHTree:
 
     @classmethod
     def FromPolygons(
-        cls,
-        vertices: typing.List[float],
-        polygons: "bpy.types.Sequence",
-        all_triangles: bool = False,
-        epsilon: float = 0.0,
+        cls, vertices, polygons, all_triangles: bool = False, epsilon: float = 0.0
     ):
         """BVH tree constructed geometry passed in as arguments.
 
-        :param vertices: float triplets each representing ``(x, y, z)``
-        :type vertices: typing.List[float]
+        :param vertices: float triplets each representing (x, y, z)
         :param polygons: Sequence of polyugons, each containing indices to the vertices argument.
-        :type polygons: 'bpy.types.Sequence'
-        :param all_triangles: Use when all **polygons** are triangles for more efficient conversion.
+        :param all_triangles: Use when all polygons are triangles for more efficient conversion.
         :type all_triangles: bool
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
         :type epsilon: float
         """
         ...
 
-    def find_nearest(self, origin, distance: float = 1.84467e19) -> typing.Tuple:
+    def find_nearest(self, origin, distance: float = 1.84467e19) -> float:
         """Find the nearest element (typically face index) to a point.
 
-        :param co: Find nearest element to this point.
-        :type co: typing.Union[typing.Sequence[float], 'mathutils.Vector']
-        :param distance: Maximum distance threshold.
-        :type distance: float
-        :rtype: typing.Tuple
-        :return: Returns a tuple (`Vector` location, `Vector` normal, int index, float distance), Values will all be None if no hit is found.
+                :param origin:
+                :param distance: Maximum distance threshold.
+                :type distance: float
+                :return: Returns a tuple
+        (`Vector` location, `Vector` normal, int index, float distance),
+        Values will all be None if no hit is found.
+                :rtype: tuple
         """
         ...
 
-    def find_nearest_range(self, origin, distance: float = 1.84467e19) -> typing.List:
+    def find_nearest_range(self, origin, distance: float = 1.84467e19) -> float:
         """Find the nearest elements (typically face index) to a point in the distance range.
 
-        :param co: Find nearest elements to this point.
-        :type co: typing.Union[typing.Sequence[float], 'mathutils.Vector']
-        :param distance: Maximum distance threshold.
-        :type distance: float
-        :rtype: typing.List
-        :return: Returns a list of tuples (`Vector` location, `Vector` normal, int index, float distance),
+                :param origin:
+                :param distance: Maximum distance threshold.
+                :type distance: float
+                :return: Returns a list of tuples
+        (`Vector` location, `Vector` normal, int index, float distance),
+                :rtype: list
         """
         ...
 
-    def overlap(self, other_tree: "BVHTree") -> typing.List:
+    def overlap(self, other_tree: BVHTree) -> BVHTree:
         """Find overlapping indices between 2 trees.
 
         :param other_tree: Other tree to perform overlap test on.
-        :type other_tree: 'BVHTree'
-        :rtype: typing.List
-        :return: Returns a list of unique index pairs, the first index referencing this tree, the second referencing the **other_tree**.
+        :type other_tree: BVHTree
+        :return: Returns a list of unique index pairs,      the first index referencing this tree, the second referencing the other_tree.
+        :rtype: list
         """
         ...
 
     def ray_cast(
         self,
-        origin: typing.Union[typing.Sequence[float], "mathutils.Vector"],
-        direction: typing.Union[typing.Sequence[float], "mathutils.Vector"],
-        distance: float = "sys.float_info.max",
-    ) -> typing.Tuple:
+        origin: typing.Union[typing.Sequence[float], mathutils.Vector],
+        direction: typing.Union[typing.Sequence[float], mathutils.Vector],
+        distance: float = None,
+    ) -> float:
         """Cast a ray onto the mesh.
 
-        :param origin: Start location of the ray in object space.
-        :type origin: typing.Union[typing.Sequence[float], 'mathutils.Vector']
-        :param direction: Direction of the ray in object space.
-        :type direction: typing.Union[typing.Sequence[float], 'mathutils.Vector']
-        :param distance: Maximum distance threshold.
-        :type distance: float
-        :rtype: typing.Tuple
-        :return: Returns a tuple (`Vector` location, `Vector` normal, int index, float distance), Values will all be None if no hit is found.
+                :param origin: Start location of the ray in object space.
+                :type origin: typing.Union[typing.Sequence[float], mathutils.Vector]
+                :param direction: Direction of the ray in object space.
+                :type direction: typing.Union[typing.Sequence[float], mathutils.Vector]
+                :param distance: Maximum distance threshold.
+                :type distance: float
+                :return: Returns a tuple
+        (`Vector` location, `Vector` normal, int index, float distance),
+        Values will all be None if no hit is found.
+                :rtype: tuple
         """
         ...
 
-    def __init__(self, size) -> typing.Any:
+    def __init__(self, size):
         """
 
-        :rtype: typing.Any
+        :param size:
         """
         ...