basilisk-engine 0.1.42__py3-none-any.whl → 0.1.43__py3-none-any.whl

basilisk/collisions/narrow/line_intersections.py

@@ -1,107 +1,107 @@
-import glm
-from .helper import is_ccw_turn
-
-# intersectionn algorithms for lines
-def line_line_intersect(points1:list[glm.vec2], points2:list[glm.vec2]) -> list[glm.vec2]:
-    """gets the intersection of 2 2d lines. if the lines are parallel, returns the second line"""
-    # orders points from smallest x to greatest x
-    points1 = sorted(points1, key=lambda p: (p.x, p.y))
-    points2 = sorted(points2, key=lambda p: (p.x, p.y))
-    vec1, vec2 = points1[1] - points1[0], points2[1] - points2[0]
-    
-    # if vectors have the same slope return the smallest line
-    if have_same_slope(vec1, vec2): return sorted(points1 + points2, key=lambda p: (p.x, p.y))[1:3]
-    
-    # line - line intersection
-    det = vec1.x * vec2.y - vec1.y * vec2.x
-    if det == 0: return []
-    t = (points2[0].x - points1[0].x) * vec2.y - (points2[0].y - points1[0].y) * vec2.x
-    t /= det
-    return [points1[0] + t * vec1]
-    
-def have_same_slope(vec1:glm.vec2, vec2:glm.vec2, epsilon:float=1e-5) -> bool:
-    """determines if two vectors moving in the positive x direction have the same slope"""
-    return abs(vec1.y * vec2.x - vec2.y * vec1.x) < epsilon
-
-def line_poly_intersect(line:list[glm.vec2], polygon:list[glm.vec2]) -> list[glm.vec2]: #TODO Reseach into faster algorithm < O(2n)
-    """computes which parts of the line clip with the polygon"""
-    # calculate the center of the polygon
-    assert len(polygon) > 2, 'polygon is does not contain engough points'
-    center = glm.vec2(0,0)
-    for point in polygon: center += point
-    center /= len(polygon)
-    orig_line = line[:]
-    # determine which points are in or out of the polygon
-    exterior_points = []
-    for i in range(len(polygon)): # nearest even number below n
-        for line_point in line[:]:
-            if not is_ccw_turn(polygon[i], polygon[(i + 1) % len(polygon)], line_point): # if point is on the outside
-                exterior_points.append((polygon[i], polygon[(i + 1) % len(polygon)], line_point)) # polypoint1, polypoint2, linepoint
-                line.remove(line_point) # removes line point if it is confirmed to be outside
-                
-    # determine what to with line based on number of points found outside
-    if len(exterior_points) == 0:
-        return line
-    if len(exterior_points) == 1:
-        return line_line_intersect(line + [exterior_points[0][2]], exterior_points[0][0:2]) + [line[0]] # [intersecting point, exterior point]
-    if len(exterior_points) == 2: # line must intersect with two edges
-        points = []
-        for i in range(len(polygon)):
-            intersection = line_line_intersect(orig_line, [polygon[i], polygon[(i + 1) % len(polygon)]])
-            if len(intersection) > 0: points += intersection
-            if len(points) > 1: break # exit if two intersections have been found
-        else: return [] # fallback if 0 or one intersections found
-        return points
-    
-def closest_two_lines(p1: glm.vec3, q1: glm.vec3, p2: glm.vec3, q2: glm.vec3, epsilon: float=1e-7) -> tuple[glm.vec3, glm.vec3]:
-    """
-    Determines the closest point on each line segment to the other line segment. 
-    """
-    # create direction vector
-    d1 = q1 - p1
-    d2 = q2 - p2
-    r = p1 - p2
-    
-    # get lengths of line segments
-    a = glm.dot(d1, d1)
-    e = glm.dot(d2, d2)
-    f = glm.dot(d2, r)
-    
-    # check if either or both line segment degenerate into points
-    if a <= epsilon and e <= epsilon:
-        # both segments degenerate
-        return p1, p2
-    
-    if a <= epsilon:
-        s = 0
-        t = glm.clamp(f / e, 0, 1)
-    else: 
-        c = glm.dot(d1, r)
-        if e <= epsilon:
-            # the second line degenerates to a point
-            t = 0
-            s = glm.clamp(-c / a, 0, 1)
-        else:
-            # if neither of them degenerate to a point
-            b = glm.dot(d1, d2)
-            denom = a * e - b ** 2 # this will always be non-negative
-            
-            # if segments are not parallel, compute closest point from l1 to l2
-            s = glm.clamp((b * f - c * e) / denom, 0, 1) if denom else 0
-            
-            # compute closest point from l2 on s1(s)
-            t = (b * s + f) / e
-            
-            # if t is not in [0, 1], clamp and recompute s
-            if t < 0:
-                t = 0
-                s = glm.clamp(-c / a, 0, 1)
-            elif t > 1:
-                t = 1
-                s = glm.clamp((b - c) / a, 0, 1)
-                
-    c1 = p1 + d1 * s
-    c2 = p2 + d2 * t
-    return c1, c2
-                
+import glm
+from .helper import is_ccw_turn
+
+# intersectionn algorithms for lines
+def line_line_intersect(points1:list[glm.vec2], points2:list[glm.vec2]) -> list[glm.vec2]:
+    """gets the intersection of 2 2d lines. if the lines are parallel, returns the second line"""
+    # orders points from smallest x to greatest x
+    points1 = sorted(points1, key=lambda p: (p.x, p.y))
+    points2 = sorted(points2, key=lambda p: (p.x, p.y))
+    vec1, vec2 = points1[1] - points1[0], points2[1] - points2[0]
+    
+    # if vectors have the same slope return the smallest line
+    if have_same_slope(vec1, vec2): return sorted(points1 + points2, key=lambda p: (p.x, p.y))[1:3]
+    
+    # line - line intersection
+    det = vec1.x * vec2.y - vec1.y * vec2.x
+    if det == 0: return []
+    t = (points2[0].x - points1[0].x) * vec2.y - (points2[0].y - points1[0].y) * vec2.x
+    t /= det
+    return [points1[0] + t * vec1]
+    
+def have_same_slope(vec1:glm.vec2, vec2:glm.vec2, epsilon:float=1e-5) -> bool:
+    """determines if two vectors moving in the positive x direction have the same slope"""
+    return abs(vec1.y * vec2.x - vec2.y * vec1.x) < epsilon
+
+def line_poly_intersect(line:list[glm.vec2], polygon:list[glm.vec2]) -> list[glm.vec2]: #TODO Reseach into faster algorithm < O(2n)
+    """computes which parts of the line clip with the polygon"""
+    # calculate the center of the polygon
+    assert len(polygon) > 2, 'polygon is does not contain engough points'
+    center = glm.vec2(0,0)
+    for point in polygon: center += point
+    center /= len(polygon)
+    orig_line = line[:]
+    # determine which points are in or out of the polygon
+    exterior_points = []
+    for i in range(len(polygon)): # nearest even number below n
+        for line_point in line[:]:
+            if not is_ccw_turn(polygon[i], polygon[(i + 1) % len(polygon)], line_point): # if point is on the outside
+                exterior_points.append((polygon[i], polygon[(i + 1) % len(polygon)], line_point)) # polypoint1, polypoint2, linepoint
+                line.remove(line_point) # removes line point if it is confirmed to be outside
+                
+    # determine what to with line based on number of points found outside
+    if len(exterior_points) == 0:
+        return line
+    if len(exterior_points) == 1:
+        return line_line_intersect(line + [exterior_points[0][2]], exterior_points[0][0:2]) + [line[0]] # [intersecting point, exterior point]
+    if len(exterior_points) == 2: # line must intersect with two edges
+        points = []
+        for i in range(len(polygon)):
+            intersection = line_line_intersect(orig_line, [polygon[i], polygon[(i + 1) % len(polygon)]])
+            if len(intersection) > 0: points += intersection
+            if len(points) > 1: break # exit if two intersections have been found
+        else: return [] # fallback if 0 or one intersections found
+        return points
+    
+def closest_two_lines(p1: glm.vec3, q1: glm.vec3, p2: glm.vec3, q2: glm.vec3, epsilon: float=1e-7) -> tuple[glm.vec3, glm.vec3]:
+    """
+    Determines the closest point on each line segment to the other line segment. 
+    """
+    # create direction vector
+    d1 = q1 - p1
+    d2 = q2 - p2
+    r = p1 - p2
+    
+    # get lengths of line segments
+    a = glm.dot(d1, d1)
+    e = glm.dot(d2, d2)
+    f = glm.dot(d2, r)
+    
+    # check if either or both line segment degenerate into points
+    if a <= epsilon and e <= epsilon:
+        # both segments degenerate
+        return p1, p2
+    
+    if a <= epsilon:
+        s = 0
+        t = glm.clamp(f / e, 0, 1)
+    else: 
+        c = glm.dot(d1, r)
+        if e <= epsilon:
+            # the second line degenerates to a point
+            t = 0
+            s = glm.clamp(-c / a, 0, 1)
+        else:
+            # if neither of them degenerate to a point
+            b = glm.dot(d1, d2)
+            denom = a * e - b ** 2 # this will always be non-negative
+            
+            # if segments are not parallel, compute closest point from l1 to l2
+            s = glm.clamp((b * f - c * e) / denom, 0, 1) if denom else 0
+            
+            # compute closest point from l2 on s1(s)
+            t = (b * s + f) / e
+            
+            # if t is not in [0, 1], clamp and recompute s
+            if t < 0:
+                t = 0
+                s = glm.clamp(-c / a, 0, 1)
+            elif t > 1:
+                t = 1
+                s = glm.clamp((b - c) / a, 0, 1)
+                
+    c1 = p1 + d1 * s
+    c2 = p2 + d2 * t
+    return c1, c2
+                
         

