basilisk-engine 0.1.25__py3-none-any.whl → 0.1.26__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,4 +1,4 @@
-class Config():
-    def __init__(self) -> None:
-        self.chunk_size = 40
+class Config():
+    def __init__(self) -> None:
+        self.chunk_size = 40
         self.render_distance = 5

basilisk/draw/draw.py

@@ -1,101 +1,101 @@
-from ..engine import Engine
-from ..render.image import Image
-
-def rect(engine: Engine, color: tuple, rect: tuple) -> None:
-    """
-    Draws a rectagle to the screen
-    Args:
-        engine: bsk.Engine
-            The destination engine for the rectangle
-        color: tuple(r, g, b) | tuple(r, g, b, a)
-            The color value of the rectangle, with int components in range [0, 255]
-        rect: tuple(x, y, w, h)
-            The screen position and size of the rectangle given in pixels
-    """
-    
-    # Get the draw handler from the engine
-    draw_handler = engine.draw_handler
-    if not draw_handler: return
-
-    # Draw the rect
-    draw_handler.draw_rect(color, rect)
-
-
-def circle(engine: Engine, color: tuple, center: tuple, radius: int, resolution: int=20, outer_color: tuple=None) -> None:
-    """
-    Draws a rect between centered on x, y with width and height
-        Args:
-            color: tuple(r, g, b) | tuple(r, g, b, a)
-                The color value of the circle, with int components in range [0, 255]
-            center: tuple (x: float, y: float)
-                Center of the circle, given in pixels
-            radius: float
-                Radius of the circle, given in pixels
-            resolution: float
-                    The number of triangles used to approximate the circle
-    """
-    
-    # Get the draw handler from the engine
-    draw_handler = engine.draw_handler
-    if not draw_handler: return
-
-    # Draw the circle
-    draw_handler.draw_circle(color, center, radius, resolution, outer_color)
-
-def line(engine: Engine, color: tuple, p1: tuple, p2: tuple, thickness: int=1) -> None:
-    """
-    Draws a line between two points
-        Args:
-            color: tuple=(r, g, b) | tuple=(r, g, b, a)
-                Color of the line
-            p1: tuple=((x1, y1), (x2, y2))
-                Starting point of the line. Given in pixels
-            p1: tuple=((x1, y1), (x2, y2))
-                Starting point of the line. Given in pixels
-            thickness: int
-                Size of the line on either side. pixels
-    """
-    
-    # Get the draw handler from the engine
-    draw_handler = engine.draw_handler
-    if not draw_handler: return
-
-    # Draw the line
-    draw_handler.draw_line(color, p1, p2, thickness)
-
-def blit(engine: Engine, image: Image, rect: tuple, alpha: float=1.0):
-    """
-    Blits a basilisk image to the engine screen.
-    Args:
-        image: bsk.Image
-            The image to display on the screen
-        rect: tuple(x, y, w, h)
-            The screen position and size of the image given in pixels
-    """
-
-    # Get the draw handler from the engine
-    draw_handler = engine.draw_handler
-    if not draw_handler: return
-
-    engine.material_handler.image_handler.add(image)
-
-    # Blit the image
-    draw_handler.blit(image, rect, alpha)
-
-def text(engine: Engine, text: str, position: tuple, scale: float=1.0):
-    """
-    Renders text do the screen
-    USE SPARINGLY, INEFFICIENT IMPLAMENTATION
-    """
-    
-    font_renderer = engine.draw_handler.font_renderer
-
-    # Render the text if it has not been cached
-    if text not in font_renderer.text_renders:
-        surf = font_renderer.render(text).convert_alpha()
-        text_image = Image(surf)
-        font_renderer.text_renders[text] = (text_image, surf.get_rect())
-    
-    # Blit the text image
-    img, rect = font_renderer.text_renders[text]
+from ..engine import Engine
+from ..render.image import Image
+
+def rect(engine: Engine, color: tuple, rect: tuple) -> None:
+    """
+    Draws a rectagle to the screen
+    Args:
+        engine: bsk.Engine
+            The destination engine for the rectangle
+        color: tuple(r, g, b) | tuple(r, g, b, a)
+            The color value of the rectangle, with int components in range [0, 255]
+        rect: tuple(x, y, w, h)
+            The screen position and size of the rectangle given in pixels
+    """
+    
+    # Get the draw handler from the engine
+    draw_handler = engine.draw_handler
+    if not draw_handler: return
+
+    # Draw the rect
+    draw_handler.draw_rect(color, rect)
+
+
+def circle(engine: Engine, color: tuple, center: tuple, radius: int, resolution: int=20, outer_color: tuple=None) -> None:
+    """
+    Draws a rect between centered on x, y with width and height
+        Args:
+            color: tuple(r, g, b) | tuple(r, g, b, a)
+                The color value of the circle, with int components in range [0, 255]
+            center: tuple (x: float, y: float)
+                Center of the circle, given in pixels
+            radius: float
+                Radius of the circle, given in pixels
+            resolution: float
+                    The number of triangles used to approximate the circle
+    """
+    
+    # Get the draw handler from the engine
+    draw_handler = engine.draw_handler
+    if not draw_handler: return
+
+    # Draw the circle
+    draw_handler.draw_circle(color, center, radius, resolution, outer_color)
+
+def line(engine: Engine, color: tuple, p1: tuple, p2: tuple, thickness: int=1) -> None:
+    """
+    Draws a line between two points
+        Args:
+            color: tuple=(r, g, b) | tuple=(r, g, b, a)
+                Color of the line
+            p1: tuple=((x1, y1), (x2, y2))
+                Starting point of the line. Given in pixels
+            p1: tuple=((x1, y1), (x2, y2))
+                Starting point of the line. Given in pixels
+            thickness: int
+                Size of the line on either side. pixels
+    """
+    
+    # Get the draw handler from the engine
+    draw_handler = engine.draw_handler
+    if not draw_handler: return
+
+    # Draw the line
+    draw_handler.draw_line(color, p1, p2, thickness)
+
+def blit(engine: Engine, image: Image, rect: tuple, alpha: float=1.0):
+    """
+    Blits a basilisk image to the engine screen.
+    Args:
+        image: bsk.Image
+            The image to display on the screen
+        rect: tuple(x, y, w, h)
+            The screen position and size of the image given in pixels
+    """
+
+    # Get the draw handler from the engine
+    draw_handler = engine.draw_handler
+    if not draw_handler: return
+
+    engine.material_handler.image_handler.add(image)
+
+    # Blit the image
+    draw_handler.blit(image, rect, alpha)
+
+def text(engine: Engine, text: str, position: tuple, scale: float=1.0):
+    """
+    Renders text do the screen
+    USE SPARINGLY, INEFFICIENT IMPLAMENTATION
+    """
+    
+    font_renderer = engine.draw_handler.font_renderer
+
+    # Render the text if it has not been cached
+    if text not in font_renderer.text_renders:
+        surf = font_renderer.render(text).convert_alpha()
+        text_image = Image(surf)
+        font_renderer.text_renders[text] = (text_image, surf.get_rect())
+    
+    # Blit the text image
+    img, rect = font_renderer.text_renders[text]
     blit(engine, img, (position[0] - rect[2] * scale / 2, position[1] - rect[3] * scale / 2, rect[2] * scale, rect[3] * scale))