aether-engine 1.0.0__py3-none-any.whl

aether/graphics/light.py

@@ -0,0 +1,32 @@
+"""Источники света"""
+import numpy as np
+
+
+class DirectionalLight:
+    def __init__(self, direction=(0, -1, 0), color=(1,1,1), intensity=1.0):
+        self.direction = np.array(direction, dtype=np.float32)
+        self.color = np.array(color, dtype=np.float32)
+        self.intensity = intensity
+        self.cast_shadows = True
+
+
+class PointLight:
+    def __init__(self, position=(0, 2, 0), color=(1,1,1), intensity=1.0, range=10.0):
+        self.position = np.array(position, dtype=np.float32)
+        self.color = np.array(color, dtype=np.float32)
+        self.intensity = intensity
+        self.range = range
+        self.cast_shadows = False
+
+
+class SpotLight:
+    def __init__(self, position=(0, 5, 0), direction=(0, -1, 0), 
+                 color=(1,1,1), intensity=1.0, range=15.0, 
+                 inner_angle=12.5, outer_angle=17.5):
+        self.position = np.array(position, dtype=np.float32)
+        self.direction = np.array(direction, dtype=np.float32)
+        self.color = np.array(color, dtype=np.float32)
+        self.intensity = intensity
+        self.range = range
+        self.inner_angle = inner_angle
+        self.outer_angle = outer_angle

aether/graphics/lod_system.py

@@ -0,0 +1,170 @@
+"""Система уровней детализации (LOD)"""
+import numpy as np
+from typing import List, Tuple, Optional, Dict
+from aether.graphics.mesh import Mesh
+
+
+class LODLevel:
+    """Уровень детализации"""
+    
+    def __init__(self, mesh: Mesh, distance: float, name: str = ""):
+        self.mesh = mesh
+        self.distance = distance  # Расстояние, на котором активируется
+        self.name = name or f"LOD_{distance}"
+        self.screen_coverage = 1.0  # Процент покрытия экрана
+
+
+class LODGroup:
+    """Группа LOD для одного объекта"""
+    
+    def __init__(self):
+        self.levels: List[LODLevel] = []
+        self._current_level = -1
+        self._transition_progress = 0.0
+        self._transition_speed = 2.0
+        self._fade_enabled = True
+    
+    def add_level(self, mesh: Mesh, distance: float, name: str = ""):
+        """Добавляет уровень детализации"""
+        level = LODLevel(mesh, distance, name)
+        self.levels.append(level)
+        # Сортируем по расстоянию (ближние первыми)
+        self.levels.sort(key=lambda x: x.distance)
+    
+    def get_mesh_for_distance(self, distance: float) -> Mesh:
+        """Возвращает подходящий меш для расстояния"""
+        if not self.levels:
+            return None
+        
+        selected_level = self.levels[0]
+        
+        for level in self.levels:
+            if distance <= level.distance:
+                selected_level = level
+                break
+            selected_level = level
+        
+        return selected_level.mesh
+    
+    def update(self, camera_position: np.ndarray, 
+               object_position: np.ndarray,
+               object_bounds: float = 1.0,
+               fov: float = 60.0,
+               screen_height: int = 1080) -> Tuple[Mesh, float]:
+        """
+        Обновляет LOD и возвращает (меш, прогресс перехода)
+        """
+        if not self.levels:
+            return None, 0.0
+        
+        distance = np.linalg.norm(object_position - camera_position)
+        
+        # Вычисляем screen coverage
+        screen_coverage = self._calculate_screen_coverage(
+            distance, object_bounds, fov, screen_height
+        )
+        
+        # Выбираем уровень
+        new_level_idx = 0
+        for i, level in enumerate(self.levels):
+            if screen_coverage > level.screen_coverage or distance <= level.distance:
+                new_level_idx = i
+                break
+        
+        # Плавный переход
+        if self._fade_enabled and new_level_idx != self._current_level:
+            if self._current_level >= 0:
+                self._transition_progress += self._transition_speed * 0.016
+                if self._transition_progress >= 1.0:
+                    self._current_level = new_level_idx
+                    self._transition_progress = 0.0
+            else:
+                self._current_level = new_level_idx
+                self._transition_progress = 0.0
+        
+        current_mesh = self.levels[self._current_level].mesh
+        return current_mesh, self._transition_progress
+    
+    def _calculate_screen_coverage(self, distance: float, 
+                                   object_size: float,
+                                   fov: float, 
+                                   screen_height: int) -> float:
+        """Вычисляет процент покрытия экрана объектом"""
+        if distance <= 0:
+            return 1.0
+        
+        # Размер объекта в мировых единицах на экране
+        fov_rad = np.radians(fov)
+        screen_world_size = 2.0 * distance * np.tan(fov_rad / 2.0)
+        screen_coverage = object_size / screen_world_size
+        
+        return np.clip(screen_coverage, 0.0, 1.0)
+
+
+class LODManager:
+    """Менеджер LOD для всей сцены"""
+    
+    _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._lod_groups: Dict[str, LODGroup] = {}
+        self._enabled = True
+        self._global_lod_bias = 1.0  # Множитель расстояния (1.0 = нормально)
+        
+        print("[LODManager] Initialized")
+    
+    def create_lod_group(self, entity_id: str, mesh_distances: List[Tuple[Mesh, float]]) -> LODGroup:
+        """
+        Создаёт LOD группу.
+        mesh_distances: список (меш, расстояние)
+        """
+        group = LODGroup()
+        
+        for mesh, distance in mesh_distances:
+            group.add_level(mesh, distance * self._global_lod_bias)
+        
+        self._lod_groups[entity_id] = group
+        return group
+    
+    def get_lod_mesh(self, entity_id: str, 
+                     camera_position: np.ndarray,
+                     object_position: np.ndarray,
+                     object_bounds: float = 1.0) -> Optional[Mesh]:
+        """Получает подходящий LOD меш для объекта"""
+        if not self._enabled:
+            return None
+        
+        group = self._lod_groups.get(entity_id)
+        if not group:
+            return None
+        
+        distance = np.linalg.norm(object_position - camera_position)
+        return group.get_mesh_for_distance(distance * self._global_lod_bias)
+    
+    def set_global_lod_bias(self, bias: float):
+        """Устанавливает глобальное смещение LOD"""
+        self._global_lod_bias = max(0.1, min(3.0, bias))
+    
+    def remove_lod_group(self, entity_id: str):
+        """Удаляет LOD группу"""
+        if entity_id in self._lod_groups:
+            del self._lod_groups[entity_id]
+    
+    def clear(self):
+        """Очищает все LOD группы"""
+        self._lod_groups.clear()
+    
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+    
+    @enabled.setter
+    def enabled(self, value: bool):
+        self._enabled = value