basilisk/collisions/narrow/sutherland_hodgman.py

@@ -1,76 +1,76 @@
-import glm
-from .helper import is_ccw_turn
-from .line_intersections import line_line_intersect
-
-def sutherland_hodgman(subject:list[glm.vec2], clip:list[glm.vec2]) -> list[glm.vec2]:
-    """determines the clipped polygon vertices from ccw oriented polygons"""
-    output_poly = subject
-    
-    for i in range(len(clip)):
-        input_poly = output_poly
-        output_poly = []
-        
-        edge_start, edge_end = clip[i], clip[(i + 1) % len(clip)]
-        for j in range(len(input_poly)):
-            prev_point, curr_point = input_poly[j - 1], input_poly[j]
-
-            if is_ccw_turn(curr_point, edge_start, edge_end):
-                if not is_ccw_turn(prev_point, edge_start, edge_end):
-                    output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
-                output_poly.append(curr_point)
-            elif is_ccw_turn(prev_point, edge_start, edge_end):
-                output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
-                
-    return output_poly
-
-# def get_intersect(one: glm.vec2, two: glm.vec2, thr: glm.vec2, fou: glm.vec2) -> glm.vec2:
-#     """
-#     Gets the intersection point between two lines
-#     """
-#     deno = (one.x - two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x - fou.x)
-#     if deno == 0: # TODO determine if this happens
-#         print('sutherland-hodgman line intersection had zero denominator')
-#         return None
-#     x_num = (one.x * two.y - one.y * two.x) * (thr.x - fou.x) - (one.x - two.x) * (thr.x * fou.y - thr.y * fou.x)
-#     y_num = (one.x * two.y - one.y * two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x * fou.y - thr.y * fou.x)
-#     return glm.vec2(x_num / deno, y_num / deno)
-
-# def clip(poly: list[glm.vec2], one: glm.vec2, two: glm.vec2) -> list[glm.vec2]:
-#     """
-#     Clip all edges of polygon with one of the clipping edges
-#     """
-#     num_points = len(poly)
-#     new_points = []
-    
-#     for i in range(num_points):
-#         k    = (i + 1) % num_points
-#         veci = poly[i]
-#         veck = poly[k]
-        
-#         posi = (two.x - one.x) * (veci.y - one.y) - (two.y - one.y) * (veci.x - one.x)
-#         posk = (two.x - one.x) * (veck.y - one.y) - (two.y - one.y) * (veck.x - one.x)
-        
-#         if posi < 0 and posk < 0: new_points.append(veck)
-#         elif posi >= 0 and posk < 0: 
-            
-#             new_points.append(get_intersect(one, two, veci, veck))
-#             new_points.append(veck)
-            
-#         elif posi < 0 and posk >= 0:
-            
-#             new_points.append(get_intersect(one, two, veci, veck))
-        
-#     return new_points
-
-# def sutherland_hodgman(subj_poly:list[glm.vec2], clip_poly:list[glm.vec2]) -> list[glm.vec2]:
-#     """
-#     Determines the clipped polygon vertices from ccw oriented polygons.
-#     """
-#     num_clip = len(clip_poly)
-    
-#     for i in range(num_clip):
-#         k = (i + 1) % num_clip
-        
-#         subj_poly = clip(subj_poly, clip_poly[i], clip_poly[k])
-        
+import glm
+from .helper import is_ccw_turn
+from .line_intersections import line_line_intersect
+
+def sutherland_hodgman(subject:list[glm.vec2], clip:list[glm.vec2]) -> list[glm.vec2]:
+    """determines the clipped polygon vertices from ccw oriented polygons"""
+    output_poly = subject
+    
+    for i in range(len(clip)):
+        input_poly = output_poly
+        output_poly = []
+        
+        edge_start, edge_end = clip[i], clip[(i + 1) % len(clip)]
+        for j in range(len(input_poly)):
+            prev_point, curr_point = input_poly[j - 1], input_poly[j]
+
+            if is_ccw_turn(curr_point, edge_start, edge_end):
+                if not is_ccw_turn(prev_point, edge_start, edge_end):
+                    output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
+                output_poly.append(curr_point)
+            elif is_ccw_turn(prev_point, edge_start, edge_end):
+                output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
+                
+    return output_poly
+
+# def get_intersect(one: glm.vec2, two: glm.vec2, thr: glm.vec2, fou: glm.vec2) -> glm.vec2:
+#     """
+#     Gets the intersection point between two lines
+#     """
+#     deno = (one.x - two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x - fou.x)
+#     if deno == 0: # TODO determine if this happens
+#         print('sutherland-hodgman line intersection had zero denominator')
+#         return None
+#     x_num = (one.x * two.y - one.y * two.x) * (thr.x - fou.x) - (one.x - two.x) * (thr.x * fou.y - thr.y * fou.x)
+#     y_num = (one.x * two.y - one.y * two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x * fou.y - thr.y * fou.x)
+#     return glm.vec2(x_num / deno, y_num / deno)
+
+# def clip(poly: list[glm.vec2], one: glm.vec2, two: glm.vec2) -> list[glm.vec2]:
+#     """
+#     Clip all edges of polygon with one of the clipping edges
+#     """
+#     num_points = len(poly)
+#     new_points = []
+    
+#     for i in range(num_points):
+#         k    = (i + 1) % num_points
+#         veci = poly[i]
+#         veck = poly[k]
+        
+#         posi = (two.x - one.x) * (veci.y - one.y) - (two.y - one.y) * (veci.x - one.x)
+#         posk = (two.x - one.x) * (veck.y - one.y) - (two.y - one.y) * (veck.x - one.x)
+        
+#         if posi < 0 and posk < 0: new_points.append(veck)
+#         elif posi >= 0 and posk < 0: 
+            
+#             new_points.append(get_intersect(one, two, veci, veck))
+#             new_points.append(veck)
+            
+#         elif posi < 0 and posk >= 0:
+            
+#             new_points.append(get_intersect(one, two, veci, veck))
+        
+#     return new_points
+
+# def sutherland_hodgman(subj_poly:list[glm.vec2], clip_poly:list[glm.vec2]) -> list[glm.vec2]:
+#     """
+#     Determines the clipped polygon vertices from ccw oriented polygons.
+#     """
+#     num_clip = len(clip_poly)
+    
+#     for i in range(num_clip):
+#         k = (i + 1) % num_clip
+        
+#         subj_poly = clip(subj_poly, clip_poly[i], clip_poly[k])
+        
 #     return subj_poly

