aether-engine 1.0.0__py3-none-any.whl

aether/resources/serialization.py

@@ -0,0 +1,114 @@
+"""Сериализация сцен и префабов"""
+import json
+import yaml
+from typing import Dict, Any, Type
+from aether.scene.entity import Entity
+from aether.scene.component import Component
+
+
+class Serializer:
+    """Сериализатор игровых объектов"""
+    
+    def __init__(self):
+        self._component_serializers: Dict[str, Type['ComponentSerializer']] = {}
+    
+    def register_component(self, component_class, serializer):
+        """Регистрирует сериализатор для компонента"""
+        self._component_serializers[component_class.__name__] = serializer
+    
+    def serialize_entity(self, entity: Entity) -> dict:
+        """Сериализует Entity в словарь"""
+        data = {
+            'id': entity.id,
+            'name': entity.name,
+            'tag': entity.tag,
+            'enabled': entity.enabled,
+            'components': {}
+        }
+        
+        for comp_name, component in entity.components.items():
+            if comp_name in self._component_serializers:
+                serializer = self._component_serializers[comp_name]
+                data['components'][comp_name] = serializer.serialize(component)
+        
+        if entity.children:
+            data['children'] = [
+                self.serialize_entity(child) 
+                for child in entity.children
+            ]
+        
+        return data
+    
+    def deserialize_entity(self, data: dict) -> Entity:
+        """Создаёт Entity из словаря"""
+        entity = Entity(name=data['name'], tag=data.get('tag', ''))
+        entity.id = data.get('id', entity.id)
+        entity.enabled = data.get('enabled', True)
+        
+        for comp_name, comp_data in data.get('components', {}).items():
+            if comp_name in self._component_serializers:
+                serializer = self._component_serializers[comp_name]
+                component = serializer.deserialize(comp_data)
+                entity.add_component(component)
+        
+        for child_data in data.get('children', []):
+            child = self.deserialize_entity(child_data)
+            entity.add_child(child)
+        
+        return entity
+
+
+class ComponentSerializer(ABC):
+    """Базовый класс сериализатора компонентов"""
+    
+    @abstractmethod
+    def serialize(self, component: Component) -> dict:
+        pass
+    
+    @abstractmethod
+    def deserialize(self, data: dict) -> Component:
+        pass
+
+
+class SceneSerializer:
+    """Сериализатор целых сцен"""
+    
+    def __init__(self, entity_serializer: Serializer):
+        self.entity_serializer = entity_serializer
+    
+    def save_scene(self, scene, path: str):
+        """Сохраняет сцену в файл"""
+        data = {
+            'name': scene.name,
+            'version': '1.0',
+            'entities': []
+        }
+        
+        for entity in scene.entities:
+            entity_data = self.entity_serializer.serialize_entity(entity)
+            data['entities'].append(entity_data)
+        
+        with open(path, 'w') as f:
+            if path.endswith('.json'):
+                json.dump(data, f, indent=2)
+            elif path.endswith('.yaml') or path.endswith('.yml'):
+                yaml.dump(data, f, default_flow_style=False)
+    
+    def load_scene(self, path: str) -> 'Scene':
+        """Загружает сцену из файла"""
+        with open(path, 'r') as f:
+            if path.endswith('.json'):
+                data = json.load(f)
+            elif path.endswith('.yaml') or path.endswith('.yml'):
+                data = yaml.safe_load(f)
+            else:
+                raise ValueError(f"Unsupported format: {path}")
+        
+        from aether.scene.scene import Scene
+        scene = Scene(name=data['name'])
+        
+        for entity_data in data.get('entities', []):
+            entity = self.entity_serializer.deserialize_entity(entity_data)
+            scene.spawn(entity)
+        
+        return scene

aether/scene/component.py