aether/graphics/material.py

@@ -0,0 +1,25 @@
+"""PBR-материал"""
+import numpy as np
+from aether.graphics.texture import Texture
+
+
+class Material:
+    def __init__(self, name="Material"):
+        self.name = name
+        self.albedo = np.array([1.0, 1.0, 1.0], dtype=np.float32)
+        self.metallic = 0.0
+        self.roughness = 0.5
+        self.ao = 1.0
+        
+        self.albedo_map: Texture = None
+        self.normal_map: Texture = None
+        self.metallic_map: Texture = None
+        self.roughness_map: Texture = None
+    
+    def apply(self, shader):
+        """Применяет материал к шейдеру"""
+        shader.set_vec3("material.albedo", self.albedo)
+        shader.set_float("material.metallic", self.metallic)
+        shader.set_float("material.roughness", self.roughness)
+        shader.set_float("material.ao", self.ao)
+        # Текстуры будут привязаны позже

aether/graphics/mesh.py

@@ -0,0 +1,83 @@
+"""Геометрия: VAO, VBO, EBO"""
+import numpy as np
+from OpenGL.GL import *
+import ctypes
+
+
+class Mesh:
+    def __init__(self, vertices: np.ndarray, indices: np.ndarray, 
+                 normals: np.ndarray = None, uvs: np.ndarray = None):
+        self.vertex_count = len(vertices)
+        self.index_count = len(indices)
+        
+        # Автоматические нормали
+        if normals is None:
+            normals = self._generate_normals(vertices, indices)
+        
+        # VAO
+        self.vao = glGenVertexArrays(1)
+        glBindVertexArray(self.vao)
+        
+        # VBO
+        self.vbo = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        
+        # Упаковываем данные: позиции + нормали + UV
+        data = []
+        for i, v in enumerate(vertices):
+            data.extend(v)
+            data.extend(normals[i] if i < len(normals) else [0, 1, 0])
+            if uvs is not None and i < len(uvs):
+                data.extend(uvs[i])
+            else:
+                data.extend([0.0, 0.0])
+        
+        data = np.array(data, dtype=np.float32)
+        glBufferData(GL_ARRAY_BUFFER, data.nbytes, data, GL_STATIC_DRAW)
+        
+        stride = (3 + 3 + 2) * 4  # pos + normal + uv
+        # Позиции (location = 0)
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(0))
+        glEnableVertexAttribArray(0)
+        # Нормали (location = 1)
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(12))
+        glEnableVertexAttribArray(1)
+        # UV (location = 2)
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(24))
+        glEnableVertexAttribArray(2)
+        
+        # EBO
+        self.ebo = glGenBuffers(1)
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices, GL_STATIC_DRAW)
+        
+        glBindVertexArray(0)
+    
+    def _generate_normals(self, vertices, indices):
+        """Вычисляет нормали для каждого треугольника"""
+        normals = np.zeros_like(vertices)
+        for i in range(0, len(indices), 3):
+            i0, i1, i2 = indices[i], indices[i+1], indices[i+2]
+            v0, v1, v2 = vertices[i0], vertices[i1], vertices[i2]
+            edge1 = v1 - v0
+            edge2 = v2 - v0
+            normal = np.cross(edge1, edge2)
+            normals[i0] += normal
+            normals[i1] += normal
+            normals[i2] += normal
+        # Нормализуем
+        for i in range(len(normals)):
+            n = np.linalg.norm(normals[i])
+            if n > 0:
+                normals[i] /= n
+        return normals
+    
+    def draw(self):
+        glBindVertexArray(self.vao)
+        glDrawElements(GL_TRIANGLES, self.index_count, GL_UNSIGNED_INT, None)
+        glBindVertexArray(0)
+    
+    def cleanup(self):
+        glDeleteVertexArrays(1, [self.vao])
+        glDeleteBuffers(1, [self.vbo])
+        glDeleteBuffers(1, [self.ebo])