basilisk/config.py

@@ -1,54 +1,54 @@
-import glm
-from .generic.input_validation import validate_glm_float, validate_int
-from typing import Any
-
-
-class Config():
-    engine: Any
-    """Reference to the parent engine"""
-    chunk_size: int
-    """The size of the chunks in the chunk handler"""
-    render_distance: int
-    """The number of chunks that are rendered around the camera"""
-    bloom_enabled: bool
-    """Flag for bloom to be enabled or disabled"""
-    bloom_quality: int
-    """Quality of the bloom. Suggested values from 2-8"""
-    gamma: glm.float32
-    """The global gamma level"""
-    exposure: glm.float32
-    """The global HDR exposure level"""
-
-    def __init__(self, engine) -> None:
-        # Reference to the engine
-        self.engine = engine
-        
-        # Chunk configs
-        self.chunk_size = 40
-        self.render_distance = 5
-        
-        # Render configs
-        self.bloom_enabled  = True
-        self._bloom_quality = 6
-        self.bloom_quality  = 6
-        self.gamma          = 2.2
-        self.exposure       = 1.0
-
-    @property
-    def bloom_quality(self): return self._bloom_quality
-    @property
-    def gamma(self): return self._gamma
-    @property
-    def exposure(self): return self._exposure
-
-    @bloom_quality.setter
-    def bloom_quality(self, value):
-        if self._bloom_quality == value: return
-        self._bloom_quality = validate_int('engine.config', 'bloom quality', value)
-        self.engine.frame.bloom.generate_bloom_buffers()
-    @gamma.setter
-    def gamma(self, value):
-        self._gamma = validate_glm_float('engine.config', 'gamma', value)
-    @exposure.setter
-    def exposure(self, value):
+import glm
+from .generic.input_validation import validate_glm_float, validate_int
+from typing import Any
+
+
+class Config():
+    engine: Any
+    """Reference to the parent engine"""
+    chunk_size: int
+    """The size of the chunks in the chunk handler"""
+    render_distance: int
+    """The number of chunks that are rendered around the camera"""
+    bloom_enabled: bool
+    """Flag for bloom to be enabled or disabled"""
+    bloom_quality: int
+    """Quality of the bloom. Suggested values from 2-8"""
+    gamma: glm.float32
+    """The global gamma level"""
+    exposure: glm.float32
+    """The global HDR exposure level"""
+
+    def __init__(self, engine) -> None:
+        # Reference to the engine
+        self.engine = engine
+        
+        # Chunk configs
+        self.chunk_size = 40
+        self.render_distance = 5
+        
+        # Render configs
+        self.bloom_enabled  = True
+        self._bloom_quality = 6
+        self.bloom_quality  = 6
+        self.gamma          = 2.2
+        self.exposure       = 1.0
+
+    @property
+    def bloom_quality(self): return self._bloom_quality
+    @property
+    def gamma(self): return self._gamma
+    @property
+    def exposure(self): return self._exposure
+
+    @bloom_quality.setter
+    def bloom_quality(self, value):
+        if self._bloom_quality == value: return
+        self._bloom_quality = validate_int('engine.config', 'bloom quality', value)
+        self.engine.frame.bloom.generate_bloom_buffers()
+    @gamma.setter
+    def gamma(self, value):
+        self._gamma = validate_glm_float('engine.config', 'gamma', value)
+    @exposure.setter
+    def exposure(self, value):
         self._exposure = validate_glm_float('engine.config', 'exposure', value)