aether-engine 1.0.0__py3-none-any.whl

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/audio/audio_manager.py

@@ -0,0 +1,211 @@
+"""Менеджер звука на pygame.mixer"""
+import numpy as np
+from typing import Dict, Optional
+import os
+
+
+class Sound:
+    """Звуковой эффект"""
+    
+    def __init__(self, path: str = ""):
+        self.path = path
+        self.volume = 1.0
+        self.pitch = 1.0
+        self.loop = False
+        self._sound = None
+        self._channel = None
+        
+        if path:
+            self.load(path)
+    
+    def load(self, path: str):
+        """Загружает звук"""
+        try:
+            import pygame
+            self._sound = pygame.mixer.Sound(path)
+            self.path = path
+        except Exception as e:
+            print(f"[Sound] Failed to load {path}: {e}")
+    
+    def play(self, volume: float = 1.0, pitch: float = 1.0):
+        """Проигрывает звук"""
+        if self._sound:
+            self._sound.set_volume(volume * self.volume)
+            self._channel = self._sound.play()
+    
+    def stop(self):
+        """Останавливает звук"""
+        if self._channel:
+            self._channel.stop()
+    
+    def set_volume(self, volume: float):
+        """Устанавливает громкость"""
+        self.volume = max(0.0, min(1.0, volume))
+        if self._channel:
+            self._channel.set_volume(self.volume)
+
+
+class Music:
+    """Фоновая музыка"""
+    
+    def __init__(self, path: str = ""):
+        self.path = path
+        self.volume = 1.0
+        self.loop = True
+        self._loaded = False
+    
+    def load(self, path: str):
+        """Загружает музыку"""
+        try:
+            import pygame
+            pygame.mixer.music.load(path)
+            self.path = path
+            self._loaded = True
+        except Exception as e:
+            print(f"[Music] Failed to load {path}: {e}")
+    
+    def play(self, volume: float = 1.0, loop: bool = True):
+        """Проигрывает музыку"""
+        if self._loaded:
+            try:
+                import pygame
+                pygame.mixer.music.set_volume(volume * self.volume)
+                pygame.mixer.music.play(-1 if loop else 0)
+            except Exception as e:
+                print(f"[Music] Failed to play: {e}")
+    
+    def pause(self):
+        """Ставит на паузу"""
+        try:
+            import pygame
+            pygame.mixer.music.pause()
+        except:
+            pass
+    
+    def resume(self):
+        """Продолжает проигрывание"""
+        try:
+            import pygame
+            pygame.mixer.music.unpause()
+        except:
+            pass
+    
+    def stop(self):
+        """Останавливает музыку"""
+        try:
+            import pygame
+            pygame.mixer.music.stop()
+        except:
+            pass
+
+
+class AudioManager:
+    """Менеджер звука"""
+    
+    _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.sounds: Dict[str, Sound] = {}
+        self.current_music: Optional[Music] = None
+        
+        self.master_volume = 1.0
+        self.sfx_volume = 1.0
+        self.music_volume = 0.8
+        
+        self._initialized = False
+        
+        try:
+            import pygame
+            pygame.mixer.init(frequency=44100, size=-16, channels=32, buffer=512)
+            self._initialized = True
+            print("[Audio] Initialized (pygame.mixer)")
+        except ImportError:
+            print("[Audio] pygame not available, audio disabled")
+        except Exception as e:
+            print(f"[Audio] Failed to initialize: {e}")
+    
+    @property
+    def initialized(self) -> bool:
+        return self._initialized
+    
+    def load_sound(self, name: str, path: str) -> Sound:
+        """Загружает звуковой эффект"""
+        sound = Sound(path)
+        self.sounds[name] = sound
+        return sound
+    
+    def play_sound(self, name: str, volume: float = 1.0, pitch: float = 1.0):
+        """Проигрывает звук по имени"""
+        if not self._initialized:
+            return
+        
+        sound = self.sounds.get(name)
+        if sound:
+            sound.play(volume * self.sfx_volume * self.master_volume, pitch)
+    
+    def stop_sound(self, name: str):
+        """Останавливает звук"""
+        sound = self.sounds.get(name)
+        if sound:
+            sound.stop()
+    
+    def play_music(self, path: str, volume: float = 1.0, loop: bool = True):
+        """Проигрывает фоновую музыку"""
+        if not self._initialized:
+            return
+        
+        if self.current_music:
+            self.current_music.stop()
+        
+        self.current_music = Music(path)
+        self.current_music.play(volume * self.music_volume * self.master_volume, loop)
+    
+    def pause_music(self):
+        """Ставит музыку на паузу"""
+        if self.current_music:
+            self.current_music.pause()
+    
+    def resume_music(self):
+        """Продолжает музыку"""
+        if self.current_music:
+            self.current_music.resume()
+    
+    def stop_music(self):
+        """Останавливает музыку"""
+        if self.current_music:
+            self.current_music.stop()
+            self.current_music = None
+    
+    def set_master_volume(self, volume: float):
+        """Устанавливает общую громкость"""
+        self.master_volume = max(0.0, min(1.0, volume))
+    
+    def set_sfx_volume(self, volume: float):
+        """Устанавливает громкость эффектов"""
+        self.sfx_volume = max(0.0, min(1.0, volume))
+    
+    def set_music_volume(self, volume: float):
+        """Устанавливает громкость музыки"""
+        self.music_volume = max(0.0, min(1.0, volume))
+        if self.current_music:
+            self.current_music.play(self.music_volume * self.master_volume)
+    
+    def cleanup(self):
+        """Очищает аудио систему"""
+        self.stop_music()
+        self.sounds.clear()
+        
+        try:
+            import pygame
+            pygame.mixer.quit()
+        except:
+            pass
+        
+        print("[Audio] Cleanup complete")