aether/graphics/mesh_factory.py

@@ -0,0 +1,67 @@
+"""Фабрика примитивов"""
+import numpy as np
+from aether.graphics.mesh import Mesh
+
+
+class MeshFactory:
+    @staticmethod
+    def create_cube(size: float = 1.0) -> Mesh:
+        s = size / 2
+        vertices = np.array([
+            # Front face
+            [-s, -s,  s], [ s, -s,  s], [ s,  s,  s], [-s,  s,  s],
+            # Back face
+            [ s, -s, -s], [-s, -s, -s], [-s,  s, -s], [ s,  s, -s],
+            # Right face
+            [ s, -s,  s], [ s, -s, -s], [ s,  s, -s], [ s,  s,  s],
+            # Left face
+            [-s, -s, -s], [-s, -s,  s], [-s,  s,  s], [-s,  s, -s],
+            # Top face
+            [-s,  s,  s], [ s,  s,  s], [ s,  s, -s], [-s,  s, -s],
+            # Bottom face
+            [-s, -s, -s], [ s, -s, -s], [ s, -s,  s], [-s, -s,  s],
+        ], dtype=np.float32)
+        
+        indices = np.array([
+            0,1,2, 2,3,0,    4,5,6, 6,7,4,
+            8,9,10, 10,11,8,  12,13,14, 14,15,12,
+            16,17,18, 18,19,16, 20,21,22, 22,23,20,
+        ], dtype=np.uint32)
+        
+        return Mesh(vertices, indices)
+    
+    @staticmethod
+    def create_sphere(radius: float = 1.0, segments: int = 32) -> Mesh:
+        vertices = []
+        indices = []
+        
+        for y in range(segments + 1):
+            for x in range(segments + 1):
+                x_seg = x / segments
+                y_seg = y / segments
+                x_pos = radius * np.cos(x_seg * 2 * np.pi) * np.sin(y_seg * np.pi)
+                y_pos = radius * np.cos(y_seg * np.pi)
+                z_pos = radius * np.sin(x_seg * 2 * np.pi) * np.sin(y_seg * np.pi)
+                vertices.append([x_pos, y_pos, z_pos])
+        
+        vertices = np.array(vertices, dtype=np.float32)
+        
+        for y in range(segments):
+            for x in range(segments):
+                i0 = y * (segments + 1) + x
+                i1 = i0 + 1
+                i2 = i0 + segments + 1
+                i3 = i2 + 1
+                indices.extend([i0, i2, i1, i1, i2, i3])
+        
+        indices = np.array(indices, dtype=np.uint32)
+        return Mesh(vertices, indices)
+    
+    @staticmethod
+    def create_plane(size: float = 10.0) -> Mesh:
+        s = size / 2
+        vertices = np.array([
+            [-s, 0, -s], [ s, 0, -s], [ s, 0, s], [-s, 0, s],
+        ], dtype=np.float32)
+        indices = np.array([0, 2, 1, 0, 3, 2], dtype=np.uint32)
+        return Mesh(vertices, indices)