@@ -0,0 +1,368 @@
+"""Компоненты для Entity"""
+import numpy as np
+from abc import ABC, abstractmethod
+from OpenGL.GL import *
+from aether.graphics.shader import Shader
+from aether.graphics.shader_library import ShaderLibrary
+
+
+class Component(ABC):
+    """Базовый класс компонента"""
+    
+    def __init__(self):
+        self.entity = None
+        self.enabled = True
+        self._started = False
+    
+    def awake(self):
+        """Вызывается при добавлении компонента"""
+        pass
+    
+    def start(self):
+        """Вызывается один раз перед первым update"""
+        self._started = True
+    
+    @abstractmethod
+    def update(self, dt: float):
+        """Вызывается каждый кадр"""
+        pass
+    
+    def on_enable(self):
+        """Вызывается при включении компонента"""
+        pass
+    
+    def on_disable(self):
+        """Вызывается при выключении компонента"""
+        pass
+    
+    def destroy(self):
+        """Вызывается при удалении компонента"""
+        pass
+
+
+class Transform(Component):
+    """Компонент трансформации"""
+    
+    def __init__(self, position=(0, 0, 0), rotation=(0, 0, 0), scale=(1, 1, 1)):
+        super().__init__()
+        self.position = np.array(position, dtype=np.float32)
+        self.rotation = np.array(rotation, dtype=np.float32)  # Euler angles
+        self.scale = np.array(scale, dtype=np.float32)
+        
+        # Кэшированная матрица
+        self._matrix_dirty = True
+        self._cached_matrix = np.identity(4, dtype=np.float32)
+    
+    def update(self, dt: float):
+        if self._matrix_dirty:
+            self._update_matrix()
+    
+    def _update_matrix(self):
+        """Обновляет модельную матрицу"""
+        # Translate
+        m = np.identity(4, dtype=np.float32)
+        m[3, :3] = self.position
+        
+        # Rotation
+        rx, ry, rz = np.radians(self.rotation)
+        
+        # Rotate X
+        cx, sx = np.cos(rx), np.sin(rx)
+        rot_x = np.array([
+            [1, 0, 0],
+            [0, cx, -sx],
+            [0, sx, cx]
+        ], dtype=np.float32)
+        
+        # Rotate Y
+        cy, sy = np.cos(ry), np.sin(ry)
+        rot_y = np.array([
+            [cy, 0, sy],
+            [0, 1, 0],
+            [-sy, 0, cy]
+        ], dtype=np.float32)
+        
+        # Rotate Z
+        cz, sz = np.cos(rz), np.sin(rz)
+        rot_z = np.array([
+            [cz, -sz, 0],
+            [sz, cz, 0],
+            [0, 0, 1]
+        ], dtype=np.float32)
+        
+        # Комбинированная ротация
+        rot = rot_z @ rot_y @ rot_x
+        
+        # Применяем ротацию и скейл
+        m[:3, :3] = rot * self.scale
+        
+        self._cached_matrix = m
+        self._matrix_dirty = False
+    
+    def get_model_matrix(self) -> np.ndarray:
+        """Возвращает модельную матрицу (с кэшированием)"""
+        if self._matrix_dirty:
+            self._update_matrix()
+        return self._cached_matrix
+    
+    def translate(self, dx, dy, dz):
+        """Перемещает объект"""
+        self.position += np.array([dx, dy, dz], dtype=np.float32)
+        self._matrix_dirty = True
+    
+    def set_position(self, x, y, z):
+        """Устанавливает позицию"""
+        self.position = np.array([x, y, z], dtype=np.float32)
+        self._matrix_dirty = True
+    
+    def rotate(self, rx, ry, rz):
+        """Поворачивает объект"""
+        self.rotation += np.array([rx, ry, rz], dtype=np.float32)
+        self._matrix_dirty = True
+    
+    def look_at(self, target: np.ndarray):
+        """Поворачивает объект в сторону цели"""
+        direction = target - self.position
+        direction = direction / np.linalg.norm(direction)
+        
+        # Вычисляем углы Эйлера из направления
+        self.rotation[0] = np.degrees(np.arcsin(-direction[1]))
+        self.rotation[1] = np.degrees(np.arctan2(-direction[0], -direction[2]))
+        self._matrix_dirty = True
+
+
+class MeshRenderer(Component):
+    """Компонент рендеринга меша"""
+    
+    def __init__(self, mesh=None, material=None, cast_shadows=True, receive_shadows=True):
+        super().__init__()
+        self.mesh = mesh
+        self.material = material
+        self.visible = True
+        self.cast_shadows = cast_shadows
+        self.receive_shadows = receive_shadows
+        self._shader_library = ShaderLibrary()
+    
+    def update(self, dt: float):
+        pass
+    
+    def render(self, view: np.ndarray, projection: np.ndarray):
+        """Рендерит меш"""
+        if not self.mesh or not self.material or not self.visible:
+            return
+        
+        if not self.entity:
+            return
+        
+        transform = self.entity.get_component("Transform")
+        if not transform:
+            return
+        
+        # Получаем шейдер
+        shader = self._shader_library.get_pbr_shader()
+        if not shader:
+            return
+        
+        shader.use()
+        
+        # Устанавливаем матрицы
+        model = transform.get_model_matrix()
+        shader.set_mat4("model", model)
+        shader.set_mat4("view", view)
+        shader.set_mat4("projection", projection)
+        
+        # Устанавливаем свойства материала
+        shader.set_vec3("albedo", self.material.albedo)
+        shader.set_float("metallic", self.material.metallic)
+        shader.set_float("roughness", self.material.roughness)
+        shader.set_float("ao", self.material.ao)
+        
+        # Устанавливаем текстуры
+        if self.material.albedo_map:
+            self.material.albedo_map.bind(0)
+            shader.set_int("albedoMap", 0)
+        
+        if self.material.normal_map:
+            self.material.normal_map.bind(1)
+            shader.set_int("normalMap", 1)
+        
+        if self.material.metallic_map:
+            self.material.metallic_map.bind(2)
+            shader.set_int("metallicMap", 2)
+        
+        if self.material.roughness_map:
+            self.material.roughness_map.bind(3)
+            shader.set_int("roughnessMap", 3)
+        
+        # Рендерим меш
+        self.mesh.draw()
+    
+    def destroy(self):
+        """Очищает ресурсы"""
+        if self.mesh:
+            self.mesh.cleanup()
+        self.mesh = None
+        self.material = None
+
+
+class CameraComponent(Component):
+    """Компонент камеры"""
+    
+    def __init__(self, camera=None):
+        super().__init__()
+        self.camera = camera
+        self.is_main = False
+    
+    def update(self, dt: float):
+        pass
+    
+    def set_as_main(self):
+        """Делает камеру основной в сцене"""
+        if self.entity and hasattr(self.entity, 'scene'):
+            self.entity.scene.set_main_camera(self.camera)
+            self.is_main = True
+
+
+class LightComponent(Component):
+    """Компонент источника света"""
+    
+    def __init__(self, light=None):
+        super().__init__()
+        self.light = light
+        self.intensity_multiplier = 1.0
+    
+    def update(self, dt: float):
+        if self.light and self.entity:
+            transform = self.entity.get_component("Transform")
+            if transform:
+                self.light.position = transform.position
+                self.light.direction = -transform.position / np.linalg.norm(transform.position)
+
+
+class RigidbodyComponent(Component):
+    """Компонент физического тела"""
+    
+    def __init__(self, mass=1.0, use_gravity=True, is_kinematic=False):
+        super().__init__()
+        self.mass = mass
+        self.use_gravity = use_gravity
+        self.is_kinematic = is_kinematic
+        self.velocity = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self.angular_velocity = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self.drag = 0.0
+        self.angular_drag = 0.05
+    
+    def update(self, dt: float):
+        if self.is_kinematic:
+            return
+        
+        transform = self.entity.get_component("Transform")
+        if not transform:
+            return
+        
+        # Применяем drag
+        self.velocity *= (1.0 - self.drag * dt)
+        self.angular_velocity *= (1.0 - self.angular_drag * dt)
+        
+        # Обновляем позицию
+        transform.position += self.velocity * dt
+        transform.rotation += self.angular_velocity * dt
+        transform._matrix_dirty = True
+    
+    def add_force(self, force: np.ndarray):
+        """Добавляет силу"""
+        if not self.is_kinematic and self.mass > 0:
+            self.velocity += force / self.mass
+    
+    def add_impulse(self, impulse: np.ndarray):
+        """Мгновенный импульс"""
+        if not self.is_kinematic and self.mass > 0:
+            self.velocity += impulse / self.mass
+
+
+class ScriptComponent(Component):
+    """Компонент для пользовательских скриптов"""
+    
+    def __init__(self):
+        super().__init__()
+        self._scripts = []
+    
+    def add_script(self, script):
+        """Добавляет скрипт"""
+        self._scripts.append(script)
+        if hasattr(script, 'entity'):
+            script.entity = self.entity
+        if hasattr(script, 'awake'):
+            script.awake()
+        if hasattr(script, 'start'):
+            script.start()
+    
+    def update(self, dt: float):
+        for script in self._scripts:
+            if hasattr(script, 'update'):
+                script.update(dt)
+
+
+class AnimatorComponent(Component):
+    """Компонент анимации"""
+    
+    def __init__(self):
+        super().__init__()
+        self.animations = {}
+        self.current_animation = None
+        self.playback_speed = 1.0
+        self._time = 0.0
+        self._playing = False
+        self._loop = True
+    
+    def add_animation(self, name: str, animation):
+        """Добавляет анимацию"""
+        self.animations[name] = animation
+    
+    def play(self, name: str, loop: bool = True):
+        """Проигрывает анимацию"""
+        if name in self.animations:
+            self.current_animation = name
+            self._time = 0.0
+            self._playing = True
+            self._loop = loop
+    
+    def stop(self):
+        """Останавливает анимацию"""
+        self._playing = False
+        self._time = 0.0
+    
+    def pause(self):
+        """Ставит на паузу"""
+        self._playing = False
+    
+    def resume(self):
+        """Продолжает проигрывание"""
+        self._playing = True
+    
+    def update(self, dt: float):
+        if not self._playing or not self.current_animation:
+            return
+        
+        anim = self.animations.get(self.current_animation)
+        if not anim:
+            return
+        
+        self._time += dt * self.playback_speed
+        
+        if self._time >= anim.duration:
+            if self._loop:
+                self._time %= anim.duration
+            else:
+                self._time = anim.duration
+                self._playing = False
+        
+        # Применяем анимацию к трансформу
+        transform = self.entity.get_component("Transform")
+        if transform:
+            frame_data = anim.get_frame(self._time)
+            if frame_data:
+                transform.position = frame_data.get('position', transform.position)
+                transform.rotation = frame_data.get('rotation', transform.rotation)
+                transform.scale = frame_data.get('scale', transform.scale)
+                transform._matrix_dirty = True

