e2D 1.4.19__tar.gz → 2.0.1__tar.gz

{e2d-1.4.19 → e2d-2.0.1}/LICENSE

@@ -1,21 +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.
+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.1/MANIFEST.in

@@ -0,0 +1,31 @@
+# Include Cython source files for compilation during install
+include e2D/*.pyx
+include e2D/*.pxd
+include e2D/*.pyi
+
+# Include shader files
+recursive-include e2D/shaders *.glsl
+
+# Include documentation
+include README.md
+include LICENSE
+include QUICKSTART.md
+
+# Include configuration files
+include pyproject.toml
+include setup.py
+include setup.cfg
+
+# Include examples
+recursive-include examples *.py
+
+# Exclude build artifacts
+global-exclude __pycache__
+global-exclude *.py[co]
+global-exclude *.so
+global-exclude *.pyd
+global-exclude .DS_Store
+
+# SECURITY: Exclude version management scripts (contain API keys)
+exclude new_version.bat
+exclude new_version.py

e2d-2.0.1/PKG-INFO

@@ -0,0 +1,288 @@
+Metadata-Version: 2.4
+Name: e2D
+Version: 2.0.1
+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
+Requires-Dist: opencv-python
+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 and TTF fonts
+- **Screen recording** with async video encoding
+- **Color system** with 80+ pre-defined colors
+- **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
+- OpenCV (for video recording)
+
+## 🚀 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, DefEnv
+
+class MyApp(DefEnv):
+    def __init__(self) -> None:
+        pass
+    
+    def update(self) -> None:
+        # Your game logic here
+        pass
+    
+    def draw(self) -> None:
+        # Your rendering code here
+        pass
+
+# Initialize and run
+rootEnv = RootEnv(window_size=(1920, 1080), target_fps=60)
+rootEnv.init(MyApp())
+
+# Optional: Enable screen recording
+rootEnv.init_rec(fps=30, draw_on_screen=True, path='output.mp4')
+
+rootEnv.loop()
+```
+
+### Color System
+
+```python
+from e2D import Color, WHITE, RED, CYAN, normalize_color
+from e2D.color_defs import MD_BLUE, PASTEL_PINK, NEON_GREEN
+
+# Create colors
+color1 = Color.from_hex("#FF5733")
+color2 = Color.from_rgb255(100, 150, 200)
+color3 = Color.from_hsv(0.5, 0.8, 1.0)
+
+# Color operations
+lighter = color1.lighten(0.2)
+darker = color1.darken(0.2)
+inverted = color1.invert()
+rotated = color1.rotate_hue(120)
+
+# Use pre-defined colors
+from e2D import draw_circle
+draw_circle((100, 100), 50, color=RED, fill_mode='fill')
+```
+
+## 📊 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.1/QUICKSTART.md

@@ -0,0 +1,165 @@
+# Vector2D - Quick Start Guide
+
+## 🚀 Get Started in 3 Steps
+
+### Step 1: Build the Extension
+
+**Windows:**
+```bash
+build.bat
+```
+
+**Linux/Mac:**
+```bash
+chmod +x build.sh
+./build.sh
+```
+
+### Step 2: Test It Works
+
+```bash
+python -m e2D.vectors
+```
+
+You should see benchmark results like:
+```
+Vector2D Benchmark (100000 iterations)
+==================================================
+Creation:      15.23 ms
+Addition:      18.45 ms
+In-place add:  12.67 ms
+Normalize:     45.12 ms
+Batch add:     2.34 ms
+==================================================
+✓ Using compiled Cython extension (optimal performance)
+```
+
+### Step 3: Use in Your Code
+
+```python
+from e2D.vectors import Vector2D, V2
+
+# Create a vector
+position = Vector2D(100.0, 200.0)
+velocity = V2(5.0, -2.0)
+
+# Update position
+position += velocity * 0.016  # ~60 FPS
+
+print(f"New position: {position}")
+```
+
+## 📚 Next Steps
+
+- Check out [example_usage.py](example_usage.py) for more examples
+- Integrate with your ModernGL/GLFW project
+
+## ⚡ Performance Tips
+
+1. **Use in-place operations** for maximum speed:
+   ```python
+   v.iadd(other)  # Faster than v += other
+   v.imul(2.0)    # Faster than v *= 2.0
+   ```
+
+2. **Use batch operations** for many vectors:
+   ```python
+   from e2D.vectors import batch_add_inplace
+   batch_add_inplace(vectors, displacement)  # MUCH faster
+   ```
+
+3. **Avoid Python loops** when possible:
+   ```python
+   # Slow
+   for v in vectors:
+       v.normalize()
+   
+   # Fast
+   batch_normalize_inplace(vectors)
+   ```
+
+## 🔧 Troubleshooting
+
+**"ImportError: No module named 'cvectors'"**
+- Run the build script again: `build.bat` or `./build.sh`
+
+**"ERROR: Microsoft Visual C++ 14.0 is required" (Windows)**
+- Install [Visual C++ Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/)
+
+**Build errors on Linux/Mac**
+- Install build tools:
+  - Ubuntu/Debian: `sudo apt-get install build-essential python3-dev`
+  - CentOS/RHEL: `sudo yum install gcc gcc-c++ python3-devel`
+  - Mac: `xcode-select --install`
+
+## 📦 For Distribution
+
+To prepare for PyPI upload:
+
+```bash
+# Install build tools
+pip install build twine
+
+# Build distributions
+python -m build
+
+# Test upload (optional)
+python -m twine upload --repository testpypi dist/*
+
+# Upload to PyPI
+python -m twine upload dist/*
+```
+
+## 💡 Integration Example
+
+```python
+from e2D.vectors import Vector2D, vectors_to_array
+import moderngl
+import numpy as np
+
+# Create particle system
+positions = [Vector2D.random(-10, 10) for _ in range(10000)]
+velocities = [Vector2D.random(-1, 1) for _ in range(10000)]
+
+# Update loop (optimized)
+def update(dt):
+    for i in range(len(positions)):
+        temp = velocities[i].mul(dt)
+        positions[i].iadd(temp)
+
+# Upload to GPU
+def get_gpu_buffer():
+    pos_array = vectors_to_array(positions).astype(np.float32)
+    return pos_array
+
+# Use with ModernGL
+# vbo.write(get_gpu_buffer())
+```
+
+## 📈 Expected Performance
+
+For a typical simulation with 100,000 vectors:
+
+| Operation | Pure Python | Vector2D | Speedup |
+|-----------|-------------|--------------|---------|
+| Creation | ~500 ms | ~15 ms | **33x** |
+| Addition | ~800 ms | ~20 ms | **40x** |
+| Normalize | ~2000 ms | ~45 ms | **44x** |
+| Batch ops | ~1000 ms | ~2 ms | **500x** |
+
+## 🎯 Use Cases
+
+Perfect for:
+- Particle systems (10,000+ particles)
+- Physics simulations
+- Collision detection
+- Path finding
+- Procedural generation
+- Game engines
+- Scientific computing
+
+## 📝 License
+
+MIT License - Use freely in your projects!
+
+