aether-engine 1.0.0__py3-none-any.whl

aether/scene/scene_graph.py

@@ -0,0 +1,252 @@
+"""Граф сцены с иерархией объектов и трансформациями"""
+import numpy as np
+from typing import Optional, List, Set, Dict
+from aether.scene.entity import Entity
+
+
+class SceneNode:
+    """Узел графа сцены"""
+    
+    def __init__(self, entity: Entity):
+        self.entity = entity
+        self.parent: Optional['SceneNode'] = None
+        self.children: List['SceneNode'] = []
+        
+        # Кэшированная мировая матрица
+        self._world_matrix_dirty = True
+        self._cached_world_matrix = np.identity(4, dtype=np.float32)
+        
+        # Мировые трансформации (кэш)
+        self._world_position = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self._world_rotation = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self._world_scale = np.array([1.0, 1.0, 1.0], dtype=np.float32)
+    
+    def add_child(self, child: 'SceneNode'):
+        """Добавляет дочерний узел"""
+        if child.parent:
+            child.parent.remove_child(child)
+        
+        child.parent = self
+        self.children.append(child)
+        child._mark_dirty()
+    
+    def remove_child(self, child: 'SceneNode'):
+        """Удаляет дочерний узел"""
+        if child in self.children:
+            self.children.remove(child)
+            child.parent = None
+            child._mark_dirty()
+    
+    def set_parent(self, parent: Optional['SceneNode']):
+        """Устанавливает родительский узел"""
+        if parent:
+            parent.add_child(self)
+        elif self.parent:
+            self.parent.remove_child(self)
+    
+    def _mark_dirty(self):
+        """Помечает матрицу как устаревшую (рекурсивно)"""
+        self._world_matrix_dirty = True
+        for child in self.children:
+            child._mark_dirty()
+    
+    def get_world_matrix(self) -> np.ndarray:
+        """Получает мировую матрицу с учётом иерархии"""
+        if not self._world_matrix_dirty:
+            return self._cached_world_matrix
+        
+        # Получаем локальную матрицу
+        transform = self.entity.get_component("Transform")
+        if transform:
+            local_matrix = transform.get_model_matrix()
+        else:
+            local_matrix = np.identity(4, dtype=np.float32)
+        
+        # Применяем родительскую матрицу
+        if self.parent:
+            parent_matrix = self.parent.get_world_matrix()
+            self._cached_world_matrix = parent_matrix @ local_matrix
+        else:
+            self._cached_world_matrix = local_matrix.copy()
+        
+        # Извлекаем мировые компоненты
+        self._extract_world_components()
+        
+        self._world_matrix_dirty = False
+        return self._cached_world_matrix
+    
+    def _extract_world_components(self):
+        """Извлекает позицию, поворот и масштаб из мировой матрицы"""
+        m = self._cached_world_matrix
+        
+        # Позиция
+        self._world_position = m[3, :3].copy()
+        
+        # Масштаб
+        scale_x = np.linalg.norm(m[0, :3])
+        scale_y = np.linalg.norm(m[1, :3])
+        scale_z = np.linalg.norm(m[2, :3])
+        self._world_scale = np.array([scale_x, scale_y, scale_z], dtype=np.float32)
+        
+        # Поворот (упрощённо)
+        if scale_x > 0 and scale_y > 0 and scale_z > 0:
+            rot_matrix = m[:3, :3].copy()
+            rot_matrix[0, :3] /= scale_x
+            rot_matrix[1, :3] /= scale_y
+            rot_matrix[2, :3] /= scale_z
+            
+            # Извлекаем углы Эйлера
+            self._world_rotation = self._matrix_to_euler(rot_matrix)
+    
+    def _matrix_to_euler(self, m: np.ndarray) -> np.ndarray:
+        """Конвертирует матрицу поворота в углы Эйлера"""
+        sy = np.sqrt(m[0, 0] ** 2 + m[1, 0] ** 2)
+        
+        if sy > 1e-6:
+            x = np.arctan2(m[2, 1], m[2, 2])
+            y = np.arctan2(-m[2, 0], sy)
+            z = np.arctan2(m[1, 0], m[0, 0])
+        else:
+            x = np.arctan2(-m[1, 2], m[1, 1])
+            y = np.arctan2(-m[2, 0], sy)
+            z = 0.0
+        
+        return np.degrees(np.array([x, y, z], dtype=np.float32))
+    
+    @property
+    def world_position(self) -> np.ndarray:
+        """Мировая позиция"""
+        self.get_world_matrix()
+        return self._world_position.copy()
+    
+    @property
+    def world_rotation(self) -> np.ndarray:
+        """Мировой поворот"""
+        self.get_world_matrix()
+        return self._world_rotation.copy()
+    
+    @property
+    def world_scale(self) -> np.ndarray:
+        """Мировой масштаб"""
+        self.get_world_matrix()
+        return self._world_scale.copy()
+    
+    def forward(self) -> np.ndarray:
+        """Направление вперёд в мировом пространстве"""
+        m = self.get_world_matrix()
+        forward = -m[2, :3]
+        return forward / np.linalg.norm(forward)
+    
+    def right(self) -> np.ndarray:
+        """Направление вправо в мировом пространстве"""
+        m = self.get_world_matrix()
+        right = m[0, :3]
+        return right / np.linalg.norm(right)
+    
+    def up(self) -> np.ndarray:
+        """Направление вверх в мировом пространстве"""
+        m = self.get_world_matrix()
+        up = m[1, :3]
+        return up / np.linalg.norm(up)
+
+
+class SceneGraph:
+    """Граф сцены"""
+    
+    def __init__(self):
+        self._nodes: Dict[str, SceneNode] = {}
+        self._root_nodes: List[SceneNode] = []
+        self._dirty = True
+    
+    def register_entity(self, entity: Entity) -> SceneNode:
+        """Регистрирует Entity в графе"""
+        if entity.id in self._nodes:
+            return self._nodes[entity.id]
+        
+        node = SceneNode(entity)
+        self._nodes[entity.id] = node
+        self._root_nodes.append(node)
+        self._dirty = True
+        
+        return node
+    
+    def unregister_entity(self, entity: Entity):
+        """Удаляет Entity из графа"""
+        if entity.id in self._nodes:
+            node = self._nodes[entity.id]
+            
+            # Отсоединяем от родителя
+            if node.parent:
+                node.parent.remove_child(node)
+            
+            # Удаляем из корневых
+            if node in self._root_nodes:
+                self._root_nodes.remove(node)
+            
+            # Переносим детей в корень
+            for child in node.children[:]:
+                node.remove_child(child)
+                self._root_nodes.append(child)
+            
+            del self._nodes[entity.id]
+            self._dirty = True
+    
+    def set_parent(self, child_entity: Entity, parent_entity: Entity):
+        """Устанавливает родительскую связь"""
+        child_node = self._nodes.get(child_entity.id)
+        parent_node = self._nodes.get(parent_entity.id)
+        
+        if child_node and parent_node:
+            if child_node in self._root_nodes:
+                self._root_nodes.remove(child_node)
+            
+            parent_node.add_child(child_node)
+            self._dirty = True
+    
+    def get_node(self, entity: Entity) -> Optional[SceneNode]:
+        """Получает узел по Entity"""
+        return self._nodes.get(entity.id)
+    
+    def get_root_nodes(self) -> List[SceneNode]:
+        """Возвращает корневые узлы"""
+        return self._root_nodes.copy()
+    
+    def get_all_nodes(self) -> List[SceneNode]:
+        """Возвращает все узлы"""
+        return list(self._nodes.values())
+    
+    def update(self):
+        """Обновляет все мировые матрицы"""
+        for root in self._root_nodes:
+            self._update_node_recursive(root)
+        
+        self._dirty = False
+    
+    def _update_node_recursive(self, node: SceneNode):
+        """Рекурсивно обновляет узел и его детей"""
+        node._mark_dirty()
+        node.get_world_matrix()
+        
+        for child in node.children:
+            self._update_node_recursive(child)
+    
+    def find_entity_at_point(self, point: np.ndarray) -> Optional[Entity]:
+        """Находит Entity в заданной точке (упрощённо)"""
+        for node in reversed(self.get_all_nodes()):
+            collider = node.entity.get_component("Collider") or \
+                      node.entity.get_component("BoxCollider") or \
+                      node.entity.get_component("SphereCollider")
+            
+            if collider:
+                world_pos = node.world_position
+                # Простая проверка AABB (можно улучшить)
+                if isinstance(collider, BoxCollider):
+                    min_point = world_pos + collider.center - collider.size / 2
+                    max_point = world_pos + collider.center + collider.size / 2
+                    
+                    if (min_point[0] <= point[0] <= max_point[0] and
+                        min_point[1] <= point[1] <= max_point[1] and
+                        min_point[2] <= point[2] <= max_point[2]):
+                        return node.entity
+        
+        return None

