aether-engine 1.0.0__py3-none-any.whl

aether/ui/button.py

@@ -0,0 +1,297 @@
+"""UI Button и интерактивные элементы"""
+import numpy as np
+from OpenGL.GL import *
+from typing import Callable, Optional
+from aether.ui.text import TextRenderer, Font
+
+
+class UIElement:
+    """Базовый класс UI элемента"""
+    
+    def __init__(self, x: float = 0, y: float = 0, 
+                 width: float = 200, height: float = 50):
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self.enabled = True
+        self.visible = True
+        self.parent = None
+        self.children = []
+        
+        # Состояние
+        self.is_hovered = False
+        self.is_pressed = False
+        self.is_focused = False
+    
+    def update(self, dt: float, mouse_x: float, mouse_y: float, 
+               mouse_pressed: bool, mouse_just_pressed: bool):
+        """Обновляет состояние элемента"""
+        if not self.enabled or not self.visible:
+            return
+        
+        # Проверка наведения
+        self.is_hovered = self._point_inside(mouse_x, mouse_y)
+        
+        # Обновляем детей
+        for child in self.children:
+            child.update(dt, mouse_x, mouse_y, mouse_pressed, mouse_just_pressed)
+    
+    def render(self):
+        """Рендерит элемент (переопределяется в наследниках)"""
+        if not self.visible:
+            return
+        
+        for child in self.children:
+            child.render()
+    
+    def _point_inside(self, px: float, py: float) -> bool:
+        """Проверяет, находится ли точка внутри элемента"""
+        return (self.x <= px <= self.x + self.width and 
+                self.y <= py <= self.y + self.height)
+    
+    def get_absolute_position(self) -> Tuple[float, float]:
+        """Получает абсолютную позицию с учётом родителей"""
+        x, y = self.x, self.y
+        if self.parent:
+            px, py = self.parent.get_absolute_position()
+            x += px
+            y += py
+        return (x, y)
+
+
+class Button(UIElement):
+    """Кнопка"""
+    
+    def __init__(self, text: str = "Button", x: float = 0, y: float = 0,
+                 width: float = 200, height: float = 50,
+                 callback: Callable = None):
+        super().__init__(x, y, width, height)
+        self.text = text
+        self.callback = callback
+        
+        # Визуальные настройки
+        self.normal_color = (0.2, 0.3, 0.5, 1.0)
+        self.hover_color = (0.3, 0.4, 0.6, 1.0)
+        self.press_color = (0.1, 0.2, 0.4, 1.0)
+        self.text_color = (1.0, 1.0, 1.0, 1.0)
+        self.border_radius = 8.0
+        self.font_size = 20
+        
+        self._was_pressed = False
+    
+    def update(self, dt: float, mouse_x: float, mouse_y: float,
+               mouse_pressed: bool, mouse_just_pressed: bool):
+        super().update(dt, mouse_x, mouse_y, mouse_pressed, mouse_just_pressed)
+        
+        if not self.enabled:
+            return
+        
+        # Обработка нажатия
+        if self.is_hovered:
+            if mouse_just_pressed:
+                self.is_pressed = True
+                self._was_pressed = True
+            elif mouse_pressed and self._was_pressed:
+                self.is_pressed = True
+            else:
+                if self._was_pressed and not mouse_pressed:
+                    # Клик!
+                    if self.callback:
+                        self.callback()
+                self.is_pressed = False
+                self._was_pressed = False
+        else:
+            self.is_pressed = False
+            self._was_pressed = False
+    
+    def render(self):
+        if not self.visible:
+            return
+        
+        # Определяем цвет
+        if self.is_pressed:
+            color = self.press_color
+        elif self.is_hovered:
+            color = self.hover_color
+        else:
+            color = self.normal_color
+        
+        # Рисуем фон
+        self._draw_rounded_rect(self.x, self.y, self.width, self.height, 
+                                self.border_radius, color)
+        
+        # Рендерим текст
+        text_renderer = TextRenderer()
+        if text_renderer.default_font:
+            text_width, text_height = text_renderer.measure_text(
+                self.text, self.font_size / 48.0
+            )
+            
+            text_x = self.x + (self.width - text_width) / 2
+            text_y = self.y + (self.height - text_height) / 2
+            
+            text_renderer.render_text(
+                self.text, text_x, text_y,
+                self.font_size / 48.0, self.text_color
+            )
+        
+        super().render()
+    
+    def _draw_rounded_rect(self, x, y, w, h, r, color):
+        """Рисует закруглённый прямоугольник"""
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        
+        # Простой прямоугольник (закругления можно добавить через шейдер)
+        glColor4f(*color)
+        glBegin(GL_QUADS)
+        glVertex2f(x, y)
+        glVertex2f(x + w, y)
+        glVertex2f(x + w, y + h)
+        glVertex2f(x, y + h)
+        glEnd()
+        
+        glDisable(GL_BLEND)
+
+
+class Panel(UIElement):
+    """Панель (контейнер)"""
+    
+    def __init__(self, x: float = 0, y: float = 0,
+                 width: float = 400, height: float = 300):
+        super().__init__(x, y, width, height)
+        self.background_color = (0.1, 0.1, 0.15, 0.9)
+        self.border_color = (0.3, 0.3, 0.4, 1.0)
+        self.border_width = 2.0
+        self.padding = 10.0
+        self.title = ""
+    
+    def render(self):
+        if not self.visible:
+            return
+        
+        # Фон
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        
+        glColor4f(*self.background_color)
+        glBegin(GL_QUADS)
+        glVertex2f(self.x, self.y)
+        glVertex2f(self.x + self.width, self.y)
+        glVertex2f(self.x + self.width, self.y + self.height)
+        glVertex2f(self.x, self.y + self.height)
+        glEnd()
+        
+        # Граница
+        glColor4f(*self.border_color)
+        glLineWidth(self.border_width)
+        glBegin(GL_LINE_LOOP)
+        glVertex2f(self.x, self.y)
+        glVertex2f(self.x + self.width, self.y)
+        glVertex2f(self.x + self.width, self.y + self.height)
+        glVertex2f(self.x, self.y + self.height)
+        glEnd()
+        glLineWidth(1.0)
+        
+        glDisable(GL_BLEND)
+        
+        # Заголовок
+        if self.title:
+            text_renderer = TextRenderer()
+            if text_renderer.default_font:
+                text_renderer.render_text(
+                    self.title,
+                    self.x + self.padding,
+                    self.y + self.height - 30,
+                    0.5, (1.0, 1.0, 1.0, 1.0)
+                )
+        
+        super().render()
+
+
+class Label(UIElement):
+    """Текстовая метка"""
+    
+    def __init__(self, text: str = "", x: float = 0, y: float = 0,
+                 font_size: float = 20):
+        super().__init__(x, y, 0, 0)
+        self.text = text
+        self.font_size = font_size
+        self.color = (1.0, 1.0, 1.0, 1.0)
+    
+    def render(self):
+        if not self.visible or not self.text:
+            return
+        
+        text_renderer = TextRenderer()
+        if text_renderer.default_font:
+            w, h = text_renderer.render_text(
+                self.text, self.x, self.y,
+                self.font_size / 48.0, self.color
+            )
+            self.width = w
+            self.height = h
+        
+        super().render()
+
+
+class Canvas:
+    """Корневой Canvas для UI"""
+    
+    def __init__(self, screen_width: int = 1920, screen_height: int = 1080):
+        self.elements = []
+        self.screen_width = screen_width
+        self.screen_height = screen_height
+        
+        # Настройка ортографической проекции для UI
+        self._setup_projection()
+    
+    def _setup_projection(self):
+        """Настройка проекции для UI"""
+        glMatrixMode(GL_PROJECTION)
+        glLoadIdentity()
+        glOrtho(0, self.screen_width, 0, self.screen_height, -1, 1)
+        glMatrixMode(GL_MODELVIEW)
+        glLoadIdentity()
+    
+    def add(self, element: UIElement):
+        """Добавляет элемент"""
+        self.elements.append(element)
+    
+    def remove(self, element: UIElement):
+        """Удаляет элемент"""
+        if element in self.elements:
+            self.elements.remove(element)
+    
+    def update(self, dt: float, mouse_x: float, mouse_y: float,
+               mouse_pressed: bool, mouse_just_pressed: bool):
+        """Обновляет все элементы"""
+        for element in self.elements:
+            element.update(dt, mouse_x, mouse_y, mouse_pressed, mouse_just_pressed)
+    
+    def render(self):
+        """Рендерит все элементы"""
+        # Сохраняем состояние
+        glPushAttrib(GL_ALL_ATTRIB_BITS)
+        glMatrixMode(GL_PROJECTION)
+        glPushMatrix()
+        glMatrixMode(GL_MODELVIEW)
+        glPushMatrix()
+        
+        # Устанавливаем ортографическую проекцию
+        self._setup_projection()
+        
+        # Отключаем тест глубины для UI
+        glDisable(GL_DEPTH_TEST)
+        
+        for element in self.elements:
+            element.render()
+        
+        # Восстанавливаем состояние
+        glEnable(GL_DEPTH_TEST)
+        glMatrixMode(GL_PROJECTION)
+        glPopMatrix()
+        glMatrixMode(GL_MODELVIEW)
+        glPopMatrix()
+        glPopAttrib()

