aether-engine 1.0.0__py3-none-any.whl

aether/graphics/post_process.py

@@ -0,0 +1,279 @@
+"""Эффекты пост-обработки: Bloom, SSAO, HDR, DOF"""
+import numpy as np
+from OpenGL.GL import *
+from aether.graphics.shader import Shader
+from aether.graphics.framebuffer import Framebuffer
+
+
+class PostProcessEffect:
+    """Базовый класс эффекта пост-обработки"""
+    
+    def __init__(self, name: str):
+        self.name = name
+        self.enabled = True
+    
+    def apply(self, input_texture: int, output_fbo: Framebuffer, 
+              width: int, height: int):
+        """Применяет эффект"""
+        pass
+
+
+class BloomEffect(PostProcessEffect):
+    """Эффект Bloom (свечение)"""
+    
+    def __init__(self, threshold: float = 1.0, intensity: float = 0.5, 
+                 blur_iterations: int = 5):
+        super().__init__("Bloom")
+        self.threshold = threshold
+        self.intensity = intensity
+        self.blur_iterations = blur_iterations
+        
+        self._setup_shaders()
+        self._setup_buffers()
+    
+    def _setup_shaders(self):
+        """Настройка шейдеров"""
+        threshold_vert = """
+        #version 460 core
+        layout(location = 0) in vec2 aPos;
+        layout(location = 1) in vec2 aTexCoord;
+        out vec2 TexCoord;
+        void main() {
+            gl_Position = vec4(aPos, 0.0, 1.0);
+            TexCoord = aTexCoord;
+        }
+        """
+        
+        threshold_frag = """
+        #version 460 core
+        in vec2 TexCoord;
+        out vec4 FragColor;
+        uniform sampler2D sceneTexture;
+        uniform float threshold;
+        void main() {
+            vec3 color = texture(sceneTexture, TexCoord).rgb;
+            float brightness = dot(color, vec3(0.2126, 0.7152, 0.0722));
+            if (brightness > threshold) {
+                FragColor = vec4(color, 1.0);
+            } else {
+                FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+            }
+        }
+        """
+        
+        blur_vert = threshold_vert
+        
+        blur_frag = """
+        #version 460 core
+        in vec2 TexCoord;
+        out vec4 FragColor;
+        uniform sampler2D image;
+        uniform bool horizontal;
+        uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+        void main() {
+            vec2 tex_offset = 1.0 / textureSize(image, 0);
+            vec3 result = texture(image, TexCoord).rgb * weight[0];
+            if (horizontal) {
+                for (int i = 1; i < 5; i++) {
+                    result += texture(image, TexCoord + vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
+                    result += texture(image, TexCoord - vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
+                }
+            } else {
+                for (int i = 1; i < 5; i++) {
+                    result += texture(image, TexCoord + vec2(0.0, tex_offset.y * i)).rgb * weight[i];
+                    result += texture(image, TexCoord - vec2(0.0, tex_offset.y * i)).rgb * weight[i];
+                }
+            }
+            FragColor = vec4(result, 1.0);
+        }
+        """
+        
+        final_vert = threshold_vert
+        
+        final_frag = """
+        #version 460 core
+        in vec2 TexCoord;
+        out vec4 FragColor;
+        uniform sampler2D sceneTexture;
+        uniform sampler2D bloomTexture;
+        uniform float bloomIntensity;
+        void main() {
+            vec3 sceneColor = texture(sceneTexture, TexCoord).rgb;
+            vec3 bloomColor = texture(bloomTexture, TexCoord).rgb;
+            vec3 result = sceneColor + bloomColor * bloomIntensity;
+            
+            // HDR tonemapping
+            result = result / (result + vec3(1.0));
+            
+            // Gamma correction
+            result = pow(result, vec3(1.0 / 2.2));
+            
+            FragColor = vec4(result, 1.0);
+        }
+        """
+        
+        from aether.graphics.shader import Shader
+        self.threshold_shader = Shader(threshold_vert, threshold_frag)
+        self.blur_shader = Shader(blur_vert, blur_frag)
+        self.final_shader = Shader(final_vert, final_frag)
+    
+    def _setup_buffers(self):
+        """Создаёт буферы для Bloom"""
+        self.ping_pong_fbos = [Framebuffer(1920, 1080) for _ in range(2)]
+        self.threshold_fbo = Framebuffer(1920, 1080)
+    
+    def apply(self, input_texture: int, output_fbo: Framebuffer,
+              width: int, height: int):
+        """Применяет Bloom эффект"""
+        if not self.enabled:
+            return
+        
+        # 1. Выделяем яркие области
+        self.threshold_fbo.bind()
+        glClear(GL_COLOR_BUFFER_BIT)
+        self.threshold_shader.use()
+        self.threshold_shader.set_float("threshold", self.threshold)
+        glBindTexture(GL_TEXTURE_2D, input_texture)
+        self._render_quad()
+        
+        # 2. Размытие (ping-pong)
+        horizontal = True
+        first_iteration = True
+        
+        for i in range(self.blur_iterations):
+            self.ping_pong_fbos[1 if horizontal else 0].bind()
+            glClear(GL_COLOR_BUFFER_BIT)
+            self.blur_shader.use()
+            self.blur_shader.set_bool("horizontal", horizontal)
+            
+            if first_iteration:
+                glBindTexture(GL_TEXTURE_2D, self.threshold_fbo.color_texture)
+                first_iteration = False
+            else:
+                glBindTexture(GL_TEXTURE_2D, 
+                    self.ping_pong_fbos[0 if horizontal else 1].color_texture)
+            
+            self._render_quad()
+            horizontal = not horizontal
+        
+        # 3. Комбинируем с исходным изображением
+        output_fbo.bind()
+        glClear(GL_COLOR_BUFFER_BIT)
+        self.final_shader.use()
+        self.final_shader.set_float("bloomIntensity", self.intensity)
+        
+        glActiveTexture(GL_TEXTURE0)
+        glBindTexture(GL_TEXTURE_2D, input_texture)
+        self.final_shader.set_int("sceneTexture", 0)
+        
+        glActiveTexture(GL_TEXTURE1)
+        glBindTexture(GL_TEXTURE_2D, self.ping_pong_fbos[0].color_texture)
+        self.final_shader.set_int("bloomTexture", 1)
+        
+        self._render_quad()
+    
+    def _render_quad(self):
+        """Рендерит полноэкранный quad"""
+        vertices = np.array([
+            -1, -1, 0, 0,
+             1, -1, 1, 0,
+             1,  1, 1, 1,
+            -1,  1, 0, 1,
+        ], dtype=np.float32)
+        
+        # Простой рендеринг quad (можно вынести в общий метод)
+        vao = glGenVertexArrays(1)
+        vbo = glGenBuffers(1)
+        glBindVertexArray(vao)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo)
+        glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4*4, ctypes.c_void_p(0))
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4*4, ctypes.c_void_p(8))
+        glEnableVertexAttribArray(1)
+        
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4)
+        
+        glDeleteVertexArrays(1, [vao])
+        glDeleteBuffers(1, [vbo])
+
+
+class SSAOEffect(PostProcessEffect):
+    """Screen Space Ambient Occlusion"""
+    
+    def __init__(self, radius: float = 0.5, bias: float = 0.025, 
+                 sample_count: int = 64):
+        super().__init__("SSAO")
+        self.radius = radius
+        self.bias = bias
+        self.sample_count = sample_count
+        
+        self._generate_samples()
+        self._generate_noise()
+    
+    def _generate_samples(self):
+        """Генерирует сэмплы в полусфере"""
+        self.samples = []
+        for _ in range(self.sample_count):
+            sample = np.array([
+                np.random.uniform(-1, 1),
+                np.random.uniform(-1, 1),
+                np.random.uniform(0, 1)
+            ], dtype=np.float32)
+            sample = sample / np.linalg.norm(sample)
+            sample *= np.random.uniform(0, 1)
+            
+            # Больше сэмплов ближе к центру
+            scale = _ / self.sample_count
+            scale = 0.1 + 0.9 * scale * scale
+            sample *= scale
+            
+            self.samples.append(sample)
+        
+        self.samples = np.array(self.samples, dtype=np.float32)
+    
+    def _generate_noise(self):
+        """Генерирует шум для поворота сэмплов"""
+        self.noise = np.random.randn(16, 3).astype(np.float32)
+    
+    def apply(self, input_texture: int, output_fbo: Framebuffer,
+              width: int, height: int):
+        """Применяет SSAO"""
+        # TODO: реализовать SSAO шейдер
+        pass
+
+
+class PostProcessStack:
+    """Стек пост-обработки"""
+    
+    def __init__(self, width: int, height: int):
+        self.width = width
+        self.height = height
+        self.effects = []
+        
+        # Основные буферы
+        self.scene_fbo = Framebuffer(width, height)
+        self.temp_fbo = Framebuffer(width, height)
+    
+    def add_effect(self, effect: PostProcessEffect):
+        """Добавляет эффект"""
+        self.effects.append(effect)
+    
+    def process(self, input_texture: int) -> int:
+        """Применяет все эффекты по очереди"""
+        current_input = input_texture
+        current_output = self.temp_fbo
+        
+        for effect in self.effects:
+            if effect.enabled:
+                effect.apply(current_input, current_output, self.width, self.height)
+                current_input, current_output = current_output, current_input
+        
+        return current_input
+    
+    def resize(self, width: int, height: int):
+        """Изменяет размер буферов"""
+        self.width = width
+        self.height = height
+        self.scene_fbo = Framebuffer(width, height)
+        self.temp_fbo = Framebuffer(width, height)

