aether-engine 1.0.0__py3-none-any.whl

aether/physics/physics_world.py

@@ -0,0 +1,436 @@
+"""Мир физики с обнаружением коллизий и разрешением"""
+import numpy as np
+from typing import List, Optional, Tuple
+from aether.physics.collider import Collider, BoxCollider, SphereCollider
+
+
+class CollisionInfo:
+    """Информация о столкновении"""
+    
+    def __init__(self):
+        self.collided = False
+        self.point = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self.normal = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+        self.depth = 0.0
+        self.entity_a = None
+        self.entity_b = None
+
+
+class PhysicsWorld:
+    """Мир физики"""
+    
+    def __init__(self, gravity=(0, -9.81, 0)):
+        self.gravity = np.array(gravity, dtype=np.float32)
+        self.bodies = []
+        self.colliders = []
+        self.collision_pairs = []
+        
+        # Настройки
+        self.solver_iterations = 10
+        self.enable_sleeping = True
+        self.sleep_threshold = 0.01
+        self.sleep_time_threshold = 1.0
+        
+        # События
+        self.on_collision_enter = []
+        self.on_collision_exit = []
+        self.on_trigger_enter = []
+        
+        print(f"[Physics] World created (gravity: {self.gravity})")
+    
+    def add_rigidbody(self, body):
+        """Добавляет твёрдое тело в симуляцию"""
+        self.bodies.append(body)
+        if hasattr(body, 'entity') and body.entity:
+            collider = body.entity.get_component("Collider") or \
+                      body.entity.get_component("BoxCollider") or \
+                      body.entity.get_component("SphereCollider")
+            if collider:
+                self.colliders.append((body, collider))
+    
+    def remove_rigidbody(self, body):
+        """Удаляет твёрдое тело из симуляции"""
+        if body in self.bodies:
+            self.bodies.remove(body)
+        self.colliders = [(b, c) for b, c in self.colliders if b != body]
+    
+    def step(self, dt: float):
+        """Шаг симуляции"""
+        # 1. Применяем силы
+        self._apply_forces(dt)
+        
+        # 2. Обновляем скорости
+        self._integrate_velocities(dt)
+        
+        # 3. Обнаружение коллизий
+        collisions = self._detect_collisions()
+        
+        # 4. Разрешение коллизий
+        for _ in range(self.solver_iterations):
+            self._resolve_collisions(collisions, dt)
+        
+        # 5. Обновляем позиции
+        self._integrate_positions(dt)
+        
+        # 6. Проверка на сон
+        if self.enable_sleeping:
+            self._check_sleeping(dt)
+    
+    def _apply_forces(self, dt: float):
+        """Применяет силы к телам"""
+        for body in self.bodies:
+            if body.use_gravity and not body.is_kinematic:
+                body.velocity += self.gravity * dt
+    
+    def _integrate_velocities(self, dt: float):
+        """Интегрирует скорости"""
+        for body in self.bodies:
+            if not body.is_kinematic:
+                # Применяем drag
+                body.velocity *= (1.0 - body.drag * dt)
+                body.angular_velocity *= (1.0 - body.angular_drag * dt)
+    
+    def _integrate_positions(self, dt: float):
+        """Интегрирует позиции"""
+        for body in self.bodies:
+            if not body.is_kinematic and not body.is_sleeping:
+                transform = body.entity.get_component("Transform") if hasattr(body, 'entity') and body.entity else None
+                if transform:
+                    transform.position += body.velocity * dt
+                    transform.rotation += body.angular_velocity * dt
+                    transform._matrix_dirty = True
+    
+    def _detect_collisions(self) -> List[CollisionInfo]:
+        """Обнаруживает все коллизии"""
+        collisions = []
+        
+        for i in range(len(self.colliders)):
+            for j in range(i + 1, len(self.colliders)):
+                body_a, collider_a = self.colliders[i]
+                body_b, collider_b = self.colliders[j]
+                
+                # Пропускаем спящие и кинематические пары
+                if (body_a.is_sleeping and body_b.is_sleeping) or \
+                   (body_a.is_kinematic and body_b.is_kinematic):
+                    continue
+                
+                collision = self._check_collision(collider_a, collider_b)
+                if collision:
+                    collision.entity_a = body_a.entity if hasattr(body_a, 'entity') else None
+                    collision.entity_b = body_b.entity if hasattr(body_b, 'entity') else None
+                    collisions.append(collision)
+        
+        return collisions
+    
+    def _check_collision(self, collider_a: Collider, collider_b: Collider) -> Optional[CollisionInfo]:
+        """Проверяет столкновение между двумя коллайдерами"""
+        
+        # Box vs Box
+        if isinstance(collider_a, BoxCollider) and isinstance(collider_b, BoxCollider):
+            return self._box_vs_box(collider_a, collider_b)
+        
+        # Sphere vs Sphere
+        if isinstance(collider_a, SphereCollider) and isinstance(collider_b, SphereCollider):
+            return self._sphere_vs_sphere(collider_a, collider_b)
+        
+        # Box vs Sphere
+        if isinstance(collider_a, BoxCollider) and isinstance(collider_b, SphereCollider):
+            return self._box_vs_sphere(collider_a, collider_b)
+        
+        if isinstance(collider_a, SphereCollider) and isinstance(collider_b, BoxCollider):
+            collision = self._box_vs_sphere(collider_b, collider_a)
+            if collision:
+                collision.normal = -collision.normal
+            return collision
+        
+        return None
+    
+    def _box_vs_box(self, a: BoxCollider, b: BoxCollider) -> Optional[CollisionInfo]:
+        """AABB vs AABB коллизия"""
+        # Получаем позиции из трансформов
+        pos_a = self._get_collider_position(a)
+        pos_b = self._get_collider_position(b)
+        
+        if pos_a is None or pos_b is None:
+            return None
+        
+        # AABB проверка
+        min_a = pos_a + a.center - a.size / 2
+        max_a = pos_a + a.center + a.size / 2
+        min_b = pos_b + b.center - b.size / 2
+        max_b = pos_b + b.center + b.size / 2
+        
+        # Проверка пересечения
+        overlap_x = min(max_a[0], max_b[0]) - max(min_a[0], min_b[0])
+        overlap_y = min(max_a[1], max_b[1]) - max(min_a[1], min_b[1])
+        overlap_z = min(max_a[2], max_b[2]) - max(min_a[2], min_b[2])
+        
+        if overlap_x <= 0 or overlap_y <= 0 or overlap_z <= 0:
+            return None
+        
+        # Определяем нормаль и глубину
+        collision = CollisionInfo()
+        collision.collided = True
+        
+        if overlap_x < overlap_y and overlap_x < overlap_z:
+            collision.depth = overlap_x
+            collision.normal = np.array([1, 0, 0] if (pos_a[0] < pos_b[0]) else [-1, 0, 0], dtype=np.float32)
+        elif overlap_y < overlap_z:
+            collision.depth = overlap_y
+            collision.normal = np.array([0, 1, 0] if (pos_a[1] < pos_b[1]) else [0, -1, 0], dtype=np.float32)
+        else:
+            collision.depth = overlap_z
+            collision.normal = np.array([0, 0, 1] if (pos_a[2] < pos_b[2]) else [0, 0, -1], dtype=np.float32)
+        
+        # Точка контакта (центр пересечения)
+        collision.point = (pos_a + pos_b) / 2
+        
+        return collision
+    
+    def _sphere_vs_sphere(self, a: SphereCollider, b: SphereCollider) -> Optional[CollisionInfo]:
+        """Sphere vs Sphere коллизия"""
+        pos_a = self._get_collider_position(a)
+        pos_b = self._get_collider_position(b)
+        
+        if pos_a is None or pos_b is None:
+            return None
+        
+        center_a = pos_a + a.center
+        center_b = pos_b + b.center
+        
+        distance_vec = center_b - center_a
+        distance = np.linalg.norm(distance_vec)
+        min_distance = a.radius + b.radius
+        
+        if distance >= min_distance:
+            return None
+        
+        collision = CollisionInfo()
+        collision.collided = True
+        collision.depth = min_distance - distance
+        collision.normal = distance_vec / distance if distance > 0 else np.array([0, 1, 0], dtype=np.float32)
+        collision.point = center_a + collision.normal * a.radius
+        
+        return collision
+    
+    def _box_vs_sphere(self, box: BoxCollider, sphere: SphereCollider) -> Optional[CollisionInfo]:
+        """Box vs Sphere коллизия"""
+        pos_box = self._get_collider_position(box)
+        pos_sphere = self._get_collider_position(sphere)
+        
+        if pos_box is None or pos_sphere is None:
+            return None
+        
+        # Находим ближайшую точку на AABB к центру сферы
+        box_min = pos_box + box.center - box.size / 2
+        box_max = pos_box + box.center + box.size / 2
+        sphere_center = pos_sphere + sphere.center
+        
+        closest_point = np.clip(sphere_center, box_min, box_max)
+        distance_vec = sphere_center - closest_point
+        distance = np.linalg.norm(distance_vec)
+        
+        if distance >= sphere.radius:
+            return None
+        
+        collision = CollisionInfo()
+        collision.collided = True
+        collision.depth = sphere.radius - distance
+        
+        if distance > 0:
+            collision.normal = distance_vec / distance
+        else:
+            # Сфера внутри бокса
+            collision.normal = np.array([0, 1, 0], dtype=np.float32)
+            collision.depth = sphere.radius + min(
+                closest_point[0] - box_min[0],
+                box_max[0] - closest_point[0],
+                closest_point[1] - box_min[1],
+                box_max[1] - closest_point[1],
+                closest_point[2] - box_min[2],
+                box_max[2] - closest_point[2]
+            )
+        
+        collision.point = closest_point
+        
+        return collision
+    
+    def _resolve_collisions(self, collisions: List[CollisionInfo], dt: float):
+        """Разрешает коллизии"""
+        for collision in collisions:
+            if not collision.entity_a or not collision.entity_b:
+                continue
+            
+            body_a = self._get_body_from_entity(collision.entity_a)
+            body_b = self._get_body_from_entity(collision.entity_b)
+            
+            if not body_a or not body_b:
+                continue
+            
+            # Для триггеров только уведомляем
+            collider_a = collision.entity_a.get_component("Collider") or \
+                         collision.entity_a.get_component("BoxCollider") or \
+                         collision.entity_a.get_component("SphereCollider")
+            collider_b = collision.entity_b.get_component("Collider") or \
+                         collision.entity_b.get_component("BoxCollider") or \
+                         collision.entity_b.get_component("SphereCollider")
+            
+            if (collider_a and collider_a.is_trigger) or \
+               (collider_b and collider_b.is_trigger):
+                # Вызываем событие триггера
+                for callback in self.on_trigger_enter:
+                    callback(collision)
+                continue
+            
+            # Вычисляем общую инверсную массу
+            inv_mass_a = 0 if body_a.is_kinematic else 1.0 / body_a.mass
+            inv_mass_b = 0 if body_b.is_kinematic else 1.0 / body_b.mass
+            total_inv_mass = inv_mass_a + inv_mass_b
+            
+            if total_inv_mass <= 0:
+                continue
+            
+            # Разделение
+            separation = collision.normal * (collision.depth / total_inv_mass)
+            
+            transform_a = collision.entity_a.get_component("Transform")
+            transform_b = collision.entity_b.get_component("Transform")
+            
+            if transform_a and not body_a.is_kinematic:
+                transform_a.position -= separation * inv_mass_a
+                transform_a._matrix_dirty = True
+            
+            if transform_b and not body_b.is_kinematic:
+                transform_b.position += separation * inv_mass_b
+                transform_b._matrix_dirty = True
+            
+            # Обновляем скорости (простое отражение с коэффициентом)
+            restitution = 0.3  # Коэффициент упругости
+            
+            relative_velocity = body_b.velocity - body_a.velocity
+            velocity_along_normal = np.dot(relative_velocity, collision.normal)
+            
+            if velocity_along_normal > 0:
+                continue
+            
+            impulse = collision.normal * (-(1 + restitution) * velocity_along_normal / total_inv_mass)
+            
+            if not body_a.is_kinematic:
+                body_a.velocity -= impulse * inv_mass_a
+            if not body_b.is_kinematic:
+                body_b.velocity += impulse * inv_mass_b
+            
+            # Трение
+            tangent = relative_velocity - collision.normal * velocity_along_normal
+            tangent_norm = np.linalg.norm(tangent)
+            
+            if tangent_norm > 0.001:
+                tangent /= tangent_norm
+                friction_coefficient = 0.5
+                friction_impulse = tangent * (-friction_coefficient * np.linalg.norm(impulse))
+                
+                if not body_a.is_kinematic:
+                    body_a.velocity -= friction_impulse * inv_mass_a
+                if not body_b.is_kinematic:
+                    body_b.velocity += friction_impulse * inv_mass_b
+            
+            # Вызываем событие коллизии
+            for callback in self.on_collision_enter:
+                callback(collision)
+    
+    def _get_collider_position(self, collider: Collider):
+        """Получает мировую позицию коллайдера из трансформа"""
+        if hasattr(collider, 'entity') and collider.entity:
+            transform = collider.entity.get_component("Transform")
+            if transform:
+                return transform.position.copy()
+        return None
+    
+    def _get_body_from_entity(self, entity):
+        """Находит RigidbodyComponent у entity"""
+        return entity.get_component("Rigidbody")
+    
+    def _check_sleeping(self, dt: float):
+        """Проверяет, можно ли усыпить тело"""
+        for body in self.bodies:
+            if body.is_kinematic:
+                continue
+            
+            speed = np.linalg.norm(body.velocity)
+            
+            if speed < self.sleep_threshold:
+                body._sleep_timer += dt
+                if body._sleep_timer >= self.sleep_time_threshold:
+                    body.is_sleeping = True
+            else:
+                body._sleep_timer = 0
+                body.is_sleeping = False
+    
+    def raycast(self, origin: np.ndarray, direction: np.ndarray, max_distance=100.0):
+        """Пуск луча и поиск пересечений"""
+        ray_dir = direction / np.linalg.norm(direction)
+        closest_hit = None
+        closest_distance = max_distance
+        
+        for body, collider in self.colliders:
+            pos = self._get_collider_position(collider)
+            if pos is None:
+                continue
+            
+            hit_distance = None
+            
+            if isinstance(collider, BoxCollider):
+                hit_distance = self._ray_vs_aabb(origin, ray_dir, pos, collider)
+            elif isinstance(collider, SphereCollider):
+                hit_distance = self._ray_vs_sphere(origin, ray_dir, pos, collider)
+            
+            if hit_distance and hit_distance < closest_distance:
+                closest_distance = hit_distance
+                from aether.physics.raycast import RaycastHit
+                closest_hit = RaycastHit()
+                closest_hit.hit = True
+                closest_hit.distance = hit_distance
+                closest_hit.point = origin + ray_dir * hit_distance
+                if hasattr(body, 'entity'):
+                    closest_hit.entity = body.entity
+        
+        return closest_hit
+    
+    def _ray_vs_aabb(self, origin, direction, box_pos, collider: BoxCollider):
+        """Луч vs AABB"""
+        box_min = box_pos + collider.center - collider.size / 2
+        box_max = box_pos + collider.center + collider.size / 2
+        
+        t_min = (box_min - origin) / (direction + 1e-10)
+        t_max = (box_max - origin) / (direction + 1e-10)
+        
+        t1 = np.minimum(t_min, t_max)
+        t2 = np.maximum(t_min, t_max)
+        
+        t_near = np.max(t1)
+        t_far = np.min(t2)
+        
+        if t_near <= t_far and t_far >= 0:
+            return t_near if t_near >= 0 else t_far
+        return None
+    
+    def _ray_vs_sphere(self, origin, direction, sphere_pos, collider: SphereCollider):
+        """Луч vs Sphere"""
+        center = sphere_pos + collider.center
+        oc = origin - center
+        
+        a = np.dot(direction, direction)
+        b = 2.0 * np.dot(oc, direction)
+        c = np.dot(oc, oc) - collider.radius ** 2
+        
+        discriminant = b * b - 4 * a * c
+        
+        if discriminant < 0:
+            return None
+        
+        t = (-b - np.sqrt(discriminant)) / (2 * a)
+        
+        if t >= 0:
+            return t
+        
+        return None

