e2D 1.4.20__py3-none-any.whl → 1.4.24__py3-none-any.whl

e2D/winrec.py

@@ -1,27 +1,211 @@
-from e2D.envs import *
+from typing import Optional, TYPE_CHECKING
+from e2D import V2
+from e2D.envs import RootEnv, FONT_MONOSPACE_16
+from e2D.colors import BLACK_COLOR_PYG
 import pygame as pg
 import numpy as np
 import cv2
+import threading
+import queue
+import time
 
 class WinRec:
-    def __init__(self, rootEnv:RootEnv, fps:int=30, path:str='output.mp4') -> None:
+    def __init__(self, rootEnv:RootEnv, fps:int=30, draw_on_screen:bool=True, path:str='output.mp4', font:pg.font.Font=FONT_MONOSPACE_16) -> None:
         self.rootEnv = rootEnv
         self.path = path
         self.fps = fps
-        self.video_writer = cv2.VideoWriter(self.path, cv2.VideoWriter_fourcc(*'mp4v'), self.fps, self.rootEnv.screen_size()) #type: ignore
+        self.draw_on_screen = draw_on_screen
+        self.font = font
+        self.is_recording = True  # Recording state (pause/resume)
+        self.screenshot_counter = 0  # Counter for screenshot filenames
+        self.recording_frames = 0  # Frames actually recorded (excludes paused frames)
+        self.pause_start_time = None  # Track when recording was paused
+        self.total_pause_duration = 0.0  # Cumulative pause time
+        size = self.rootEnv.screen_size
+        self.video_writer = cv2.VideoWriter(self.path, cv2.VideoWriter_fourcc(*'mp4v'), self.fps, size()) #type: ignore
+        
+        # Pre-allocate buffers for zero-copy operations
+        self.frame_buffer = np.empty(shape=(int(size.y), int(size.x), 3), dtype=np.uint8)
+        
+        # Setup async video writing
+        self.frame_queue = queue.Queue(maxsize=120)  # Buffer up to 4 seconds at 30fps
+        self.running = True
+        
+        # Statistics tracking
+        self.frames_written = 0
+        self.frames_dropped = 0
+        self.write_start_time = time.time()
+        self.last_stat_update = time.time()
+        self.current_write_fps = 0.0
+        
+        self.write_thread = threading.Thread(target=self._write_worker, daemon=False)
+        self.write_thread.start()
+    
+    def _write_worker(self) -> None:
+        """Background thread that writes frames to video file."""
+        while self.running or not self.frame_queue.empty():
+            try:
+                frame = self.frame_queue.get(timeout=0.1)
+                self.video_writer.write(frame)
+                self.frames_written += 1
+                self.frame_queue.task_done()
+                
+                # Update write FPS every second
+                current_time = time.time()
+                if current_time - self.last_stat_update >= 1.0:
+                    elapsed = current_time - self.write_start_time
+                    self.current_write_fps = self.frames_written / elapsed if elapsed > 0 else 0
+                    self.last_stat_update = current_time
+            except queue.Empty:
+                continue
+    
+    def handle_input(self) -> None:
+        """Handle recording control keyboard inputs (F9-F12)."""
+        # F9: Toggle pause/resume recording
+        if self.rootEnv.keyboard.get_key(pg.K_F9, "just_pressed"):
+            self.toggle_recording()
+            status = "REC" if self.is_recording else "PAUSED"
+            print(f"[Recording] {status}")
+        
+        # F10: Restart recording (reset all and resume)
+        if self.rootEnv.keyboard.get_key(pg.K_F10, "just_pressed"):
+            self.restart()
+            print("[Recording] Restarted (buffer cleared, timers reset)")
+        
+        # F12: Take screenshot
+        if self.rootEnv.keyboard.get_key(pg.K_F12, "just_pressed"):
+            screenshot_path = self.take_screenshot()
+            print(f"[Screenshot] Saved: {screenshot_path}")
     
     def update(self) -> None:
-        frame = cv2.cvtColor(np.swapaxes(pg.surfarray.array3d(self.rootEnv.screen), 0, 1), cv2.COLOR_RGB2BGR)
-        self.video_writer.write(frame)
+        # Handle keyboard input first
+        self.handle_input()
+        
+        # Skip frame capture if recording is paused
+        if not self.is_recording:
+            return
+        
+        # Increment recording frame counter
+        self.recording_frames += 1
+            
+        # Use pixels3d for zero-copy view, then transpose (creates view, not copy)
+        pixels = pg.surfarray.pixels3d(self.rootEnv.screen)
+        transposed = np.transpose(pixels, (1, 0, 2))
+        
+        # Convert color in-place to pre-allocated buffer
+        cv2.cvtColor(transposed, cv2.COLOR_RGB2BGR, dst=self.frame_buffer)
+        
+        # Queue frame copy for async writing (non-blocking)
+        try:
+            self.frame_queue.put_nowait(self.frame_buffer.copy())
+        except queue.Full:
+            self.frames_dropped += 1  # Track dropped frames
     
     def get_rec_seconds(self) -> float:
-        return self.rootEnv.current_frame/self.fps
+        """Get recorded time in seconds (excludes paused time)."""
+        return self.recording_frames / self.fps
+
+    def draw(self) -> None:
+        # Calculate statistics
+        buffer_size = self.frame_queue.qsize()
+        buffer_percent = (buffer_size / self.frame_queue.maxsize) * 100
+        buffer_seconds = buffer_size / self.fps if self.fps > 0 else 0
+        
+        # Estimate optimal buffer size based on write performance
+        if self.current_write_fps > 0 and self.fps > 0:
+            write_lag = self.fps / self.current_write_fps
+            estimated_buffer = int(self.fps * 2 * write_lag)  # 2 seconds of lag compensation
+        else:
+            estimated_buffer = self.frame_queue.maxsize
+        
+        # Recording state indicator
+        rec_status = "REC" if self.is_recording else "PAUSED"
+        
+        # Format with fixed width for stable display (monospace-friendly)
+        row1 = (f"[{rec_status}] RecFrames:{self.recording_frames:>6} | "
+            f"RecTime:{self.get_rec_seconds():>6.2f}s | "
+            f"AppTime:{self.rootEnv.runtime_seconds:>6.2f}s")
+        row2 = (f"Buffer:{buffer_size:>3}/{self.frame_queue.maxsize:<3} ({buffer_percent:>5.1f}%, {buffer_seconds:>4.1f}s) | "
+            f"WriteFPS:{self.current_write_fps:>5.1f}")
+        row3 = (f"Written:{self.frames_written:>6} | Dropped:{self.frames_dropped:>4} | OptBuf:{estimated_buffer:>3}")
+        row4 = "[F9]Pause/Resume [F10]Restart [F12]Screenshot"
 
