e2D 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

e2D/plots.py

@@ -9,10 +9,11 @@ def no_error_complex_function(function, args) -> V2|Vector2D:
 sign = lambda value: -1 if value < 0 else (1 if value > 0 else 0)
 
 class Function:
-    def __init__(self, function, plot:"Plot", color) -> None:
-        self.plot = plot
+    def __init__(self, function, color) -> None:
+        self.plot : Plot
         self.color = color
-        self.update_function(function)
+        self.function = function
+        self.__layer_surface__ :pg.Surface= None #type: ignore
     
     def update_points(self) -> None:
         self.update_function(self.function)
@@ -25,11 +26,25 @@ class Function:
     def update_function(self, new_function) -> None:
         self.function = new_function
         self.points = self.get_points()
+        self.render()
+    
+    def render(self) -> None:
+        self.__layer_surface__.fill((0,0,0,0))
+        offset = self.plot.dragging - self.plot.start_dragging if (self.plot.dragging != None) and (not self.plot.settings.get("use_real_time_rendering")) else None
+        if any(x < 1 for x in self.plot.scale):
+            for point in self.points:
+                # radius = max(min(self.plot.pixel_size)*.5, 1)
+                # pg.draw.circle(self.plot.canvas, self.color, (point + self.plot.pixel_size*.5)(), radius)
+                pg.draw.rect(self.__layer_surface__, self.color, (point.tolist() + (offset if offset != None else V2z))() + self.plot.pixel_size()) #type: ignore
+        else:
+            for point in self.points:
+                point = point.astype(int).tolist()
+                if self.plot.dragging != None:
+                    point = round(point + offset)()
+                self.__layer_surface__.set_at(point, self.color)
     
     def draw(self) -> None:
-        # pg.draw.aalines(self.plot.canvas, self.color, False, self.points)
-        for point in self.points:
-            self.plot.canvas.set_at(list(map(int, point)), self.color)
+        self.plot.canvas.blit(self.__layer_surface__, (0,0))
 
 # class ComplexFunction:
 #     def __init__(self, function, plot:"Plot", starting_t:float=-10, ending_t:float=10, step=.01, color=(255,255,255), auto_connect_treshold=float("inf"), points_radius=2, points_color=None) -> None:
@@ -65,6 +80,55 @@ class Function:
 #                 if point.distance_to(self.points[i]) < self.auto_connect_treshold:
 #                     pg.draw.line(self.plot.canvas, self.color, real_points[i], real_point) #type: ignore
 
+class __PlotSettings__:
+    def __init__(self, plot:Plot) -> None:
+        self.plot = plot
+        self.settings :dict= {
+            "use_real_time_rendering" : True,
+            "show_corners_coords" : True,
+
+            "use_inter_pixel_correction" : True,
+
+            "show_zoom_info": True,
+            "top_left_info_position" : self.plot.position + V2(20, 100),
+            "info_spacing" : V2(0, 32),
+            "info_precision" : 2,
+
+            "distance_to_axis_for_scalar_zoom" : 10,
+
+            "bg_color" : (25, 25, 25),
+            "axes_default_color" : (100, 100, 100),
+            "x_axis_color" : None,
+            "y_axis_color" : None,
+
+            "axes_default_width" : 5,
+            "x_axis_width" : None,
+            "y_axis_width" : None,
+
+            "show_cursor_coords" : False,
+        }
+
+    def print_current_settings(self) -> None:
+        longest_key = max(map(len, self.settings))
+        longest_type = max(map(lambda setting: len(str(type(setting)).split("'")[1]), self.settings.values()))
+        split_string = '"'
+        for setting in self.settings:
+            print(f"{setting}{' '*(longest_key-len(setting))} :{str(type(self.settings[setting])).split(split_string)[1]}{' '*(longest_type-len(str(type(self.settings[setting])).split(split_string)[1]))}=\t{self.settings[setting]}")
+    
+    def set(self, key:str, new_value) -> None:
+        if not (key in self.settings): raise ValueError(f"The key [{key}] does not exist...")
+        self.settings[key] = new_value
+
+    def multiple_set(self, keys:list[str], new_values:list) -> None:
+        for key, new_value in zip(keys, new_values):
+            self.set(key, new_value)
+    
+    def get(self, key:str) -> bool|V2|Vector2D|int|float:
+        return self.settings[key]
+
+    def multiple_get(self, keys:list[str]) -> list[bool|V2|Vector2D|int|float]:
+        return [self.get(key) for key in keys]
+
 class Plot:
     __top_left_multiplier__ = V2(1, -1)
     __bottop_right_multiplier__ = V2(1, -1)
