aether-engine 1.0.0__py3-none-any.whl

aether/physics/bullet_backend.py

@@ -0,0 +1,395 @@
+"""Интеграция с PyBullet как опциональный физический движок"""
+import numpy as np
+from typing import Optional, Dict, List, Tuple
+import sys
+
+
+class BulletPhysicsBackend:
+    """Бэкенд физики на PyBullet"""
+    
+    _instance = None
+    _available = False
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized'):
+            return
+        
+        self._initialized = True
+        self._pybullet = None
+        self._client_id = -1
+        self._bodies: Dict[str, int] = {}
+        self._collision_shapes: Dict[str, int] = {}
+        self._ghost_objects: Dict[str, int] = {}
+        
+        # Пробуем импортировать PyBullet
+        try:
+            import pybullet as p
+            self._pybullet = p
+            BulletPhysicsBackend._available = True
+            print("[BulletBackend] PyBullet available")
+        except ImportError:
+            print("[BulletBackend] PyBullet not installed. Use: pip install aether-engine[physics]")
+            print("[BulletBackend] Falling back to built-in physics")
+    
+    @property
+    def available(self) -> bool:
+        return self._available and self._pybullet is not None
+    
+    def initialize(self, gravity: Tuple[float, float, float] = (0, -9.81, 0)):
+        """Инициализирует физический мир PyBullet"""
+        if not self.available:
+            return False
+        
+        if self._client_id >= 0:
+            return True
+        
+        try:
+            self._client_id = self._pybullet.connect(self._pybullet.DIRECT)
+            self._pybullet.setGravity(*gravity)
+            self._pybullet.setPhysicsEngineParameter(
+                fixedTimeStep=1.0/60.0,
+                numSolverIterations=10,
+                numSubSteps=1
+            )
+            print(f"[BulletBackend] Initialized (client: {self._client_id})")
+            return True
+        except Exception as e:
+            print(f"[BulletBackend] Failed to initialize: {e}")
+            return False
+    
+    def create_rigid_body(self, 
+                          entity_id: str,
+                          mass: float = 1.0,
+                          shape_type: str = "box",
+                          dimensions: Tuple[float, float, float] = (1, 1, 1),
+                          position: Tuple[float, float, float] = (0, 0, 0),
+                          rotation: Tuple[float, float, float, float] = (0, 0, 0, 1),
+                          is_kinematic: bool = False,
+                          friction: float = 0.5,
+                          restitution: float = 0.3) -> Optional[int]:
+        """Создаёт твёрдое тело"""
+        if not self.available:
+            return None
+        
+        try:
+            # Создаём collision shape
+            shape_key = f"{shape_type}_{dimensions}"
+            
+            if shape_key not in self._collision_shapes:
+                if shape_type == "box":
+                    shape = self._pybullet.createCollisionShape(
+                        self._pybullet.GEOM_BOX,
+                        halfExtents=[d/2 for d in dimensions]
+                    )
+                elif shape_type == "sphere":
+                    shape = self._pybullet.createCollisionShape(
+                        self._pybullet.GEOM_SPHERE,
+                        radius=dimensions[0]
+                    )
+                elif shape_type == "capsule":
+                    shape = self._pybullet.createCollisionShape(
+                        self._pybullet.GEOM_CAPSULE,
+                        radius=dimensions[0],
+                        height=dimensions[1]
+                    )
+                elif shape_type == "cylinder":
+                    shape = self._pybullet.createCollisionShape(
+                        self._pybullet.GEOM_CYLINDER,
+                        radius=dimensions[0],
+                        height=dimensions[1]
+                    )
+                elif shape_type == "mesh":
+                    # Для mesh коллайдеров
+                    vertices = dimensions  # Передаются как массив вершин
+                    shape = self._pybullet.createCollisionShape(
+                        self._pybullet.GEOM_MESH,
+                        vertices=vertices
+                    )
+                else:
+                    shape = self._pybullet.createCollisionShape(
+                        self._pybullet.GEOM_BOX,
+                        halfExtents=[0.5, 0.5, 0.5]
+                    )
+                
+                self._collision_shapes[shape_key] = shape
+            
+            # Создаём тело
+            body_id = self._pybullet.createMultiBody(
+                baseMass=0 if is_kinematic else mass,
+                baseCollisionShapeIndex=self._collision_shapes[shape_key],
+                basePosition=position,
+                baseOrientation=rotation,
+            )
+            
+            # Настройка физических свойств
+            self._pybullet.changeDynamics(
+                body_id, -1,
+                lateralFriction=friction,
+                restitution=restitution,
+                linearDamping=0.04,
+                angularDamping=0.04,
+            )
+            
+            if is_kinematic:
+                self._pybullet.changeDynamics(body_id, -1, mass=0)
+            
+            self._bodies[entity_id] = body_id
+            return body_id
+            
+        except Exception as e:
+            print(f"[BulletBackend] Failed to create body: {e}")
+            return None
+    
+    def remove_body(self, entity_id: str):
+        """Удаляет твёрдое тело"""
+        if entity_id in self._bodies:
+            try:
+                self._pybullet.removeBody(self._bodies[entity_id])
+                del self._bodies[entity_id]
+            except Exception as e:
+                print(f"[BulletBackend] Failed to remove body: {e}")
+    
+    def step(self, dt: float):
+        """Шаг симуляции"""
+        if not self.available or self._client_id < 0:
+            return
+        
+        try:
+            self._pybullet.stepSimulation()
+        except Exception as e:
+            print(f"[BulletBackend] Step failed: {e}")
+    
+    def get_body_position(self, entity_id: str) -> Optional[np.ndarray]:
+        """Получает позицию тела"""
+        if entity_id not in self._bodies:
+            return None
+        
+        try:
+            pos, _ = self._pybullet.getBasePositionAndOrientation(
+                self._bodies[entity_id]
+            )
+            return np.array(pos, dtype=np.float32)
+        except Exception:
+            return None
+    
+    def get_body_rotation(self, entity_id: str) -> Optional[np.ndarray]:
+        """Получает поворот тела"""
+        if entity_id not in self._bodies:
+            return None
+        
+        try:
+            _, rot = self._pybullet.getBasePositionAndOrientation(
+                self._bodies[entity_id]
+            )
+            return np.array(rot, dtype=np.float32)
+        except Exception:
+            return None
+    
+    def set_body_position(self, entity_id: str, position: np.ndarray):
+        """Устанавливает позицию тела"""
+        if entity_id not in self._bodies:
+            return
+        
+        try:
+            _, rot = self._pybullet.getBasePositionAndOrientation(
+                self._bodies[entity_id]
+            )
+            self._pybullet.resetBasePositionAndOrientation(
+                self._bodies[entity_id],
+                position.tolist(),
+                rot
+            )
+        except Exception as e:
+            print(f"[BulletBackend] Failed to set position: {e}")
+    
+    def apply_force(self, entity_id: str, force: np.ndarray, 
+                    position: Optional[np.ndarray] = None):
+        """Применяет силу к телу"""
+        if entity_id not in self._bodies:
+            return
+        
+        try:
+            if position is not None:
+                self._pybullet.applyForce(
+                    self._bodies[entity_id], -1,
+                    force.tolist(),
+                    position.tolist(),
+                    self._pybullet.WORLD_FRAME
+                )
+            else:
+                # Применяем в центре масс
+                self._pybullet.applyExternalForce(
+                    self._bodies[entity_id], -1,
+                    force.tolist(),
+                    [0, 0, 0],
+                    self._pybullet.WORLD_FRAME
+                )
+        except Exception as e:
+            print(f"[BulletBackend] Failed to apply force: {e}")
+    
+    def apply_impulse(self, entity_id: str, impulse: np.ndarray):
+        """Применяет импульс"""
+        if entity_id not in self._bodies:
+            return
+        
+        try:
+            self._pybullet.applyExternalForce(
+                self._bodies[entity_id], -1,
+                impulse.tolist(),
+                [0, 0, 0],
+                self._pybullet.WORLD_FRAME
+            )
+        except Exception as e:
+            print(f"[BulletBackend] Failed to apply impulse: {e}")
+    
+    def raycast(self, from_pos: np.ndarray, to_pos: np.ndarray) -> List[dict]:
+        """Пуск луча"""
+        if not self.available:
+            return []
+        
+        try:
+            results = self._pybullet.rayTestBatch(
+                [from_pos.tolist()],
+                [to_pos.tolist()]
+            )
+            
+            hits = []
+            for result in results:
+                if result[0] >= 0:  # Есть попадание
+                    hits.append({
+                        'body_id': result[0],
+                        'link_index': result[1],
+                        'hit_position': np.array(result[3]),
+                        'hit_normal': np.array(result[4]),
+                        'hit_distance': result[2],
+                    })
+            
+            return hits
+        except Exception:
+            return []
+    
+    def create_constraint(self, 
+                          entity_a: str, entity_b: str,
+                          constraint_type: str = "point",
+                          pivot_a: Tuple[float, float, float] = (0, 0, 0),
+                          pivot_b: Tuple[float, float, float] = (0, 0, 0)) -> Optional[int]:
+        """Создаёт ограничение (joint) между телами"""
+        if not self.available:
+            return None
+        
+        if entity_a not in self._bodies or entity_b not in self._bodies:
+            return None
+        
+        try:
+            body_a = self._bodies[entity_a]
+            body_b = self._bodies[entity_b]
+            
+            if constraint_type == "point":
+                constraint = self._pybullet.createConstraint(
+                    body_a, -1, body_b, -1,
+                    self._pybullet.JOINT_POINT2POINT,
+                    [0, 0, 0],
+                    pivot_a, pivot_b
+                )
+            elif constraint_type == "hinge":
+                constraint = self._pybullet.createConstraint(
+                    body_a, -1, body_b, -1,
+                    self._pybullet.JOINT_HINGE,
+                    [0, 0, 0],
+                    pivot_a, pivot_b
+                )
+            elif constraint_type == "fixed":
+                constraint = self._pybullet.createConstraint(
+                    body_a, -1, body_b, -1,
+                    self._pybullet.JOINT_FIXED,
+                    [0, 0, 0],
+                    pivot_a, pivot_b
+                )
+            else:
+                return None
+            
+            return constraint
+            
+        except Exception as e:
+            print(f"[BulletBackend] Failed to create constraint: {e}")
+            return None
+    
+    def create_ghost_object(self, 
+                            entity_id: str,
+                            shape_type: str = "box",
+                            dimensions: Tuple[float, float, float] = (1, 1, 1),
+                            position: Tuple[float, float, float] = (0, 0, 0)):
+        """Создаёт ghost object (триггер)"""
+        # Ghost objects не поддерживаются напрямую в PyBullet,
+        # используем body с нулевой массой и без коллизий
+        return self.create_rigid_body(
+            entity_id, mass=0, shape_type=shape_type,
+            dimensions=dimensions, position=position,
+            is_kinematic=True
+        )
+    
+    def get_overlapping_objects(self, entity_id: str) -> List[str]:
+        """Получает список объектов, пересекающихся с данным"""
+        if entity_id not in self._bodies:
+            return []
+        
+        try:
+            # Получаем AABB тела
+            aabb_min, aabb_max = self._pybullet.getAABB(
+                self._bodies[entity_id]
+            )
+            
+            # Ищем все тела в этом AABB
+            overlapping = []
+            for other_id, body_id in self._bodies.items():
+                if other_id != entity_id:
+                    other_aabb_min, other_aabb_max = self._pybullet.getAABB(body_id)
+                    
+                    # Проверка пересечения AABB
+                    if (aabb_min[0] <= other_aabb_max[0] and aabb_max[0] >= other_aabb_min[0] and
+                        aabb_min[1] <= other_aabb_max[1] and aabb_max[1] >= other_aabb_min[1] and
+                        aabb_min[2] <= other_aabb_max[2] and aabb_max[2] >= other_aabb_min[2]):
+                        overlapping.append(other_id)
+            
+            return overlapping
+        except Exception:
+            return []
+    
+    def set_gravity(self, gravity: Tuple[float, float, float]):
+        """Устанавливает гравитацию"""
+        if self.available and self._client_id >= 0:
+            self._pybullet.setGravity(*gravity)
+    
+    def cleanup(self):
+        """Очищает физический мир"""
+        if self.available and self._client_id >= 0:
+            try:
+                # Удаляем все тела
+                for body_id in self._bodies.values():
+                    self._pybullet.removeBody(body_id)
+                
+                self._bodies.clear()
+                self._collision_shapes.clear()
+                
+                self._pybullet.disconnect()
+                self._client_id = -1
+                
+                print("[BulletBackend] Cleanup complete")
+            except Exception:
+                pass
+
+
+# Удобная функция для проверки доступности
+def is_bullet_available() -> bool:
+    """Проверяет, установлен ли PyBullet"""
+    return BulletPhysicsBackend._available
+
+
+def get_physics_backend() -> BulletPhysicsBackend:
+    """Возвращает синглтон физического бэкенда"""
+    return BulletPhysicsBackend()

aether/physics/collider.py

@@ -0,0 +1,22 @@
+"""Коллайдеры"""
+import numpy as np
+
+
+class Collider:
+    def __init__(self, is_trigger=False):
+        self.is_trigger = is_trigger
+        self.enabled = True
+
+
+class BoxCollider(Collider):
+    def __init__(self, size=(1,1,1), center=(0,0,0), is_trigger=False):
+        super().__init__(is_trigger)
+        self.size = np.array(size, dtype=np.float32)
+        self.center = np.array(center, dtype=np.float32)
+
+
+class SphereCollider(Collider):
+    def __init__(self, radius=0.5, center=(0,0,0), is_trigger=False):
+        super().__init__(is_trigger)
+        self.radius = radius
+        self.center = np.array(center, dtype=np.float32)