aether-engine 1.0.0__py3-none-any.whl

aether/utils/object_pool.py

@@ -0,0 +1,137 @@
+"""Пул объектов для оптимизации"""
+from typing import Type, TypeVar, List, Optional, Callable
+from collections import deque
+
+T = TypeVar('T')
+
+
+class ObjectPool:
+    """
+    Пул объектов для переиспользования.
+    
+    Пример:
+    pool = ObjectPool(Particle, max_size=1000)
+    particle = pool.acquire()
+    pool.release(particle)
+    """
+    
+    def __init__(self, 
+                 object_type: Type[T],
+                 max_size: int = 100,
+                 pre_create: int = 0,
+                 factory: Optional[Callable[[], T]] = None,
+                 on_acquire: Optional[Callable[[T], None]] = None,
+                 on_release: Optional[Callable[[T], None]] = None):
+        
+        self.object_type = object_type
+        self.max_size = max_size
+        
+        # Очереди
+        self._available: deque = deque()
+        self._in_use: set = set()
+        
+        # Коллбэки
+        self.factory = factory or (lambda: object_type())
+        self.on_acquire = on_acquire
+        self.on_release = on_release
+        
+        # Статистика
+        self.total_created = 0
+        self.total_acquired = 0
+        self.total_released = 0
+        
+        # Предсоздание объектов
+        for _ in range(min(pre_create, max_size)):
+            obj = self.factory()
+            self._available.append(obj)
+            self.total_created += 1
+        
+        print(f"[ObjectPool] Created for {object_type.__name__} (max: {max_size})")
+    
+    def acquire(self) -> Optional[T]:
+        """
+        Получает объект из пула.
+        Возвращает None если пул пуст и достигнут максимум.
+        """
+        if self._available:
+            obj = self._available.popleft()
+        elif len(self._in_use) < self.max_size:
+            obj = self.factory()
+            self.total_created += 1
+        else:
+            print(f"[ObjectPool] Pool exhausted for {self.object_type.__name__}")
+            return None
+        
+        self._in_use.add(id(obj))
+        self.total_acquired += 1
+        
+        if self.on_acquire:
+            self.on_acquire(obj)
+        
+        return obj
+    
+    def release(self, obj: T):
+        """
+        Возвращает объект в пул.
+        """
+        obj_id = id(obj)
+        
+        if obj_id in self._in_use:
+            self._in_use.remove(obj_id)
+            self.total_released += 1
+            
+            if self.on_release:
+                self.on_release(obj)
+            
+            self._available.append(obj)
+    
+    def release_all(self):
+        """Возвращает все объекты в пул"""
+        in_use = list(self._in_use)
+        for obj_id in in_use:
+            # Здесь нужен доступ к объектам
+            pass
+    
+    def clear(self):
+        """Очищает пул"""
+        self._available.clear()
+        self._in_use.clear()
+        self.total_created = 0
+        self.total_acquired = 0
+        self.total_released = 0
+    
+    def prewarm(self, count: int):
+        """Предсоздаёт объекты"""
+        for _ in range(count):
+            if len(self._available) + len(self._in_use) < self.max_size:
+                obj = self.factory()
+                self._available.append(obj)
+                self.total_created += 1
+    
+    @property
+    def available_count(self) -> int:
+        return len(self._available)
+    
+    @property
+    def in_use_count(self) -> int:
+        return len(self._in_use)
+    
+    @property
+    def usage_percent(self) -> float:
+        total = self.available_count + self.in_use_count
+        if total == 0:
+            return 0.0
+        return (self.in_use_count / total) * 100
+    
+    def get_stats(self) -> dict:
+        """Возвращает статистику"""
+        return {
+            'type': self.object_type.__name__,
+            'available': self.available_count,
+            'in_use': self.in_use_count,
+            'max': self.max_size,
+            'usage_percent': f"{self.usage_percent:.1f}%",
+            'total_created': self.total_created,
+            'total_acquired': self.total_acquired,
+            'total_released': self.total_released,
+        }

aether/utils/profiler.py