aether/graphics/renderer.py

@@ -0,0 +1,135 @@
+"""Главный рендерер с системой Render Pass"""
+from OpenGL.GL import *
+import numpy as np
+from typing import List, Optional
+from aether.graphics.shader import Shader
+from aether.graphics.camera import Camera
+from aether.graphics.shader_library import ShaderLibrary
+
+
+class RenderPass:
+    """Один проход рендеринга"""
+    
+    def __init__(self, name: str, shader: Shader):
+        self.name = name
+        self.shader = shader
+        self.enabled = True
+        self.clear_color = (0.0, 0.0, 0.0, 1.0)
+        self.clear_flags = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+    
+    def begin(self):
+        """Начало прохода"""
+        if self.enabled:
+            self.shader.use()
+    
+    def end(self):
+        """Конец прохода"""
+        pass
+
+
+class Renderer:
+    """Главный рендерер движка"""
+    
+    def __init__(self, width: int, height: int):
+        self.width = width
+        self.height = height
+        self.clear_color = (0.05, 0.05, 0.1, 1.0)
+        
+        # Статистика
+        self.draw_calls = 0
+        self.triangles = 0
+        
+        # Render Passes
+        self.passes: List[RenderPass] = []
+        
+        # Настройка OpenGL
+        self._setup_opengl()
+        
+        # Создаём стандартные проходы
+        self._create_default_passes()
+        
+        print(f"[Renderer] Initialized ({width}x{height})")
+    
+    def _setup_opengl(self):
+        """Настройка состояния OpenGL"""
+        glClearColor(*self.clear_color)
+        glEnable(GL_DEPTH_TEST)
+        glDepthFunc(GL_LESS)
+        glEnable(GL_CULL_FACE)
+        glCullFace(GL_BACK)
+        glEnable(GL_MULTISAMPLE)
+        glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS)
+        
+        # Настройка для PBR
+        glEnable(GL_FRAMEBUFFER_SRGB)
+    
+    def _create_default_passes(self):
+        """Создаёт стандартные проходы рендеринга"""
+        shader_lib = ShaderLibrary()
+        
+        # Основной проход (PBR)
+        pbr_pass = RenderPass("PBR", shader_lib.get_pbr_shader())
+        self.passes.append(pbr_pass)
+        
+        # Можно добавить: Shadow Pass, UI Pass, Post-process Pass
+        print(f"[Renderer] Created {len(self.passes)} render passes")
+    
+    def begin_frame(self):
+        """Начало кадра"""
+        self.draw_calls = 0
+        self.triangles = 0
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+        glClearColor(*self.clear_color)
+    
+    def render_scene(self, scene):
+        """Рендерит сцену"""
+        if not scene:
+            return
+        
+        camera = scene.main_camera
+        if not camera:
+            return
+        
+        # Обновляем матрицы
+        projection = camera.get_projection_matrix(self.width / self.height)
+        view = camera.get_view_matrix()
+        view_pos = camera.position
+        
+        for render_pass in self.passes:
+            if not render_pass.enabled:
+                continue
+            
+            render_pass.begin()
+            shader = render_pass.shader
+            
+            # Устанавливаем общие uniform-ы
+            shader.set_mat4("projection", projection)
+            shader.set_mat4("view", view)
+            shader.set_vec3("viewPos", view_pos)
+            
+            # Рендерим все объекты
+            for entity in scene.entities:
+                if not entity.enabled:
+                    continue
+                
+                mesh_renderer = entity.get_component("MeshRenderer")
+                if mesh_renderer and mesh_renderer.enabled and mesh_renderer.visible:
+                    mesh_renderer.render(view, projection)
+                    self.draw_calls += 1
+            
+            render_pass.end()
+    
+    def end_frame(self):
+        """Конец кадра"""
+        pass
+    
+    def resize(self, width: int, height: int):
+        """Обработчик изменения размера окна"""
+        self.width = width
+        self.height = height
+        glViewport(0, 0, width, height)
+        print(f"[Renderer] Resized to {width}x{height}")
+    
+    def cleanup(self):
+        """Очистка ресурсов"""
+        print("[Renderer] Cleanup complete")