aether/physics/raycast.py

@@ -0,0 +1,25 @@
+"""Raycasting"""
+import numpy as np
+
+
+class Ray:
+    def __init__(self, origin, direction):
+        self.origin = np.array(origin, dtype=np.float32)
+        self.direction = np.array(direction, dtype=np.float32)
+        self.direction = self.direction / np.linalg.norm(self.direction)
+
+
+class RaycastHit:
+    def __init__(self):
+        self.hit = False
+        self.point = None
+        self.normal = None
+        self.distance = 0.0
+        self.entity = None
+
+
+def raycast(ray: Ray, colliders, max_distance=100.0) -> RaycastHit:
+    """Простой raycast против AABB"""
+    hit = RaycastHit()
+    # TODO: реализовать
+    return hit

aether/physics/rigidbody.py

@@ -0,0 +1,7 @@
+"""Физическое твёрдое тело"""
+class Rigidbody:
+    def __init__(self, mass=1.0, use_gravity=True):
+        self.mass = mass
+        self.use_gravity = use_gravity
+        self.velocity = [0.0, 0.0, 0.0]
+        self.angular_velocity = [0.0, 0.0, 0.0]

aether/resources/asset_database.py

@@ -0,0 +1,76 @@
+"""База данных ассетов с GUID"""
+import uuid
+import json
+from typing import Dict, Any, Optional
+from pathlib import Path
+
+
+class AssetInfo:
+    """Информация об ассете"""
+    def __init__(self, path: str, asset_type: str):
+        self.guid = str(uuid.uuid4())
+        self.path = Path(path)
+        self.asset_type = asset_type
+        self.dependencies = []
+        self.metadata = {}
+    
+    def to_dict(self) -> dict:
+        return {
+            'guid': self.guid,
+            'path': str(self.path),
+            'type': self.asset_type,
+            'dependencies': self.dependencies,
+            'metadata': self.metadata
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'AssetInfo':
+        asset = cls(data['path'], data['type'])
+        asset.guid = data['guid']
+        asset.dependencies = data.get('dependencies', [])
+        asset.metadata = data.get('metadata', {})
+        return asset
+
+
+class AssetDatabase:
+    """База данных всех ассетов проекта"""
+    
+    def __init__(self):
+        self._assets: Dict[str, AssetInfo] = {}
+        self._guid_index: Dict[str, AssetInfo] = {}
+    
+    def register_asset(self, path: str, asset_type: str) -> AssetInfo:
+        """Регистрирует ассет"""
+        asset = AssetInfo(path, asset_type)
+        self._assets[str(asset.path)] = asset
+        self._guid_index[asset.guid] = asset
+        return asset
+    
+    def get_by_path(self, path: str) -> Optional[AssetInfo]:
+        return self._assets.get(path)
+    
+    def get_by_guid(self, guid: str) -> Optional[AssetInfo]:
+        return self._guid_index.get(guid)
+    
+    def save(self, path: str):
+        """Сохраняет базу данных"""
+        data = {
+            'version': '1.0',
+            'assets': [a.to_dict() for a in self._assets.values()]
+        }
+        with open(path, 'w') as f:
+            json.dump(data, f, indent=2)
+    
+    @classmethod
+    def load(cls, path: str) -> 'AssetDatabase':
+        """Загружает базу данных"""
+        with open(path, 'r') as f:
+            data = json.load(f)
+        
+        db = cls()
+        for asset_data in data.get('assets', []):
+            asset = AssetInfo.from_dict(asset_data)
+            db._assets[str(asset.path)] = asset
+            db._guid_index[asset.guid] = asset
+        
+        return db

aether/resources/resource_manager.py

@@ -0,0 +1,147 @@
+"""Менеджер ресурсов с асинхронной загрузкой и кэшированием"""
+import threading
+from typing import Dict, Any, Callable, Optional
+from pathlib import Path
+from queue import Queue
+import time
+
+
+class Resource:
+    """Базовый класс ресурса"""
+    
+    def __init__(self, path: str):
+        self.path = Path(path)
+        self.loaded = False
+        self.reference_count = 0
+    
+    def load(self):
+        """Загружает ресурс"""
+        self.loaded = True
+    
+    def unload(self):
+        """Выгружает ресурс"""
+        self.loaded = False
+    
+    def add_reference(self):
+        self.reference_count += 1
+    
+    def remove_reference(self):
+        self.reference_count = max(0, self.reference_count - 1)
+
+
+class ResourceManager:
+    """Менеджер ресурсов с кэшированием"""
+    
+    _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._cache: Dict[str, Resource] = {}
+        self._loaders: Dict[str, Callable] = {}
+        self._load_queue = Queue()
+        self._async_loading = False
+        self._loader_thread = None
+        print("[ResourceManager] Initialized")
+    
+    def register_loader(self, extension: str, loader: Callable):
+        """Регистрирует загрузчик для расширения"""
+        self._loaders[extension.lower()] = loader
+        print(f"[ResourceManager] Registered loader for .{extension}")
+    
+    def load(self, path: str) -> Optional[Resource]:
+        """Загружает ресурс (синхронно)"""
+        key = str(Path(path).resolve())
+        
+        # Проверяем кэш
+        if key in self._cache:
+            resource = self._cache[key]
+            resource.add_reference()
+            return resource
+        
+        # Определяем расширение
+        ext = Path(path).suffix.lower()
+        if ext not in self._loaders:
+            print(f"[ResourceManager] No loader for {ext}")
+            return None
+        
+        # Загружаем
+        try:
+            resource = self._loaders[ext](path)
+            if resource:
+                resource.load()
+                resource.add_reference()
+                self._cache[key] = resource
+                print(f"[ResourceManager] Loaded: {path}")
+                return resource
+        except Exception as e:
+            print(f"[ResourceManager] Failed to load {path}: {e}")
+        
+        return None
+    
+    def load_async(self, path: str, callback: Callable = None):
+        """Загружает ресурс асинхронно"""
+        self._load_queue.put((path, callback))
+        
+        if not self._async_loading:
+            self._start_async_loader()
+    
+    def _start_async_loader(self):
+        """Запускает поток асинхронной загрузки"""
+        self._async_loading = True
+        self._loader_thread = threading.Thread(target=self._async_loader_loop, daemon=True)
+        self._loader_thread.start()
+    
+    def _async_loader_loop(self):
+        """Цикл асинхронной загрузки"""
+        while self._async_loading:
+            try:
+                if not self._load_queue.empty():
+                    path, callback = self._load_queue.get()
+                    resource = self.load(path)
+                    if callback:
+                        callback(resource)
+                else:
+                    time.sleep(0.01)
+            except Exception as e:
+                print(f"[ResourceManager] Async load error: {e}")
+    
+    def unload(self, path: str):
+        """Выгружает ресурс"""
+        key = str(Path(path).resolve())
+        if key in self._cache:
+            resource = self._cache[key]
+            resource.remove_reference()
+            if resource.reference_count <= 0:
+                resource.unload()
+                del self._cache[key]
+                print(f"[ResourceManager] Unloaded: {path}")
+    
+    def get(self, path: str) -> Optional[Resource]:
+        """Получает ресурс из кэша"""
+        key = str(Path(path).resolve())
+        return self._cache.get(key)
+    
+    def clear_cache(self):
+        """Очищает весь кэш"""
+        for resource in self._cache.values():
+            resource.unload()
+        self._cache.clear()
+        print("[ResourceManager] Cache cleared")
+    
+    def get_stats(self) -> dict:
+        """Возвращает статистику"""
+        total_memory = sum(
+            getattr(r, 'memory_usage', 0) 
+            for r in self._cache.values()
+        )
+        return {
+            'cached_resources': len(self._cache),
+            'total_memory_mb': total_memory / (1024 * 1024),
+            'queue_size': self._load_queue.qsize()
+        }