aether/audio/music.py

@@ -0,0 +1,6 @@
+"""Фоновая музыка"""
+class Music:
+    def __init__(self, path=""):
+        self.path = path
+        self.volume = 1.0
+        self.loop = True

aether/audio/sound.py

@@ -0,0 +1,6 @@
+"""Звуковой эффект"""
+class Sound:
+    def __init__(self, path=""):
+        self.path = path
+        self.volume = 1.0
+        self.pitch = 1.0

aether/core/__init__.py

@@ -0,0 +1,211 @@
+"""Обработка ввода: клавиатура, мышь, геймпад"""
+import glfw
+import numpy as np
+
+
+class Input:
+    """Система ввода"""
+    
+    # Константы кнопок мыши
+    MOUSE_LEFT = glfw.MOUSE_BUTTON_LEFT
+    MOUSE_RIGHT = glfw.MOUSE_BUTTON_RIGHT
+    MOUSE_MIDDLE = glfw.MOUSE_BUTTON_MIDDLE
+    
+    # Константы геймпада
+    GAMEPAD_A = 0
+    GAMEPAD_B = 1
+    GAMEPAD_X = 2
+    GAMEPAD_Y = 3
+    GAMEPAD_LB = 4
+    GAMEPAD_RB = 5
+    GAMEPAD_START = 7
+    GAMEPAD_LEFT_STICK_X = 0
+    GAMEPAD_LEFT_STICK_Y = 1
+    GAMEPAD_RIGHT_STICK_X = 2
+    GAMEPAD_RIGHT_STICK_Y = 3
+    GAMEPAD_LEFT_TRIGGER = 4
+    GAMEPAD_RIGHT_TRIGGER = 5
+    
+    def __init__(self, window):
+        self.window = window
+        
+        # Клавиатура
+        self._keys = {}
+        self._keys_prev = {}
+        
+        # Мышь
+        self._mouse_buttons = {}
+        self._mouse_buttons_prev = {}
+        self.mouse_x = 0.0
+        self.mouse_y = 0.0
+        self.mouse_dx = 0.0
+        self.mouse_dy = 0.0
+        self.mouse_scroll = 0.0
+        self._first_mouse = True
+        self._cursor_locked = False
+        
+        # Геймпад
+        self._gamepad_connected = False
+        self._gamepad_id = None
+        self._gamepad_buttons = {}
+        self._gamepad_buttons_prev = {}
+        self._gamepad_axes = {}
+        self._gamepad_axes_prev = {}
+        
+        # Настройка коллбэков
+        glfw.set_key_callback(window.handle, self._key_callback)
+        glfw.set_mouse_button_callback(window.handle, self._mouse_button_callback)
+        glfw.set_cursor_pos_callback(window.handle, self._cursor_callback)
+        glfw.set_scroll_callback(window.handle, self._scroll_callback)
+        
+        # Проверяем наличие геймпада
+        self._check_gamepad()
+    
+    def _key_callback(self, window, key, scancode, action, mods):
+        """Коллбэк клавиатуры"""
+        if action == glfw.PRESS:
+            self._keys[key] = True
+        elif action == glfw.RELEASE:
+            self._keys[key] = False
+    
+    def _mouse_button_callback(self, window, button, action, mods):
+        """Коллбэк кнопок мыши"""
+        if action == glfw.PRESS:
+            self._mouse_buttons[button] = True
+        elif action == glfw.RELEASE:
+            self._mouse_buttons[button] = False
+    
+    def _cursor_callback(self, window, xpos, ypos):
+        """Коллбэк движения мыши"""
+        if self._first_mouse:
+            self.mouse_x = xpos
+            self.mouse_y = ypos
+            self._first_mouse = False
+        
+        self.mouse_dx = xpos - self.mouse_x
+        self.mouse_dy = ypos - self.mouse_y
+        self.mouse_x = xpos
+        self.mouse_y = ypos
+    
+    def _scroll_callback(self, window, xoffset, yoffset):
+        """Коллбэк колёсика мыши"""
+        self.mouse_scroll = yoffset
+    
+    def _check_gamepad(self):
+        """Проверяет подключение геймпада"""
+        for jid in range(glfw.JOYSTICK_1, glfw.JOYSTICK_16):
+            if glfw.joystick_present(jid):
+                self._gamepad_connected = True
+                self._gamepad_id = jid
+                name = glfw.get_joystick_name(jid)
+                print(f"[Input] Gamepad connected: {name}")
+                return
+        
+        self._gamepad_connected = False
+        self._gamepad_id = None
+    
+    def update(self):
+        """Обновляет состояние ввода"""
+        # Сохраняем предыдущее состояние
+        self._keys_prev = self._keys.copy()
+        self._mouse_buttons_prev = self._mouse_buttons.copy()
+        self._gamepad_buttons_prev = self._gamepad_buttons.copy()
+        self._gamepad_axes_prev = self._gamepad_axes.copy()
+        
+        # Сбрасываем дельты мыши
+        self.mouse_dx = 0.0
+        self.mouse_dy = 0.0
+        self.mouse_scroll = 0.0
+        
+        # Обновляем геймпад
+        if self._gamepad_connected and self._gamepad_id is not None:
+            if not glfw.joystick_present(self._gamepad_id):
+                self._gamepad_connected = False
+                self._gamepad_id = None
+                print("[Input] Gamepad disconnected")
+            else:
+                buttons = glfw.get_joystick_buttons(self._gamepad_id)
+                for i, state in enumerate(buttons):
+                    self._gamepad_buttons[i] = (state == glfw.PRESS)
+                
+                axes = glfw.get_joystick_axes(self._gamepad_id)
+                for i, value in enumerate(axes):
+                    self._gamepad_axes[i] = value
+    
+    # ---- Клавиатура ----
+    
+    def get_key(self, key) -> bool:
+        """Клавиша нажата (удерживается)"""
+        return self._keys.get(key, False)
+    
+    def get_key_down(self, key) -> bool:
+        """Клавиша нажата в этом кадре"""
+        return self._keys.get(key, False) and not self._keys_prev.get(key, False)
+    
+    def get_key_up(self, key) -> bool:
+        """Клавиша отпущена в этом кадре"""
+        return not self._keys.get(key, False) and self._keys_prev.get(key, False)
+    
+    # ---- Мышь ----
+    
+    def get_mouse_button(self, button) -> bool:
+        """Кнопка мыши нажата (удерживается)"""
+        return self._mouse_buttons.get(button, False)
+    
+    def get_mouse_button_down(self, button) -> bool:
+        """Кнопка мыши нажата в этом кадре"""
+        return self._mouse_buttons.get(button, False) and not self._mouse_buttons_prev.get(button, False)
+    
+    def get_mouse_button_up(self, button) -> bool:
+        """Кнопка мыши отпущена в этом кадре"""
+        return not self._mouse_buttons.get(button, False) and self._mouse_buttons_prev.get(button, False)
+    
+    def get_mouse_position(self) -> tuple:
+        """Возвращает позицию мыши"""
+        return (self.mouse_x, self.mouse_y)
+    
+    def get_mouse_delta(self) -> tuple:
+        """Возвращает дельту движения мыши"""
+        return (self.mouse_dx, self.mouse_dy)
+    
+    def get_mouse_scroll(self) -> float:
+        """Возвращает значение колёсика"""
+        return self.mouse_scroll
+    
+    # ---- Геймпад ----
+    
+    def get_gamepad_button(self, button) -> bool:
+        """Кнопка геймпада нажата (удерживается)"""
+        return self._gamepad_buttons.get(button, False)
+    
+    def get_gamepad_button_down(self, button) -> bool:
+        """Кнопка геймпада нажата в этом кадре"""
+        return self._gamepad_buttons.get(button, False) and not self._gamepad_buttons_prev.get(button, False)
+    
+    def get_gamepad_axis(self, axis) -> float:
+        """Возвращает значение оси геймпада"""
+        value = self._gamepad_axes.get(axis, 0.0)
+        # Мёртвая зона
+        if abs(value) < 0.15:
+            return 0.0
+        return value
+    
+    def is_gamepad_connected(self) -> bool:
+        """Подключён ли геймпад"""
+        return self._gamepad_connected
+    
+    # ---- Управление курсором ----
+    
+    def lock_cursor(self):
+        """Захватывает курсор (для FPS)"""
+        glfw.set_input_mode(self.window.handle, glfw.CURSOR, glfw.CURSOR_DISABLED)
+        self._cursor_locked = True
+    
+    def unlock_cursor(self):
+        """Освобождает курсор"""
+        glfw.set_input_mode(self.window.handle, glfw.CURSOR, glfw.CURSOR_NORMAL)
+        self._cursor_locked = False
+    
+    def is_cursor_locked(self) -> bool:
+        """Захвачен ли курсор"""
+        return self._cursor_locked