aether/graphics/shader.py

@@ -0,0 +1,61 @@
+"""Загрузка и компиляция шейдеров"""
+from OpenGL.GL import *
+from OpenGL.GL.shaders import compileProgram, compileShader
+import numpy as np
+
+
+class Shader:
+    _cache = {}
+    
+    def __init__(self, vertex_source: str, fragment_source: str):
+        self.program = compileProgram(
+            compileShader(vertex_source, GL_VERTEX_SHADER),
+            compileShader(fragment_source, GL_FRAGMENT_SHADER)
+        )
+        self._uniform_locations = {}
+    
+    @classmethod
+    def from_files(cls, vertex_path: str, fragment_path: str) -> 'Shader':
+        cache_key = (vertex_path, fragment_path)
+        if cache_key in cls._cache:
+            return cls._cache[cache_key]
+        
+        with open(vertex_path, 'r') as f:
+            vert = f.read()
+        with open(fragment_path, 'r') as f:
+            frag = f.read()
+        
+        shader = cls(vert, frag)
+        cls._cache[cache_key] = shader
+        return shader
+    
+    def use(self):
+        glUseProgram(self.program)
+    
+    def _get_location(self, name: str):
+        if name not in self._uniform_locations:
+            self._uniform_locations[name] = glGetUniformLocation(self.program, name)
+        return self._uniform_locations[name]
+    
+    def set_mat4(self, name: str, matrix: np.ndarray):
+        loc = self._get_location(name)
+        glUniformMatrix4fv(loc, 1, GL_TRUE, matrix)
+    
+    def set_vec3(self, name: str, vec):
+        loc = self._get_location(name)
+        glUniform3fv(loc, 1, vec)
+    
+    def set_vec4(self, name: str, vec):
+        loc = self._get_location(name)
+        glUniform4fv(loc, 1, vec)
+    
+    def set_float(self, name: str, value: float):
+        loc = self._get_location(name)
+        glUniform1f(loc, value)
+    
+    def set_int(self, name: str, value: int):
+        loc = self._get_location(name)
+        glUniform1i(loc, value)
+    
+    def set_bool(self, name: str, value: bool):
+        self.set_int(name, 1 if value else 0)