@@ -77,7 +141,9 @@ class Plot:
         self.position = plot_position
         self.size = plot_size
         self.scale = scale
-        
+
+        self.settings = __PlotSettings__(self)
+
         self.current_zoom = V2one * -np.log2(10)*10
         self.current_offset = V2(0,0)
         self.update_grid(True)
@@ -86,6 +152,7 @@ class Plot:
 
         self.canvas = pg.Surface(self.size())
         self.dragging = None
+        self.start_dragging = V2z
         self.is_mouse_in_rect = False
 
     def set_borders_by_position_and_zoom(self) -> None:
@@ -100,8 +167,14 @@ class Plot:
             self.step = (self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size / self.scale
             X, Y = np.arange(self.top_left_plot_coord.x, self.bottom_right_plot_coord.x, self.step.x), np.arange(self.top_left_plot_coord.y, self.bottom_right_plot_coord.y, self.step.y)
             self.meshgrid = np.meshgrid(X, Y)
+            self.pixel_size = abs(self.size / (self.bottom_right_plot_coord - self.top_left_plot_coord) * (self.step * -1))
+            if self.settings.get("use_inter_pixel_correction"):
+                self.pixel_size += V2one
 
     def load_function(self, function:Function) -> None:
+        function.plot = self
+        function.__layer_surface__ = pg.Surface(self.size(), pg.SRCALPHA, 32).convert_alpha()
+        function.update_function(function.function)
         self.functions.append(function)
 
     def __plot2real__(self, plot_position:V2|Vector2D) -> V2|Vector2D:
@@ -111,19 +184,40 @@ class Plot:
         return (real_position - self.position) * (self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size + self.top_left_plot_coord
 
     def render(self) -> None:
-        self.canvas.fill((0,0,0))
-        if self.bottom_right_y < 0 < self.top_left_y: pg.draw.line(self.canvas, (100,100,100), self.__plot2real__(V2(self.top_left_x, 0))(), self.__plot2real__(V2(self.bottom_right_x, 0))())
-        if self.top_left_x < 0 < self.bottom_right_x: pg.draw.line(self.canvas, (100,100,100), self.__plot2real__(V2(0, self.top_left_y))(), self.__plot2real__(V2(0, self.bottom_right_y))())
-        
+        self.canvas.fill(self.settings.get("bg_color")) #type: ignore
+        if self.top_left_x < 0 < self.bottom_right_x:
+            pg.draw.line(self.canvas,
+                         self.settings.get("axes_default_color") if (x_color:=self.settings.get("x_axis_color"))==None else x_color, #type: ignore
+                         self.__plot2real__(V2(0, self.top_left_y))(),
+                         self.__plot2real__(V2(0, self.bottom_right_y))(),
+                         self.settings.get("axes_default_width") if (x_width:=self.settings.get("x_axis_width"))==None else x_width) #type: ignore
+        if self.bottom_right_y < 0 < self.top_left_y:
+            pg.draw.line(self.canvas,
+                         self.settings.get("axes_default_color") if (y_color:=self.settings.get("y_axis_color"))==None else y_color, #type: ignore
+                         self.__plot2real__(V2(self.top_left_x, 0))(),
+                         self.__plot2real__(V2(self.bottom_right_x, 0))(),
+                         self.settings.get("axes_default_width") if (y_width:=self.settings.get("y_axis_width"))==None else y_width) #type: ignore
+
         for function in self.functions: function.draw()
 
         pg.draw.rect(self.canvas, (255,255,255), V2z() + self.size(), 5) #type: ignore
-        self.rootEnv.print(str(self.top_left_plot_coord.__round__(.1)), V2z.copy(), bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
-        self.rootEnv.print(str(V2(self.top_left_plot_coord.x, self.bottom_right_plot_coord.y).__round__(.1)), self.size * V2(0, 1), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_LEFT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
-        self.rootEnv.print(str(self.bottom_right_plot_coord.__round__(.1)), self.size.copy(), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
-        self.rootEnv.print(str(V2(self.bottom_right_plot_coord.x, self.top_left_plot_coord.y).__round__(.1)), self.size * V2(1, 0), fixed_sides=TEXT_FIXED_SIDES_TOP_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+
+        center = self.size * .5
+        aimer_radius = 15
+        pg.draw.line(self.canvas, (100,100,100), (center + aimer_radius)(), (center - aimer_radius)(), 1)
+        pg.draw.line(self.canvas, (100,100,100), (center + self.__top_left_multiplier__ * aimer_radius)(), (center - self.__top_left_multiplier__ * aimer_radius)(), 1)
+        pg.draw.circle(self.canvas, (100,100,100), (self.size * .5)(), 15, 1)
+
+        if self.settings.get("show_corners_coords"):
+            self.rootEnv.print(str(self.top_left_plot_coord.__round__(.1)), V2z.copy(), bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(str(V2(self.top_left_plot_coord.x, self.bottom_right_plot_coord.y).__round__(.1)), self.size * V2(0, 1), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_LEFT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(str(self.bottom_right_plot_coord.__round__(.1)), self.size.copy(), fixed_sides=TEXT_FIXED_SIDES_BOTTOM_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
+            self.rootEnv.print(str(V2(self.bottom_right_plot_coord.x, self.top_left_plot_coord.y).__round__(.1)), self.size * V2(1, 0), fixed_sides=TEXT_FIXED_SIDES_TOP_RIGHT, bg_color=(0,0,0), border_color=(255,255,255), border_width=2, border_radius=15, margin=V2(10,10), personalized_surface=self.canvas)
     
     def update(self) -> None:
+        self.plot_mouse_position = self.__real2plot__(self.rootEnv.mouse.position)
+        self.plot_center_real_position = self.__plot2real__(V2z) + self.position
+
         self.is_mouse_in_rect = self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and \
                                 self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
 
@@ -133,11 +227,16 @@ class Plot:
             for function in self.functions:
                 function.update_points()
             self.render()
+        
 
         if self.is_mouse_in_rect:
             for event in self.rootEnv.events:
                 if event.type == pg.MOUSEWHEEL:
-                    self.current_zoom += event.y
+                    
+                    range_n = self.settings.get("distance_to_axis_for_scalar_zoom")
+                    scalar = V2(0 if abs(self.plot_center_real_position.x - self.rootEnv.mouse.position.x) < range_n else 1, 0 if abs(self.plot_center_real_position.y - self.rootEnv.mouse.position.y) < range_n else 1) #type: ignore
+                    self.current_zoom += event.y * scalar
+
                     self.update_grid(True)
                     for function in self.functions:
                         function.update_points()
@@ -145,15 +244,31 @@ class Plot:
             
             if self.rootEnv.mouse.just_pressed[0] and self.dragging == None:
                 self.dragging = self.rootEnv.mouse.position.copy()
+                self.start_dragging = self.dragging.copy()
             
         if self.dragging:
             offset = (self.dragging - self.rootEnv.mouse.position)* V2(1, -1) * (abs(self.bottom_right_plot_coord - self.top_left_plot_coord) / self.size)
             self.dragging = self.rootEnv.mouse.position.copy()
             self.current_offset += offset
-            self.update_grid()
+
+            if self.settings.get("use_real_time_rendering"):
+                self.update_grid(True)
+                for function in self.functions: function.update_points()
+            else:
+                self.update_grid()
             self.render()
 
     def draw(self) -> None:
         self.rootEnv.screen.blit(self.canvas, self.position())
-        if self.is_mouse_in_rect:
-            self.rootEnv.print(str(round(self.__real2plot__(self.rootEnv.mouse.position), .1)), self.rootEnv.mouse.position, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_MIDDLE)
+        if self.is_mouse_in_rect and self.settings.get("show_cursor_coords"):
+            self.rootEnv.print(str(round(self.plot_mouse_position, .1)), self.rootEnv.mouse.position, fixed_sides=TEXT_FIXED_SIDES_BOTTOM_MIDDLE) #type: ignore
+
+        data = [
+            [f"ZOOM:", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+            [f"  x: {self.current_zoom.x:.{self.settings.get('info_precision')}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+            [f"  y: {self.current_zoom.y:.{self.settings.get('info_precision')}f};", TEXT_FIXED_SIDES_TOP_LEFT, self.settings.get("show_zoom_info")],
+        ]
+
+        for i, (d, fixed_side, show) in enumerate(data):
+            if show:
+                self.rootEnv.print(d, self.settings.get("top_left_info_position") + self.settings.get("info_spacing") * i, fixed_sides=fixed_side) #type: ignore

{e2D-1.3.3.dist-info → e2D-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e2D
-Version: 1.3.3
+Version: 1.3.5
 Summary: Python library for 2D games. Streamlines dev with keyboard/mouse input, vector calculations, color manipulation, and collision detection. Simplify game creation and unleash creativity!
 Home-page: https://github.com/marick-py/e2D
 Author: Riccardo Mariani

e2D-1.3.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+e2D/__init__.py,sha256=1aJPqvWfZmIB_Ti7RaPX7KrHULha3VQe_ulsowcNqO8,58309
+e2D/envs.py,sha256=mhq3SI2EmckXp9h6RYKzTGSKkvzlH-SyMTBhl3yDVZU,3929
+e2D/plots.py,sha256=leq6KUTaiIBQCYfn8ksOAd6Y8LKTbXutMDd9_SaCpJ4,15186
+e2D/utils.py,sha256=sq9efoNnSlJAfjvf18qDQpvO1jyz-9-mWBW3P4WMkD4,5368
+e2D-1.3.5.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
+e2D-1.3.5.dist-info/METADATA,sha256=exsNCqNEUrbxasah6uqwfpFtV-Ee4vOMSLm1LZWNwxs,9608
+e2D-1.3.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+e2D-1.3.5.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
+e2D-1.3.5.dist-info/RECORD,,

e2D-1.3.3.dist-info/RECORD

@@ -1,9 +0,0 @@
-e2D/__init__.py,sha256=1aJPqvWfZmIB_Ti7RaPX7KrHULha3VQe_ulsowcNqO8,58309
-e2D/envs.py,sha256=mhq3SI2EmckXp9h6RYKzTGSKkvzlH-SyMTBhl3yDVZU,3929
-e2D/plots.py,sha256=BOfWFsezpYtLv-33gHY48WnEineiW8gLlsxKRfcemNc,9154
-e2D/utils.py,sha256=sq9efoNnSlJAfjvf18qDQpvO1jyz-9-mWBW3P4WMkD4,5368
-e2D-1.3.3.dist-info/LICENSE,sha256=wymkNVDvj3qmjdO_rAhkRPM4t5y3_SqffGsFdgfvznU,1066
-e2D-1.3.3.dist-info/METADATA,sha256=b1xbCyKlMK0RNSlDbXy6JYeVeyae37cGbAKBcDs2u6Q,9608
-e2D-1.3.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-e2D-1.3.3.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
-e2D-1.3.3.dist-info/RECORD,,