@@ -0,0 +1,187 @@
+"""Профилировщик производительности"""
+import time
+from collections import defaultdict
+from typing import Dict, List, Optional
+import statistics
+
+
+class ProfilerSection:
+    """Секция профилирования"""
+    
+    def __init__(self, name: str):
+        self.name = name
+        self.start_time = 0.0
+        self.end_time = 0.0
+        self.duration = 0.0
+        self.call_count = 0
+        self._running = False
+    
+    def start(self):
+        self.start_time = time.perf_counter()
+        self._running = True
+        self.call_count += 1
+    
+    def stop(self):
+        if self._running:
+            self.end_time = time.perf_counter()
+            self.duration += self.end_time - self.start_time
+            self._running = False
+    
+    def reset(self):
+        self.duration = 0.0
+        self.call_count = 0
+
+
+class Profiler:
+    """Профилировщик производительности"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialize()
+        return cls._instance
+    
+    def _initialize(self):
+        """Инициализация профилировщика"""
+        self._sections: Dict[str, ProfilerSection] = {}
+        self._frame_times: List[float] = []
+        self._max_frame_samples = 300
+        
+        self.enabled = True
+        self._current_section: Optional[str] = None
+        
+        print("[Profiler] Initialized")
+    
+    def begin_section(self, name: str):
+        """Начинает секцию профилирования"""
+        if not self.enabled:
+            return
+        
+        if name not in self._sections:
+            self._sections[name] = ProfilerSection(name)
+        
+        self._sections[name].start()
+        self._current_section = name
+    
+    def end_section(self, name: str):
+        """Заканчивает секцию профилирования"""
+        if not self.enabled:
+            return
+        
+        if name in self._sections:
+            self._sections[name].stop()
+        
+        if self._current_section == name:
+            self._current_section = None
+    
+    def begin_frame(self):
+        """Начинает новый кадр"""
+        self._frame_start = time.perf_counter()
+    
+    def end_frame(self):
+        """Заканчивает кадр"""
+        if hasattr(self, '_frame_start'):
+            frame_time = time.perf_counter() - self._frame_start
+            
+            self._frame_times.append(frame_time)
+            if len(self._frame_times) > self._max_frame_samples:
+                self._frame_times.pop(0)
+    
+    def get_frame_stats(self) -> dict:
+        """Возвращает статистику кадров"""
+        if not self._frame_times:
+            return {
+                'avg_ms': 0,
+                'min_ms': 0,
+                'max_ms': 0,
+                'fps': 0,
+                'frame_count': 0
+            }
+        
+        avg = statistics.mean(self._frame_times)
+        return {
+            'avg_ms': avg * 1000,
+            'min_ms': min(self._frame_times) * 1000,
+            'max_ms': max(self._frame_times) * 1000,
+            'p99_ms': sorted(self._frame_times)[int(len(self._frame_times) * 0.99)] * 1000,
+            'fps': 1.0 / avg if avg > 0 else 0,
+            'frame_count': len(self._frame_times)
+        }
+    
+    def get_section_stats(self) -> List[dict]:
+        """Возвращает статистику по секциям"""
+        stats = []
+        
+        for section in self._sections.values():
+            if section.call_count > 0:
+                stats.append({
+                    'name': section.name,
+                    'total_ms': section.duration * 1000,
+                    'avg_ms': (section.duration / section.call_count) * 1000,
+                    'call_count': section.call_count
+                })
+        
+        # Сортируем по общему времени
+        stats.sort(key=lambda x: x['total_ms'], reverse=True)
+        
+        return stats
+    
+    def print_report(self):
+        """Выводит отчёт в консоль"""
+        frame_stats = self.get_frame_stats()
+        
+        print("\n" + "=" * 60)
+        print(" PROFILER REPORT")
+        print("=" * 60)
+        
+        print(f"\n📊 Frame Statistics:")
+        print(f"   FPS: {frame_stats['fps']:.1f}")
+        print(f"   Avg: {frame_stats['avg_ms']:.2f} ms")
+        print(f"   Min: {frame_stats['min_ms']:.2f} ms")
+        print(f"   Max: {frame_stats['max_ms']:.2f} ms")
+        print(f"   P99: {frame_stats['p99_ms']:.2f} ms")
+        
+        print(f"\n🔍 Section Breakdown:")
+        print(f"   {'Name':<30} {'Total ms':>10} {'Avg ms':>10} {'Calls':>8}")
+        print(f"   {'-'*30} {'-'*10} {'-'*10} {'-'*8}")
+        
+        for stat in self.get_section_stats():
+            print(f"   {stat['name']:<30} {stat['total_ms']:>10.2f} {stat['avg_ms']:>10.3f} {stat['call_count']:>8}")
+        
+        print("=" * 60 + "\n")
+    
+    def reset(self):
+        """Сбрасывает всю статистику"""
+        self._sections.clear()
+        self._frame_times.clear()
+    
+    def __enter__(self):
+        """Контекстный менеджер для автоматического профилирования"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            self.print_report()
+
+
+class ScopedProfiler:
+    """
+    Контекстный менеджер для профилирования блока кода.
+    
+    Использование:
+    with ScopedProfiler("Physics Update"):
+        physics.step(dt)
+    """
+    
+    def __init__(self, name: str):
+        self.name = name
+        self.profiler = Profiler()
+    
+    def __enter__(self):
+        self.profiler.begin_section(self.name)
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.profiler.end_section(self.name)

