aether-engine 1.0.0__tar.gz

aether_engine-1.0.0/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/MANIFEST.in

@@ -0,0 +1,14 @@
+include README.md
+include LICENSE
+include pyproject.toml
+
+recursive-include aether *.py
+recursive-include aether *.glsl
+recursive-include aether *.vert
+recursive-include aether *.frag
+recursive-include aether *.json
+
+recursive-include examples *.py
+
+exclude __pycache__
+exclude *.pyc

aether_engine-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,32 @@
+# 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/aether/__init__.py

@@ -0,0 +1,54 @@
+"""
+Aether Engine — полноценный 3D игровой движок на Python с OpenGL
+"""
+
+__version__ = "1.0.0"
+__author__ = "entiti937"
+
+# Ядро
+from aether.core.engine import Engine
+from aether.core.application import Application
+from aether.core.config import EngineConfig, GraphicsConfig, PhysicsConfig, AudioConfig
+
+# Сцена
+from aether.scene.entity import Entity
+from aether.scene.component import (
+    Transform, MeshRenderer, CameraComponent, 
+    LightComponent, RigidbodyComponent, ScriptComponent, AnimatorComponent
+)
+from aether.scene.scene import Scene
+from aether.scene.scene_manager import SceneManager
+
+# Графика
+from aether.graphics.shader import Shader
+from aether.graphics.shader_library import ShaderLibrary
+from aether.graphics.mesh import Mesh
+from aether.graphics.mesh_factory import MeshFactory
+from aether.graphics.material import Material
+from aether.graphics.texture import Texture
+from aether.graphics.camera import Camera
+from aether.graphics.light import DirectionalLight, PointLight, SpotLight
+from aether.graphics.renderer import Renderer
+from aether.graphics.particle_system import ParticleEmitter, ParticleRenderer
+
+# Физика
+from aether.physics.physics_world import PhysicsWorld
+from aether.physics.collider import BoxCollider, SphereCollider
+from aether.physics.rigidbody import Rigidbody
+
+# Ресурсы
+from aether.resources.resource_manager import ResourceManager
+from aether.resources.asset_database import AssetDatabase
+from aether.resources.loaders.obj_loader import OBJLoader
+from aether.resources.loaders.texture_loader import TextureLoader
+
+# UI
+from aether.ui.canvas import Canvas
+from aether.ui.button import Button, Panel, Label
+from aether.ui.text import Font, TextRenderer
+
+# Аудио
+from aether.audio.audio_manager import AudioManager, Sound, Music
+
+# Утилиты
+from aether.utils.profiler import Profiler, ScopedProfiler

aether_engine-1.0.0/aether/ai/behavior_tree.py

