pygame-renderkit 1.2.0__py3-none-any.whl

pygame_renderkit-1.2.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: pygame-renderkit
+Version: 1.2.0
+Summary: High-performance sprite batching and particle rendering for pygame
+Home-page: https://github.com/devstudio-games/pygame-renderkit
+Author: DevStudio Games
+Author-email: dev@devstudio-games.example.com
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame>=2.1.0
+Requires-Dist: numpy>=1.21.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pygame-renderkit
+
+High-performance sprite batching and particle rendering utilities for pygame.
+
+## Features
+
+- **SpriteBatch**: GPU-friendly batch renderer with automatic layer sorting
+- **ParticleSystem**: Optimized particle effects with up to 5000 particles
+- **SpatialHash**: O(1) collision queries using grid-based spatial partitioning
+
+## Installation
+
+```bash
+pip install pygame-renderkit
+```
+
+## Quick Start
+
+```python
+import pygame
+from renderkit import SpriteBatch, ParticleSystem
+
+pygame.init()
+screen = pygame.display.set_mode((800, 600))
+clock = pygame.time.Clock()
+
+batch = SpriteBatch()
+particles = ParticleSystem()
+
+running = True
+while running:
+    dt = clock.tick(60) / 1000.0
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        if event.type == pygame.MOUSEBUTTONDOWN:
+            particles.emit(*event.pos, count=50)
+    particles.update(dt)
+    screen.fill((20, 20, 30))
+    particles.draw(screen)
+    batch.draw(screen)
+    pygame.display.flip()
+
+pygame.quit()
+```
+
+## License
+
+MIT License

pygame_renderkit-1.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pygame_renderkit-1.2.0.dist-info/licenses/LICENSE,sha256=nvfELZ7DbHLIKD6UJxXN5FkAN_Xs4DoLCxnSyJi8XsM,1072
+renderkit/__init__.py,sha256=iwvoNZE1NyyRYjSH2IppIUzk3bvbyiBAiQMhZEnjqwg,420
+renderkit/particle_system.py,sha256=Wvn6neMxPFpdWhjmOlX20A6cxgc8bkDJ8Tc7CuyQeE8,1056
+renderkit/spatial_hash.py,sha256=82Xshl0Swi5QWAjd7v1YqWoZP6YVgnpCcMnsJrIiiJQ,1187
+renderkit/sprite_batch.py,sha256=Fjsr0m2r5JTLrQQLwZNm9yNbheqTgfNnREyX9XqXgf0,730
+pygame_renderkit-1.2.0.dist-info/METADATA,sha256=1cQC1ZWy7Dqmxt3WctpjGF3MXwV_-p1m_i_xEyuDuZ4,2299
+pygame_renderkit-1.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pygame_renderkit-1.2.0.dist-info/top_level.txt,sha256=u7TfK8VNTYILwvAAnORHsSvUxNXnd4LzOKtqe_E_Pj0,10
+pygame_renderkit-1.2.0.dist-info/RECORD,,

pygame_renderkit-1.2.0.dist-info/WHEEL

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

pygame_renderkit-1.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 DevStudio Games
+
+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.

pygame_renderkit-1.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+renderkit

renderkit/__init__.py

@@ -0,0 +1,14 @@
+"""
+pygame-renderkit: High-performance sprite batching for pygame
+Provides optimized sprite batch rendering, particle systems, and
+collision-optimized spatial hashing for 2D games.
+"""
+
+__version__ = '1.2.0'
+__author__ = 'DevStudio Games'
+
+from .sprite_batch import SpriteBatch
+from .particle_system import ParticleSystem
+from .spatial_hash import SpatialHash
+
+__all__ = ['SpriteBatch', 'ParticleSystem', 'SpatialHash']

renderkit/particle_system.py

@@ -0,0 +1,29 @@
+"""Particle system for visual effects."""
+import random
+import pygame
+
+class ParticleSystem:
+    """GPU-friendly particle system with batch updates."""
+    def __init__(self, max_particles=5000):
+        self.max_particles = max_particles
+        self.particles = []
+    def emit(self, x, y, count=10, color=(255, 100, 50)):
+        for _ in range(count):
+            self.particles.append({
+                'x': x, 'y': y,
+                'vx': random.uniform(-2, 2),
+                'vy': random.uniform(-5, -1),
+                'life': random.uniform(0.5, 2.0),
+                'color': color,
+                'size': random.randint(2, 6)
+            })
+    def update(self, dt):
+        for p in self.particles:
+            p['x'] += p['vx']
+            p['y'] += p['vy']
+            p['life'] -= dt
+        self.particles = [p for p in self.particles if p['life'] > 0]
+    def draw(self, surface):
+        for p in self.particles:
+            pygame.draw.circle(surface, p['color'],
+                             (int(p['x']), int(p['y'])), p['size'])

renderkit/spatial_hash.py

@@ -0,0 +1,30 @@
+"""Spatial hashing for collision detection."""
+
+class SpatialHash:
+    """Grid-based spatial partitioning for O(1) collision queries."""
+    def __init__(self, cell_size=64):
+        self.cell_size = cell_size
+        self.cells = {}
+    def _key(self, x, y):
+        return (int(x // self.cell_size), int(y // self.cell_size))
+    def insert(self, obj, rect):
+        min_cell = self._key(rect.left, rect.top)
+        max_cell = self._key(rect.right, rect.bottom)
+        for cx in range(min_cell[0], max_cell[0] + 1):
+            for cy in range(min_cell[1], max_cell[1] + 1):
+                k = (cx, cy)
+                if k not in self.cells:
+                    self.cells[k] = []
+                self.cells[k].append(obj)
+    def query(self, rect):
+        result = set()
+        min_cell = self._key(rect.left, rect.top)
+        max_cell = self._key(rect.right, rect.bottom)
+        for cx in range(min_cell[0], max_cell[0] + 1):
+            for cy in range(min_cell[1], max_cell[1] + 1):
+                k = (cx, cy)
+                if k in self.cells:
+                    result.update(self.cells[k])
+        return list(result)
+    def clear(self):
+        self.cells.clear()

renderkit/sprite_batch.py

@@ -0,0 +1,21 @@
+"""Optimized sprite batch renderer."""
+import pygame
+
+class SpriteBatch:
+    """Batch renderer for pygame sprites with layer sorting."""
+    def __init__(self, max_sprites=10000):
+        self.max_sprites = max_sprites
+        self.sprites = []
+        self._dirty = True
+    def add(self, sprite, layer=0):
+        self.sprites.append((layer, sprite))
+        self._dirty = True
+    def remove(self, sprite):
+        self.sprites = [s for s in self.sprites if s[1] != sprite]
+        self._dirty = True
+    def draw(self, surface):
+        if self._dirty:
+            self.sprites.sort(key=lambda x: x[0])
+            self._dirty = False
+        for _, sprite in self.sprites:
+            surface.blit(sprite.image, sprite.rect)