aether_engine-1.0.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: aether-engine
+Version: 1.0.0
+Summary: Полноценный 3D игровой движок на Python с OpenGL
+Author: entiti937
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: glfw>=2.6
+Requires-Dist: PyOpenGL>=3.1.7
+Requires-Dist: Pillow>=10.0
+Provides-Extra: physics
+Requires-Dist: PyBullet>=3.2.5; extra == "physics"
+Provides-Extra: audio
+Requires-Dist: pygame>=2.5; extra == "audio"
+Provides-Extra: full
+Requires-Dist: PyBullet>=3.2.5; extra == "full"
+Requires-Dist: pygame>=2.5; extra == "full"
+Requires-Dist: freetype-py>=2.4; extra == "full"
+Requires-Dist: imgui>=2.0; extra == "full"
+Requires-Dist: noise>=1.2; extra == "full"
+Requires-Dist: pyyaml>=6.0; extra == "full"
+Requires-Dist: imageio>=2.31; extra == "full"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Aether Engine
+
+Полноценный 3D игровой движок на Python с OpenGL 4.6.
+
+## Возможности
+- PBR-рендеринг
+- Система Entity-Component
+- Физика (базовая)
+- Звуковая система
+- UI-фреймворк
+- Загрузка моделей (OBJ)
+- Пост-обработка
+
+## Установка
+```bash
+pip install -e .
+# Быстрый старт
+from aether import Engine, Scene, Entity, MeshFactory, Material
+
+engine = Engine(1280, 720, "Моя игра")
+scene = Scene("Level 1")
+
+cube = Entity("Куб")
+cube.add_component(Transform())
+cube.add_component(MeshRenderer(
+    mesh=MeshFactory.create_cube(),
+    material=Material()
+))
+
+scene.spawn(cube)
+engine.load_scene(scene)
+engine.run()

aether_engine-1.0.0.dist-info/RECORD

@@ -0,0 +1,64 @@
+aether/__init__.py,sha256=OcJ67fdM9PH4zdKvkqiXMRKlVUVo4T-ta_7avGuviRw,1967
+aether/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aether/audio/audio_manager.py,sha256=tHCTr5jIDUrgUy8X669-9CuHOSzANkQFLZo9gdn0xz0,6695
+aether/audio/music.py,sha256=oDHgLsTCJkg8OBpJk4KTWCEfLibLHZCJ5GuNqR5EQBE,162
+aether/audio/sound.py,sha256=bpT6xXk9sUfnkVhjlba2NlUKrpGAmPfc5e2AcWN4p2Q,164
+aether/core/__init__.py,sha256=xo2SYiVHY_K5oGfbLc3RhUY-Ve6eIyjdnpSSXcJDlrw,8191
+aether/core/achievement_system.py,sha256=hhnI7La0ht71zhZFKsfYy6EAM6I2qBuSAzNHoeTilYg,11290
+aether/core/application.py,sha256=2QVzG2oFcKer3d3YIV8CSkVlF7VUS8AFbpIPU7FqHus,711
+aether/core/config.py,sha256=zq7yf7xllr8Al8q_I5rFTC_yApjKhDvlNkbscEEhj4c,2309
+aether/core/console.py,sha256=j8VeDocE4ihwsPAB3ph-BJRnbRq6kukwGLqmS4yvSBg,14054
+aether/core/engine.py,sha256=Ug0n_1bATD2CpullHgiL3JvQRASZDYg0_xmoYF6-nCA,1641
+aether/core/event_bus.py,sha256=r921Jwu_MOa1I1I1Uwj8icbPpLWFWlxVy5d19sJi1P4,834
+aether/core/input.py,sha256=Eg1-WpXl0Rsef2nfSDg0XjQshaJuaVofVPQO__Trgsk,2165
+aether/core/plugin_system.py,sha256=9CtqsxPwL0hNXu55OyLU_LMFfQIYg8Pb7ZPFRi6Xhe8,3436
+aether/core/save_system.py,sha256=a1vuCPQ3muJBKDwILjF-4tnJWraAfWN-GJju2U_N6HY,15339
+aether/core/time_manager.py,sha256=pRhBp3E_2iI9ops2daAk_xgX3MfqhogVV6CxNu8BlKc,757
+aether/core/window.py,sha256=q8n3M9MMRGIaedT62da2SdhXpp6xVzEf62hyiNiOcZ0,1805
+aether/graphics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aether/graphics/camera.py,sha256=UF2Zr8u9z-5vYdoQ7jDBhPUmwqjlh-RC8-x6F7a5hCM,2471
+aether/graphics/framebuffer.py,sha256=9yrRQVp6c4ogyMUHLwM4-MGJowFpp3stmywD9fDTpZQ,5044
+aether/graphics/light.py,sha256=a4Ckg8TP7QhfUNfhVC_8o9zdgSpnqgZ62buFM8-8U0I,1211
+aether/graphics/lod_system.py,sha256=tloF8hHaNSt1YUPmeOGCJsHwq7rx3uka_W6xXcHnum8,6510
+aether/graphics/material.py,sha256=fnKNTufE-agMkISPbxL3ANp0BgC4SJj1T0ENc6b6o-s,917
+aether/graphics/mesh.py,sha256=zbRysidEdrUOsjQST0qdvtOXEF1dRtBecPAUULFCZMs,3150
+aether/graphics/mesh_factory.py,sha256=AVC64mj_oJk1CSk6TjtJXJOdI97jxWQRqwQPO8uefgw,2485
+aether/graphics/particle_system.py,sha256=-n-M9EfnQkEkfQGcrwt_3gxtlB5Zb4UAJxEiWCLa_ZU,9416
+aether/graphics/post_process.py,sha256=jmnZ-B66sBpSY3LybRHDnaVfvSyk1_G8acw4gUQ2hqE,10284
+aether/graphics/renderer.py,sha256=1WkmCg9-IPFaFqIR9H7E278GyE7Rru-n2tD49kINe5U,4539
+aether/graphics/shader.py,sha256=joDnmNo_p5xWPcqOWWIH3fSbiy8TmwJEuwssG8r82vI,2033
+aether/graphics/shader_library.py,sha256=0-M3-SHN2Vqyl_OGGOA2DE7wpl7i7kyh6YL9xqD1fDM,4741
+aether/graphics/sky_atmosphere.py,sha256=UJPzG3YfwFFm-sXoCldWFi3-nkMGs3JqctbdFAtJUzE,11626
+aether/graphics/terrain.py,sha256=FjzUUTK068CpYUEZDNSs6EQWuMEmmtZOAPIqjc-Fkd4,16068
+aether/graphics/texture.py,sha256=knBsVEhGhq4ilLh1zwCA4UHzANYdCY_H0Z9vsY3moKU,1198
+aether/graphics/water.py,sha256=JY9Zx71B16S0O7w-9SKht257pD1RTkNhWwJTEoCNhW8,16106
+aether/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aether/physics/bullet_backend.py,sha256=rnP31Ok1lsjbPGeR0QiaiNdRq2GzIsF39qjiFKbRjPc,15616
+aether/physics/collider.py,sha256=ZQ3FqjAOQjrTQXHf-3PP7_Cbv__RjIK60zRuInfBdco,670
+aether/physics/physics_world.py,sha256=LH6_nF_jbYD3SsSk-lozB4Hs9AN-wkEfI-U-OBwtW2w,18393
+aether/physics/raycast.py,sha256=U3PpavN3LKCctb5zJggXBsZMJXHQRRkOEFSEEoC8Fno,681
+aether/physics/rigidbody.py,sha256=kc4dmlYdJ5ZwXrNi3KTbC9IXgL8fNwXQxEFURtRgxPE,279
+aether/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aether/resources/asset_database.py,sha256=QVDE-IvmO2LfBgskJEiFzYSFbcM2qBZ_eQwGmQ4yXSk,2486
+aether/resources/resource_manager.py,sha256=0WqS9ovd4dVHM4cjSZ_dXO9_nfRNDGzkx_rNexQMGX8,5239
+aether/resources/serialization.py,sha256=y2YOgtAQ6lVg5VYKCVp_gngdXIWHHo1Jufs5c5fe1Ho,4168
+aether/scene/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aether/scene/component.py,sha256=CqDQMygiIVq9Mvn8SNmYw0ZiwI-m18P96y5izbuQmzE,12410
+aether/scene/entity.py,sha256=xgbjCuk9kOL-YY0PQmJA69TV35r6TDXe0qpBSx9My-U,1452
+aether/scene/scene.py,sha256=zKD8Tn20STfc0r07DpYj36XtoWL5llyVvNrWAaEZIQE,833
+aether/scene/scene_graph.py,sha256=UBIKbVE365INtHV6Gh9k3OgQWahY3agq-M8YeNAb5sY,9892
+aether/scene/scene_manager.py,sha256=wrI5AMjJFk9OcMlHpbd3tBmLFLqMhEK_ZzGDxFzfEyY,6982
+aether/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aether/ui/button.py,sha256=02IaPm1m88SfCUSl3AKUHrwEZujsuFCtlM9RuKXt6IM,10259
+aether/ui/canvas.py,sha256=BhSgQog1X1olziXv9NJOF6eAX0tykcB9HuNxR2oHxU8,257
+aether/ui/text.py,sha256=uZyHlvuDX8vr1cRifsTTGyPi-E-OWMh-rumCZvZWEww,10157
+aether/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aether/utils/logger.py,sha256=Z1bAyXqJUDhsLJQu9cE3Lg9D4aBY8MWHwljt7zakUtc,407
+aether/utils/math_utils.py,sha256=XRw7feNGjWnsMYmqO4ao2d75NiuaLw-JkeBo383c2d4,808
+aether/utils/object_pool.py,sha256=na9yhkg40Gv4eF5yTbPwAyVQf4ESQtJxpQfXrGonm4U,4453
+aether/utils/profiler.py,sha256=N9-g6uXEdj9ppaLn0ZMNA6M39yD7j3zk2gRDRG1XZNw,6291
+aether_engine-1.0.0.dist-info/licenses/LICENSE,sha256=Gt4I9VSsehJDfU0SS90SkP15UAf5CoorLYB0Nt5Mcoc,1085
+aether_engine-1.0.0.dist-info/METADATA,sha256=6keEvFobY558N_JAKFtKilHjN0vkCa2GHFYDYq6sLMw,2121
+aether_engine-1.0.0.dist-info/WHEEL,sha256=YLJXdYXQ2FQ0Uqn2J-6iEIC-3iOey8lH3xCtvFLkd8Q,91
+aether_engine-1.0.0.dist-info/top_level.txt,sha256=QynFGsNdIRoJ6JBODYhcXgsoKtpwAuDfgGNOsy3UPsE,7
+aether_engine-1.0.0.dist-info/RECORD,,

aether_engine-1.0.0.dist-info/WHEEL

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

aether_engine-1.0.0.dist-info/licenses/LICENSE

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

aether_engine-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aether