@@ -0,0 +1,403 @@
+"""Система деревьев поведения для AI"""
+from enum import Enum
+from typing import List, Dict, Optional, Callable, Any
+import time
+
+
+class BTStatus(Enum):
+    """Статус узла дерева поведения"""
+    SUCCESS = 1
+    FAILURE = 2
+    RUNNING = 3
+
+
+class BTNode:
+    """Базовый узел дерева поведения"""
+    
+    def __init__(self, name: str = ""):
+        self.name = name or self.__class__.__name__
+        self.parent: Optional['BTNode'] = None
+        self._status = BTStatus.FAILURE
+    
+    def tick(self, context: Dict[str, Any]) -> BTStatus:
+        """Выполняет узел"""
+        self._status = self._execute(context)
+        return self._status
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        """Внутренняя логика (переопределяется)"""
+        return BTStatus.SUCCESS
+    
+    def reset(self):
+        """Сбрасывает состояние"""
+        self._status = BTStatus.FAILURE
+    
+    @property
+    def status(self) -> BTStatus:
+        return self._status
+
+
+class Sequence(BTNode):
+    """
+    Последовательность: выполняет детей по порядку.
+    Останавливается при первой FAILURE или RUNNING.
+    """
+    
+    def __init__(self, name: str = "Sequence"):
+        super().__init__(name)
+        self.children: List[BTNode] = []
+        self._current_index = 0
+    
+    def add_child(self, node: BTNode) -> 'Sequence':
+        node.parent = self
+        self.children.append(node)
+        return self
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        while self._current_index < len(self.children):
+            child = self.children[self._current_index]
+            status = child.tick(context)
+            
+            if status == BTStatus.FAILURE:
+                self._current_index = 0
+                return BTStatus.FAILURE
+            
+            if status == BTStatus.RUNNING:
+                return BTStatus.RUNNING
+            
+            self._current_index += 1
+        
+        self._current_index = 0
+        return BTStatus.SUCCESS
+    
+    def reset(self):
+        super().reset()
+        self._current_index = 0
+        for child in self.children:
+            child.reset()
+
+
+class Selector(BTNode):
+    """
+    Селектор: выполняет детей по порядку.
+    Останавливается при первой SUCCESS или RUNNING.
+    """
+    
+    def __init__(self, name: str = "Selector"):
+        super().__init__(name)
+        self.children: List[BTNode] = []
+        self._current_index = 0
+    
+    def add_child(self, node: BTNode) -> 'Selector':
+        node.parent = self
+        self.children.append(node)
+        return self
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        while self._current_index < len(self.children):
+            child = self.children[self._current_index]
+            status = child.tick(context)
+            
+            if status == BTStatus.SUCCESS:
+                self._current_index = 0
+                return BTStatus.SUCCESS
+            
+            if status == BTStatus.RUNNING:
+                return BTStatus.RUNNING
+            
+            self._current_index += 1
+        
+        self._current_index = 0
+        return BTStatus.FAILURE
+    
+    def reset(self):
+        super().reset()
+        self._current_index = 0
+        for child in self.children:
+            child.reset()
+
+
+class Parallel(BTNode):
+    """
+    Параллельное выполнение всех детей.
+    """
+    
+    def __init__(self, name: str = "Parallel", 
+                 success_threshold: int = -1):
+        super().__init__(name)
+        self.children: List[BTNode] = []
+        self.success_threshold = success_threshold  # -1 = все должны выполниться
+    
+    def add_child(self, node: BTNode) -> 'Parallel':
+        node.parent = self
+        self.children.append(node)
+        return self
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        success_count = 0
+        failure_count = 0
+        
+        for child in self.children:
+            status = child.tick(context)
+            
+            if status == BTStatus.SUCCESS:
+                success_count += 1
+            elif status == BTStatus.FAILURE:
+                failure_count += 1
+        
+        threshold = self.success_threshold
+        if threshold < 0:
+            threshold = len(self.children)
+        
+        if success_count >= threshold:
+            return BTStatus.SUCCESS
+        elif failure_count > len(self.children) - threshold:
+            return BTStatus.FAILURE
+        
+        return BTStatus.RUNNING
+    
+    def reset(self):
+        super().reset()
+        for child in self.children:
+            child.reset()
+
+
+class Condition(BTNode):
+    """Условие (проверка)"""
+    
+    def __init__(self, name: str, condition_fn: Callable):
+        super().__init__(name)
+        self.condition_fn = condition_fn
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        if self.condition_fn(context):
+            return BTStatus.SUCCESS
+        return BTStatus.FAILURE
+
+
+class Action(BTNode):
+    """Действие"""
+    
+    def __init__(self, name: str, action_fn: Callable):
+        super().__init__(name)
+        self.action_fn = action_fn
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        return self.action_fn(context)
+
+
+class Inverter(BTNode):
+    """Инвертирует результат дочернего узла"""
+    
+    def __init__(self, name: str = "Inverter"):
+        super().__init__(name)
+        self.child: Optional[BTNode] = None
+    
+    def set_child(self, node: BTNode) -> 'Inverter':
+        node.parent = self
+        self.child = node
+        return self
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        if not self.child:
+            return BTStatus.FAILURE
+        
+        status = self.child.tick(context)
+        
+        if status == BTStatus.SUCCESS:
+            return BTStatus.FAILURE
+        elif status == BTStatus.FAILURE:
+            return BTStatus.SUCCESS
+        
+        return BTStatus.RUNNING
+
+
+class Repeater(BTNode):
+    """Повторяет дочерний узел N раз или пока не FAILURE"""
+    
+    def __init__(self, name: str = "Repeater", 
+                 count: int = -1, 
+                 stop_on_failure: bool = True):
+        super().__init__(name)
+        self.child: Optional[BTNode] = None
+        self.count = count  # -1 = бесконечно
+        self.stop_on_failure = stop_on_failure
+        self._iteration = 0
+    
+    def set_child(self, node: BTNode) -> 'Repeater':
+        node.parent = self
+        self.child = node
+        return self
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        if not self.child:
+            return BTStatus.FAILURE
+        
+        status = self.child.tick(context)
+        
+        if self.stop_on_failure and status == BTStatus.FAILURE:
+            return BTStatus.FAILURE
+        
+        if status != BTStatus.RUNNING:
+            self._iteration += 1
+            
+            if self.count > 0 and self._iteration >= self.count:
+                return BTStatus.SUCCESS
+            
+            self.child.reset()
+        
+        return BTStatus.RUNNING
+    
+    def reset(self):
+        super().reset()
+        self._iteration = 0
+        if self.child:
+            self.child.reset()
+
+
+class Wait(BTNode):
+    """Ожидание заданное время"""
+    
+    def __init__(self, name: str = "Wait", duration: float = 1.0):
+        super().__init__(name)
+        self.duration = duration
+        self._start_time = 0.0
+        self._started = False
+    
+    def _execute(self, context: Dict[str, Any]) -> BTStatus:
+        if not self._started:
+            self._start_time = time.time()
+            self._started = True
+        
+        elapsed = time.time() - self._start_time
+        
+        if elapsed >= self.duration:
+            self._started = False
+            return BTStatus.SUCCESS
+        
+        return BTStatus.RUNNING
+
+
+class BehaviorTree:
+    """Дерево поведения"""
+    
+    def __init__(self, root: BTNode = None):
+        self.root = root
+        self._context: Dict[str, Any] = {}
+        self._running = True
+    
+    def set_root(self, node: BTNode):
+        self.root = node
+    
+    def set_context(self, key: str, value: Any):
+        self._context[key] = value
+    
+    def get_context(self, key: str, default: Any = None) -> Any:
+        return self._context.get(key, default)
+    
+    def tick(self) -> BTStatus:
+        """Один такт дерева поведения"""
+        if not self.root or not self._running:
+            return BTStatus.FAILURE
+        
+        return self.root.tick(self._context)
+    
+    def reset(self):
+        """Сбрасывает дерево"""
+        if self.root:
+            self.root.reset()
+    
+    def pause(self):
+        self._running = False
+    
+    def resume(self):
+        self._running = True
+
+
+# ---- ПРИМЕРЫ ПОВЕДЕНИЯ ----
+
+class IsEnemyNearby(Condition):
+    """Проверка: есть ли враг рядом"""
+    def __init__(self, radius: float = 5.0):
+        super().__init__("IsEnemyNearby", self._check)
+        self.radius = radius
+    
+    def _check(self, context: Dict[str, Any]) -> bool:
+        entity = context.get('entity')
+        if not entity:
+            return False
+        
+        # Здесь должна быть реальная проверка
+        enemies = context.get('enemies', [])
+        position = context.get('position')
+        
+        if position is None:
+            transform = entity.get_component("Transform")
+            if transform:
+                position = transform.position
+        
+        for enemy in enemies:
+            enemy_pos = enemy.get_component("Transform").position
+            if np.linalg.norm(position - enemy_pos) < self.radius:
+                return True
+        
+        return False
+
+
+class MoveToTarget(Action):
+    """Движение к цели"""
+    def __init__(self, speed: float = 3.0):
+        super().__init__("MoveToTarget", self._move)
+        self.speed = speed
+    
+    def _move(self, context: Dict[str, Any]) -> BTStatus:
+        entity = context.get('entity')
+        target = context.get('target')
+        
+        if not entity or not target:
+            return BTStatus.FAILURE
+        
+        transform = entity.get_component("Transform")
+        target_pos = target.get_component("Transform").position
+        
+        if transform is None:
+            return BTStatus.FAILURE
+        
+        direction = target_pos - transform.position
+        distance = np.linalg.norm(direction)
+        
+        if distance < 0.5:
+            return BTStatus.SUCCESS
+        
+        direction = direction / distance
+        transform.position += direction * self.speed * 0.016
+        transform._matrix_dirty = True
+        
+        return BTStatus.RUNNING
+
+
+class AttackTarget(Action):
+    """Атака цели"""
+    def __init__(self, damage: float = 10.0):
+        super().__init__("AttackTarget", self._attack)
+        self.damage = damage
+        self._cooldown = 1.0
+        self._last_attack = 0.0
+    
+    def _attack(self, context: Dict[str, Any]) -> BTStatus:
+        target = context.get('target')
+        if not target:
+            return BTStatus.FAILURE
+        
+        current_time = time.time()
+        if current_time - self._last_attack < self._cooldown:
+            return BTStatus.RUNNING
+        
+        # Наносим урон
+        health = target.get_component("Health")
+        if health:
+            health.take_damage(self.damage)
+        
+        self._last_attack = current_time
+        
+        return BTStatus.SUCCESS