aether/scene/scene_manager.py

@@ -0,0 +1,191 @@
+"""Менеджер сцен — загрузка, выгрузка, переходы"""
+from typing import Dict, Optional, List
+from aether.scene.scene import Scene
+import json
+import os
+from pathlib import Path
+
+
+class SceneTransition:
+    """Переход между сценами"""
+    
+    def __init__(self, from_scene: str, to_scene: str, 
+                 transition_time: float = 1.0):
+        self.from_scene = from_scene
+        self.to_scene = to_scene
+        self.transition_time = transition_time
+        self.elapsed = 0.0
+        self.completed = False
+        self.progress = 0.0
+    
+    def update(self, dt: float):
+        """Обновляет прогресс перехода"""
+        self.elapsed += dt
+        self.progress = min(1.0, self.elapsed / self.transition_time)
+        if self.progress >= 1.0:
+            self.completed = True
+
+
+class SceneManager:
+    """Менеджер сцен"""
+    
+    _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._scenes: Dict[str, Scene] = {}
+        self._active_scene: Optional[Scene] = None
+        self._scene_queue: List[str] = []
+        self._transition: Optional[SceneTransition] = None
+        self._loading = False
+        
+        # Пути для сохранения сцен
+        self._scenes_path = Path("./scenes")
+        
+        print("[SceneManager] Initialized")
+    
+    def register_scene(self, scene: Scene):
+        """Регистрирует сцену"""
+        self._scenes[scene.name] = scene
+        print(f"[SceneManager] Registered scene: {scene.name}")
+    
+    def unregister_scene(self, name: str):
+        """Удаляет сцену"""
+        if name in self._scenes:
+            if self._active_scene and self._active_scene.name == name:
+                self._active_scene.destroy()
+                self._active_scene = None
+            
+            del self._scenes[name]
+    
+    def load_scene(self, name: str, additive: bool = False):
+        """Загружает сцену"""
+        if name not in self._scenes:
+            print(f"[SceneManager] Scene '{name}' not found!")
+            return False
+        
+        # Если есть активная сцена и не аддитивная загрузка
+        if self._active_scene and not additive:
+            self._active_scene.destroy()
+        
+        scene = self._scenes[name]
+        
+        if not additive:
+            self._active_scene = scene
+        else:
+            # Аддитивная загрузка — добавляем объекты к текущей сцене
+            if self._active_scene:
+                for entity in scene.entities:
+                    self._active_scene.spawn(entity)
+        
+        scene.awake()
+        scene.start()
+        
+        print(f"[SceneManager] Loaded scene: {name}")
+        return True
+    
+    def load_scene_async(self, name: str):
+        """Асинхронная загрузка сцены"""
+        import threading
+        
+        def _load():
+            self._loading = True
+            success = self.load_scene(name)
+            self._loading = False
+            if success:
+                print(f"[SceneManager] Async load complete: {name}")
+        
+        thread = threading.Thread(target=_load, daemon=True)
+        thread.start()
+    
+    def transition_to(self, name: str, transition_time: float = 1.0):
+        """Переход к новой сцене с эффектом"""
+        if name not in self._scenes:
+            print(f"[SceneManager] Scene '{name}' not found!")
+            return
+        
+        if self._active_scene:
+            self._transition = SceneTransition(
+                self._active_scene.name, name, transition_time
+            )
+    
+    def update(self, dt: float):
+        """Обновляет менеджер"""
+        if self._transition:
+            self._transition.update(dt)
+            
+            if self._transition.completed:
+                self.load_scene(self._transition.to_scene)
+                self._transition = None
+    
+    def get_active_scene(self) -> Optional[Scene]:
+        """Возвращает активную сцену"""
+        return self._active_scene
+    
+    def get_scene(self, name: str) -> Optional[Scene]:
+        """Возвращает сцену по имени"""
+        return self._scenes.get(name)
+    
+    def get_all_scenes(self) -> Dict[str, Scene]:
+        """Возвращает все сцены"""
+        return self._scenes.copy()
+    
+    def save_scene(self, name: str, path: Optional[str] = None):
+        """Сохраняет сцену в файл"""
+        scene = self._scenes.get(name)
+        if not scene:
+            print(f"[SceneManager] Scene '{name}' not found!")
+            return
+        
+        if path is None:
+            os.makedirs(self._scenes_path, exist_ok=True)
+            path = self._scenes_path / f"{name}.json"
+        
+        try:
+            from aether.resources.serialization import SceneSerializer, Serializer
+            
+            serializer = Serializer()
+            scene_serializer = SceneSerializer(serializer)
+            scene_serializer.save_scene(scene, str(path))
+            
+            print(f"[SceneManager] Saved scene '{name}' to {path}")
+        except Exception as e:
+            print(f"[SceneManager] Failed to save scene: {e}")
+    
+    def load_scene_from_file(self, path: str) -> Optional[Scene]:
+        """Загружает сцену из файла"""
+        try:
+            from aether.resources.serialization import SceneSerializer, Serializer
+            
+            serializer = Serializer()
+            scene_serializer = SceneSerializer(serializer)
+            scene = scene_serializer.load_scene(path)
+            
+            self.register_scene(scene)
+            print(f"[SceneManager] Loaded scene from {path}")
+            
+            return scene
+        except Exception as e:
+            print(f"[SceneManager] Failed to load scene: {e}")
+            return None
+    
+    @property
+    def is_transitioning(self) -> bool:
+        """Идёт ли переход между сценами"""
+        return self._transition is not None
+    
+    @property
+    def is_loading(self) -> bool:
+        """Идёт ли загрузка сцены"""
+        return self._loading
+    
+    @property
+    def transition_progress(self) -> float:
+        """Прогресс перехода (0.0 - 1.0)"""
+        return self._transition.progress if self._transition else 0.0