aether-engine 1.0.0__py3-none-any.whl

aether/graphics/water.py

@@ -0,0 +1,432 @@
+"""Система рендеринга воды с отражениями и волнами"""
+import numpy as np
+from OpenGL.GL import *
+from typing import Optional, Tuple
+from aether.graphics.shader import Shader
+from aether.graphics.framebuffer import Framebuffer
+from aether.graphics.mesh import Mesh
+from aether.graphics.mesh_factory import MeshFactory
+
+
+class WaveParameters:
+    """Параметры волн (Gerstner waves)"""
+    
+    def __init__(self):
+        # Основные параметры
+        self.amplitude = 1.0
+        self.frequency = 0.5
+        self.speed = 1.0
+        self.direction = np.array([1.0, 0.0], dtype=np.float32)
+        self.steepness = 0.3
+        self.wavelength = 10.0
+
+
+class WaterBody:
+    """Водная поверхность"""
+    
+    def __init__(self, 
+                 size: float = 100.0,
+                 resolution: int = 256,
+                 position: Tuple[float, float, float] = (0, 0, 0)):
+        
+        self.size = size
+        self.resolution = resolution
+        self.position = np.array(position, dtype=np.float32)
+        
+        # Меш
+        self.mesh: Optional[Mesh] = None
+        self._generate_mesh()
+        
+        # Параметры
+        self.waves: list[WaveParameters] = []
+        self._create_default_waves()
+        
+        # Отражения
+        self.reflection_enabled = True
+        self.reflection_fbo: Optional[Framebuffer] = None
+        self.reflection_clip_plane = (0.0, -1.0, 0.0, 0.0)
+        
+        # Преломление
+        self.refraction_enabled = True
+        self.refraction_fbo: Optional[Framebuffer] = None
+        
+        # Визуальные настройки
+        self.water_color = np.array([0.0, 0.3, 0.6], dtype=np.float32)
+        self.foam_color = np.array([1.0, 1.0, 1.0], dtype=np.float32)
+        self.transparency = 0.8
+        self.reflectivity = 0.6
+        self.fresnel_power = 3.0
+        
+        # Анимация
+        self.time = 0.0
+        self.wave_speed = 1.0
+        
+        # Шейдер
+        self._setup_shader()
+        
+        print(f"[Water] Created {size}x{size} water body")
+    
+    def _generate_mesh(self):
+        """Генерирует плоский меш"""
+        vertices = []
+        normals = []
+        uvs = []
+        indices = []
+        
+        step = self.size / (self.resolution - 1)
+        
+        for z in range(self.resolution):
+            for x in range(self.resolution):
+                vx = x * step - self.size / 2
+                vz = z * step - self.size / 2
+                
+                vertices.append([vx, 0.0, vz])
+                normals.append([0.0, 1.0, 0.0])
+                uvs.append([x / (self.resolution - 1), z / (self.resolution - 1)])
+        
+        vertices = np.array(vertices, dtype=np.float32)
+        normals = np.array(normals, dtype=np.float32)
+        uvs = np.array(uvs, dtype=np.float32)
+        
+        # Индексы
+        for z in range(self.resolution - 1):
+            for x in range(self.resolution - 1):
+                tl = z * self.resolution + x
+                tr = tl + 1
+                bl = (z + 1) * self.resolution + x
+                br = bl + 1
+                
+                indices.extend([tl, bl, tr])
+                indices.extend([tr, bl, br])
+        
+        indices = np.array(indices, dtype=np.uint32)
+        
+        self.mesh = Mesh(vertices, indices, normals, uvs)
+    
+    def _create_default_waves(self):
+        """Создаёт волны по умолчанию"""
+        wave1 = WaveParameters()
+        wave1.amplitude = 0.5
+        wave1.frequency = 0.3
+        wave1.direction = np.array([1.0, 0.3], dtype=np.float32)
+        wave1.wavelength = 8.0
+        
+        wave2 = WaveParameters()
+        wave2.amplitude = 0.3
+        wave2.frequency = 0.5
+        wave2.direction = np.array([-0.5, 0.7], dtype=np.float32)
+        wave2.wavelength = 5.0
+        
+        wave3 = WaveParameters()
+        wave3.amplitude = 0.2
+        wave3.frequency = 0.7
+        wave3.direction = np.array([0.2, -0.8], dtype=np.float32)
+        wave3.wavelength = 3.0
+        
+        self.waves = [wave1, wave2, wave3]
+    
+    def _setup_shader(self):
+        """Настройка шейдера воды"""
+        vertex_shader = """
+        #version 460 core
+        layout(location = 0) in vec3 aPos;
+        layout(location = 1) in vec3 aNormal;
+        layout(location = 2) in vec2 aTexCoord;
+        
+        out vec3 FragPos;
+        out vec3 Normal;
+        out vec2 TexCoord;
+        out vec4 ClipSpace;
+        out vec3 ViewPos;
+        
+        uniform mat4 model;
+        uniform mat4 view;
+        uniform mat4 projection;
+        uniform float time;
+        
+        // Wave parameters
+        uniform int waveCount;
+        uniform float amplitudes[8];
+        uniform float frequencies[8];
+        uniform float speeds[8];
+        uniform vec2 directions[8];
+        uniform float steepnesses[8];
+        uniform float wavelengths[8];
+        
+        float wave(int i, vec2 pos, float time) {
+            float freq = frequencies[i];
+            float amp = amplitudes[i];
+            float speed = speeds[i];
+            vec2 dir = normalize(directions[i]);
+            float steep = steepnesses[i];
+            float wl = wavelengths[i];
+            
+            float f = 2.0 * 3.14159 / wl;
+            float phase = speed * 2.0 / wl;
+            float theta = dot(dir, pos) * f + time * phase;
+            
+            return amp * sin(theta);
+        }
+        
+        float waveDerivativeX(int i, vec2 pos, float time) {
+            float freq = frequencies[i];
+            float amp = amplitudes[i];
+            float speed = speeds[i];
+            vec2 dir = normalize(directions[i]);
+            float steep = steepnesses[i];
+            float wl = wavelengths[i];
+            
+            float f = 2.0 * 3.14159 / wl;
+            float phase = speed * 2.0 / wl;
+            float theta = dot(dir, pos) * f + time * phase;
+            
+            return amp * dir.x * f * cos(theta);
+        }
+        
+        float waveDerivativeZ(int i, vec2 pos, float time) {
+            float freq = frequencies[i];
+            float amp = amplitudes[i];
+            float speed = speeds[i];
+            vec2 dir = normalize(directions[i]);
+            float steep = steepnesses[i];
+            float wl = wavelengths[i];
+            
+            float f = 2.0 * 3.14159 / wl;
+            float phase = speed * 2.0 / wl;
+            float theta = dot(dir, pos) * f + time * phase;
+            
+            return amp * dir.y * f * cos(theta);
+        }
+        
+        void main() {
+            vec3 pos = aPos;
+            
+            // Применяем волны
+            vec2 xz = pos.xz;
+            for (int i = 0; i < waveCount && i < 8; i++) {
+                pos.y += wave(i, xz, time);
+            }
+            
+            // Вычисляем нормаль
+            float dx = 0.0;
+            float dz = 0.0;
+            for (int i = 0; i < waveCount && i < 8; i++) {
+                dx += waveDerivativeX(i, xz, time);
+                dz += waveDerivativeZ(i, xz, time);
+            }
+            
+            vec3 calcNormal = normalize(vec3(-dx, 1.0, -dz));
+            
+            vec4 worldPos = model * vec4(pos, 1.0);
+            
+            FragPos = worldPos.xyz;
+            Normal = mat3(transpose(inverse(model))) * calcNormal;
+            TexCoord = aTexCoord;
+            ClipSpace = projection * view * worldPos;
+            ViewPos = (inverse(view) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+            
+            gl_Position = ClipSpace;
+        }
+        """
+        
+        fragment_shader = """
+        #version 460 core
+        in vec3 FragPos;
+        in vec3 Normal;
+        in vec2 TexCoord;
+        in vec4 ClipSpace;
+        in vec3 ViewPos;
+        
+        out vec4 FragColor;
+        
+        uniform vec3 waterColor;
+        uniform vec3 foamColor;
+        uniform float transparency;
+        uniform float reflectivity;
+        uniform float fresnelPower;
+        uniform float time;
+        uniform sampler2D reflectionTexture;
+        uniform sampler2D refractionTexture;
+        uniform sampler2D foamTexture;
+        uniform sampler2D normalMap;
+        
+        void main() {
+            vec3 N = normalize(Normal);
+            vec3 V = normalize(ViewPos - FragPos);
+            
+            // Fresnel эффект
+            float fresnel = pow(1.0 - max(dot(N, V), 0.0), fresnelPower);
+            fresnel = mix(0.04, 1.0, fresnel);
+            
+            // Отражение
+            vec2 ndc = (ClipSpace.xy / ClipSpace.w) * 0.5 + 0.5;
+            vec3 reflection = texture(reflectionTexture, ndc).rgb;
+            
+            // Преломление
+            vec3 refraction = texture(refractionTexture, ndc).rgb;
+            
+            // Искажение через normal map
+            vec2 distortion = texture(normalMap, TexCoord * 10.0 + time * 0.05).rg * 0.02;
+            vec2 distortedUV = ndc + distortion;
+            
+            reflection = texture(reflectionTexture, distortedUV).rgb;
+            refraction = texture(refractionTexture, distortedUV).rgb;
+            
+            // Комбинируем
+            vec3 color = mix(refraction, reflection, fresnel * reflectivity);
+            color = mix(color, waterColor, 0.3);
+            
+            // Пена на гребнях волн
+            float foam = texture(foamTexture, TexCoord * 5.0 + time * 0.1).r;
+            foam *= pow(fresnel, 0.5);
+            color = mix(color, foamColor, foam * 0.3);
+            
+            // Прозрачность на мелководье
+            float depthFactor = 1.0 - exp(-length(FragPos - ViewPos) * 0.1);
+            color = mix(waterColor, color, depthFactor);
+            
+            FragColor = vec4(color, mix(0.8, 1.0, depthFactor));
+        }
+        """
+        
+        from aether.graphics.shader import Shader
+        self.shader = Shader(vertex_shader, fragment_shader)
+    
+    def create_reflection_fbo(self, width: int, height: int):
+        """Создаёт FBO для отражений"""
+        self.reflection_fbo = Framebuffer(width, height)
+    
+    def create_refraction_fbo(self, width: int, height: int):
+        """Создаёт FBO для преломлений"""
+        self.refraction_fbo = Framebuffer(width, height)
+    
+    def begin_reflection(self):
+        """Начинает рендеринг отражения"""
+        if self.reflection_fbo:
+            self.reflection_fbo.bind()
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+            # Здесь была бы отсекающая плоскость
+    
+    def end_reflection(self):
+        """Заканчивает рендеринг отражения"""
+        Framebuffer.unbind()
+    
+    def begin_refraction(self):
+        """Начинает рендеринг преломления"""
+        if self.refraction_fbo:
+            self.refraction_fbo.bind()
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    def end_refraction(self):
+        """Заканчивает рендеринг преломления"""
+        Framebuffer.unbind()
+    
+    def update(self, dt: float):
+        """Обновляет анимацию воды"""
+        self.time += dt * self.wave_speed
+    
+    def render(self, view: np.ndarray, projection: np.ndarray, 
+               camera_position: np.ndarray):
+        """Рендерит воду"""
+        if not self.mesh or not self.shader:
+            return
+        
+        self.shader.use()
+        
+        # Матрицы
+        model = np.identity(4, dtype=np.float32)
+        model[3, :3] = self.position
+        self.shader.set_mat4("model", model)
+        self.shader.set_mat4("view", view)
+        self.shader.set_mat4("projection", projection)
+        
+        # Время
+        self.shader.set_float("time", self.time)
+        
+        # Параметры волн
+        wave_count = min(len(self.waves), 8)
+        self.shader.set_int("waveCount", wave_count)
+        
+        amplitudes = np.array([w.amplitude for w in self.waves[:8]] + [0] * (8 - wave_count), dtype=np.float32)
+        frequencies = np.array([w.frequency for w in self.waves[:8]] + [0] * (8 - wave_count), dtype=np.float32)
+        speeds = np.array([w.speed for w in self.waves[:8]] + [0] * (8 - wave_count), dtype=np.float32)
+        
+        self.shader.set_vec4("amplitudes", amplitudes[:4])
+        self.shader.set_vec4("frequencies", frequencies[:4])
+        self.shader.set_vec4("speeds", speeds[:4])
+        
+        # Визуальные параметры
+        self.shader.set_vec3("waterColor", self.water_color)
+        self.shader.set_vec3("foamColor", self.foam_color)
+        self.shader.set_float("transparency", self.transparency)
+        self.shader.set_float("reflectivity", self.reflectivity)
+        self.shader.set_float("fresnelPower", self.fresnel_power)
+        
+        # Текстуры отражений/преломлений
+        if self.reflection_fbo:
+            glActiveTexture(GL_TEXTURE0)
+            glBindTexture(GL_TEXTURE_2D, self.reflection_fbo.color_texture)
+            self.shader.set_int("reflectionTexture", 0)
+        
+        if self.refraction_fbo:
+            glActiveTexture(GL_TEXTURE1)
+            glBindTexture(GL_TEXTURE_2D, self.refraction_fbo.color_texture)
+            self.shader.set_int("refractionTexture", 1)
+        
+        self.mesh.draw()
+    
+    def cleanup(self):
+        """Очищает ресурсы"""
+        if self.mesh:
+            self.mesh.cleanup()
+        if self.reflection_fbo:
+            self.reflection_fbo.cleanup()
+        if self.refraction_fbo:
+            self.refraction_fbo.cleanup()
+        print("[Water] Cleanup complete")
+
+
+class Ocean:
+    """Океан (бесконечная вода с LOD)"""
+    
+    def __init__(self, size: float = 1000.0):
+        self.size = size
+        self.patches: dict = {}
+        self.patch_size = 128.0
+        self.load_radius = 3
+        
+        print(f"[Ocean] Created infinite ocean")
+    
+    def update(self, camera_position: np.ndarray):
+        """Обновляет патчи вокруг камеры"""
+        # Определяем, какие патчи должны быть видны
+        cx = int(camera_position[0] // self.patch_size)
+        cz = int(camera_position[2] // self.patch_size)
+        
+        active_patches = set()
+        
+        for x in range(cx - self.load_radius, cx + self.load_radius + 1):
+            for z in range(cz - self.load_radius, cz + self.load_radius + 1):
+                active_patches.add((x, z))
+        
+        # Удаляем невидимые патчи
+        for key in list(self.patches.keys()):
+            if key not in active_patches:
+                self.patches[key].cleanup()
+                del self.patches[key]
+        
+        # Создаём новые патчи
+        for key in active_patches:
+            if key not in self.patches:
+                position = (
+                    key[0] * self.patch_size,
+                    0.0,
+                    key[1] * self.patch_size
+                )
+                patch = WaterBody(self.patch_size, 64, position)
+                self.patches[key] = patch
+    
+    def render(self, view, projection, camera_position):
+        """Рендерит все видимые патчи"""
+        for patch in self.patches.values():
+            patch.render(view, projection, camera_position)