aether/graphics/particle_system.py

@@ -0,0 +1,268 @@
+"""Система частиц"""
+import numpy as np
+from OpenGL.GL import *
+import random
+from typing import List
+import time
+
+
+class Particle:
+    """Одна частица"""
+    
+    def __init__(self):
+        self.position = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self.velocity = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self.color = np.array([1.0, 1.0, 1.0, 1.0], dtype=np.float32)
+        self.size = 1.0
+        self.life = 1.0
+        self.max_life = 1.0
+        self.alive = False
+    
+    def reset(self, position, velocity, color, size, life):
+        """Сбрасывает частицу"""
+        self.position = np.array(position, dtype=np.float32)
+        self.velocity = np.array(velocity, dtype=np.float32)
+        self.color = np.array(color, dtype=np.float32)
+        self.size = size
+        self.life = life
+        self.max_life = life
+        self.alive = True
+
+
+class ParticleEmitter:
+    """Эмиттер частиц"""
+    
+    def __init__(self, max_particles=1000):
+        self.max_particles = max_particles
+        self.particles: List[Particle] = []
+        self._pool = []
+        
+        # Настройки эмиссии
+        self.emission_rate = 100  # частиц в секунду
+        self._emission_accumulator = 0.0
+        
+        self.position = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        self.velocity = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+        self.velocity_variation = np.array([0.5, 0.5, 0.5], dtype=np.float32)
+        
+        self.start_color = np.array([1.0, 0.5, 0.0, 1.0], dtype=np.float32)
+        self.end_color = np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float32)
+        
+        self.start_size = 0.5
+        self.end_size = 0.0
+        
+        self.min_life = 0.5
+        self.max_life = 2.0
+        
+        self.looping = True
+        self.playing = True
+        
+        # Силы, влияющие на частицы
+        self.gravity = np.array([0.0, -2.0, 0.0], dtype=np.float32)
+        self.wind = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        
+        # Предсоздаём пул частиц
+        for _ in range(max_particles):
+            self._pool.append(Particle())
+        
+        print(f"[ParticleEmitter] Created with {max_particles} max particles")
+    
+    def emit(self, count: int):
+        """Выпускает частицы"""
+        for _ in range(count):
+            particle = self._get_dead_particle()
+            if particle is None:
+                break
+            
+            # Случайные вариации
+            vel = self.velocity.copy()
+            vel += np.array([
+                random.uniform(-1, 1) * self.velocity_variation[0],
+                random.uniform(-1, 1) * self.velocity_variation[1],
+                random.uniform(-1, 1) * self.velocity_variation[2]
+            ], dtype=np.float32)
+            
+            life = random.uniform(self.min_life, self.max_life)
+            
+            particle.reset(
+                self.position.copy(),
+                vel,
+                self.start_color.copy(),
+                self.start_size,
+                life
+            )
+            
+            self.particles.append(particle)
+    
+    def update(self, dt: float):
+        """Обновляет все частицы"""
+        if not self.playing:
+            return
+        
+        # Эмиссия
+        if self.looping:
+            self._emission_accumulator += self.emission_rate * dt
+            emit_count = int(self._emission_accumulator)
+            if emit_count > 0:
+                self._emission_accumulator -= emit_count
+                self.emit(emit_count)
+        
+        # Обновление существующих частиц
+        for particle in self.particles[:]:
+            particle.life -= dt
+            
+            if particle.life <= 0:
+                particle.alive = False
+                self.particles.remove(particle)
+                continue
+            
+            # Применяем силы
+            particle.velocity += (self.gravity + self.wind) * dt
+            
+            # Обновляем позицию
+            particle.position += particle.velocity * dt
+            
+            # Интерполяция цвета
+            t = 1.0 - (particle.life / particle.max_life)
+            particle.color = self.start_color * (1 - t) + self.end_color * t
+            
+            # Интерполяция размера
+            particle.size = self.start_size * (1 - t) + self.end_size * t
+    
+    def _get_dead_particle(self) -> Particle:
+        """Получает мёртвую частицу из пула"""
+        for particle in self._pool:
+            if not particle.alive:
+                return particle
+        return None
+    
+    def stop(self):
+        """Останавливает эмиссию"""
+        self.playing = False
+    
+    def play(self):
+        """Запускает эмиссию"""
+        self.playing = True
+    
+    def clear(self):
+        """Очищает все частицы"""
+        for particle in self.particles:
+            particle.alive = False
+        self.particles.clear()
+    
+    def get_particle_data(self) -> tuple:
+        """Возвращает данные для рендеринга"""
+        positions = []
+        colors = []
+        sizes = []
+        
+        for particle in self.particles:
+            positions.extend(particle.position)
+            colors.extend(particle.color)
+            sizes.append(particle.size)
+        
+        return (
+            np.array(positions, dtype=np.float32),
+            np.array(colors, dtype=np.float32),
+            np.array(sizes, dtype=np.float32)
+        )
+
+
+class ParticleRenderer:
+    """Рендерер для системы частиц"""
+    
+    def __init__(self):
+        self.vao = glGenVertexArrays(1)
+        self.vbo = glGenBuffers(1)
+        
+        # Простой шейдер для частиц
+        self._setup_shader()
+        
+        print("[ParticleRenderer] Initialized")
+    
+    def _setup_shader(self):
+        """Настройка шейдера частиц"""
+        vertex_shader = """
+        #version 460 core
+        layout(location = 0) in vec3 aPos;
+        layout(location = 1) in vec4 aColor;
+        layout(location = 2) in float aSize;
+        
+        out vec4 vertexColor;
+        
+        uniform mat4 view;
+        uniform mat4 projection;
+        
+        void main() {
+            vec4 viewPos = view * vec4(aPos, 1.0);
+            gl_Position = projection * viewPos;
+            gl_PointSize = aSize * (300.0 / -viewPos.z);  // Размер с учётом перспективы
+            vertexColor = aColor;
+        }
+        """
+        
+        fragment_shader = """
+        #version 460 core
+        in vec4 vertexColor;
+        out vec4 FragColor;
+        
+        void main() {
+            // Круглая частица
+            vec2 coord = gl_PointCoord - vec2(0.5);
+            float dist = length(coord);
+            if (dist > 0.5) discard;
+            
+            // Мягкий край
+            float alpha = 1.0 - smoothstep(0.4, 0.5, dist);
+            
+            FragColor = vec4(vertexColor.rgb, vertexColor.a * alpha);
+        }
+        """
+        
+        from aether.graphics.shader import Shader
+        self.shader = Shader(vertex_shader, fragment_shader)
+    
+    def render(self, emitter: ParticleEmitter, view: np.ndarray, projection: np.ndarray):
+        """Рендерит частицы"""
+        if not emitter.particles:
+            return
+        
+        positions, colors, sizes = emitter.get_particle_data()
+        
+        # Обновляем буфер
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        
+        # Собираем все данные в один массив
+        data = []
+        for i in range(len(emitter.particles)):
+            data.extend(positions[i*3:(i+1)*3])
+            data.extend(colors[i*4:(i+1)*4])
+            data.append(sizes[i])
+        
+        data = np.array(data, dtype=np.float32)
+        glBufferData(GL_ARRAY_BUFFER, data.nbytes, data, GL_DYNAMIC_DRAW)
+        
+        stride = (3 + 4 + 1) * 4  # pos + color + size
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(0))
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(12))
+        glEnableVertexAttribArray(1)
+        glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(28))
+        glEnableVertexAttribArray(2)
+        
+        # Рендеринг
+        self.shader.use()
+        self.shader.set_mat4("view", view)
+        self.shader.set_mat4("projection", projection)
+        
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glDepthMask(GL_FALSE)
+        
+        glDrawArrays(GL_POINTS, 0, len(emitter.particles))
+        
+        glDepthMask(GL_TRUE)
+        glDisable(GL_BLEND)
+        
+        glBindVertexArray(0)