e2D 2.0.0__cp313-cp313-win_amd64.whl

e2D/vectors.py

@@ -0,0 +1,247 @@
+"""
+High-level Python wrapper for Vector2D with additional utilities
+Provides compatibility layer and convenience functions
+"""
+
+try:
+    from .cvectors import (
+        Vector2D,
+        batch_add_inplace,
+        batch_scale_inplace,
+        batch_normalize_inplace,
+        vectors_to_array,
+        array_to_vectors,
+    )
+    _COMPILED = True
+except ImportError:
+    print("WARNING: Compiled cvectors module not found. Please run: python setup.py build_ext --inplace")
+    print("Falling back to pure Python implementation (slower)")
+    _COMPILED = False
+    
+    # Fallback implementation
+    import numpy as np
+    
+    class Vector2D:
+        """Pure Python fallback (much slower than compiled version)"""
+        def __init__(self, x=0.0, y=0.0):
+            self.data = np.array([x, y], dtype=np.float64)
+        
+        @property
+        def x(self):
+            return self.data[0]
+        
+        @x.setter
+        def x(self, value):
+            self.data[0] = value
+        
+        @property
+        def y(self):
+            return self.data[1]
+        
+        @y.setter
+        def y(self, value):
+            self.data[1] = value
+        
+        @property
+        def length(self):
+            return np.linalg.norm(self.data)
+        
+        @property
+        def length_sqrd(self):
+            return np.dot(self.data, self.data)
+        
+        def copy(self):
+            return Vector2D(self.x, self.y)
+        
+        def __add__(self, other):
+            if isinstance(other, Vector2D):
+                return Vector2D(self.x + other.x, self.y + other.y)
+            return Vector2D(self.x + other, self.y + other)
+        
+        def __sub__(self, other):
+            if isinstance(other, Vector2D):
+                return Vector2D(self.x - other.x, self.y - other.y)
+            return Vector2D(self.x - other, self.y - other)
+        
+        def __mul__(self, other):
+            if isinstance(other, Vector2D):
+                return Vector2D(self.x * other.x, self.y * other.y)
+            return Vector2D(self.x * other, self.y * other)
+        
+        def __repr__(self):
+            return f"Vector2D({self.x}, {self.y})"
+
+
+# Convenience aliases
+V2 = Vector2D
+Vec2 = Vector2D
+
+
+# Pre-defined common vectors (reusable instances for performance)
+class CommonVectors:
+    """Pre-allocated common vectors (do not modify these!)"""
+    ZERO = Vector2D(0.0, 0.0)
+    ONE = Vector2D(1.0, 1.0)
+    UP = Vector2D(0.0, 1.0)
+    DOWN = Vector2D(0.0, -1.0)
+    LEFT = Vector2D(-1.0, 0.0)
+    RIGHT = Vector2D(1.0, 0.0)
+    
+    @staticmethod
+    def zero():
+        """Create new zero vector"""
+        return Vector2D(0.0, 0.0)
+    
+    @staticmethod
+    def one():
+        """Create new one vector"""
+        return Vector2D(1.0, 1.0)
+    
+    @staticmethod
+    def up():
+        """Create new up vector"""
+        return Vector2D(0.0, 1.0)
+    
+    @staticmethod
+    def down():
+        """Create new down vector"""
+        return Vector2D(0.0, -1.0)
+    
+    @staticmethod
+    def left():
+        """Create new left vector"""
+        return Vector2D(-1.0, 0.0)
+    
+    @staticmethod
+    def right():
+        """Create new right vector"""
+        return Vector2D(1.0, 0.0)
+
+
+# Export all public API
+__all__ = [
+    'Vector2D',
+    'V2',
+    'Vec2',
+    'CommonVectors',
+    'batch_add_inplace',
+    'batch_scale_inplace',
+    'batch_normalize_inplace',
+    'vectors_to_array',
+    'array_to_vectors',
+]
+
+
+# Additional utility functions
+def lerp(start, end, t):
+    """Linear interpolation between two values"""
+    return start + (end - start) * t
+
+
+def create_grid(width, height, spacing=1.0):
+    """
+    Create a grid of vectors
+    
+    Args:
+        width: Number of columns
+        height: Number of rows
+        spacing: Distance between points
+    
+    Returns:
+        List of Vector2D objects
+    """
+    vectors = []
+    for y in range(height):
+        for x in range(width):
+            vectors.append(Vector2D(x * spacing, y * spacing))
+    return vectors
+
+
+def create_circle(radius, num_points):
+    """
+    Create vectors arranged in a circle
+    
+    Args:
+        radius: Circle radius
+        num_points: Number of points
+    
+    Returns:
+        List of Vector2D objects
+    """
+    import math
+    vectors = []
+    angle_step = 2 * math.pi / num_points
+    for i in range(num_points):
+        angle = i * angle_step
+        x = radius * math.cos(angle)
+        y = radius * math.sin(angle)
+        vectors.append(Vector2D(x, y))
+    return vectors
+
+
+# Performance benchmark function
+def benchmark(num_iterations=100000):
+    """
+    Run a simple benchmark to test vector performance
+    """
+    import time
+    
+    print(f"Vector2D Benchmark ({num_iterations} iterations)")
+    print("=" * 50)
+    
+    # Test 1: Vector creation
+    start = time.perf_counter()
+    for i in range(num_iterations):
+        v = Vector2D(1.0, 2.0)
+    end = time.perf_counter()
+    print(f"Creation:      {(end - start) * 1000:.2f} ms")
+    
+    # Test 2: Addition
+    v1 = Vector2D(1.0, 2.0)
+    v2 = Vector2D(3.0, 4.0)
+    start = time.perf_counter()
+    for i in range(num_iterations):
+        v3 = v1 + v2
+    end = time.perf_counter()
+    print(f"Addition:      {(end - start) * 1000:.2f} ms")
+    
+    # Test 3: In-place addition
+    v1 = Vector2D(1.0, 2.0)
+    v2 = Vector2D(3.0, 4.0)
+    start = time.perf_counter()
+    for i in range(num_iterations):
+        v1 += v2
+        v1 -= v2  # Keep value constant
+    end = time.perf_counter()
+    print(f"In-place add:  {(end - start) * 1000:.2f} ms")
+    
+    # Test 4: Normalization
+    vectors = [Vector2D(i, i+1) for i in range(1000)]
+    start = time.perf_counter()
+    for i in range(num_iterations // 1000):
+        for v in vectors:
+            v.normalize()
+    end = time.perf_counter()
+    print(f"Normalize:     {(end - start) * 1000:.2f} ms")
+    
+    # Test 5: Batch operations
+    if _COMPILED:
+        vectors = [Vector2D(i, i+1) for i in range(1000)]
+        displacement = Vector2D(1.0, 1.0)
+        start = time.perf_counter()
+        for i in range(num_iterations // 1000):
+            batch_add_inplace(vectors, displacement)
+        end = time.perf_counter()
+        print(f"Batch add:     {(end - start) * 1000:.2f} ms")
+    
+    print("=" * 50)
+    if _COMPILED:
+        print("✓ Using compiled Cython extension (optimal performance)")
+    else:
+        print("⚠ Using pure Python fallback (compile for better performance)")
+
+
+if __name__ == "__main__":
+    # Run benchmark when executed directly
+    benchmark()
+

e2d-2.0.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: e2D
+Version: 2.0.0
+Summary: High-performance 2D graphics and math library with ultra-optimized vector operations
+Home-page: https://github.com/marick-py/e2D
+Author: Riccardo Mariani
+Author-email: Riccardo Mariani <ricomari2006@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marick-py/e2D
+Project-URL: Repository, https://github.com/marick-py/e2D
+Project-URL: Issues, https://github.com/marick-py/e2D/issues
+Keywords: vector,2d,simulation,performance,cython,numpy,moderngl,games,graphics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: C
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: pygame
+Requires-Dist: moderngl
+Requires-Dist: glfw
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: performance
+Requires-Dist: cython>=0.29.0; extra == "performance"
+Dynamic: license-file
+
+# e2D - High-Performance 2D Graphics and Math Library
+
+![Python](https://img.shields.io/badge/python-3.9+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+![Status](https://img.shields.io/badge/status-beta-orange.svg)
+
+**e2D** combines ultra-optimized vector mathematics with modern OpenGL rendering for high-performance 2D applications. Perfect for games, simulations, and real-time graphics.
+
+## ✨ Features
+
+### 🚀 Optimized Vector Operations
+- **Cython-compiled** Vector2D class (10-500x faster than pure Python)
+- **Batch operations** for processing thousands of vectors efficiently
+- **Direct memory access** with zero-copy operations
+- **NumPy integration** for seamless GPU data upload
+
+### 🎮 Modern Graphics
+- **ModernGL** rendering pipeline
+- **Shape rendering** with instancing support
+- **Text rendering** with custom styles
+- **GLFW window management**
+
+### 🎯 Game Development Tools
+- **Keyboard and mouse input** handling
+- **Collision detection**
+- **Color manipulation**
+- **Vector mathematics**
+
+## 📦 Installation
+
+```bash
+pip install e2D
+```
+
+The package will automatically compile the Cython extensions during installation for optimal performance (like numpy). If compilation fails, it falls back to pure Python mode.
+
+### Requirements
+- Python 3.9+
+- NumPy
+- ModernGL
+- GLFW
+- Pygame
+
+## 🚀 Quick Start
+
+### Optimized Vector Operations
+
+```python
+from e2D import Vector2D, batch_add_inplace, vectors_to_array
+
+# Create vectors
+v1 = Vector2D(3.0, 4.0)
+v2 = Vector2D(1.0, 2.0)
+
+# Basic operations
+v3 = v1 + v2
+length = v1.length
+dot = v1.dot_product(v2)
+
+# In-place operations (faster!)
+v1.iadd(v2)
+v1.normalize()
+v1.irotate(0.1)
+
+# Process thousands of vectors instantly
+positions = [Vector2D.random(-10, 10) for _ in range(10000)]
+displacement = Vector2D(1.0, 0.5)
+batch_add_inplace(positions, displacement)  # 🚀 Lightning fast!
+
+# Convert to numpy for GPU upload
+pos_array = vectors_to_array(positions)
+```
+
+### Graphics Rendering
+
+```python
+from e2D import RootEnv
+
+class MyApp(RootEnv):
+    def __init__(self):
+        super().__init__(
+            window_size=(1920, 1080),
+            target_fps=60,
+            vsync=True
+        )
+    
+    def update(self):
+        # Your game logic here
+        pass
+    
+    def draw(self):
+        # Your rendering code here
+        pass
+
+app = MyApp()
+app.run()
+```
+
+## 📊 Performance
+
+Vector2D benchmark (100,000 operations):
+
+| Operation | Time | vs Pure Python |
+|-----------|------|----------------|
+| Creation | 42 ms | 10x faster |
+| Addition | 64 ms | 15x faster |
+| In-place ops | 3.8 ms | **100x faster** |
+| Normalization | 1.9 ms | **200x faster** |
+| Batch operations | 0.17 ms | **500x+ faster** 🔥 |
+
+Perfect for:
+- Particle systems (10,000+ particles)
+- Physics simulations
+- Collision detection
+- Path finding
+- Real-time graphics
+
+## 📚 Documentation
+
+- **[Quick Start Guide](QUICKSTART.md)** - Get up and running in minutes
+- **[API Reference](https://github.com/marick-py/e2D)** - Full API documentation
+- **[Examples](examples/)** - Working code examples
+
+## 🎯 Use Cases
+
+### Particle System
+```python
+from e2D import Vector2D, batch_add_inplace, vectors_to_array
+
+positions = [Vector2D.random(-10, 10) for _ in range(10000)]
+velocities = [Vector2D.random(-1, 1) for _ in range(10000)]
+
+def update(dt):
+    # Update all particles in milliseconds
+    for i in range(len(positions)):
+        temp = velocities[i].mul(dt)
+        positions[i].iadd(temp)
+
+def render():
+    # Upload to GPU
+    pos_array = vectors_to_array(positions).astype(np.float32)
+    vbo.write(pos_array)
+```
+
+### Physics Simulation
+```python
+from e2D import Vector2D
+
+class RigidBody:
+    def __init__(self, pos, vel):
+        self.position = Vector2D(*pos)
+        self.velocity = Vector2D(*vel)
+        self.acceleration = Vector2D(0, -9.8)
+    
+    def update(self, dt):
+        # Optimized in-place physics
+        temp = self.acceleration.mul(dt)
+        self.velocity.iadd(temp)
+        
+        temp = self.velocity.mul(dt)
+        self.position.iadd(temp)
+```
+
+## 🔧 Development
+
+### Building from Source
+
+```bash
+git clone https://github.com/marick-py/e2D.git
+cd e2D
+pip install -e .[dev]
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Building Distribution
+
+```bash
+python -m build
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 👤 Author
+
+**Riccardo Mariani**
+- Email: ricomari2006@gmail.com
+- GitHub: [@marick-py](https://github.com/marick-py)
+
+## 🙏 Acknowledgments
+
+- Built with [ModernGL](https://github.com/moderngl/moderngl)
+- Optimized with [Cython](https://cython.org/)
+- Inspired by the need for high-performance 2D mathematics in Python
+
+## 📈 Version History
+
+- **2.0.0** - Added ultra-optimized Vector2D with Cython compilation
+- **1.4.24** - Previous stable release with pure Python vectors
+
+---
+
+**Made with ❤️ for high-performance 2D development**
+
+

e2d-2.0.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+e2D/__init__.py,sha256=rNGyv9X8ZdmTJvgjXaO8SKGTnQlrvhtIBF8PP3VpBFA,18054
+e2D/commons.py,sha256=vs6UqYGtm2-oHfv5kCSjMaQ243Xq6OqWh4Jt520H6Ho,2522
+e2D/cvectors.c,sha256=Rqj99mKXScJ2OMc4y5KSBXhjLyuV4bP7T5v-nOgEooY,1222782
+e2D/cvectors.cp313-win_amd64.pyd,sha256=_gzGIOVkH7XbiEr2fQ_QjCkuOytuzPqWgscRqUL2xmE,228864
+e2D/cvectors.pxd,sha256=7y2VUafKkVFezGQioTlF66dy4g5aNbGnGLhLtHZpuM4,2137
+e2D/cvectors.pyx,sha256=xJW6dD6JikkUXy0cuytgIijZJLcTpzJ0NpJ-aIErdzg,19048
+e2D/devices.py,sha256=iAUNXSSD0wEqLqHV6ET3dcqx4C62ifxaXcN_8xaV7sI,2440
+e2D/plots.py,sha256=gaCnnA-gUY1Hnmgquo7mqWlxSzAY4swTfwoPmw9ZF2k,21272
+e2D/shapes.py,sha256=PY2G0EFCLqERTR0UfK8jqSanh5wwIBTYRPA5a6LRs7w,45450
+e2D/text_renderer.py,sha256=u3i0qxnqgnVGUB6f0bKb1QtElVe535cDIIpjtRRcLAY,19752
+e2D/vectors.py,sha256=WXNzaA1bLjM5movVWOn7gDy73H1xA0cavlP7djO1FSc,6781
+e2D/shaders/curve_fragment.glsl,sha256=tKI3rDSlJPrWrQiATn6Rf4bJv7YGWVF6sgU9Y5H5qOk,94
+e2D/shaders/curve_vertex.glsl,sha256=uEp9OwcTSB_EfJhQRkNPalpT6jvJ2FO42vnPeKZl9J8,324
+e2D/shaders/line_instanced_vertex.glsl,sha256=r4XUNFogDH-Q9d_uXZQcT47iuiO8LeYXbEbqzRCFKSo,1049
+e2D/shaders/plot_grid_fragment.glsl,sha256=rOKW6Bold7d9Bunaf1SJeLYOgbsHfKk_UVFGMpkMq4c,1338
+e2D/shaders/plot_grid_vertex.glsl,sha256=-t8E3D0KBjaxIFbhZl87A0_4TzJ7fmajyLXoAaLu7_M,139
+e2D/shaders/segment_fragment.glsl,sha256=tKI3rDSlJPrWrQiATn6Rf4bJv7YGWVF6sgU9Y5H5qOk,94
+e2D/shaders/segment_vertex.glsl,sha256=I-hgbl2SnR5tWH9KRhz3CCj3ZZ7poz_gUfph1ydisaQ,233
+e2D/shaders/stream_fragment.glsl,sha256=EBI2wXv_LjoikQ3sbPtRw5gA5lIeLimNBUSoU6UWSqM,246
+e2D/shaders/stream_shift_compute.glsl,sha256=nwTD8IJjsFpl2XUXInc8IBDdW-DOmvaMLygLdquidyg,290
+e2D/shaders/stream_vertex.glsl,sha256=Wxa8YtgxlMNL7OYq5LwqoOA_B4iRilC5_ArznyT018Y,608
+e2d-2.0.0.dist-info/licenses/LICENSE,sha256=hbjljn38VVW9en51B0qzRK-v2FBDijqRWbZIVTk7ipU,1094
+e2d-2.0.0.dist-info/METADATA,sha256=EKooTJt_akYAd3s_-S7pvJlmnogTloMGmR-pFnutUMc,7117
+e2d-2.0.0.dist-info/WHEEL,sha256=T5i2ODeLs0s2las6bzoWK6w-WYjxkhtXh7SRJsBsjo4,102
+e2d-2.0.0.dist-info/top_level.txt,sha256=3vKZ-CGzNlTCpzVMmM0Ht76krCofKw7hZ0wBf-dnKdM,4
+e2d-2.0.0.dist-info/RECORD,,

e2d-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

e2d-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Riccardo Mariani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

e2d-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+e2D