aether-engine 1.0.0__py3-none-any.whl

aether/graphics/terrain.py

@@ -0,0 +1,408 @@
+"""Система террайна с LOD и текстурированием"""
+import numpy as np
+from OpenGL.GL import *
+from typing import List, Tuple, Optional
+from aether.graphics.mesh import Mesh
+from aether.graphics.texture import Texture
+
+
+class TerrainChunk:
+    """Чанк террайна"""
+    
+    def __init__(self, 
+                 x: int, z: int,
+                 size: int,
+                 resolution: int,
+                 height_map: np.ndarray):
+        self.grid_x = x
+        self.grid_z = z
+        self.size = size
+        self.resolution = resolution
+        self.height_map = height_map
+        
+        # Позиция в мире
+        self.world_x = x * size
+        self.world_z = z * size
+        
+        # Меш
+        self.mesh: Optional[Mesh] = None
+        self._generate_mesh()
+    
+    def _generate_mesh(self):
+        """Генерирует меш чанка"""
+        vertices = []
+        normals = []
+        uvs = []
+        indices = []
+        
+        step = self.size / (self.resolution - 1)
+        
+        # Вершины
+        for iz in range(self.resolution):
+            for ix in range(self.resolution):
+                # Локальные координаты
+                lx = ix * step
+                lz = iz * step
+                
+                # Высота из height_map
+                hx = int(ix * self.height_map.shape[0] / self.resolution)
+                hz = int(iz * self.height_map.shape[1] / self.resolution)
+                
+                height = 0.0
+                if 0 <= hx < self.height_map.shape[0] and 0 <= hz < self.height_map.shape[1]:
+                    height = self.height_map[hx, hz]
+                
+                vertices.append([lx, height, lz])
+                
+                # UV координаты
+                uvs.append([ix / (self.resolution - 1), iz / (self.resolution - 1)])
+        
+        vertices = np.array(vertices, dtype=np.float32)
+        
+        # Нормали (вычисляем из соседних вершин)
+        normals = self._calculate_normals(vertices)
+        
+        # Индексы (треугольники)
+        for iz in range(self.resolution - 1):
+            for ix in range(self.resolution - 1):
+                top_left = iz * self.resolution + ix
+                top_right = top_left + 1
+                bottom_left = (iz + 1) * self.resolution + ix
+                bottom_right = bottom_left + 1
+                
+                # Два треугольника
+                indices.extend([top_left, bottom_left, top_right])
+                indices.extend([top_right, bottom_left, bottom_right])
+        
+        indices = np.array(indices, dtype=np.uint32)
+        
+        # Создаём меш
+        self.mesh = Mesh(vertices, indices, normals, np.array(uvs, dtype=np.float32))
+    
+    def _calculate_normals(self, vertices: np.ndarray) -> np.ndarray:
+        """Вычисляет нормали из вершин"""
+        normals = np.zeros_like(vertices)
+        
+        for iz in range(1, self.resolution - 1):
+            for ix in range(1, self.resolution - 1):
+                i = iz * self.resolution + ix
+                
+                # Соседние вершины
+                left = vertices[iz * self.resolution + (ix - 1)]
+                right = vertices[iz * self.resolution + (ix + 1)]
+                top = vertices[(iz - 1) * self.resolution + ix]
+                bottom = vertices[(iz + 1) * self.resolution + ix]
+                
+                # Вычисляем нормаль
+                dx = right - left
+                dz = bottom - top
+                
+                normal = np.cross(dz, dx)
+                norm = np.linalg.norm(normal)
+                
+                if norm > 0:
+                    normals[i] = normal / norm
+                else:
+                    normals[i] = np.array([0, 1, 0])
+        
+        return normals
+    
+    def get_height_at(self, world_x: float, world_z: float) -> float:
+        """Получает высоту в точке мира"""
+        # Локальные координаты
+        local_x = world_x - self.world_x
+        local_z = world_z - self.world_z
+        
+        if local_x < 0 or local_x > self.size or local_z < 0 or local_z > self.size:
+            return 0.0
+        
+        # Нормализованные координаты
+        nx = local_x / self.size
+        nz = local_z / self.size
+        
+        # Индексы в height_map
+        hx = int(nx * (self.height_map.shape[0] - 1))
+        hz = int(nz * (self.height_map.shape[1] - 1))
+        
+        if 0 <= hx < self.height_map.shape[0] - 1 and 0 <= hz < self.height_map.shape[1] - 1:
+            # Билинейная интерполяция
+            fx = nx * (self.height_map.shape[0] - 1) - hx
+            fz = nz * (self.height_map.shape[1] - 1) - hz
+            
+            h00 = self.height_map[hx, hz]
+            h10 = self.height_map[hx + 1, hz]
+            h01 = self.height_map[hx, hz + 1]
+            h11 = self.height_map[hx + 1, hz + 1]
+            
+            return (h00 * (1 - fx) * (1 - fz) +
+                    h10 * fx * (1 - fz) +
+                    h01 * (1 - fx) * fz +
+                    h11 * fx * fz)
+        
+        return 0.0
+
+
+class Terrain:
+    """Террайн (ландшафт)"""
+    
+    def __init__(self, 
+                 width: int = 512,
+                 depth: int = 512,
+                 max_height: float = 100.0,
+                 chunk_size: int = 64,
+                 chunk_resolution: int = 65):
+        
+        self.width = width
+        self.depth = depth
+        self.max_height = max_height
+        self.chunk_size = chunk_size
+        self.chunk_resolution = chunk_resolution
+        
+        # Чанки
+        self.chunks: dict = {}
+        self._chunks_x = width // chunk_size
+        self._chunks_z = depth // chunk_size
+        
+        # Текстуры
+        self.splat_map: Optional[Texture] = None
+        self.detail_textures: List[Texture] = []
+        
+        # Height map всего террайна
+        self.height_map = np.zeros((width + 1, depth + 1), dtype=np.float32)
+        
+        # Настройки
+        self.tesselation_enabled = False
+        self.tesselation_factor = 1.0
+        self.wireframe = False
+        
+        print(f"[Terrain] Created {width}x{depth} ({self._chunks_x * self._chunks_z} chunks)")
+    
+    def generate_height_map(self, 
+                           seed: int = 0,
+                           octaves: int = 6,
+                           persistence: float = 0.5,
+                           lacunarity: float = 2.0,
+                           scale: float = 100.0):
+        """Генерирует height map с помощью шума Перлина"""
+        try:
+            from noise import pnoise2
+            
+            np.random.seed(seed)
+            
+            for x in range(self.width + 1):
+                for z in range(self.depth + 1):
+                    height = pnoise2(
+                        x / scale,
+                        z / scale,
+                        octaves=octaves,
+                        persistence=persistence,
+                        lacunarity=lacunarity,
+                        base=seed
+                    )
+                    # Нормализуем от [-1, 1] к [0, max_height]
+                    self.height_map[x, z] = (height + 1) * 0.5 * self.max_height
+            
+            print(f"[Terrain] Height map generated (seed: {seed})")
+            
+        except ImportError:
+            print("[Terrain] 'noise' module not found. Using random heights.")
+            self._generate_random_height_map(seed)
+    
+    def _generate_random_height_map(self, seed: int):
+        """Генерирует случайную height map"""
+        np.random.seed(seed)
+        
+        # Простой шум через интерполяцию
+        points = np.random.rand(16, 16) * self.max_height
+        
+        for x in range(self.width + 1):
+            for z in range(self.depth + 1):
+                fx = (x / self.width) * (points.shape[0] - 1)
+                fz = (z / self.depth) * (points.shape[1] - 1)
+                
+                ix, iz = int(fx), int(fz)
+                fx -= ix
+                fz -= iz
+                
+                ix = min(ix, points.shape[0] - 2)
+                iz = min(iz, points.shape[1] - 2)
+                
+                h = (points[ix, iz] * (1 - fx) * (1 - fz) +
+                     points[ix + 1, iz] * fx * (1 - fz) +
+                     points[ix, iz + 1] * (1 - fx) * fz +
+                     points[ix + 1, iz + 1] * fx * fz)
+                
+                self.height_map[x, z] = h
+    
+    def generate_chunks(self):
+        """Генерирует все чанки"""
+        for cx in range(self._chunks_x):
+            for cz in range(self._chunks_z):
+                self._generate_chunk(cx, cz)
+        
+        print(f"[Terrain] Generated {len(self.chunks)} chunks")
+    
+    def _generate_chunk(self, cx: int, cz: int):
+        """Генерирует один чанк"""
+        # Извлекаем часть height map для чанка
+        x_start = cx * self.chunk_size
+        z_start = cz * self.chunk_size
+        
+        chunk_hmap = np.zeros((self.chunk_size + 1, self.chunk_size + 1), dtype=np.float32)
+        
+        for x in range(self.chunk_size + 1):
+            for z in range(self.chunk_size + 1):
+                world_x = x_start + x
+                world_z = z_start + z
+                
+                if world_x <= self.width and world_z <= self.depth:
+                    chunk_hmap[x, z] = self.height_map[world_x, world_z]
+        
+        chunk = TerrainChunk(
+            cx, cz,
+            self.chunk_size,
+            self.chunk_resolution,
+            chunk_hmap
+        )
+        
+        self.chunks[(cx, cz)] = chunk
+    
+    def get_height(self, world_x: float, world_z: float) -> float:
+        """Получает высоту в точке мира"""
+        # Определяем чанк
+        cx = int(world_x // self.chunk_size)
+        cz = int(world_z // self.chunk_size)
+        
+        chunk = self.chunks.get((cx, cz))
+        if chunk:
+            return chunk.get_height_at(world_x, world_z)
+        
+        return 0.0
+    
+    def get_normal(self, world_x: float, world_z: float) -> np.ndarray:
+        """Получает нормаль в точке мира"""
+        eps = 0.1
+        
+        h_left = self.get_height(world_x - eps, world_z)
+        h_right = self.get_height(world_x + eps, world_z)
+        h_down = self.get_height(world_x, world_z - eps)
+        h_up = self.get_height(world_x, world_z + eps)
+        
+        normal = np.array([
+            (h_left - h_right) / (2 * eps),
+            1.0,
+            (h_down - h_up) / (2 * eps)
+        ], dtype=np.float32)
+        
+        return normal / np.linalg.norm(normal)
+    
+    def add_texture_layer(self, texture: Texture, 
+                         min_height: float = 0.0,
+                         max_height: float = 1.0,
+                         min_slope: float = 0.0,
+                         max_slope: float = 90.0):
+        """Добавляет слой текстуры"""
+        self.detail_textures.append(texture)
+    
+    def render(self, view: np.ndarray, projection: np.ndarray, 
+               camera_position: np.ndarray, shader=None):
+        """Рендерит террайн"""
+        if self.wireframe:
+            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+        
+        for chunk in self.chunks.values():
+            if chunk.mesh:
+                # Здесь был бы рендеринг с шейдером
+                chunk.mesh.draw()
+        
+        if self.wireframe:
+            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+    
+    def cleanup(self):
+        """Очищает ресурсы"""
+        for chunk in self.chunks.values():
+            if chunk.mesh:
+                chunk.mesh.cleanup()
+        self.chunks.clear()
+        print("[Terrain] Cleanup complete")
+
+
+class TerrainEditor:
+    """Инструменты редактирования террайна"""
+    
+    def __init__(self, terrain: Terrain):
+        self.terrain = terrain
+        self.brush_size = 5.0
+        self.brush_strength = 1.0
+        self.brush_falloff = 2.0
+    
+    def raise_terrain(self, world_x: float, world_z: float, amount: float):
+        """Поднимает террайн в точке"""
+        self._modify_terrain(world_x, world_z, amount)
+    
+    def lower_terrain(self, world_x: float, world_z: float, amount: float):
+        """Опускает террайн в точке"""
+        self._modify_terrain(world_x, world_z, -amount)
+    
+    def smooth_terrain(self, world_x: float, world_z: float, radius: float):
+        """Сглаживает террайн"""
+        cx = int(world_x)
+        cz = int(world_z)
+        r = int(radius)
+        
+        heights = []
+        
+        for x in range(max(0, cx - r), min(self.terrain.width, cx + r + 1)):
+            for z in range(max(0, cz - r), min(self.terrain.depth, cz + r + 1)):
+                dist = np.sqrt((x - cx)**2 + (z - cz)**2)
+                if dist <= r:
+                    heights.append(self.terrain.height_map[x, z])
+        
+        if heights:
+            avg = np.mean(heights)
+            
+            for x in range(max(0, cx - r), min(self.terrain.width, cx + r + 1)):
+                for z in range(max(0, cz - r), min(self.terrain.depth, cz + r + 1)):
+                    dist = np.sqrt((x - cx)**2 + (z - cz)**2)
+                    if dist <= r:
+                        t = dist / r
+                        self.terrain.height_map[x, z] = (
+                            self.terrain.height_map[x, z] * t + avg * (1 - t)
+                        )
+    
+    def flatten_terrain(self, world_x: float, world_z: float, 
+                        radius: float, target_height: float):
+        """Выравнивает террайн"""
+        cx = int(world_x)
+        cz = int(world_z)
+        r = int(radius)
+        
+        for x in range(max(0, cx - r), min(self.terrain.width, cx + r + 1)):
+            for z in range(max(0, cz - r), min(self.terrain.depth, cz + r + 1)):
+                dist = np.sqrt((x - cx)**2 + (z - cz)**2)
+                if dist <= r:
+                    t = dist / r
+                    self.terrain.height_map[x, z] = (
+                        self.terrain.height_map[x, z] * t + target_height * (1 - t)
+                    )
+    
+    def _modify_terrain(self, world_x: float, world_z: float, amount: float):
+        """Модифицирует террайн в точке"""
+        cx = int(world_x)
+        cz = int(world_z)
+        r = int(self.brush_size)
+        
+        for x in range(max(0, cx - r), min(self.terrain.width, cx + r + 1)):
+            for z in range(max(0, cz - r), min(self.terrain.depth, cz + r + 1)):
+                dist = np.sqrt((x - cx)**2 + (z - cz)**2)
+                
+                if dist <= r:
+                    # Функция falloff
+                    falloff = 1.0 - (dist / r) ** self.brush_falloff
+                    self.terrain.height_map[x, z] += amount * falloff * self.brush_strength
+                    
+                    # Ограничиваем высоту
+                    self.terrain.height_map[x, z] = max(0.0, min(
+                        self.terrain.max_height,
+                        self.terrain.height_map[x, z]
+                    ))

aether/graphics/texture.py

@@ -0,0 +1,34 @@
+"""Текстура"""
+from OpenGL.GL import *
+from PIL import Image
+import numpy as np
+
+
+class Texture:
+    def __init__(self, path=None):
+        self.id = glGenTextures(1)
+        self.width = 0
+        self.height = 0
+        
+        if path:
+            self.load(path)
+    
+    def load(self, path: str):
+        image = Image.open(path).convert("RGBA")
+        image = image.transpose(Image.FLIP_TOP_BOTTOM)
+        self.width, self.height = image.size
+        data = np.array(image, dtype=np.uint8)
+        
+        glBindTexture(GL_TEXTURE_2D, self.id)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 
+                     0, GL_RGBA, GL_UNSIGNED_BYTE, data)
+        glGenerateMipmap(GL_TEXTURE_2D)
+        
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+    
+    def bind(self, unit=0):
+        glActiveTexture(GL_TEXTURE0 + unit)
+        glBindTexture(GL_TEXTURE_2D, self.id)