aether/scene/entity.py

@@ -0,0 +1,46 @@
+"""Игровой объект"""
+from typing import Dict, Optional, List
+import uuid
+
+
+class Entity:
+    def __init__(self, name="Entity", tag=""):
+        self.id = str(uuid.uuid4())
+        self.name = name
+        self.tag = tag
+        self.enabled = True
+        self.components: Dict[str, 'Component'] = {}
+        self.children: List['Entity'] = []
+        self.parent: Optional['Entity'] = None
+    
+    def add_component(self, component: 'Component'):
+        component.entity = self
+        self.components[component.__class__.__name__] = component
+        component.awake()
+        component.start()
+        return component
+    
+    def get_component(self, name: str) -> Optional['Component']:
+        return self.components.get(name)
+    
+    def remove_component(self, name: str):
+        if name in self.components:
+            self.components[name].destroy()
+            del self.components[name]
+    
+    def add_child(self, child: 'Entity'):
+        child.parent = self
+        self.children.append(child)
+    
+    def update(self, dt: float):
+        for comp in self.components.values():
+            if comp.enabled:
+                comp.update(dt)
+        for child in self.children:
+            child.update(dt)
+    
+    def destroy(self):
+        for comp in list(self.components.values()):
+            comp.destroy()
+        for child in self.children:
+            child.destroy()

aether/scene/scene.py

@@ -0,0 +1,33 @@
+"""Сцена"""
+from typing import List, Optional
+from aether.scene.entity import Entity
+from aether.graphics.camera import Camera
+
+
+class Scene:
+    def __init__(self, name="Scene"):
+        self.name = name
+        self.entities: List[Entity] = []
+        self.main_camera: Optional[Camera] = None
+    
+    def spawn(self, entity: Entity):
+        self.entities.append(entity)
+        return entity
+    
+    def set_main_camera(self, camera: Camera):
+        self.main_camera = camera
+    
+    def awake(self):
+        pass
+    
+    def start(self):
+        pass
+    
+    def update(self, dt: float):
+        for entity in self.entities:
+            if entity.enabled:
+                entity.update(dt)
+    
+    def destroy(self):
+        for entity in self.entities:
+            entity.destroy()