aether/ui/canvas.py

@@ -0,0 +1,11 @@
+"""UI Canvas"""
+class Canvas:
+    def __init__(self):
+        self.elements = []
+    
+    def add(self, element):
+        self.elements.append(element)
+    
+    def render(self):
+        for element in self.elements:
+            element.render()

aether/ui/text.py

@@ -0,0 +1,286 @@
+"""Рендеринг текста с использованием FreeType"""
+import numpy as np
+from OpenGL.GL import *
+import os
+from typing import Dict, Tuple
+
+
+class Character:
+    """Глиф символа"""
+    __slots__ = ('texture_id', 'size', 'bearing', 'advance')
+    
+    def __init__(self, texture_id: int, size: Tuple[int, int], 
+                 bearing: Tuple[int, int], advance: int):
+        self.texture_id = texture_id
+        self.size = size
+        self.bearing = bearing
+        self.advance = advance
+
+
+class Font:
+    """Шрифт"""
+    
+    def __init__(self, path: str, size: int = 48):
+        self.characters: Dict[str, Character] = {}
+        self.size = size
+        self.line_height = 0
+        
+        self._load_font(path, size)
+    
+    def _load_font(self, path: str, size: int):
+        """Загружает шрифт"""
+        try:
+            from PIL import Image, ImageDraw, ImageFont
+            
+            font = ImageFont.truetype(path, size)
+            
+            # Загружаем ASCII символы
+            for c in range(32, 127):
+                char = chr(c)
+                self._load_character(char, font)
+            
+            # Добавляем кириллицу
+            for c in range(1040, 1104):
+                char = chr(c)
+                self._load_character(char, font)
+            
+            # Дополнительные символы
+            for char in "—«»…№":
+                self._load_character(char, font)
+            
+            # Высота строки
+            self.line_height = size + 10
+            
+            print(f"[Font] Loaded: {path} ({size}px, {len(self.characters)} chars)")
+            
+        except ImportError:
+            print("[Font] PIL not installed, using default font")
+            self._create_default_font()
+    
+    def _load_character(self, char: str, font):
+        """Загружает один символ"""
+        from PIL import Image
+        
+        # Получаем размеры символа
+        bbox = font.getbbox(char)
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+        
+        if width <= 0 or height <= 0:
+            width = self.size // 2
+            height = self.size
+        
+        # Рендерим символ
+        image = Image.new('RGBA', (width + 4, height + 4), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(image)
+        draw.text((2 - bbox[0], 2 - bbox[1]), char, font=font, fill=(255, 255, 255, 255))
+        
+        # Создаём OpenGL текстуру
+        texture_id = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, texture_id)
+        
+        image_data = np.array(image, dtype=np.uint8)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height,
+                     0, GL_RGBA, GL_UNSIGNED_BYTE, image_data)
+        
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        
+        # Сохраняем информацию
+        self.characters[char] = Character(
+            texture_id,
+            (width + 4, height + 4),
+            (bbox[0], -bbox[3]),
+            width + 4
+        )
+    
+    def _create_default_font(self):
+        """Создаёт простой встроенный шрифт"""
+        for c in range(32, 127):
+            char = chr(c)
+            texture_id = glGenTextures(1)
+            
+            # Создаём простой символ 16x16
+            image = np.zeros((16, 16, 4), dtype=np.uint8)
+            image[:, :, 3] = 255
+            
+            glBindTexture(GL_TEXTURE_2D, texture_id)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16,
+                         0, GL_RGBA, GL_UNSIGNED_BYTE, image)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+            
+            self.characters[char] = Character(texture_id, (16, 16), (0, -16), 8)
+        
+        self.line_height = 16
+
+
+class TextRenderer:
+    """Рендерер текста"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialize()
+        return cls._instance
+    
+    def _initialize(self):
+        """Инициализация рендерера"""
+        # VAO и VBO для текста
+        self.vao = glGenVertexArrays(1)
+        self.vbo = glGenBuffers(1)
+        
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        
+        # Выделяем память (6 вершин * 4 floats на глиф * максимум 256 символов)
+        glBufferData(GL_ARRAY_BUFFER, 256 * 6 * 4 * 4, None, GL_DYNAMIC_DRAW)
+        
+        # Позиция (vec2) и UV (vec2)
+        glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * 4, ctypes.c_void_p(0))
+        glEnableVertexAttribArray(0)
+        
+        glBindVertexArray(0)
+        
+        # Шейдер текста
+        self._setup_shader()
+        
+        # Текущий шрифт
+        self.default_font = None
+        
+        print("[TextRenderer] Initialized")
+    
+    def _setup_shader(self):
+        """Настройка шейдера для текста"""
+        vertex_shader = """
+        #version 460 core
+        layout(location = 0) in vec4 vertex;  // xy: pos, zw: uv
+        
+        out vec2 TexCoords;
+        
+        uniform mat4 projection;
+        
+        void main() {
+            gl_Position = projection * vec4(vertex.xy, 0.0, 1.0);
+            TexCoords = vertex.zw;
+        }
+        """
+        
+        fragment_shader = """
+        #version 460 core
+        in vec2 TexCoords;
+        out vec4 color;
+        
+        uniform sampler2D text;
+        uniform vec4 textColor;
+        
+        void main() {
+            vec4 sampled = vec4(1.0, 1.0, 1.0, texture(text, TexCoords).r);
+            color = textColor * sampled;
+        }
+        """
+        
+        from aether.graphics.shader import Shader
+        self.shader = Shader(vertex_shader, fragment_shader)
+    
+    def set_default_font(self, font_path: str, size: int = 48):
+        """Устанавливает шрифт по умолчанию"""
+        self.default_font = Font(font_path, size)
+    
+    def render_text(self, text: str, x: float, y: float, 
+                    scale: float = 1.0, color: tuple = (1.0, 1.0, 1.0, 1.0),
+                    font: Font = None, screen_width: int = 1920, 
+                    screen_height: int = 1080) -> Tuple[float, float]:
+        """Рендерит текст и возвращает (width, height)"""
+        if not text:
+            return (0, 0)
+        
+        if font is None:
+            font = self.default_font
+        
+        if font is None:
+            return (0, 0)
+        
+        # Ортографическая проекция
+        projection = np.array([
+            [2.0 / screen_width, 0, 0, -1],
+            [0, 2.0 / screen_height, 0, -1],
+            [0, 0, -1, 0],
+            [0, 0, 0, 1]
+        ], dtype=np.float32)
+        
+        self.shader.use()
+        self.shader.set_mat4("projection", projection)
+        self.shader.set_vec4("textColor", color)
+        
+        glActiveTexture(GL_TEXTURE0)
+        glBindVertexArray(self.vao)
+        
+        total_width = 0
+        total_height = 0
+        
+        for char in text:
+            if char not in font.characters:
+                continue
+            
+            ch = font.characters[char]
+            
+            xpos = x + ch.bearing[0] * scale
+            ypos = y - (ch.size[1] - ch.bearing[1]) * scale
+            
+            w = ch.size[0] * scale
+            h = ch.size[1] * scale
+            
+            # 6 вершин на символ (2 треугольника)
+            vertices = np.array([
+                xpos,     ypos + h, 0.0, 0.0,
+                xpos,     ypos,     0.0, 1.0,
+                xpos + w, ypos,     1.0, 1.0,
+                
+                xpos,     ypos + h, 0.0, 0.0,
+                xpos + w, ypos,     1.0, 1.0,
+                xpos + w, ypos + h, 1.0, 0.0,
+            ], dtype=np.float32)
+            
+            # Рендерим глиф
+            glBindTexture(GL_TEXTURE_2D, ch.texture_id)
+            glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+            glBufferSubData(GL_ARRAY_BUFFER, 0, vertices.nbytes, vertices)
+            glDrawArrays(GL_TRIANGLES, 0, 6)
+            
+            # Сдвигаем позицию для следующего символа
+            x += (ch.advance >> 6) * scale
+            
+            total_width += (ch.advance >> 6) * scale
+            total_height = max(total_height, ch.size[1] * scale)
+        
+        glBindVertexArray(0)
+        glBindTexture(GL_TEXTURE_2D, 0)
+        
+        return (total_width, total_height)
+    
+    def measure_text(self, text: str, scale: float = 1.0, font: Font = None) -> Tuple[float, float]:
+        """Измеряет размер текста без рендеринга"""
+        if not text or font is None:
+            return (0, 0)
+        
+        if font is None:
+            font = self.default_font
+        
+        if font is None:
+            return (0, 0)
+        
+        width = 0
+        height = 0
+        
+        for char in text:
+            if char in font.characters:
+                ch = font.characters[char]
+                width += (ch.advance >> 6) * scale
+                height = max(height, ch.size[1] * scale)
+        
+        return (width, height)

aether/utils/logger.py

@@ -0,0 +1,16 @@
+"""Логирование"""
+import logging
+
+
+def setup_logger(name="Aether", level=logging.INFO):
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(
+        '[%(asctime)s] [%(levelname)s] %(message)s',
+        datefmt='%H:%M:%S'
+    ))
+    logger.addHandler(handler)
+    
+    return logger

aether/utils/math_utils.py

@@ -0,0 +1,31 @@
+"""Математические утилиты"""
+import numpy as np
+
+
+def lerp(a: float, b: float, t: float) -> float:
+    return a + (b - a) * t
+
+
+def clamp(value: float, min_val: float, max_val: float) -> float:
+    return max(min_val, min(max_val, value))
+
+
+def normalize(v: np.ndarray) -> np.ndarray:
+    norm = np.linalg.norm(v)
+    return v / norm if norm > 0 else v
+
+
+def look_at(eye: np.ndarray, target: np.ndarray, up: np.ndarray) -> np.ndarray:
+    """Создаёт look-at матрицу"""
+    f = target - eye
+    f = f / np.linalg.norm(f)
+    s = np.cross(f, up)
+    s = s / np.linalg.norm(s)
+    u = np.cross(s, f)
+    
+    m = np.identity(4, dtype=np.float32)
+    m[0, :3] = s
+    m[1, :3] = u
+    m[2, :3] = -f
+    m[3, :3] = eye
+    return np.linalg.inv(m)