-    def draw(self, draw_on_screen=False) -> None:
-        text = f"[cfps:{self.rootEnv.current_frame} || realtime:{round(self.get_rec_seconds(),2)} || apptime:{round(self.rootEnv.runtime_seconds,2)}]"
-        pg.display.set_caption(text)
-        if draw_on_screen: self.rootEnv.print(text, self.rootEnv.screen_size, pivot_position='bottom_right')
+        if self.draw_on_screen:
+            size = self.rootEnv.print(row4, self.rootEnv.screen_size - V2(16, 16), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+            self.rootEnv.print(row3, self.rootEnv.screen_size - V2(16, 16 + size.y), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+            self.rootEnv.print(row2, self.rootEnv.screen_size - V2(16, 16 + size.y * 2), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+            self.rootEnv.print(row1, self.rootEnv.screen_size - V2(16, 16 + size.y * 3), pivot_position='bottom_right', font=self.font, margin=V2(10, 10), bg_color=BLACK_COLOR_PYG, border_radius=10)
+    
+    def pause(self) -> None:
+        """Pause recording (stop capturing frames)."""
+        if self.is_recording:
+            self.is_recording = False
+            self.pause_start_time = time.time()
+    
+    def resume(self) -> None:
+        """Resume recording (continue capturing frames)."""
+        if not self.is_recording and self.pause_start_time is not None:
+            self.total_pause_duration += time.time() - self.pause_start_time
+            self.pause_start_time = None
+        self.is_recording = True
+    
+    def toggle_recording(self) -> None:
+        """Toggle between pause and resume."""
+        self.is_recording = not self.is_recording
+    
+    def restart(self) -> None:
+        """Restart recording: clear buffer, reset all counters and timers, resume recording."""
+        self.clear_buffer()
+        self.recording_frames = 0
+        self.total_pause_duration = 0.0
+        self.pause_start_time = None
+        self.is_recording = True
+    
+    def clear_buffer(self) -> None:
+        """Clear the frame queue and reset write statistics."""
+        # Clear the queue
+        while not self.frame_queue.empty():
+            try:
+                self.frame_queue.get_nowait()
+                self.frame_queue.task_done()
+            except queue.Empty:
+                break
+        
+        # Reset write counters (but keep recording frames)
+        self.frames_written = 0
+        self.frames_dropped = 0
+        self.write_start_time = time.time()
+        self.last_stat_update = time.time()
+        self.current_write_fps = 0.0
+    
+    def take_screenshot(self, filename:Optional[str]=None) -> str:
+        """Save current screen as PNG screenshot.
+        
+        Args:
+            filename: Optional custom filename. If None, auto-generates with counter.
+        
+        Returns:
+            str: Path to saved screenshot
+        """
+        if filename is None:
+            # Auto-generate filename with counter
+            base_path = self.path.rsplit('.', 1)[0]  # Remove .mp4 extension
+            filename = f"{base_path}_screenshot_{self.screenshot_counter:04d}.png"
+            self.screenshot_counter += 1
+        
+        # Capture current screen
+        pixels = pg.surfarray.pixels3d(self.rootEnv.screen)
+        transposed = np.transpose(pixels, (1, 0, 2))
+        screenshot_buffer = np.empty(shape=(int(self.rootEnv.screen_size.y), int(self.rootEnv.screen_size.x), 3), dtype=np.uint8)
+        cv2.cvtColor(transposed, cv2.COLOR_RGB2BGR, dst=screenshot_buffer)
+        
+        # Save as PNG
+        cv2.imwrite(filename, screenshot_buffer)
+        return filename
     
     def quit(self) -> None:
-        self.video_writer.release()
-
+        # Stop accepting new frames and wait for queue to flush
+        self.running = False
+        self.frame_queue.join()  # Wait for all queued frames to be written
+        self.write_thread.join(timeout=5.0)  # Wait for thread to finish
+        self.video_writer.release()

{e2d-1.4.20.dist-info → e2d-1.4.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e2D
-Version: 1.4.20
+Version: 1.4.24
 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.4.24.dist-info/RECORD

@@ -0,0 +1,13 @@
+e2D/__init__.py,sha256=ZTja5nMPyg3_fulzuSWhjA-JexSG9QHHr3sc0w7Qcpk,23857
+e2D/__init__.pyi,sha256=1WNOYOyNyroL2LLrzE7CIJ7uubh_zhVbMvJINpy5PIY,53979
+e2D/colors.py,sha256=4ZFcp6ZfdQ2eG3INw_Hx-KI2PkVustZ5TurnooHGSvw,19063
+e2D/def_colors.py,sha256=3sJq2L6qFZ3svn2qEWIx0SinNXjb9huNaFigDeJipm8,43805
+e2D/envs.py,sha256=5ah8SW9HNC3NqqZZfCBZs1BWtWHLA43dWwQruawzm9U,9240
+e2D/plots.py,sha256=_d72ZJo-GIhcJ44XCphFH288cf_ZSwWcbLh_olgGjBc,35880
+e2D/utils.py,sha256=Yamt6_JS6MVKrNtfzjP7BRWjCeXHuzFcFlL7H2Au7_M,29687
+e2D/winrec.py,sha256=cZCqnCVwQ-n9HTcQj6vB4nKfu-YJ-GogtTTHiWDH3dc,9744
+e2d-1.4.24.dist-info/licenses/LICENSE,sha256=hbjljn38VVW9en51B0qzRK-v2FBDijqRWbZIVTk7ipU,1094
+e2d-1.4.24.dist-info/METADATA,sha256=UcXuDKt3kNK8fdd-o2ldBVfxkx8sMD1fz74lrtVtpxA,9634
+e2d-1.4.24.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+e2d-1.4.24.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
+e2d-1.4.24.dist-info/RECORD,,

{e2d-1.4.20.dist-info → e2d-1.4.24.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

e2d-1.4.20.dist-info/RECORD

@@ -1,13 +0,0 @@
-e2D/__init__.py,sha256=7UmgGI4WotqPLGXyGlNzddUdd5eK1VWqsb2BMAOA78g,22522
-e2D/__init__.pyi,sha256=ckPL2_iz5439-lD-wRLF7t54b_ndF4LT_A24_oyCCTU,45403
-e2D/colors.py,sha256=SwO52zowBs9l_VK1TjyT2GK1Npn5UAsHdCxz3lvaSKQ,18011
-e2D/def_colors.py,sha256=3sJq2L6qFZ3svn2qEWIx0SinNXjb9huNaFigDeJipm8,43805
-e2D/envs.py,sha256=1QnOEI2lCO3B6_EkIBBqgaXfPYLFE_u0_H6AwmZ1R9U,7171
-e2D/plots.py,sha256=_d72ZJo-GIhcJ44XCphFH288cf_ZSwWcbLh_olgGjBc,35880
-e2D/utils.py,sha256=42anOSUxvQ9SOof26VkJPsm6vN9AvckeW0U0RILzi8w,27843
-e2D/winrec.py,sha256=EFFfWYbk27NhS-rWD-BLChXvLjFW1uYZ5LkRGMj_Xo0,1116
-e2d-1.4.20.dist-info/licenses/LICENSE,sha256=hbjljn38VVW9en51B0qzRK-v2FBDijqRWbZIVTk7ipU,1094
-e2d-1.4.20.dist-info/METADATA,sha256=YOwcgB_fj4q1bHxAbh1uK-qcFEWAK8qoA4lZ4-dOFZI,9634
-e2d-1.4.20.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-e2d-1.4.20.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
-e2d-1.4.20.dist-info/RECORD,,