aether-engine 1.0.0__py3-none-any.whl

aether/graphics/sky_atmosphere.py

@@ -0,0 +1,309 @@
+"""Система неба, атмосферы и освещения окружения"""
+import numpy as np
+from OpenGL.GL import *
+from typing import Optional, Tuple
+from aether.graphics.shader import Shader
+from aether.graphics.mesh_factory import MeshFactory
+from aether.graphics.mesh import Mesh
+from aether.graphics.texture import Texture
+
+
+class SkyDome:
+    """Купол неба с процедурной генерацией"""
+    
+    def __init__(self, radius: float = 500.0):
+        self.radius = radius
+        self.mesh: Optional[Mesh] = None
+        
+        # Параметры неба
+        self.sun_position = np.array([100.0, 100.0, 0.0], dtype=np.float32)
+        self.sun_color = np.array([1.0, 0.9, 0.7], dtype=np.float32)
+        self.sun_intensity = 1.5
+        self.sun_disk_size = 5.0
+        
+        # Цвета неба
+        self.sky_top_color = np.array([0.3, 0.5, 0.9], dtype=np.float32)
+        self.sky_horizon_color = np.array([0.7, 0.8, 1.0], dtype=np.float32)
+        self.sky_bottom_color = np.array([0.4, 0.4, 0.5], dtype=np.float32)
+        
+        # Атмосфера
+        self.atmosphere_density = 1.0
+        self.mie_scattering = 0.1
+        self.rayleigh_scattering = 0.5
+        
+        # Генерация
+        self._generate_mesh()
+        self._setup_shader()
+        
+        print(f"[SkyDome] Created (radius: {radius})")
+    
+    def _generate_mesh(self):
+        """Генерирует сферу для неба"""
+        self.mesh = MeshFactory.create_sphere(self.radius, 64)
+    
+    def _setup_shader(self):
+        """Настройка шейдера неба"""
+        vertex_shader = """
+        #version 460 core
+        layout(location = 0) in vec3 aPos;
+        
+        out vec3 WorldPos;
+        out vec3 LocalPos;
+        
+        uniform mat4 model;
+        uniform mat4 view;
+        uniform mat4 projection;
+        
+        void main() {
+            vec4 worldPos = model * vec4(aPos, 1.0);
+            WorldPos = worldPos.xyz;
+            LocalPos = aPos;
+            
+            // Отключаем трансляцию для неба
+            mat4 skyView = mat4(mat3(view));
+            gl_Position = projection * skyView * worldPos;
+        }
+        """
+        
+        fragment_shader = """
+        #version 460 core
+        in vec3 WorldPos;
+        in vec3 LocalPos;
+        
+        out vec4 FragColor;
+        
+        uniform vec3 sunPosition;
+        uniform vec3 sunColor;
+        uniform float sunIntensity;
+        uniform float sunDiskSize;
+        
+        uniform vec3 skyTopColor;
+        uniform vec3 skyHorizonColor;
+        uniform vec3 skyBottomColor;
+        
+        uniform float atmosphereDensity;
+        uniform float mieScattering;
+        uniform float rayleighScattering;
+        
+        void main() {
+            vec3 pos = normalize(LocalPos);
+            vec3 sunDir = normalize(sunPosition);
+            
+            // Высота (для градиента неба)
+            float height = pos.y;
+            float horizonBlend = 1.0 - abs(height);
+            horizonBlend = pow(horizonBlend, 2.0);
+            
+            // Базовый градиент неба
+            vec3 skyGradient;
+            if (height > 0.0) {
+                skyGradient = mix(skyHorizonColor, skyTopColor, pow(height, 0.5));
+            } else {
+                skyGradient = mix(skyBottomColor, skyHorizonColor, pow(abs(height), 0.5));
+            }
+            
+            // Солнце
+            float sunAngle = dot(pos, sunDir);
+            float sunDisk = smoothstep(1.0 - sunDiskSize * 0.001, 
+                                       1.0 - sunDiskSize * 0.002, 
+                                       sunAngle);
+            
+            // Ореол вокруг солнца
+            float sunGlow = exp(sunAngle * 20.0 - 20.0) * 0.5;
+            float sunHalo = pow(max(sunAngle, 0.0), 100.0) * 0.3;
+            
+            vec3 sunContribution = sunColor * sunIntensity * (sunDisk + sunGlow + sunHalo);
+            
+            // Рэлеевское рассеяние (голубой цвет)
+            float rayleigh = pow(1.0 - abs(height), rayleighScattering * 5.0);
+            vec3 rayleighColor = vec3(0.3, 0.5, 0.9);
+            
+            // Ми-рассеяние (белый цвет вокруг солнца)
+            float mie = exp(-(1.0 - sunAngle) * mieScattering * 10.0);
+            vec3 mieColor = vec3(1.0, 0.9, 0.7);
+            
+            // Комбинируем
+            vec3 atmosphere = rayleighColor * rayleigh * atmosphereDensity;
+            atmosphere += mieColor * mie * atmosphereDensity * 0.5;
+            
+            vec3 finalColor = skyGradient + atmosphere + sunContribution;
+            
+            // HDR tonemapping
+            finalColor = finalColor / (finalColor + vec3(1.0));
+            
+            FragColor = vec4(finalColor, 1.0);
+        }
+        """
+        
+        from aether.graphics.shader import Shader
+        self.shader = Shader(vertex_shader, fragment_shader)
+    
+    def set_time_of_day(self, time: float):
+        """Устанавливает время суток (0.0 - 24.0)"""
+        # Вычисляем позицию солнца
+        angle = (time - 6.0) * np.pi / 12.0  # Восход в 6, закат в 18
+        
+        self.sun_position = np.array([
+            np.cos(angle) * 500.0,
+            np.sin(angle) * 500.0,
+            0.0
+        ], dtype=np.float32)
+        
+        # Меняем цвета в зависимости от времени
+        if 6 <= time <= 18:  # День
+            t = (time - 6) / 12
+            self.sky_top_color = np.array([0.3, 0.5 + t * 0.2, 0.9], dtype=np.float32)
+            self.sun_intensity = 1.5
+        elif time < 6 or time > 18:  # Ночь
+            night_factor = 1.0 if time < 4 or time > 20 else 0.5
+            self.sky_top_color = np.array([0.05, 0.05, 0.15 * night_factor + 0.1], dtype=np.float32)
+            self.sun_intensity = 0.1
+    
+    def render(self, view: np.ndarray, projection: np.ndarray):
+        """Рендерит небо"""
+        if not self.mesh or not self.shader:
+            return
+        
+        glDepthFunc(GL_LEQUAL)
+        glDepthMask(GL_FALSE)
+        
+        self.shader.use()
+        
+        model = np.identity(4, dtype=np.float32)
+        self.shader.set_mat4("model", model)
+        self.shader.set_mat4("view", view)
+        self.shader.set_mat4("projection", projection)
+        
+        # Параметры солнца
+        self.shader.set_vec3("sunPosition", self.sun_position)
+        self.shader.set_vec3("sunColor", self.sun_color)
+        self.shader.set_float("sunIntensity", self.sun_intensity)
+        self.shader.set_float("sunDiskSize", self.sun_disk_size)
+        
+        # Цвета неба
+        self.shader.set_vec3("skyTopColor", self.sky_top_color)
+        self.shader.set_vec3("skyHorizonColor", self.sky_horizon_color)
+        self.shader.set_vec3("skyBottomColor", self.sky_bottom_color)
+        
+        # Атмосфера
+        self.shader.set_float("atmosphereDensity", self.atmosphere_density)
+        self.shader.set_float("mieScattering", self.mie_scattering)
+        self.shader.set_float("rayleighScattering", self.rayleigh_scattering)
+        
+        self.mesh.draw()
+        
+        glDepthFunc(GL_LESS)
+        glDepthMask(GL_TRUE)
+
+
+class VolumetricClouds:
+    """Объёмные облака"""
+    
+    def __init__(self, coverage: float = 0.5):
+        self.coverage = coverage
+        self.cloud_scale = 100.0
+        self.cloud_height = 200.0
+        self.cloud_thickness = 50.0
+        
+        self.wind_direction = np.array([1.0, 0.0, 0.0], dtype=np.float32)
+        self.wind_speed = 10.0
+        self.time = 0.0
+        
+        self._setup_shader()
+        print(f"[Clouds] Created (coverage: {coverage})")
+    
+    def _setup_shader(self):
+        """Шейдер объёмных облаков"""
+        vertex_shader = """
+        #version 460 core
+        layout(location = 0) in vec3 aPos;
+        out vec3 WorldPos;
+        uniform mat4 model;
+        uniform mat4 view;
+        uniform mat4 projection;
+        void main() {
+            WorldPos = (model * vec4(aPos, 1.0)).xyz;
+            gl_Position = projection * view * vec4(WorldPos, 1.0);
+        }
+        """
+        
+        fragment_shader = """
+        #version 460 core
+        in vec3 WorldPos;
+        out vec4 FragColor;
+        
+        uniform float time;
+        uniform float coverage;
+        uniform float cloudScale;
+        uniform float cloudHeight;
+        uniform float cloudThickness;
+        uniform vec3 windDirection;
+        uniform float windSpeed;
+        uniform vec3 sunPosition;
+        
+        // Шум (можно заменить на текстуру шума)
+        float hash(vec3 p) {
+            p = fract(p * 0.3183099 + 0.1);
+            p *= 17.0;
+            return fract(p.x * p.y * p.z * (p.x + p.y + p.z));
+        }
+        
+        float noise(vec3 p) {
+            vec3 i = floor(p);
+            vec3 f = fract(p);
+            f = f * f * (3.0 - 2.0 * f);
+            
+            return mix(
+                mix(mix(hash(i), hash(i + vec3(1,0,0)), f.x),
+                    mix(hash(i + vec3(0,1,0)), hash(i + vec3(1,1,0)), f.x), f.y),
+                mix(mix(hash(i + vec3(0,0,1)), hash(i + vec3(1,0,1)), f.x),
+                    mix(hash(i + vec3(0,1,1)), hash(i + vec3(1,1,1)), f.x), f.y), f.z);
+        }
+        
+        float fbm(vec3 p) {
+            float value = 0.0;
+            float amplitude = 0.5;
+            float frequency = 1.0;
+            
+            for (int i = 0; i < 4; i++) {
+                value += amplitude * noise(p * frequency);
+                frequency *= 2.0;
+                amplitude *= 0.5;
+            }
+            
+            return value;
+        }
+        
+        void main() {
+            vec3 pos = WorldPos / cloudScale;
+            pos += windDirection * time * windSpeed * 0.01;
+            
+            // Сэмплируем облака
+            float heightFactor = smoothstep(cloudHeight - cloudThickness, cloudHeight, WorldPos.y) *
+                                smoothstep(cloudHeight + cloudThickness, cloudHeight, WorldPos.y);
+            
+            float cloud = fbm(pos);
+            cloud = (cloud - (1.0 - coverage)) / coverage;
+            cloud = clamp(cloud, 0.0, 1.0);
+            cloud *= heightFactor;
+            
+            // Освещение от солнца
+            vec3 sunDir = normalize(sunPosition);
+            float sunLight = max(dot(vec3(0,1,0), sunDir), 0.0);
+            
+            vec3 cloudColor = mix(vec3(0.8, 0.8, 0.8), vec3(1.0, 0.9, 0.7), sunLight * 0.3);
+            cloudColor *= 0.7 + sunLight * 0.3;
+            
+            FragColor = vec4(cloudColor, cloud * 0.7);
+        }
+        """
+        
+        from aether.graphics.shader import Shader
+        self.shader = Shader(vertex_shader, fragment_shader)
+    
+    def update(self, dt: float):
+        self.time += dt
+    
+    def render(self, view, projection):
+        """Рендерит облака"""
+        pass  # Требует специального подхода к рендерингу