aether/graphics/shader_library.py

@@ -0,0 +1,157 @@
+"""Библиотека встроенных шейдеров"""
+from aether.graphics.shader import Shader
+
+
+class ShaderLibrary:
+    """Хранит и кэширует встроенные шейдеры"""
+    
+    # PBR шейдер (Physically Based Rendering)
+    PBR_VERTEX = """
+    #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;
+    
+    uniform mat4 model;
+    uniform mat4 view;
+    uniform mat4 projection;
+    
+    void main() {
+        FragPos = vec3(model * vec4(aPos, 1.0));
+        Normal = mat3(transpose(inverse(model))) * aNormal;
+        TexCoord = aTexCoord;
+        
+        gl_Position = projection * view * vec4(FragPos, 1.0);
+    }
+    """
+    
+    PBR_FRAGMENT = """
+    #version 460 core
+    in vec3 FragPos;
+    in vec3 Normal;
+    in vec2 TexCoord;
+    
+    out vec4 FragColor;
+    
+    uniform vec3 viewPos;
+    uniform vec3 albedo;
+    uniform float metallic;
+    uniform float roughness;
+    uniform float ao;
+    
+    // Источники света
+    struct DirectionalLight {
+        vec3 direction;
+        vec3 color;
+        float intensity;
+    };
+    
+    uniform DirectionalLight sunLight;
+    
+    const float PI = 3.14159265359;
+    
+    float DistributionGGX(vec3 N, vec3 H, float roughness) {
+        float a = roughness * roughness;
+        float a2 = a * a;
+        float NdotH = max(dot(N, H), 0.0);
+        float NdotH2 = NdotH * NdotH;
+        
+        float nom = a2;
+        float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+        denom = PI * denom * denom;
+        
+        return nom / denom;
+    }
+    
+    float GeometrySchlickGGX(float NdotV, float roughness) {
+        float r = roughness + 1.0;
+        float k = (r * r) / 8.0;
+        
+        float nom = NdotV;
+        float denom = NdotV * (1.0 - k) + k;
+        
+        return nom / denom;
+    }
+    
+    float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
+        float NdotV = max(dot(N, V), 0.0);
+        float NdotL = max(dot(N, L), 0.0);
+        float ggx2 = GeometrySchlickGGX(NdotV, roughness);
+        float ggx1 = GeometrySchlickGGX(NdotL, roughness);
+        
+        return ggx1 * ggx2;
+    }
+    
+    vec3 FresnelSchlick(float cosTheta, vec3 F0) {
+        return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
+    }
+    
+    void main() {
+        vec3 N = normalize(Normal);
+        vec3 V = normalize(viewPos - FragPos);
+        
+        vec3 F0 = vec3(0.04);
+        F0 = mix(F0, albedo, metallic);
+        
+        // Освещение от солнца
+        vec3 L = normalize(-sunLight.direction);
+        vec3 H = normalize(V + L);
+        
+        // Радианс источника
+        vec3 radiance = sunLight.color * sunLight.intensity;
+        
+        // Cook-Torrance BRDF
+        float NDF = DistributionGGX(N, H, roughness);
+        float G = GeometrySmith(N, V, L, roughness);
+        vec3 F = FresnelSchlick(max(dot(H, V), 0.0), F0);
+        
+        vec3 kS = F;
+        vec3 kD = (vec3(1.0) - kS) * (1.0 - metallic);
+        
+        vec3 numerator = NDF * G * F;
+        float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0) + 0.0001;
+        vec3 specular = numerator / denominator;
+        
+        float NdotL = max(dot(N, L), 0.0);
+        vec3 Lo = (kD * albedo / PI + specular) * radiance * NdotL;
+        
+        // Ambient
+        vec3 ambient = vec3(0.03) * albedo * ao;
+        vec3 color = ambient + Lo;
+        
+        // HDR tonemapping
+        color = color / (color + vec3(1.0));
+        
+        // Gamma correction
+        color = pow(color, vec3(1.0/2.2));
+        
+        FragColor = vec4(color, 1.0);
+    }
+    """
+    
+    _instance = None
+    _shaders = {}
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def get_pbr_shader(self) -> Shader:
+        """Возвращает PBR шейдер"""
+        if 'pbr' not in self._shaders:
+            self._shaders['pbr'] = Shader(self.PBR_VERTEX, self.PBR_FRAGMENT)
+        return self._shaders['pbr']
+    
+    def get_shader(self, name: str) -> Shader:
+        """Получает шейдер по имени"""
+        return self._shaders.get(name)
+    
+    def preload_all(self):
+        """Предзагружает все встроенные шейдеры"""
+        self.get_pbr_shader()
+        print("[ShaderLibrary] All shaders preloaded")