using OpenTK . Graphics . OpenGL4; using OpenTK . ...

using OpenTK . Graphics . OpenGL4;
using OpenTK . Mathematics;
using OpenTK . Windowing . GraphicsLibraryFramework;
using StbImageSharp;

namespace Cube
{
public partial class Form1 : Form
{
private int reflectionFBO, reflectionTexture;
private int refractionFBO, refractionTexture;

text
    private const float LogWidth = 9.5f; // Ширина бревна (2 * радиус 4.75f)
    private const float LaneWidth = 30f; // Расстояние между центрами линий

    private float _noseOffset = bodyLength * 0.5f; // Расстояние от центра до носа
    private bool _isInvulnerable = false; // Флаг неуязвимости
    private float _invulnerabilityTimer = 0f;
    private const float InvulnerabilityDuration = 1.0f; // Длительность неуязвимости в секундах
    private float _blinkTimer = 0f;
    private const float BlinkInterval = 0.05f; // Интервал мигания
    private bool _isVisibleDuringBlink = true;

    private const int TEXTURE_UNIT_LOG = 10; // Текстурный юнит для брёвен
    private int _logVao, _logVbo, _logEbo;
    private int _logShaderProgram;
    private List<LogPart> _logParts = new List<LogPart>();
    private List<LogVertex> _logVertices = new List<LogVertex>();
    private List<uint> _logIndices = new List<uint>();
    private List<Log> _logs = new List<Log>();
    private float _logSpawnTimer = 0f;
    private const float LogSpawnInterval = 0.1f; // Интервал появления брёвен
    private float _lastLogZ = 0f; // Для контроля расстояния между брёвнами

    private const int TEXTURE_UNIT_ROCK = 9; // Новый текстурный юнит для камней
    private int _rockVao, _rockVbo, _rockEbo;
    private int _rockShaderProgram;
    private List<RockPart> _rockParts = new List<RockPart>();
    private List<RockVertex> _rockVertices = new List<RockVertex>();
    private List<uint> _rockIndices = new List<uint>();
    private List<Rock> _rocks = new List<Rock>();
    private float _rockSpawnTimer = 0f;
    private const float RockSpawnInterval = 0.05f; // Интервал появления камней
    private float _lastRockZ = 0f; // Для контроля расстояния между камнями

    // Добавляем в начало класса Form1 (рядом с константами для кувшинок)
    private const int TEXTURE_UNIT_BRANCH = 8; // Новый текстурный юнит для веточек
    private int _branchVao, _branchVbo, _branchEbo;
    private int _branchShaderProgram;
    private List<BranchPart> _branchParts = new List<BranchPart>();
    private List<BranchVertex> _branchVertices = new List<BranchVertex>();
    private List<uint> _branchIndices = new List<uint>();
    private List<Branch> _branches = new List<Branch>();
    private float _branchSpawnTimer = 0f;
    private const float BranchSpawnInterval = 0.032f; // Интервал появления веточек

    private const int TEXTURE_UNIT_LILY = 7; // Новый текстурный юнит для кувшинок

    private int _lilyVao, _lilyVbo, _lilyEbo;
    private int _lilyShaderProgram;
    private List<LilyPart> _lilyParts = new List<LilyPart>();
    private List<LilyVertex> _lilyVertices = new List<LilyVertex>();
    private List<uint> _lilyIndices = new List<uint>();
    private List<Lily> _lilies = new List<Lily>();
    private Random _random = new Random();
    private float _lilySpawnTimer = 0f;
    private const float LilySpawnInterval = 0.032f; // Интервал появления новых кувшинок

    private float _laneChangeProgress = 0f; // 0-1, прогресс перестроения
    private const float LaneChangeDuration = 0.5f; // Длительность анимации перестроения в секундах
    private int _targetLane; // Новая переменная для хранения целевой полосы
    private float _currentHeadAngle = 0f;

    private const int TEXTURE_UNIT_BODY = 1;
    private const int TEXTURE_UNIT_FIN = 2;
    private const int TEXTURE_UNIT_FACE = 3;
    private const int TEXTURE_UNIT_EYE = 4;
    private const int TEXTURE_UNIT_PLANE = 5;
    private const int TEXTURE_UNIT_WATER = 6;

    private int _planeVao, _planeVbo, _planeEbo;
    private int _planeShaderProgram;
    private PlanePart _planePart;
    private List<PlaneVertex> _planeVertices = new List<PlaneVertex>();
    private List<uint> _planeIndices = new List<uint>();
    private const float salmonElevation = 7f;

    private int _waterVao, _waterVbo, _waterEbo;
    private int _waterShaderProgram;
    private WaterPart _waterPart;
    private List<WaterVertex> _waterVertices = new List<WaterVertex>();
    private List<uint> _waterIndices = new List<uint>();
    private const float waterHeight = 10.5f;

    private bool _areEyesLocked = false;

    private float _headTurnProgress = 0f; // 0-1, прогресс поворота головы
    private const float HeadTurnSpeed = 5.5f; // Скорость поворота головы
    private Matrix4 _headRotationMatrix = Matrix4.Identity; // Текущая матрица поворота головы

    private bool _isPectoralFinSpecialAnim = false;
    private float _pectoralFinSpecialAnimTime = 0f;
    private const float PectoralFinAnimDuration = 0.5f; // Длительность спец-анимации в секундах
    private const float PectoralFinAnimSpeed = 31f;     // Скорость колебаний
    private const float PectoralFinAnimAmplitude = 4.75f; // Амплитуда колебаний

    private const float VentralFinLockPhaseFactor = 0.8f; // Более агрессивное дрожание
    private const float VentralFinShakeAmplitude = 1.25f; // Сильная амплитуда
    private const float VentralFinShakeSpeed = 15.5f;      // Высокая скорость дрожания
    private bool _areVentralFinsLocked = false;
    private float _lockedVentralFinAngle = 0f;

    private const float LockedTailFinAmplitudeBoost = 1.375f; // Усиление амплитуды при блокировке
    private const float TailFinLockPhaseFactor = 0.7f; // Фактор масштабирования фазы
    private bool _isTailFinLocked = false;
    private float _lockedTailFinAngle = 0f;

    private bool _isTurningLeft = false;
    private bool _isTurningRight = false;
    private float _tailSwingDirection = 0f; // -1 для левого поворота, 1 для правого

    private bool _isLaneChangingAnimation = false;
    private float _laneChangeTailSwing = 0f;
    private readonly float _maxLaneChangeSwing = 100f; // Максимальное отклонение хвоста при перестроении
    private readonly float _laneChangeSwingDecay = 9f; // Скорость затухания отклонения

    private int _currentLane = 1; // 0-левая, 1-центральная, 2-правая
    private readonly float[] _lanePositions = { -30f, 0f, 30f }; // Фиксированные позиции полос
    private bool _isChangingLane = false;
    private float _laneChangeSpeed = 0.5f;
    private float _currentXPosition = 0f;
    private float _turnAnimationProgress = 100f; // Прогресс анимации поворота
    private readonly float _maxTurnAngle = 27.5f; // Максимальный угол поворота тела
    private int _turnDirection = 0; // -1 - влево, 1 - вправо, 0 - нет поворота

    // Анимационные параметры
    private float _wiggleTime = 0f;
    private const float WiggleSpeed = 2.75f;
    private const float MaxWiggleAmplitude = 0.5f;
    private System.Windows.Forms.Timer _animationTimer;
    private bool _isWPressed = false;
    private float _tailSwingAmplitude = 5f;
    private float tailWiggleAmplitude = 0f;

    // Параметры модели лосося
    private const float bodyLength = 30f;
    private const float bodyWidth = 4f;
    private const int bodySegments = 128;
    private const int radialSegments = 128;

    // Углы вращения
    private readonly float _rotationAngleY = 0f;

    // Буферы данных
    private readonly List<Vertex> vertices = [];
    private readonly List<uint> indices = [];
    private readonly List<ModelPart> _salmonParts = [];

    // OpenGL объекты
    private int _salmonVao, _salmonVbo, _salmonEbo;
    private int _shaderProgram;
    private int _headShaderProgram;
    private Matrix4 _projection, _view, _model;

    public struct LogVertex
        {
        public Vector3 Pos;
        public Vector2 TexCoord;

        public static readonly int SizeInBytes = Vector3.SizeInBytes + Vector2.SizeInBytes;

        public LogVertex ( Vector3 pos , Vector2 texCoord )
            {
            Pos = pos;
            TexCoord = texCoord;
            }
        }

    public class LogPart
        {
        public int StartIndex;
        public int IndexCount;
        public int TextureId;
        public Vector4 Color;
        }

    public class Log
        {
        public Vector3 Position;
        public float Rotation;
        public float Scale;
        public float Speed;
        public bool IsActive;
        public int Lane; // 0 - левая, 1 - центральная, 2 - правая
        }

    public struct BranchVertex
        {
        public Vector3 Pos;
        public Vector2 TexCoord;

        public static readonly int SizeInBytes = Vector3.SizeInBytes + Vector2.SizeInBytes;

        public BranchVertex ( Vector3 pos , Vector2 texCoord )
            {
            Pos = pos;
            TexCoord = texCoord;
            }
        }

    public class BranchPart
        {
        public int StartIndex;
        public int IndexCount;
        public int TextureId;
        public Vector4 Color;
        }

    public class Branch
        {
        public Vector3 Position;
        public float Rotation;
        public float Scale;
        public float Speed;
        public bool IsActive;
        }

    public struct LilyVertex
        {
        public Vector3 Pos;
        public Vector2 TexCoord;

        public static readonly int SizeInBytes = Vector3.SizeInBytes + Vector2.SizeInBytes;

        public LilyVertex ( Vector3 pos , Vector2 texCoord )
            {
            Pos = pos;
            TexCoord = texCoord;
            }
        }

    public class LilyPart
        {
        public int StartIndex;
        public int IndexCount;
        public int TextureId;
        public Vector4 Color;
        }

    public class Lily
        {
        public Vector3 Position;
        public float Rotation;
        public float Scale;
        public float Speed;
        public bool IsActive;
        }

    private struct WaterVertex
        {
        public Vector3 Pos;
        public Vector2 TexCoord;

        public static readonly int SizeInBytes = Vector3.SizeInBytes + Vector2.SizeInBytes;

        public WaterVertex ( Vector3 pos , Vector2 texCoord )
            {
            Pos = pos;
            TexCoord = texCoord;
            }
        }
    // Структура для хранения данных вершины
    private struct PlaneVertex
        {
        public Vector3 Pos;
        public Vector2 TexCoord;

        public static readonly int SizeInBytes = Vector3.SizeInBytes + Vector2.SizeInBytes;

        public PlaneVertex ( Vector3 pos , Vector2 texCoord )
            {
            Pos = pos;
            TexCoord = texCoord;
            }
        }
    private struct Vertex
        {
        public Vector3 Pos;
        public Vector2 TexCoordBody;
        public Vector2 TexCoordFin;
        public Vector2 TexCoordFace;
        public Vector2 TexCoordEye;

        public static readonly int SizeInBytes = Vector3.SizeInBytes + (4 * Vector2.SizeInBytes);

        public Vertex ( Vector3 pos , Vector2 texBody , Vector2 texFin , Vector2 texFace , Vector2 texEye )
            {
            Pos = pos;
            TexCoordBody = texBody;
            TexCoordFin = texFin;
            TexCoordFace = texFace;
            TexCoordEye = texEye;
            }
        }

    private class WaterPart
        {
        public int StartIndex;
        public int IndexCount;
        public Vector4 Color;
        public int TextureId;
        }
    // Класс для хранения частей модели
    private class PlanePart
        {
        public int StartIndex;
        public int IndexCount;
        public int TextureId;
        public Vector4 Color;
        }
    private class ModelPart
        {
        public int StartIndex;
        public int IndexCount;
        public Vector4 Color;
        public bool IsVisible;
        public int TextureId;
        }

    public struct RockVertex
        {
        public Vector3 Pos;
        public Vector2 TexCoord;

        public static readonly int SizeInBytes = Vector3.SizeInBytes + Vector2.SizeInBytes;

        public RockVertex ( Vector3 pos , Vector2 texCoord )
            {
            Pos = pos;
            TexCoord = texCoord;
            }
        }

    public class RockPart
        {
        public int StartIndex;
        public int IndexCount;
        public int TextureId;
        public Vector4 Color;
        }

    public class Rock
        {
        public Vector3 Position;
        public float Rotation;
        public float Scale;
        public float Speed;
        public bool IsActive;
        public int Lane; // 0 - левая, 1 - центральная, 2 - правая
        }

    // В метод InitializeLilies() добавляем инициализацию камней

    private void InitializeLogs ( )
        {
        CreateLogGeometry ( );
        InitializeLogBuffers ( );
        InitializeLogShaders ( );
        LoadTexture ( "D:\\Cube\\log_texture.jpg" , TEXTURE_UNIT_LOG , TextureWrapMode . Repeat , TextureWrapMode . Repeat );
        }

    private void InitializeRocks ( )
        {
        CreateRockGeometry ( );
        InitializeRockBuffers ( );
        InitializeRockShaders ( );
        LoadTexture ( "D:\\Cube\\rock_texture.jpg" , TEXTURE_UNIT_ROCK , TextureWrapMode . Repeat , TextureWrapMode . Repeat );
        }

    private void CreateLogGeometry ( )
        {
        const int segments = 32;
        const float length = 55f;
        const float radius = 4.75f;
        const float barkRoughness = 0.15f;
        const float underwaterRatio = 0.0f;

        Random rand = new Random(42);

        // Основная геометрия бревна (без изменений)
        for ( int i = 0 ; i <= segments ; i++ )
            {
            float v = (float)i / segments;
            float z = length * (v - underwaterRatio);

            for ( int j = 0 ; j <= segments ; j++ )
                {
                float u = (float)j / segments;
                float angle = u * MathHelper.TwoPi;

                float noise = barkRoughness * (float)(rand.NextDouble() - 0.5);
                float currentRadius = radius * (1 + noise);

                float x = currentRadius * MathF.Cos(angle);
                float y = currentRadius * MathF.Sin(angle);

                _logVertices . Add ( new LogVertex (
                    new Vector3 ( x , y , z ) ,
                    new Vector2 ( u , v )
                ) );
                }
            }

        // Крышки бревна (без изменений)
        for ( int cap = 0 ; cap < 2 ; cap++ )
            {
            float z = length * (cap - underwaterRatio);

            _logVertices . Add ( new LogVertex (
                new Vector3 ( 0 , 0 , z ) ,
                new Vector2 ( 0.5f , 0.5f )
            ) );

            for ( int i = 0 ; i <= segments ; i++ )
                {
                float angle = (float)i / segments * MathHelper.TwoPi;
                float x = radius * MathF.Cos(angle);
                float y = radius * MathF.Sin(angle);

                _logVertices . Add ( new LogVertex (
                    new Vector3 ( x , y , z ) ,
                    new Vector2 ( 0.5f + ( 0.5f * MathF . Cos ( angle ) ) ,
                    0.5f + ( 0.5f * MathF . Sin ( angle ) ) )
                ) );
                }
            }

        // Добавляем сучок (маленькая веточка) с правильной 3D формой
        const int knotSegments = 8;
        float knotLength = radius * 0.8f;
        float knotRadius = radius * 0.4f;
        float knotZ = length * 0.7f;

        for ( int i = 0 ; i <= knotSegments ; i++ )
            {
            float t = (float)i / knotSegments;
            float currentRadius = knotRadius * (1 - t * 0.5f); // Сужаем к концу

            // Базовая позиция на поверхности бревна
            float angle = MathHelper.PiOver2;
            float x = radius * MathF.Cos(angle);
            float y = radius * MathF.Sin(angle);

            // Изгиб сучка
            float bend = MathF.Sin(t * MathHelper.Pi) * 0.3f;
            Vector3 basePos = new Vector3(
        x + bend * knotLength,
        y + t * knotLength,
        knotZ
    );

            // Направление роста ветки (касательная к изгибу)
            Vector3 tangent = Vector3.Normalize(new Vector3(
        bend * MathF.Cos(t * MathHelper.Pi) * knotLength,
        knotLength,
        0
    ));
            Vector3 normal = Vector3.Normalize(new Vector3(0, 0, 1));
            Vector3 binormal = Vector3.Cross(tangent, normal);

            for ( int j = 0 ; j <= knotSegments ; j++ )
                {
                float u = (float)j / knotSegments;
                float angleKnot = u * MathHelper.TwoPi;

                // Создаем круглое сечение, перпендикулярное направлению ветки
                Vector3 offset =
            normal * (currentRadius * MathF.Cos(angleKnot)) +
            binormal * (currentRadius * MathF.Sin(angleKnot));

                _logVertices . Add ( new LogVertex (
                    basePos + offset ,
                    new Vector2 ( u , t )
                ) );
                }
            }

        // Добавляем большую изогнутую ветку с правильной 3D формой
        const int branchSegments = 16;
        float branchLength = radius * 2.5f;
        float branchRadius = radius * 0.25f;
        float branchZ = length * 0.3f;

        for ( int i = 0 ; i <= branchSegments ; i++ )
            {
            float t = (float)i / branchSegments;
            float currentRadius = branchRadius * (1 - t * 0.3f); // Сужаем к концу

            // Позиция основания ветки на бревне
            float angle = MathHelper.PiOver2;
            float x = radius * MathF.Cos(angle);
            float y = radius * MathF.Sin(angle);

            // Изгиб ветки (более сложная кривая)
            float curveX = MathF.Sin(t * MathHelper.Pi * 1.5f) * branchLength * 0.5f;
            float curveY = t * branchLength;
            float curveZ = MathF.Sin(t * MathHelper.Pi) * branchLength * 0.2f;

            Vector3 basePos = new Vector3(
        x + curveX,
        y + curveY,
        branchZ + curveZ
    );

            // Касательная к кривой (направление ветки)
            Vector3 tangent = Vector3.Normalize(new Vector3(
        MathF.Cos(t * MathHelper.Pi * 1.5f) * 1.5f * branchLength * 0.5f,
        branchLength,
        MathF.Cos(t * MathHelper.Pi) * branchLength * 0.2f
    ));

            // Вычисляем нормаль и бинормаль для правильного сечения
            Vector3 up = Vector3.UnitY;
            Vector3 normal = Vector3.Normalize(Vector3.Cross(tangent, up));
            Vector3 binormal = Vector3.Cross(tangent, normal);

            for ( int j = 0 ; j <= branchSegments ; j++ )
                {
                float u = (float)j / branchSegments;
                float angleBranch = u * MathHelper.TwoPi;

                // Создаем круглое сечение, перпендикулярное направлению ветки
                Vector3 offset =
            normal * (currentRadius * MathF.Cos(angleBranch)) +
            binormal * (currentRadius * MathF.Sin(angleBranch));

                _logVertices . Add ( new LogVertex (
                    basePos + offset ,
                    new Vector2 ( u , t )
                ) );
                }
            }

        // Добавляем первую дополнительную тонкую ветку (левая сторона)
        const int smallBranch1Segments = 12;
        float smallBranch1Length = branchLength * 1.5f;
        float smallBranch1Radius = branchRadius * 0.6f;
        float smallBranch1Z = length * 0.2f;

        for ( int i = 0 ; i <= smallBranch1Segments ; i++ )
            {
            float t = (float)i / smallBranch1Segments;
            float currentRadius = smallBranch1Radius * (1 - t * 0.4f);

            // Позиция основания ветки на бревне - ЛЕВАЯ СТОРОНА (Pi, а не Pi/2)
            float angle = MathHelper.Pi; // 180 градусов - левая сторона
            float x = radius * MathF.Cos(angle);
            float y = radius * MathF.Sin(angle); // Будет 0, так как sin(Pi) = 0

            // Изгиб ветки - теперь растет вверх и немного вперед
            float curveX = -MathF.Sin(t * MathHelper.Pi * 0.8f) * smallBranch1Length * 0.3f; // Влево
            float curveY = t * smallBranch1Length * 0.8f; // Вверх
            float curveZ = MathF.Cos(t * MathHelper.Pi * 0.5f) * smallBranch1Length * 0.2f; // Вдоль бревна

            Vector3 basePos = new Vector3(
    x + curveX,
    y + curveY, // Растем вверх от боковой позиции
    smallBranch1Z + curveZ
);

            // Касательная к кривой (направление роста)
            Vector3 tangent = Vector3.Normalize(new Vector3(
    -MathF.Cos(t * MathHelper.Pi * 0.8f) * 0.8f * smallBranch1Length * 0.3f,
    smallBranch1Length * 0.8f,
    -MathF.Sin(t * MathHelper.Pi * 0.5f) * smallBranch1Length * 0.2f * 0.5f
));

            // Система координат для сечения
            Vector3 up = Vector3.UnitY;
            Vector3 normal = Vector3.Normalize(Vector3.Cross(tangent, up));
            Vector3 binormal = Vector3.Cross(tangent, normal);

            for ( int j = 0 ; j <= smallBranch1Segments ; j++ )
                {
                float u = (float)j / smallBranch1Segments;
                float angleBranch = u * MathHelper.TwoPi;

                Vector3 offset =
        normal * (currentRadius * MathF.Cos(angleBranch)) +
        binormal * (currentRadius * MathF.Sin(angleBranch));

                _logVertices . Add ( new LogVertex (
                    basePos + offset ,
                    new Vector2 ( u , t )
                ) );
                }
            }

        // Добавляем вторую дополнительную тонкую ветку (правая сторона)
        const int smallBranch2Segments = 12;
        float smallBranch2Length = branchLength * 0.75f;
        float smallBranch2Radius = branchRadius * 0.5f;
        float smallBranch2Z = length * 0.8f;
        float smallBranch2Angle = MathHelper.PiOver2 * 0.9f; // Правая сторона, чуть выше горизонтали

        for ( int i = 0 ; i <= smallBranch2Segments ; i++ )
            {
            float t = (float)i / smallBranch2Segments;
            float currentRadius = smallBranch2Radius * (1 - t * 0.5f);

            // Позиция основания ветки на бревне
            float x = radius * MathF.Cos(smallBranch2Angle);
            float y = radius * MathF.Sin(smallBranch2Angle);

            // Изгиб ветки
            float curveX = MathF.Sin(t * MathHelper.Pi * 1.7f) * smallBranch2Length * 0.4f;
            float curveY = t * smallBranch2Length;
            float curveZ = MathF.Sin(t * MathHelper.Pi * 0.9f) * smallBranch2Length * 0.3f;

            Vector3 basePos = new Vector3(
        x + curveX,
        y + curveY,
        smallBranch2Z + curveZ
    );

            // Касательная к кривой
            Vector3 tangent = Vector3.Normalize(new Vector3(
        MathF.Cos(t * MathHelper.Pi * 1.7f) * 1.7f * smallBranch2Length * 0.4f,
        smallBranch2Length,
        MathF.Cos(t * MathHelper.Pi * 0.9f) * smallBranch2Length * 0.3f * 0.9f
    ));

            // Система координат для сечения
            Vector3 up = Vector3.UnitY;
            Vector3 normal = Vector3.Normalize(Vector3.Cross(tangent, up));
            Vector3 binormal = Vector3.Cross(tangent, normal);

            for ( int j = 0 ; j <= smallBranch2Segments ; j++ )
                {
                float u = (float)j / smallBranch2Segments;
                float angleBranch = u * MathHelper.TwoPi;

                Vector3 offset =
            normal * (currentRadius * MathF.Cos(angleBranch)) +
            binormal * (currentRadius * MathF.Sin(angleBranch));

                _logVertices . Add ( new LogVertex (
                    basePos + offset ,
                    new Vector2 ( u , t )
                ) );
                }
            }

        // Индексы для основного бревна (без изменений)
        for ( int i = 0 ; i < segments ; i++ )
            {
            for ( int j = 0 ; j < segments ; j++ )
                {
                int current = i * (segments + 1) + j;
                int next = current + segments + 1;

                _logIndices . Add ( ( uint ) current );
                _logIndices . Add ( ( uint ) next );
                _logIndices . Add ( ( uint ) ( current + 1 ) );

                _logIndices . Add ( ( uint ) ( current + 1 ) );
                _logIndices . Add ( ( uint ) next );
                _logIndices . Add ( ( uint ) ( next + 1 ) );
                }
            }

        // Индексы для крышек (без изменений)
        int capCenter = (segments + 1) * (segments + 1);
        for ( int cap = 0 ; cap < 2 ; cap++ )
            {
            int center = capCenter + cap * (segments + 2);

            for ( int i = 0 ; i < segments ; i++ )
                {
                _logIndices . Add ( ( uint ) center );
                _logIndices . Add ( ( uint ) ( center + 1 + i ) );
                _logIndices . Add ( ( uint ) ( center + 1 + ( ( i + 1 ) % segments ) ) );
                }
            }

        // Индексы для всех веток (нужно правильно рассчитать startIndex для каждой)
        int vertexCountBeforeBranches = _logVertices.Count -
    ((knotSegments + 1) * (knotSegments + 1) +
     (branchSegments + 1) * (branchSegments + 1) +
     (smallBranch1Segments + 1) * (smallBranch1Segments + 1) +
     (smallBranch2Segments + 1) * (smallBranch2Segments + 1));

        // Индексы для сучка
        int knotStart = vertexCountBeforeBranches;
        CreateCylinderIndices ( _logIndices , knotStart , knotSegments );

        // Индексы для основной ветки
        int branchStart = knotStart + (knotSegments + 1) * (knotSegments + 1);
        CreateCylinderIndices ( _logIndices , branchStart , branchSegments );

        // Индексы для первой тонкой ветки
        int smallBranch1Start = branchStart + (branchSegments + 1) * (branchSegments + 1);
        CreateCylinderIndices ( _logIndices , smallBranch1Start , smallBranch1Segments );

        // Индексы для второй тонкой ветки
        int smallBranch2Start = smallBranch1Start + (smallBranch1Segments + 1) * (smallBranch1Segments + 1);
        CreateCylinderIndices ( _logIndices , smallBranch2Start , smallBranch2Segments );

        _logParts . Add ( new LogPart
            {
            StartIndex = 0 ,
            IndexCount = _logIndices . Count ,
            Color = new Vector4 ( 0.4f , 0.3f , 0.2f , 1.0f ) ,
            TextureId = TEXTURE_UNIT_LOG
            } );
        }

    // Вспомогательный метод для создания индексов цилиндрических частей (веток)
    private void CreateCylinderIndices ( List<uint> indices , int startIndex , int segments )
        {
        for ( int i = 0 ; i < segments ; i++ )
            {
            for ( int j = 0 ; j < segments ; j++ )
                {
                uint current = (uint)(startIndex + i * (segments + 1) + j);
                uint next = current + (uint)(segments + 1);

                indices . Add ( current );
                indices . Add ( next );
                indices . Add ( current + 1 );

                indices . Add ( current + 1 );
                indices . Add ( next );
                indices . Add ( next + 1 );
                }
            }
        }

    private void CreateRockGeometry ( )
        {
        Random rand = new Random(42);

        const int segments = 64; // Увеличили количество сегментов для детализации
        const float baseRadius = 8f;
        float height = 20f - (float)rand.NextDouble() * 7f;
        float underwaterPart = height * 0.7f;
        float visibleHeight = height - underwaterPart;

        float noiseScale = 0.125f;

        // Вершина скалы с небольшим случайным смещением
        Vector3 top = new Vector3(
            (float)(rand.NextDouble() - 0.5) * noiseScale * 2f,
            visibleHeight + (float)(rand.NextDouble() - 0.5) * noiseScale,
            (float)(rand.NextDouble() - 0.5) * noiseScale * 2f);

        _rockVertices . Add ( new RockVertex ( top , new Vector2 ( 0.5f , 1.0f ) ) );

        // Центральная точка основания
        Vector3 bottomCenter = new Vector3(0, -underwaterPart, 0);
        _rockVertices . Add ( new RockVertex ( bottomCenter , new Vector2 ( 0.5f , 0.5f ) ) );

        // Генерируем слои скалы
        int layers = 10; // Количество горизонтальных слоев
        for ( int layer = 0 ; layer < layers ; layer++ )
            {
            float layerHeight = -underwaterPart + (height / layers) * layer;

            // Модифицированная формула радиуса - добавлено уширение к основанию
            float layerRadius;
            if ( layer < layers * 0.7 ) // Нижняя половина скалы
                {
                // Увеличиваем радиус у основания (максимальный эффект на самом нижнем слое)
                float baseWideness = 2f; // Коэффициент уширения (20%)
                float t = (float)layer / (layers * 0.7f); // Нормализованное положение в нижней половине
                layerRadius = baseRadius * ( 1.0f + ( baseWideness - 1.0f ) * ( 1.0f - t ) ) *
                             ( 1.0f - ( float ) layer / layers * 0.4f );
                }
            else // Верхняя половина скалы
                {
                layerRadius = baseRadius * ( 1.0f - ( float ) layer / layers * 0.4f );
                }

            for ( int i = 0 ; i <= segments ; i++ )
                {
                float angle = (float)i / segments * MathHelper.TwoPi;

                // Базовые координаты
                float x = layerRadius * (MathF.Cos(angle)) + 0.25f * ( float )rand.NextDouble() * ( float )(MathHelper.Sqrt(MathHelper.Sqrt(layerRadius)));
                float z;
                if ( angle >= 0 && angle <= MathHelper . Pi * 0.5f || angle >= MathHelper . Pi && angle <= MathHelper . Pi * 1.5f )
                    {
                    z = 0.2f * layerRadius * MathF . Sin ( 2 * angle ) + ( float ) ( MathHelper . Sqrt ( MathHelper . Sqrt ( layerRadius ) ) );
                    }
                else
                    {
                    z = layerRadius * MathF . Sin ( 2 * angle ) + ( float ) ( MathHelper . Sqrt ( MathHelper . Sqrt ( layerRadius ) ) );
                    }
                // Добавляем шум для неровностей
                float noise = (float)(MathHelper.Sqrt(rand.NextDouble()) * 0.25 + 0.75); // 0.75-1.25
                x *= noise * 1.1f;
                z *= noise * 0.85f;

                // Вертикальные неровности
                float yOffset = (float)(MathHelper.Sqrt(rand.NextDouble()) - 0.25) * noiseScale * 2f;

                Vector3 point = new Vector3(
            x,
            layerHeight + yOffset,
            z);

                Vector2 texCoord = new Vector2(
            (float)i / segments,
            (float)layer / layers);

                _rockVertices . Add ( new RockVertex ( point , texCoord ) );
                }
            }

        // Остальная часть метода остается без изменений
        for ( int layer = 0 ; layer < layers - 1 ; layer++ )
            {
            int currentLayerStart = 2 + layer * (segments + 1);
            int nextLayerStart = 2 + (layer + 1) * (segments + 1);

            for ( int i = 0 ; i < segments ; i++ )
                {
                // Первый треугольник
                _rockIndices . Add ( ( uint ) ( currentLayerStart + i ) );
                _rockIndices . Add ( ( uint ) ( nextLayerStart + i ) );
                _rockIndices . Add ( ( uint ) ( currentLayerStart + i + 1 ) );

                // Второй треугольник
                _rockIndices . Add ( ( uint ) ( currentLayerStart + i + 1 ) );
                _rockIndices . Add ( ( uint ) ( nextLayerStart + i ) );
                _rockIndices . Add ( ( uint ) ( nextLayerStart + i + 1 ) );
                }
            }

        // Соединяем вершину с верхним слоем
        int topLayerStart = 2 + (layers - 1) * (segments + 1);
        for ( int i = 0 ; i < segments ; i++ )
            {
            _rockIndices . Add ( 0 ); // Вершина
            _rockIndices . Add ( ( uint ) ( topLayerStart + i ) );
            _rockIndices . Add ( ( uint ) ( topLayerStart + i + 1 ) );
            }

        // Создаем дно скалы
        int bottomLayerStart = 2; // Первый слой - основание
        for ( int i = 0 ; i < segments ; i++ )
            {
            _rockIndices . Add ( 1 ); // Центр основания
            _rockIndices . Add ( ( uint ) ( bottomLayerStart + i ) );
            _rockIndices . Add ( ( uint ) ( bottomLayerStart + i + 1 ) );
            }

        _rockParts . Add ( new RockPart
            {
            StartIndex = 0 ,
            IndexCount = _rockIndices . Count ,
            Color = new Vector4 ( 0.545f , 0.549f , 0.47843f , 1.0f ) ,
            TextureId = TEXTURE_UNIT_ROCK
            } );
        }

    // Инициализация буферов для камней
    private void InitializeRockBuffers ( )
        {
        _rockVao = GL . GenVertexArray ( );
        _rockVbo = GL . GenBuffer ( );
        _rockEbo = GL . GenBuffer ( );

        GL . BindVertexArray ( _rockVao );

        GL . BindBuffer ( BufferTarget . ArrayBuffer , _rockVbo );
        GL . BufferData ( BufferTarget . ArrayBuffer ,
            _rockVertices . Count * RockVertex . SizeInBytes ,
            _rockVertices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _rockEbo );
        GL . BufferData ( BufferTarget . ElementArrayBuffer ,
            _rockIndices . Count * sizeof ( uint ) ,
            _rockIndices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . VertexAttribPointer ( 0 , 3 , VertexAttribPointerType . Float , false , RockVertex . SizeInBytes , 0 );
        GL . EnableVertexAttribArray ( 0 );
        GL . VertexAttribPointer ( TEXTURE_UNIT_ROCK , 2 , VertexAttribPointerType . Float , false , RockVertex . SizeInBytes , Vector3 . SizeInBytes );
        GL . EnableVertexAttribArray ( TEXTURE_UNIT_ROCK );

        GL . BindVertexArray ( 0 );
        }

    private void InitializeLogBuffers ( )
        {
        _logVao = GL . GenVertexArray ( );
        _logVbo = GL . GenBuffer ( );
        _logEbo = GL . GenBuffer ( );

        GL . BindVertexArray ( _logVao );

        GL . BindBuffer ( BufferTarget . ArrayBuffer , _logVbo );
        GL . BufferData ( BufferTarget . ArrayBuffer ,
            _logVertices . Count * LogVertex . SizeInBytes ,
            _logVertices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _logEbo );
        GL . BufferData ( BufferTarget . ElementArrayBuffer ,
            _logIndices . Count * sizeof ( uint ) ,
            _logIndices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . VertexAttribPointer ( 0 , 3 , VertexAttribPointerType . Float , false , LogVertex . SizeInBytes , 0 );
        GL . EnableVertexAttribArray ( 0 );
        GL . VertexAttribPointer ( TEXTURE_UNIT_LOG , 2 , VertexAttribPointerType . Float , false , LogVertex . SizeInBytes , Vector3 . SizeInBytes );
        GL . EnableVertexAttribArray ( TEXTURE_UNIT_LOG );

        GL . BindVertexArray ( 0 );
        }

    private void InitializeLogShaders ( )
        {
        const string logVertexShader = @"
#version 460 core
layout(location = 0) in vec3 aPos;
layout(location = 10) in vec2 aTexCoord;

uniform mat4 projection;
uniform mat4 view;
uniform mat4 model;

out vec2 texCoord;

void main() {
    gl_Position = projection * view * model * vec4(aPos, 1.0);
    texCoord = aTexCoord;
}";

        const string logFragmentShader = @"
    #version 460 core
    out vec4 FragColor;

    in vec2 texCoord;

    uniform sampler2D logTexture;
    uniform vec4 color;

    void main() {
            vec4 texColor = texture(logTexture, texCoord);
            float woodGrain = sin(texCoord.x * 100.0) * 0.15;
            vec3 woodEffect = texColor.rgb * (1.0 + woodGrain);
            FragColor = mix(color, vec4(woodEffect, texColor.a), 0.75);
    }";

        _logShaderProgram = GL . CreateProgram ( );
        int logVS = CompileShader(ShaderType.VertexShader, logVertexShader);
        int logFS = CompileShader(ShaderType.FragmentShader, logFragmentShader);

        GL . AttachShader ( _logShaderProgram , logVS );
        GL . AttachShader ( _logShaderProgram , logFS );
        GL . LinkProgram ( _logShaderProgram );

        GL . DetachShader ( _logShaderProgram , logVS );
        GL . DetachShader ( _logShaderProgram , logFS );
        GL . DeleteShader ( logVS );
        GL . DeleteShader ( logFS );
        }

    // Шейдеры для камней (аналогично другим объектам)
    private void InitializeRockShaders ( )
        {
        const string rockVertexShader = @"
        #version 460 core
        layout(location = 0) in vec3 aPos;
        layout(location = 9) in vec2 aTexCoord;

        uniform mat4 projection;
        uniform mat4 view;
        uniform mat4 model;

        out vec2 texCoord;

        void main() {
            gl_Position = projection * view * model * vec4(aPos, 1.0);
            texCoord = aTexCoord;
        }";

        const string rockFragmentShader = @"
        #version 460 core
        out vec4 FragColor;

        in vec2 texCoord;

        uniform sampler2D rockTexture;
        uniform vec4 color;

        void main() {
            vec4 texColor = texture(rockTexture, texCoord);
            float grain = fract(sin(dot(texCoord * 3.0, vec2(12.9898, 78.233))) * 43758.5453) * 0.1;
            texColor.rgb += grain - 0.05;
            texColor.rgb = mix(texColor.rgb, texColor.rgb * 1.05, 0.3);
            FragColor = mix(color, texColor, 0.65);
        }";

        _rockShaderProgram = GL . CreateProgram ( );
        int rockVS = CompileShader(ShaderType.VertexShader, rockVertexShader);
        int rockFS = CompileShader(ShaderType.FragmentShader, rockFragmentShader);

        GL . AttachShader ( _rockShaderProgram , rockVS );
        GL . AttachShader ( _rockShaderProgram , rockFS );
        GL . LinkProgram ( _rockShaderProgram );

        GL . DetachShader ( _rockShaderProgram , rockVS );
        GL . DetachShader ( _rockShaderProgram , rockFS );
        GL . DeleteShader ( rockVS );
        GL . DeleteShader ( rockFS );
        }

    private void SpawnLog ( )
        {
        const float spawnZ = 205f;
        const float minObstacleDistance = 60f;

        var mainRocks = _rocks.Where(r => r.Lane != -1).ToList();

        // 1. Оригинальные проверки
        if ( ( _logs . Count > 0 && Math . Abs ( _lastLogZ - spawnZ ) < 50f ) ||
            ( mainRocks . Count > 0 && Math . Abs ( mainRocks . Last ( ) . Position . Z - spawnZ ) < 50f ) )
            return;

        if ( _logs . Count ( r => Math . Abs ( r . Position . Z - spawnZ ) < 0.1f ) >= 2 )
            return;

        // 2. Новые проверки (дополнение)
        bool hasRocksAtSameZ = mainRocks.Any(r => Math.Abs(r.Position.Z - spawnZ) < minObstacleDistance);

        // Получаем список доступных линий
        var availableLanes = Enumerable.Range(0, 3).ToList();

        if ( hasRocksAtSameZ )
            {
            availableLanes = availableLanes
                . Where ( lane => !_rocks . Any ( r =>
                    Math . Abs ( r . Position . Z - spawnZ ) < minObstacleDistance &&
                    r . Lane == lane ) )
                . ToList ( );

            if ( availableLanes . Count == 0 ) return;
            }

        // 3. Выбор линии с учетом всех условий
        int lane = availableLanes[_random.Next(availableLanes.Count)];
        float scale = 0.8f + (float)_random.NextDouble() * 0.4f;

        Log log = new Log
            {
            Position = new Vector3(_lanePositions[lane], -waterHeight - salmonElevation + 21.0f, spawnZ),
            Rotation = (float)_random.NextDouble() * MathHelper.TwoPi,
            Scale = scale,
            Speed = 0.5f,
            IsActive = true,
            Lane = lane
            };

        _logs . Add ( log );
        _lastLogZ = log . Position . Z;
        }

    private void UpdateLogs ( float deltaTime )
        {
        _logSpawnTimer += deltaTime;
        if ( _logSpawnTimer >= LogSpawnInterval )
            {
            _logSpawnTimer = 0f;
            SpawnLog ( );
            }

        // Обновляем позиции брёвен (движутся навстречу)
        for ( int i = _logs . Count - 1 ; i >= 0 ; i-- )
            {
            Log log = _logs[i];
            log . Position . Z -= log . Speed * ( _isWPressed ? 2.0f : 1.0f );

            // Удаляем брёвна, которые вышли за пределы видимости
            if ( log . Position . Z < -100f )
                {
                _logs . RemoveAt ( i );
                }
            }
        }

    private void RenderLogs ( Matrix4 view )
        {
        GL . Enable ( EnableCap . DepthTest );
        GL . DepthMask ( true );

        GL . UseProgram ( _logShaderProgram );
        GL . BindVertexArray ( _logVao );

        GL . ActiveTexture ( TextureUnit . Texture0 + TEXTURE_UNIT_LOG );
        GL . BindTexture ( TextureTarget . Texture2D , TEXTURE_UNIT_LOG );
        GL . Uniform1 ( GL . GetUniformLocation ( _logShaderProgram , "logTexture" ) , TEXTURE_UNIT_LOG );

        // Получаем текущее время для анимации
        float time = (float)GLFW.GetTime();

        foreach ( Log log in _logs )
            {
            if ( !log . IsActive ) continue;

            float sideBob = MathHelper.DegreesToRadians(1f) *
           MathF.Sin(time * 3f + log.Position.Z * 0.15f);

            // Вертикальные колебания (амплитуда ~0.1 единицы)
            float verticalBob = 0.8f * MathF.Sin(time * 1.5f - log.Position.Z * 0.15f);

            // Угловые колебания (5-10 градусов в радианах)
            float angleBob = MathHelper.DegreesToRadians(3.25f) *
                    MathF.Sin(time * 1.5f + log.Position.Z * 0.15f);

            // Создаем матрицу модели с учетом колебаний
            Matrix4 modelMatrix =
        Matrix4.CreateRotationZ(sideBob) *
        Matrix4.CreateTranslation(0, verticalBob, 0) * // Вертикальные колебания
        Matrix4.CreateRotationX(angleBob) * // Наклон вперед-назад
        Matrix4.CreateScale(log.Scale) *
        Matrix4.CreateRotationY(log.Rotation) *
        Matrix4.CreateTranslation(log.Position);

            GL . UniformMatrix4 ( GL . GetUniformLocation ( _logShaderProgram , "projection" ) , false , ref _projection );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _logShaderProgram , "view" ) , false , ref view );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _logShaderProgram , "model" ) , false , ref modelMatrix );
            GL . Uniform4 ( GL . GetUniformLocation ( _logShaderProgram , "color" ) , new Vector4 ( 0.588f , 0.435f , 0.2f , 1.0f ) );

            GL . DrawElements ( PrimitiveType . Triangles , _logParts [ 0 ] . IndexCount ,
                DrawElementsType . UnsignedInt , 0 );
            }

        GL . BindVertexArray ( 0 );
        }

    private void SpawnRock ( )
        {
        const float spawnZ = 205f;
        const float minObstacleDistance = 60f;
        const float edgeSpawnChance = 0.075f; // 30% шанс спавна камня на краю

        // Решаем, спавнить обычный камень или крайний
        bool spawnEdgeRock = _random.NextDouble() < edgeSpawnChance;
        float scale;

        if ( spawnEdgeRock )
            {
            // Спавн камня на краю экрана
            float edgeX = _random.NextDouble() > 0.5 ? -122.5f - (float)_random . NextDouble ( ) * 30.0f : 122.5f + (float)_random . NextDouble ( ) * 30.0f; // Левый или правый край
            scale = 1.0f + ( float ) _random . NextDouble ( ) * 0.5f; // Немного меньше

            Rock edgeRock = new Rock
                {
                Position = new Vector3(edgeX, -waterHeight - salmonElevation + 19.0f, spawnZ),
                Rotation = (float)_random.NextDouble() * MathHelper.TwoPi,
                Scale = scale,
                Speed = 0.4f, // Медленнее обычных
                IsActive = true,
                Lane = -1 // Специальное значение для краевых камней
                };

            _rocks . Add ( edgeRock );
            return;
            }

        var mainRocks = _rocks.Where(r => r.Lane != -1).ToList();

        // Оригинальная логика спавна обычных камней
        if ( mainRocks . Count > 0 && Math . Abs ( _lastRockZ - spawnZ ) < 50f )
            return;

        if ( mainRocks . Count ( r => Math . Abs ( r . Position . Z - spawnZ ) < 0.1f ) >= 2 )
            return;

        bool hasLogsAtSameZ = _logs.Any(l => Math.Abs(l.Position.Z - spawnZ) < minObstacleDistance);

        var availableLanes = Enumerable.Range(0, 3).ToList();

        if ( hasLogsAtSameZ )
            {
            availableLanes = availableLanes
                . Where ( lane => !_logs . Any ( l =>
                    Math . Abs ( l . Position . Z - spawnZ ) < minObstacleDistance &&
                    l . Lane == lane ) )
                . ToList ( );

            if ( availableLanes . Count == 0 ) return;
            }

        int lane = availableLanes[_random.Next(availableLanes.Count)];
        scale = 1.2f + ( float ) _random . NextDouble ( ) * 0.8f;

        Rock rock = new Rock
            {
            Position = new Vector3(_lanePositions[lane], -waterHeight - salmonElevation + 19.0f, spawnZ),
            Rotation = (float)_random.NextDouble() * MathHelper.TwoPi,
            Scale = scale,
            Speed = 0.6f,
            IsActive = true,
            Lane = lane
            };

        _rocks . Add ( rock );
        _lastRockZ = rock . Position . Z;
        }

    // Обновление камней
    private void UpdateRocks ( float deltaTime )
        {
        _rockSpawnTimer += deltaTime;
        if ( _rockSpawnTimer >= RockSpawnInterval )
            {
            _rockSpawnTimer = 0f;
            SpawnRock ( );
            }

        // Обновляем позиции камней (движутся навстречу)
        for ( int i = _rocks . Count - 1 ; i >= 0 ; i-- )
            {
            Rock rock = _rocks[i];
            rock . Position . Z -= rock . Speed * ( _isWPressed ? 2.0f : 1.0f );

            // Удаляем камни, которые вышли за пределы видимости
            if ( rock . Position . Z < -50f )
                {
                _rocks . RemoveAt ( i );
                }
            }
        }

    // Рендеринг камней
    private void RenderRocks ( Matrix4 view )
        {
        GL . Enable ( EnableCap . DepthTest );
        GL . DepthMask ( true );

        GL . UseProgram ( _rockShaderProgram );
        GL . BindVertexArray ( _rockVao );

        GL . ActiveTexture ( TextureUnit . Texture0 + TEXTURE_UNIT_ROCK );
        GL . BindTexture ( TextureTarget . Texture2D , TEXTURE_UNIT_ROCK );
        GL . Uniform1 ( GL . GetUniformLocation ( _rockShaderProgram , "rockTexture" ) , TEXTURE_UNIT_ROCK );

        foreach ( Rock rock in _rocks )
            {
            if ( !rock . IsActive ) continue;

            Matrix4 modelMatrix = Matrix4.CreateScale(rock.Scale) *
                       Matrix4.CreateRotationY(rock.Rotation) *
                       Matrix4.CreateTranslation(rock.Position);
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _rockShaderProgram , "projection" ) , false , ref _projection );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _rockShaderProgram , "view" ) , false , ref view );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _rockShaderProgram , "model" ) , false , ref modelMatrix );
            GL . Uniform4 ( GL . GetUniformLocation ( _rockShaderProgram , "color" ) , new Vector4 ( 0.545f , 0.549f , 0.47843f , 1.0f ) );

            // Рендерим всю скалу (и надводную и подводную части)
            GL . DrawElements ( PrimitiveType . Triangles , _rockParts [ 0 ] . IndexCount ,
                    DrawElementsType . UnsignedInt , 0 );
            }

        GL . BindVertexArray ( 0 );
        }

    public Form1 ( )
        {
        InitializeComponent ( );
        InitializeAnimationTimer ( );

        _currentXPosition = 0f;

        KeyDown += GlControl_KeyDown;
        KeyUp += GlControl_KeyUp;
        KeyPreview = true;
        }

    private void InitializeAnimationTimer ( )
        {
        _animationTimer = new System . Windows . Forms . Timer
            {
            Interval = 1 // ~60 FPS
            };
        _animationTimer . Tick += ( s , e ) => UpdateAnimation ( );
        Load += ( s , e ) => _animationTimer . Start ( );
        }

    #region Инициализация OpenGL

    private void InitializeBranches ( )
        {
        CreateBranchGeometry ( );
        InitializeBranchBuffers ( );
        InitializeBranchShaders ( );
        LoadTexture ( "D:\\Cube\\branch_texture.jpg" , TEXTURE_UNIT_BRANCH , TextureWrapMode . Repeat , TextureWrapMode . Repeat );
        }

    // Метод создания геометрии веточки (аналогично CreateLilyGeometry)
    private void CreateBranchGeometry ( )
        {
        const float length = 8f; // Длина ветки
        const float width = 0.5f; // Ширина ветки
        const float height = waterHeight - salmonElevation + 0.1f;

        // Вершины для прямоугольной ветки (2 треугольника)
        _branchVertices . Add ( new BranchVertex ( new Vector3 ( -width / 2 , height , -length / 2 ) , new Vector2 ( 0 , 0 ) ) );
        _branchVertices . Add ( new BranchVertex ( new Vector3 ( width / 2 , height , -length / 2 ) , new Vector2 ( 1 , 0 ) ) );
        _branchVertices . Add ( new BranchVertex ( new Vector3 ( width / 2 , height , length / 2 ) , new Vector2 ( 1 , 1 ) ) );
        _branchVertices . Add ( new BranchVertex ( new Vector3 ( -width / 2 , height , length / 2 ) , new Vector2 ( 0 , 1 ) ) );

        // Индексы (2 треугольника)
        _branchIndices . Add ( 0 );
        _branchIndices . Add ( 1 );
        _branchIndices . Add ( 2 );
        _branchIndices . Add ( 0 );
        _branchIndices . Add ( 2 );
        _branchIndices . Add ( 3 );

        _branchParts . Add ( new BranchPart
            {
            StartIndex = 0 ,
            IndexCount = _branchIndices . Count ,
            Color = new Vector4 ( 0.5f , 0.35f , 0.2f , 0.9f ) , // Коричневый цвет
            TextureId = TEXTURE_UNIT_BRANCH
            } );
        }

    // Инициализация буферов для веточек (аналогично InitializeLilyBuffers)
    private void InitializeBranchBuffers ( )
        {
        _branchVao = GL . GenVertexArray ( );
        _branchVbo = GL . GenBuffer ( );
        _branchEbo = GL . GenBuffer ( );

        GL . BindVertexArray ( _branchVao );

        GL . BindBuffer ( BufferTarget . ArrayBuffer , _branchVbo );
        GL . BufferData ( BufferTarget . ArrayBuffer ,
            _branchVertices . Count * BranchVertex . SizeInBytes ,
            _branchVertices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _branchEbo );
        GL . BufferData ( BufferTarget . ElementArrayBuffer ,
            _branchIndices . Count * sizeof ( uint ) ,
            _branchIndices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . VertexAttribPointer ( 0 , 3 , VertexAttribPointerType . Float , false , BranchVertex . SizeInBytes , 0 );
        GL . EnableVertexAttribArray ( 0 );
        GL . VertexAttribPointer ( TEXTURE_UNIT_BRANCH , 2 , VertexAttribPointerType . Float , false , BranchVertex . SizeInBytes , Vector3 . SizeInBytes );
        GL . EnableVertexAttribArray ( TEXTURE_UNIT_BRANCH );

        GL . BindVertexArray ( 0 );
        }

    // Шейдеры для веточек (аналогично InitializeLilyShaders)
    private void InitializeBranchShaders ( )
        {
        const string branchVertexShader = @"
#version 460 core
layout(location = 0) in vec3 aPos;
layout(location = 8) in vec2 aTexCoord;

uniform mat4 projection;
uniform mat4 view;
uniform mat4 model;
uniform float time;
uniform float scaleFactor;
uniform float rotationFactor;
uniform float _isWPressed;

out vec2 texCoord;
out vec3 worldPos;

void main() {
    float speedMultiplier = mix(1.0, 2.0, float(_isWPressed));
    speedMultiplier = sqrt(sqrt(speedMultiplier));
    float waveHeight = 
            sin(aPos.x * 0.5 + time * 1.5) * 0.2 +
            cos(aPos.z * 0.3 + time * 1.2) * 0.3;

    float driftAmplitude = 2.75 * (2 - scaleFactor * scaleFactor); 
    float driftFrequency = 0.5 / sqrt(scaleFactor);  
    float xDrift = sign(rotationFactor) * driftAmplitude * 0.5 * (sin(time * 1.6 * speedMultiplier + worldPos.z * driftFrequency) + 0.5 * cos(time * 0.8 * speedMultiplier + worldPos.z * driftFrequency) + 0.0075 * sqrt(time * 0.8 + worldPos.z * driftFrequency));
    
    vec3 displacedPos = aPos + vec3(xDrift, waveHeight * 0.5, 0.0);
    
    float rotationAngle = sign(rotationFactor) * time * 0.225 * (2.0 - scaleFactor * sqrt(scaleFactor));
    mat4 rotationMatrix = mat4(
            cos(rotationAngle), 0.0, -sin(rotationAngle), 0.0,
            0.0, 1.0, 0.0, 0.0,
            sin(rotationAngle), 0.0, cos(rotationAngle), 0.0,
            0.0, 0.0, 0.0, 1.0
    );
    
    worldPos = (model * rotationMatrix * vec4(displacedPos, 1.0)).xyz;
    gl_Position = projection * view * model * rotationMatrix * vec4(displacedPos, 1.0);
    texCoord = aTexCoord;
}";

        const string branchFragmentShader = @"
#version 460 core
out vec4 FragColor;

in vec2 texCoord;
in vec3 worldPos;

uniform sampler2D branchTexture;
uniform vec4 color;
uniform float time;
uniform float scaleFactor;
uniform mat4 model;

float hash(vec2 p) {
        p = fract(p * vec2(123.34, 456.21));
        p += dot(p, p + 45.32);
        return fract(p.x * p.y);
}

float rippleCircle(vec2 center, vec2 uv, float speed, float size) {
    float d = length(uv - center);
    return sin(d * size - time * speed) * 0.275 / (d * 0.75 + 0.25);
}

void main() {
    vec2 centers[9];
    centers[0] = vec2(-72.5, 85.0);
    centers[1] = vec2(75.5, 60.0);
    centers[2] = vec2(-35.0, 70.0);
    centers[3] = vec2(-10.0, 90.0);
    centers[4] = vec2(15.0, 75.0);
    centers[5] = vec2(40.0, 40.0);
    centers[6] = vec2(-35.0, 15.0);
    centers[7] = vec2(39.5, -7.0);
    centers[8] = vec2(0.0, 0.0);

    float rippleEffect = 0.0;
    for(int i = 0; i < 9; i++) {
        rippleEffect += rippleCircle(centers[i], worldPos.xz, 7.75 + i*0.5, 1.375 + i*0.05);
    }
    vec2 noisyCoord = texCoord + rippleEffect * 0.4 * scaleFactor * sqrt(scaleFactor);
    noisyCoord.x += hash(worldPos.xz + time * 0.3) * 0.02 * (2.0 - scaleFactor * sqrt(scaleFactor));
    noisyCoord.y += hash(worldPos.zx - time * 0.2) * 0.02 * (2.0 - scaleFactor * sqrt(scaleFactor));

    vec4 texColor = texture(branchTexture, noisyCoord);

    FragColor = mix(color, texColor, 0.95);                
}";

        _branchShaderProgram = GL . CreateProgram ( );
        int branchVS = CompileShader(ShaderType.VertexShader, branchVertexShader);
        int branchFS = CompileShader(ShaderType.FragmentShader, branchFragmentShader);

        GL . AttachShader ( _branchShaderProgram , branchVS );
        GL . AttachShader ( _branchShaderProgram , branchFS );
        GL . LinkProgram ( _branchShaderProgram );

        GL . DetachShader ( _branchShaderProgram , branchVS );
        GL . DetachShader ( _branchShaderProgram , branchFS );
        GL . DeleteShader ( branchVS );
        GL . DeleteShader ( branchFS );
        }

    // Метод спавна веточек (аналогично SpawnLily)
    private void SpawnBranch ( )
        {
        if ( _branches . Count >= 20 ) return;

        float scaleFactor = (float)_random.NextDouble() * 1.5f;

        Branch branch = new Branch
            {
            Position = new Vector3(
        _random.NextDouble() > 0.5 ? _random.Next(-100, -25) : _random.Next(25, 100),
        -waterHeight - salmonElevation + 10.0f,
        -25f - _random.Next(0, 95)),
            Rotation = _random.NextDouble() > 0.5 ? (float)_random.NextDouble() : -(float)_random.NextDouble() * MathHelper.TwoPi * (float)MathHelper.Sqrt(scaleFactor),
            Scale = 0.5f + scaleFactor,
            Speed = 0.026f / (float)MathHelper.Sqrt(1.275f + scaleFactor * 0.5) + (float)_random.NextDouble() * 0.005f / (float)MathHelper.Sqrt(MathHelper.Sqrt(1.275f + scaleFactor * 0.5)),
            IsActive = true
            };

        _branches . Add ( branch );
        }

    // Обновление веточек (аналогично UpdateLilies)
    private void UpdateBranches ( float deltaTime )
        {
        _branchSpawnTimer += deltaTime;
        if ( _branchSpawnTimer >= BranchSpawnInterval )
            {
            _branchSpawnTimer = 0f;
            if ( _branches . Count < 75 )
                {
                SpawnBranch ( );
                }
            }

        // Обновляем позиции веточек
        for ( int i = _branches . Count - 1 ; i >= 0 ; i-- )
            {
            Branch branch = _branches[i];
            branch . Position . Z += branch . Speed * ( _isWPressed ? 1.5f : 1.0f );

            // Удаляем веточки, которые вышли за пределы видимости
            if ( branch . Position . Z > 165f )
                {
                _branches . RemoveAt ( i );
                }
            }
        }

    // Рендеринг веточек (аналогично RenderLilies)
    private void RenderBranches ( Matrix4 view )
        {
        GL . UseProgram ( _branchShaderProgram );
        GL . BindVertexArray ( _branchVao );

        float time = (float)DateTime.Now.TimeOfDay.TotalSeconds;
        GL . Uniform1 ( GL . GetUniformLocation ( _branchShaderProgram , "time" ) , time );

        GL . ActiveTexture ( TextureUnit . Texture0 + TEXTURE_UNIT_BRANCH );
        GL . BindTexture ( TextureTarget . Texture2D , TEXTURE_UNIT_BRANCH );
        GL . Uniform1 ( GL . GetUniformLocation ( _branchShaderProgram , "branchTexture" ) , TEXTURE_UNIT_BRANCH );

        foreach ( Branch branch in _branches )
            {
            if ( !branch . IsActive ) continue;

            Matrix4 modelMatrix = Matrix4.CreateScale(branch.Scale) *
                           Matrix4.CreateRotationY(branch.Rotation) *
                           Matrix4.CreateTranslation(branch.Position);
            GL . Uniform1 ( GL . GetUniformLocation ( _planeShaderProgram , "_isWPressed" ) , _isWPressed ? 2.0f : 1.0f );
            GL . Uniform1 ( GL . GetUniformLocation ( _branchShaderProgram , "rotationFactor" ) , branch . Rotation );
            GL . Uniform1 ( GL . GetUniformLocation ( _branchShaderProgram , "scaleFactor" ) , branch . Scale );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _branchShaderProgram , "projection" ) , false , ref _projection );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _branchShaderProgram , "view" ) , false , ref view );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _branchShaderProgram , "model" ) , false , ref modelMatrix );
            GL . Uniform4 ( GL . GetUniformLocation ( _branchShaderProgram , "color" ) , new Vector4 ( 0.5f , 0.35f , 0.2f , 0.9f ) );

            foreach ( BranchPart part in _branchParts )
                {
                GL . DrawElements ( PrimitiveType . Triangles , part . IndexCount ,
                        DrawElementsType . UnsignedInt , part . StartIndex * sizeof ( uint ) );
                }
            }

        GL . BindVertexArray ( 0 );
        }


    private void InitializeLilies ( )
        {
        CreateLilyGeometry ( );
        InitializeLilyBuffers ( );
        InitializeLilyShaders ( );
        LoadTexture ( "D:\\Cube\\lily_texture.jpg" , TEXTURE_UNIT_LILY , TextureWrapMode . Repeat , TextureWrapMode . Repeat );
        }

    private void InitializePlane ( )
        {
        CreatePlaneGeometry ( );
        InitializePlaneBuffers ( );
        InitializePlaneShaders ( );

        CreateWaterGeometry ( );
        InitializeWaterBuffers ( );
        InitializeWaterShaders ( );
        }

    private void CreateLilyGeometry ( )
        {
        const int segments = 32;
        const float R = 5f; // Радиус большого полукруга
        const float r = R * 0.5f; // Радиус малых полукругов (R/2)
        const float height = waterHeight - salmonElevation + 0.1f;

        // Центры полукругов (XZ-плоскость)
        Vector3 bigCenter = new Vector3(0, height, 0);      // Центр большого полукруга
        Vector3 leftCenter = new Vector3(-R/2, height, 0);  // Центр левого малого
        Vector3 rightCenter = new Vector3(R/2, height, 0);  // Центр правого малого

        // Создаем вершины для каждого полукруга
        List<Vector3> vertices = new List<Vector3>();

        // 1. Большой полукруг (нижняя половина, 180°)
        for ( int i = 0 ; i <= segments ; i++ )
            {
            float angle = MathHelper.Pi + (float)i / segments * MathHelper.Pi;
            float x = bigCenter.X + R * MathF.Cos(angle);
            float z = bigCenter.Z + R * MathF.Sin(angle);
            vertices . Add ( new Vector3 ( x , height , z ) );
            }

        // 2. Левый малый полукруг (верхняя половина, 180°)
        for ( int i = 0 ; i <= segments ; i++ )
            {
            float angle = (float)i / segments * MathHelper.Pi;
            float x = leftCenter.X + r * MathF.Cos(angle);
            float z = leftCenter.Z + r * MathF.Sin(angle);

            // Исключаем точки, которые уже есть в большом полукруге
            if ( z > 0 || ( x < -R / 2 && z == 0 ) )
                vertices . Add ( new Vector3 ( x , height , z ) );
            }

        // 3. Правый малый полукруг (верхняя половина, 180°)
        for ( int i = 0 ; i <= segments ; i++ )
            {
            float angle = (float)i / segments * MathHelper.Pi;
            float x = rightCenter.X + r * MathF.Cos(angle);
            float z = rightCenter.Z + r * MathF.Sin(angle);

            // Исключаем точки, которые уже есть в большом полукруге
            if ( z > 0 || ( x > R / 2 && z == 0 ) )
                vertices . Add ( new Vector3 ( x , height , z ) );
            }

        // Упорядочиваем вершины по часовой стрелке
        vertices = vertices . OrderBy ( v => MathF . Atan2 ( v . Z - bigCenter . Z , v . X - bigCenter . X ) ) . ToList ( );

        // Центральная точка для триангуляции
        _lilyVertices . Add ( new LilyVertex ( bigCenter , new Vector2 ( 0.5f , 0.5f ) ) );

        // Добавляем вершины с текстурными координатами
        foreach ( var vertex in vertices )
            {
            Vector2 texCoord = new Vector2(
        (vertex.X + R) / (2 * R), // X: [-R, R] &rarr; [0, 1]
        1 - (vertex.Z + R) / (2 * R) // Z: [-R, R] &rarr; [0, 1]
    );
            _lilyVertices . Add ( new LilyVertex ( vertex , texCoord ) );
            }

        // Триангуляция (веер треугольников из центра)
        for ( int i = 1 ; i < vertices . Count ; i++ )
            {
            _lilyIndices . Add ( 0 ); // Центр
            _lilyIndices . Add ( ( uint ) i );
            _lilyIndices . Add ( ( uint ) ( i + 1 ) );
            }
        // Замыкаем форму
        _lilyIndices . Add ( 0 );
        _lilyIndices . Add ( ( uint ) vertices . Count );
        _lilyIndices . Add ( 1 );

        _lilyParts . Add ( new LilyPart
            {
            StartIndex = 0 ,
            IndexCount = _lilyIndices . Count ,
            Color = new Vector4 ( 0.8f , 0.9f , 0.7f , 0.95f ) ,
            TextureId = TEXTURE_UNIT_LILY
            } );
        }

    private void InitializeLilyShaders ( )
        {
        const string lilyVertexShader = @"
    #version 460 core
    layout(location = 0) in vec3 aPos;
    layout(location = 7) in vec2 aTexCoord;
    
    uniform mat4 projection;
    uniform mat4 view;
    uniform mat4 model;
    uniform float time;
    uniform float scaleFactor;
    uniform float rotationFactor;
    uniform float _isWPressed;
    
    out vec2 texCoord;
    out vec3 worldPos;
    
    void main() {
            float speedMultiplier = mix(1.0, 2.0, float(_isWPressed));
            speedMultiplier = sqrt(sqrt(speedMultiplier));
            float waveHeight = 
                    sin(aPos.x * 0.5 + time * 1.5) * 0.2 +
                    cos(aPos.z * 0.3 + time * 1.2) * 0.3;

            float driftAmplitude = 2.75 * (2 - scaleFactor * scaleFactor); 
            float driftFrequency = 0.5 / sqrt(scaleFactor);  
            float xDrift = sign(rotationFactor) * driftAmplitude * 0.5 * (sin(time * speedMultiplier * 1.6 + worldPos.z * driftFrequency) + 0.5 * cos(time * speedMultiplier * 0.8 + worldPos.z * driftFrequency) + 0.0075 * sqrt(time * 0.8 + worldPos.z * driftFrequency));
            
            vec3 displacedPos = aPos + vec3(xDrift, waveHeight * 0.5, 0.0);
            
            float rotationAngle = sign(rotationFactor) * time * 0.225 * (2.0 - scaleFactor * sqrt(scaleFactor));
            mat4 rotationMatrix = mat4(
                    cos(rotationAngle), 0.0, -sin(rotationAngle), 0.0,
                    0.0, 1.0, 0.0, 0.0,
                    sin(rotationAngle), 0.0, cos(rotationAngle), 0.0,
                    0.0, 0.0, 0.0, 1.0
            );
            
            worldPos = (model * rotationMatrix * vec4(displacedPos, 1.0)).xyz;
            gl_Position = projection * view * model * rotationMatrix * vec4(displacedPos, 1.0);
            texCoord = aTexCoord;
    }";

        const string lilyFragmentShader = @"
    #version 460 core
    out vec4 FragColor;

    in vec2 texCoord;
    in vec3 worldPos;

    uniform sampler2D lilyTexture;
    uniform vec4 color;
    uniform float time;
    uniform float scaleFactor;
    uniform mat4 model;

    float hash(vec2 p) {
            p = fract(p * vec2(123.34, 456.21));
            p += dot(p, p + 45.32);
            return fract(p.x * p.y);
    }

    float rippleCircle(vec2 center, vec2 uv, float speed, float size) {
        float d = length(uv - center);
        return sin(d * size - time * speed) * 0.275 / (d * 0.75 + 0.25);
    }

    void main() {
        vec2 centers[9];
        centers[0] = vec2(-72.5, 85.0);
        centers[1] = vec2(75.5, 60.0);
        centers[2] = vec2(-35.0, 70.0);
        centers[3] = vec2(-10.0, 90.0);
        centers[4] = vec2(15.0, 75.0);
        centers[5] = vec2(40.0, 40.0);
        centers[6] = vec2(-35.0, 15.0);
        centers[7] = vec2(39.5, -7.0);
        centers[8] = vec2(0.0, 0.0);

        float rippleEffect = 0.0;
        for(int i = 0; i < 9; i++) {
            rippleEffect += rippleCircle(centers[i], worldPos.xz, 7.75 + i*0.5, 1.375 + i*0.05);
        }
        vec2 noisyCoord = texCoord + rippleEffect * 0.4 * scaleFactor * sqrt(scaleFactor);
        noisyCoord.x += hash(worldPos.xz + time * 0.3) * 0.02 * (2.0 - scaleFactor * sqrt(scaleFactor));
        noisyCoord.y += hash(worldPos.zx - time * 0.2) * 0.02 * (2.0 - scaleFactor * sqrt(scaleFactor));

        vec4 texColor = texture(lilyTexture, noisyCoord);

        FragColor = mix(color, texColor, 0.95);                
    }";

        _lilyShaderProgram = GL . CreateProgram ( );
        int lilyVS = CompileShader(ShaderType.VertexShader, lilyVertexShader);
        int lilyFS = CompileShader(ShaderType.FragmentShader, lilyFragmentShader);

        GL . AttachShader ( _lilyShaderProgram , lilyVS );
        GL . AttachShader ( _lilyShaderProgram , lilyFS );
        GL . LinkProgram ( _lilyShaderProgram );

        GL . DetachShader ( _lilyShaderProgram , lilyVS );
        GL . DetachShader ( _lilyShaderProgram , lilyFS );
        GL . DeleteShader ( lilyVS );
        GL . DeleteShader ( lilyFS );
        }

    private void InitializeLilyBuffers ( )
        {
        _lilyVao = GL . GenVertexArray ( );
        _lilyVbo = GL . GenBuffer ( );
        _lilyEbo = GL . GenBuffer ( );

        GL . BindVertexArray ( _lilyVao );

        GL . BindBuffer ( BufferTarget . ArrayBuffer , _lilyVbo );
        GL . BufferData ( BufferTarget . ArrayBuffer ,
            _lilyVertices . Count * LilyVertex . SizeInBytes ,
            _lilyVertices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _lilyEbo );
        GL . BufferData ( BufferTarget . ElementArrayBuffer ,
            _lilyIndices . Count * sizeof ( uint ) ,
            _lilyIndices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . VertexAttribPointer ( 0 , 3 , VertexAttribPointerType . Float , false , LilyVertex . SizeInBytes , 0 );
        GL . EnableVertexAttribArray ( 0 );
        GL . VertexAttribPointer ( TEXTURE_UNIT_LILY , 2 , VertexAttribPointerType . Float , false , LilyVertex . SizeInBytes , Vector3 . SizeInBytes );
        GL . EnableVertexAttribArray ( TEXTURE_UNIT_LILY );

        GL . BindVertexArray ( 0 );
        }

    private void SpawnLily ( )
        {
        if ( _lilies . Count >= 20 ) return;

        float skaleFactor = ( float ) _random . NextDouble ( ) * 1.5f;

        Lily lily = new Lily
            {
            Position = new Vector3(
                _random.NextDouble() > 0.5 ? _random.Next(-100, -25) : _random.Next(25, 100), // X - случайное положение по ширине
                -waterHeight - salmonElevation + 10.0f, // Y - чуть выше? поверхности воды
                -25f - _random.Next(0, 95)), // Z - появляются сзади (по направлению движения)
            Rotation = _random.NextDouble() > 0.5 ? ( float )_random.NextDouble() : -( float )_random.NextDouble() * MathHelper.TwoPi * ( float ) MathHelper.Sqrt(skaleFactor),
            Scale = 0.5f + skaleFactor,
            Speed = 0.026f / ( float ) MathHelper.Sqrt(1.275f + skaleFactor * 0.5) + (float)_random.NextDouble() * 0.005f / ( float ) MathHelper.Sqrt(MathHelper.Sqrt(1.275f + skaleFactor * 0.5)),
            IsActive = true
            };

        _lilies . Add ( lily );
        }

    private void UpdateLilies ( float deltaTime )
        {
        _lilySpawnTimer += deltaTime;
        if ( _lilySpawnTimer >= LilySpawnInterval )
            {
            _lilySpawnTimer = 0f;
            if ( _lilies . Count < 75 )
                {
                SpawnLily ( );
                }
            }

        // Обновляем позиции кувшинок
        for ( int i = _lilies . Count - 1 ; i >= 0 ; i-- )
            {
            Lily lily = _lilies[i];
            lily . Position . Z += ( lily . Speed ) * ( _isWPressed ? 1.5f : 1.0f );

            // Удаляем кувшинки, которые вышли за пределы видимости
            if ( lily . Position . Z > 165f )
                {
                _lilies . RemoveAt ( i );
                }
            }
        }

    private void RenderLilies ( Matrix4 view )
        {
        GL . UseProgram ( _lilyShaderProgram );
        GL . BindVertexArray ( _lilyVao );

        float time = (float)DateTime.Now.TimeOfDay.TotalSeconds;
        GL . Uniform1 ( GL . GetUniformLocation ( _lilyShaderProgram , "time" ) , time );

        GL . ActiveTexture ( TextureUnit . Texture0 + TEXTURE_UNIT_LILY );
        GL . BindTexture ( TextureTarget . Texture2D , TEXTURE_UNIT_LILY );
        GL . Uniform1 ( GL . GetUniformLocation ( _lilyShaderProgram , "lilyTexture" ) , TEXTURE_UNIT_LILY );

        GL . ActiveTexture ( TextureUnit . Texture0 + TEXTURE_UNIT_WATER );
        GL . BindTexture ( TextureTarget . Texture2D , TEXTURE_UNIT_WATER );
        GL . Uniform1 ( GL . GetUniformLocation ( _lilyShaderProgram , "waterTexture" ) , TEXTURE_UNIT_WATER );

        foreach ( Lily lily in _lilies )
            {
            if ( !lily . IsActive ) continue;

            Matrix4 modelMatrix = Matrix4.CreateScale(lily.Scale) *
                                   Matrix4.CreateRotationY(lily.Rotation) *
                                   Matrix4.CreateTranslation(lily.Position);
            GL . Uniform1 ( GL . GetUniformLocation ( _planeShaderProgram , "_isWPressed" ) , _isWPressed ? 2.0f : 1.0f );
            GL . Uniform1 ( GL . GetUniformLocation ( _lilyShaderProgram , "rotationFactor" ) , lily . Rotation );
            GL . Uniform1 ( GL . GetUniformLocation ( _lilyShaderProgram , "scaleFactor" ) , lily . Scale );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _lilyShaderProgram , "projection" ) , false , ref _projection );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _lilyShaderProgram , "view" ) , false , ref _view );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _lilyShaderProgram , "model" ) , false , ref modelMatrix );
            GL . Uniform4 ( GL . GetUniformLocation ( _lilyShaderProgram , "color" ) , new Vector4 ( 0.133f , 0.5451f , 0.133f , 0.975f ) );

            foreach ( LilyPart part in _lilyParts )
                {
                GL . DrawElements ( PrimitiveType . Triangles , part . IndexCount ,
                        DrawElementsType . UnsignedInt , part . StartIndex * sizeof ( uint ) );
                }
            }

        GL . BindVertexArray ( 0 );
        }

    private void CreatePlaneGeometry ( )
        {
        const float planeSize = 600f;
        const int segments = 100;

        for ( int i = 0 ; i <= segments ; i++ )
            {
            for ( int j = 0 ; j <= segments ; j++ )
                {
                float x = (i / (float)segments) * planeSize - (planeSize / 2);
                float z = (j / (float)segments) * planeSize - (planeSize / 2);
                Vector2 texCoord = new Vector2(i / (float)segments, j / (float)segments);

                _planeVertices . Add ( new PlaneVertex (
                    new Vector3 ( x , -salmonElevation , z ) ,
                    texCoord
                ) );
                }
            }

        for ( int i = 0 ; i < segments ; i++ )
            {
            for ( int j = 0 ; j < segments ; j++ )
                {
                uint topLeft = (uint)(i * (segments + 1) + j);
                uint topRight = topLeft + 1;
                uint bottomLeft = (uint)((i + 1) * (segments + 1) + j);
                uint bottomRight = bottomLeft + 1;

                _planeIndices . Add ( topLeft );
                _planeIndices . Add ( bottomLeft );
                _planeIndices . Add ( topRight );

                _planeIndices . Add ( topRight );
                _planeIndices . Add ( bottomLeft );
                _planeIndices . Add ( bottomRight );
                }
            }

        _planePart = new PlanePart
            {
            StartIndex = 0 ,
            IndexCount = _planeIndices . Count ,
            Color = new Vector4 ( 1.0f , 1.0f , 1.0f , 1.0f ) ,
            TextureId = TEXTURE_UNIT_PLANE
            };
        }
    private void CreateWaterGeometry ( )
        {
        const float waterSize = 600f; // Такой же размер как у плоскости
        const float waterLevel = -salmonElevation + waterHeight; // Позиция по Y

        // Вершины воды (верхняя грань параллелепипеда)
        _waterVertices . Add ( new WaterVertex ( new Vector3 ( -waterSize / 2 , waterLevel , -waterSize / 2 ) , new Vector2 ( 0 , 0 ) ) );
        _waterVertices . Add ( new WaterVertex ( new Vector3 ( waterSize / 2 , waterLevel , -waterSize / 2 ) , new Vector2 ( 1 , 0 ) ) );
        _waterVertices . Add ( new WaterVertex ( new Vector3 ( waterSize / 2 , waterLevel , waterSize / 2 ) , new Vector2 ( 1 , 1 ) ) );
        _waterVertices . Add ( new WaterVertex ( new Vector3 ( -waterSize / 2 , waterLevel , waterSize / 2 ) , new Vector2 ( 0 , 1 ) ) );

        // Индексы (2 треугольника)
        _waterIndices . Add ( 0 );
        _waterIndices . Add ( 1 );
        _waterIndices . Add ( 2 );
        _waterIndices . Add ( 0 );
        _waterIndices . Add ( 2 );
        _waterIndices . Add ( 3 );

        _waterPart = new WaterPart
            {
            StartIndex = 0 ,
            IndexCount = _waterIndices . Count ,
            Color = new Vector4 ( 0.2f , 0.6f , 1.0f , 0.001f ) , // Полупрозрачный голубой
            TextureId = TEXTURE_UNIT_WATER
            };
        }

    private void CreateWaterBuffers ( )
        {
        // 1. Создаем буфер для отражения
        reflectionFBO = GL . GenFramebuffer ( );
        GL . BindFramebuffer ( FramebufferTarget . Framebuffer , reflectionFBO );

        reflectionTexture = GL . GenTexture ( );
        GL . BindTexture ( TextureTarget . Texture2D , reflectionTexture );

        // Оптимальные параметры для текстуры отражения
        GL . TexImage2D ( TextureTarget . Texture2D , 0 , PixelInternalFormat . Rgba16f , // Используем 16-битный формат для HDR
                     glControl1 . Width , glControl1 . Height , 0 ,
                     PixelFormat . Rgba , PixelType . Float , IntPtr . Zero ); // Float для большей точности

        SetTextureParameters ( );

        // Прикрепляем текстуру к FBO
        GL . FramebufferTexture2D ( FramebufferTarget . Framebuffer ,
                             FramebufferAttachment . ColorAttachment0 ,
                             TextureTarget . Texture2D , reflectionTexture , 0 );

        // 2. Создаем буфер для преломления
        refractionFBO = GL . GenFramebuffer ( );
        GL . BindFramebuffer ( FramebufferTarget . Framebuffer , refractionFBO );

        refractionTexture = GL . GenTexture ( );
        GL . BindTexture ( TextureTarget . Texture2D , refractionTexture );
        GL . TexImage2D ( TextureTarget . Texture2D , 0 , PixelInternalFormat . Rgba ,
                     glControl1 . Width , glControl1 . Height , 0 ,
                     PixelFormat . Rgba , PixelType . UnsignedByte , IntPtr . Zero );

        SetTextureParameters ( );

        GL . FramebufferTexture2D ( FramebufferTarget . Framebuffer ,
                             FramebufferAttachment . ColorAttachment0 ,
                             TextureTarget . Texture2D , refractionTexture , 0 );

        // 4. Восстанавливаем дефолтный FBO
        GL . BindFramebuffer ( FramebufferTarget . Framebuffer , 0 );
        }

    private void SetTextureParameters ( )
        {
        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureMinFilter , ( int ) TextureMinFilter . Linear );
        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureMagFilter , ( int ) TextureMagFilter . Linear );
        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureWrapS , ( int ) TextureWrapMode . ClampToEdge );
        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureWrapT , ( int ) TextureWrapMode . ClampToEdge );
        }
    private void InitializeWaterBuffers ( )
        {
        _waterVao = GL . GenVertexArray ( );
        _waterVbo = GL . GenBuffer ( );
        _waterEbo = GL . GenBuffer ( );

        GL . BindVertexArray ( _waterVao );

        GL . BindBuffer ( BufferTarget . ArrayBuffer , _waterVbo );
        GL . BufferData ( BufferTarget . ArrayBuffer ,
            _waterVertices . Count * WaterVertex . SizeInBytes ,
            _waterVertices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _waterEbo );
        GL . BufferData ( BufferTarget . ElementArrayBuffer ,
            _waterIndices . Count * sizeof ( uint ) ,
            _waterIndices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . VertexAttribPointer ( 0 , 3 , VertexAttribPointerType . Float , false , WaterVertex . SizeInBytes , 0 );
        GL . EnableVertexAttribArray ( 0 );
        GL . VertexAttribPointer ( TEXTURE_UNIT_WATER , 2 , VertexAttribPointerType . Float , false , WaterVertex . SizeInBytes , Vector3 . SizeInBytes );
        GL . EnableVertexAttribArray ( TEXTURE_UNIT_WATER );

        GL . BindVertexArray ( 0 );
        }

    private void InitializePlaneBuffers ( )
        {
        _planeVao = GL . GenVertexArray ( );
        _planeVbo = GL . GenBuffer ( );
        _planeEbo = GL . GenBuffer ( );

        GL . BindVertexArray ( _planeVao );

        GL . BindBuffer ( BufferTarget . ArrayBuffer , _planeVbo );
        GL . BufferData ( BufferTarget . ArrayBuffer ,
            _planeVertices . Count * PlaneVertex . SizeInBytes ,
            _planeVertices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _planeEbo );
        GL . BufferData ( BufferTarget . ElementArrayBuffer ,
            _planeIndices . Count * sizeof ( uint ) ,
            _planeIndices . ToArray ( ) ,
            BufferUsageHint . StaticDraw );

        GL . VertexAttribPointer ( 0 , 3 , VertexAttribPointerType . Float , false , PlaneVertex . SizeInBytes , 0 );
        GL . EnableVertexAttribArray ( 0 );
        GL . VertexAttribPointer ( TEXTURE_UNIT_PLANE , 2 , VertexAttribPointerType . Float , false , PlaneVertex . SizeInBytes , Vector3 . SizeInBytes );
        GL . EnableVertexAttribArray ( TEXTURE_UNIT_PLANE );

        GL . BindVertexArray ( 0 );
        }

    private void InitializePlaneShaders ( )
        {
        const string planeVertexShader = @"
    #version 460 core
    layout(location = 0) in vec3 aPos;
    layout(location = 5) in vec2 aTexCoord;
    
    uniform mat4 projection;
    uniform mat4 view;
    uniform mat4 model;
    
    out vec2 texCoord;
    
    void main() {
        gl_Position = projection * view * model * vec4(aPos, 1.0);
        texCoord = aTexCoord * 5.0;
    }";

        const string planeFragmentShader = @"
    #version 460 core
    out vec4 FragColor;

    in vec2 texCoord;

    uniform sampler2D planeTexture;
    uniform float time;
    uniform float _isWPressed;

    float rand(vec2 n) { 
        return fract(sin(dot(n, vec2(12.9898, 4.1414))) * 43758.5453);
    }

    float hash(vec2 p) {
        p = fract(p * vec2(123.34, 456.21));
        p += dot(p, p + 45.32);
        return fract(p.x * p.y);
    }

    void main() {
        vec2 tiledCoord = fract(texCoord * 5.0);
        float noiseSpeed = 1.0;
        float rippleXSpeed = 30.3 * _isWPressed;
        float rippleYSpeed = 1.75;
        float rippleSpeed = 60.0 * _isWPressed;
        float randSpeed = 0.1;

        vec2 noise;
        noise.x = hash(tiledCoord + time * noiseSpeed * 0.2) - 0.5;
        noise.y = hash(tiledCoord.yx - time * noiseSpeed * 0.3) - 0.5;
        vec2 noisyCoord = tiledCoord + noise * 0.3 + vec2(rand(tiledCoord + time * randSpeed) * 0.025);

        float rippleX = sin(tiledCoord.y * 22.5 + time * rippleXSpeed) * 0.975;
        float rippleY = cos(tiledCoord.x * 15.0 - time * rippleYSpeed) * 0.275;
        noisyCoord += vec2(rippleX, rippleY);

        float ripple = sin(tiledCoord.x * 30.0 + time * rippleSpeed) * 0.175;
        noisyCoord.y += ripple;
        
        vec4 color;
        color.r = texture(planeTexture, noisyCoord + vec2(0.15, 0.0)).r;
        color.g = texture(planeTexture, noisyCoord + vec2(-0.15, 0.15)).g;
        color.b = texture(planeTexture, noisyCoord + vec2(0.0, -0.15)).b;
        color.a = 1.0;

        color.rgb = clamp(color.rgb * 1.5 - 0.25, 0.0, 1.0);

        FragColor = color;
    }";

        _planeShaderProgram = GL . CreateProgram ( );
        int planeVS = CompileShader(ShaderType.VertexShader, planeVertexShader);
        int planeFS = CompileShader(ShaderType.FragmentShader, planeFragmentShader);

        GL . AttachShader ( _planeShaderProgram , planeVS );
        GL . AttachShader ( _planeShaderProgram , planeFS );
        GL . LinkProgram ( _planeShaderProgram );

        GL . DetachShader ( _planeShaderProgram , planeVS );
        GL . DetachShader ( _planeShaderProgram , planeFS );
        GL . DeleteShader ( planeVS );
        GL . DeleteShader ( planeFS );
        }
    private void InitializeWaterShaders ( )
        {
        const string waterVertexShader = @"
    #version 460 core
    layout(location = 0) in vec3 aPos;
    layout(location = 6) in vec2 aTexCoord;
    
    uniform mat4 projection;
    uniform mat4 view;
    uniform mat4 model;
    uniform float time;
    
    out vec2 texCoord;
    out vec3 worldPos;
    out vec3 viewDir;
    out vec3 normal;
    
    void main() {
        float waveHeight = sin(aPos.x * 0.25 + time * 0.75) * 0.3 +
                          cos(aPos.z * 0.15 + time * 0.6) * 0.45;
        vec3 displacedPos = aPos + vec3(0.0, waveHeight * 0.5, 0.0);
    
        float dx = 0.5 * cos(aPos.x * 0.25 + time * 0.75) * 0.3;
        float dz = -0.3 * sin(aPos.z * 0.15 + time * 0.6) * 0.45;
        normal = normalize(vec3(-dx, 1.0, -dz));
        normal = normalize(normal + vec3(0.0, 0.2, 0.0));
    
        gl_Position = projection * view * model * vec4(displacedPos, 1.0);
        texCoord = aTexCoord * 5.0;
        worldPos = displacedPos;
        viewDir = normalize(-displacedPos);
    }";

        const string waterFragmentShader = @"
    #version 460 core
    out vec4 FragColor;

    in vec2 texCoord;
    in vec3 worldPos;
    in vec3 viewDir;
    in vec3 normal;

    uniform vec4 waterColor;
    uniform sampler2D waterTexture;
    uniform sampler2D reflectionTexture;
    uniform sampler2D refractionTexture;
    uniform float time;
    uniform float _wiggleTime;
    uniform float wakeCenterX = 0.0;
    uniform float tailWiggleAmplitude = 0.0;

    float fresnel(vec3 viewDir, vec3 normal, float power) {
        float fresnelFactor = dot(viewDir, normal);
        return pow(1.0 - max(fresnelFactor, 0.0), power);
    }

    float hash(vec2 p) {
        p = fract(p * vec2(123.34, 456.21));
        p += dot(p, p + 45.32);
        return fract(p.x * p.y);
    }

    float rippleCircle(vec2 center, vec2 uv, float speed, float size) {
        float d = length(uv - center);
        return sin(d * size - time * speed) * 0.275 / (sqrt(sqrt(d)) * 0.75 + 0.25);
    }

    void main() {
        vec3 reflectDir = reflect(viewDir, normal);
        vec2 reflectionCoords = vec2(0.5 + reflectDir.x * 0.5, 0.5 + reflectDir.z * 0.5);
        vec4 reflectionColor = texture(reflectionTexture, reflectionCoords);
        reflectionColor.rgb += 0.4;
        reflectionColor.rgb += reflectionColor.rgb * 3;

        float refractiveIndex = 1.33; 
        vec3 refractDir = refract(viewDir, normal, 1.0/refractiveIndex);
        vec2 refractionCoords = vec2(0.5 + refractDir.x * 0.5, 0.5 + refractDir.z * 0.5);
        vec4 refractionColor = texture(refractionTexture, refractionCoords);

        float fresnelFactor = fresnel(viewDir, normal, 1.5) * 2;
        float smoothFresnel = smoothstep(0.3, 0.6, fresnelFactor);

        vec2 centers[9];
        centers[0] = vec2(-72.5, 85.0);
        centers[1] = vec2(75.5, 60.0);
        centers[2] = vec2(-35.0, 70.0);
        centers[3] = vec2(-10.0, 90.0);
        centers[4] = vec2(15.0, 75.0);
        centers[5] = vec2(40.0, 40.0);
        centers[6] = vec2(-35.0, 15.0);
        centers[7] = vec2(39.5, -7.0);
        centers[8] = vec2(0.0, 0.0);

        float rippleEffect = 0.0;
        for(int i = 0; i < 9; i++) {
            rippleEffect += rippleCircle(centers[i], worldPos.xz, 7.75 + i*sqrt(sqrt(i))*0.5, 1.375 + sqrt(i)*i*0.05);
        }

        vec2 distortedReflection = reflectionCoords + rippleEffect * 0.1;
        vec2 distortedRefraction = refractionCoords + rippleEffect * 0.5;
    
        reflectionColor = texture(reflectionTexture, distortedReflection);
        refractionColor = texture(refractionTexture, distortedRefraction);

        float wakeEffect = 0.0;
        float zStart = -40.0 + 1.2 * tailWiggleAmplitude; 
        float zEnd;
        if (tailWiggleAmplitude <= 0.875) {
            zEnd = 39.0 * tailWiggleAmplitude;
        } else {
            zEnd = 33.25 + sin(_wiggleTime);
        }
        float shift;
        if (tailWiggleAmplitude <= 0.875) {
            shift = 15.0;
        } else {
            shift = 15.0 + cos(_wiggleTime);
        }
        float width = 7.5;
        if (tailWiggleAmplitude > 0.875) {
            width += sin(_wiggleTime);
        }   
        float z = worldPos.z;
        
        float xOffset = worldPos.x - wakeCenterX;
        
        float zFactor = smoothstep(zStart, zStart + 7.5, z) * (1.0 - smoothstep(zEnd - 7.5, zEnd, z)); 
        
        wakeEffect += sin(z * 0.1 - _wiggleTime * 1.33) * 
                     exp(-abs(xOffset) * 0.05) * 0.8 * zFactor * tailWiggleAmplitude;
        
        wakeEffect += sin(z * 0.2 + abs(xOffset) * 0.3 - _wiggleTime * 1.0) * 
                     exp(-pow(abs(xOffset) - shift, 2.0) * 0.002) * 0.48 * zFactor * tailWiggleAmplitude;
        
        wakeEffect += sin(z * 0.5 - _wiggleTime * 2.0) * 0.16 * 
                     (1.0 - smoothstep(0.0, width, abs(xOffset))) * zFactor * tailWiggleAmplitude;

        vec2 noisyCoord = texCoord;
        noisyCoord.x += hash(worldPos.xz + time * 0.25) * 10;
        noisyCoord.y += hash(worldPos.zx - time * 0.1125) * 0.0625;

        vec2 distortedCoord = noisyCoord * 1.75 + rippleEffect * 1.5 + 5.5 * vec2(0.0, wakeEffect * 0.5);
        vec4 texColor = texture(waterTexture, distortedCoord);
        
        vec4 finalColor = mix(refractionColor, reflectionColor, smoothFresnel);
        FragColor = mix(waterColor, texColor, 0.5);
        FragColor = mix(finalColor, FragColor, 0.775);
        FragColor.a = 0.375;
    }";

        _waterShaderProgram = GL . CreateProgram ( );
        int waterVS = CompileShader(ShaderType.VertexShader, waterVertexShader);
        int waterFS = CompileShader(ShaderType.FragmentShader, waterFragmentShader);

        GL . AttachShader ( _waterShaderProgram , waterVS );
        GL . AttachShader ( _waterShaderProgram , waterFS );
        GL . LinkProgram ( _waterShaderProgram );

        GL . DetachShader ( _waterShaderProgram , waterVS );
        GL . DetachShader ( _waterShaderProgram , waterFS );
        GL . DeleteShader ( waterVS );
        GL . DeleteShader ( waterFS );
        }

    private void GlControl_Load ( object sender , EventArgs e )
        {
        if ( reflectionFBO == 0 )
            {
            CreateWaterBuffers ( );
            }
        InitializeGL ( );
        LoadTextures ( );
        InitializeShaders ( );
        InitializeBuffers ( );
        InitializePlane ( );
        InitializeLilies ( );
        InitializeBranches ( );
        InitializeRocks ( );
        InitializeLogs ( );

        glControl1 . Context . SwapInterval = 1;

        // Включаем мультисэмплинг
        GL . Enable ( EnableCap . Multisample );

        UpdateProjectionMatrix ( );
        float cameraDistance = 30f;
        float cameraHeight = 40f;

        _view = Matrix4 . LookAt (
            new Vector3 ( 0 , cameraHeight , -cameraDistance ) ,
            new Vector3 ( 0 , 0 , 14.5f ) ,
            Vector3 . UnitY
        );
        _model = Matrix4 . CreateTranslation ( 0 , 0 , 0 );
        glControl1 . Invalidate ( );
        }

    private void InitializeGL ( )
        {
        GL . ClearColor ( Color . SkyBlue );
        GL . Enable ( EnableCap . DepthTest );
        GL . Enable ( EnableCap . Blend );
        GL . BlendFunc ( BlendingFactor . SrcAlpha , BlendingFactor . OneMinusSrcAlpha );
        GL . Enable ( EnableCap . Multisample );
        GL . Enable ( EnableCap . TextureCubeMapSeamless );
        GL . Hint ( HintTarget . MultisampleFilterHintNv , HintMode . Nicest );
        GL . Enable ( EnableCap . SampleShading );
        GL . MinSampleShading ( 1.0f );
        }

    private void LoadTextures ( )
        {
        LoadTexture ( "D:\\Cube\\DETAIL_PICTURE_652365_75500017.jpg" , TEXTURE_UNIT_BODY , TextureWrapMode . MirroredRepeatIbm , TextureWrapMode . MirroredRepeatIbm );
        LoadTexture ( "D:\\Cube\\4e69213cfe312406386cfdf4f9367e70.jpg" , TEXTURE_UNIT_FIN , TextureWrapMode . MirroredRepeatArb , TextureWrapMode . MirroredRepeatArb );
        LoadTexture ( "D:\\Cube\\8cbe641cf215dac715c8402df3efcb65.jpg" , TEXTURE_UNIT_FACE , TextureWrapMode . ClampToEdgeSgis , TextureWrapMode . MirroredRepeatIbm );
        LoadTexture ( "D:\\Cube\\amber-texture-1-1176589.jpg" , TEXTURE_UNIT_EYE , TextureWrapMode . ClampToEdgeSgis , TextureWrapMode . ClampToEdgeSgis );
        LoadTexture ( "D:\\Cube\\rocks-2410019_1280.jpg" , TEXTURE_UNIT_PLANE , TextureWrapMode . MirroredRepeatIbm , TextureWrapMode . MirroredRepeatIbm );
        LoadTexture ( "D:\\Cube\\fc7d26s-960.jpg" , TEXTURE_UNIT_WATER , TextureWrapMode . MirroredRepeatArb , TextureWrapMode . MirroredRepeatArb );
        }

    private void LoadTexture ( string path , int textureUnit , TextureWrapMode wrapS , TextureWrapMode wrapT )
        {
        _ = GL . GenTexture ( );
        GL . ActiveTexture ( TextureUnit . Texture0 + textureUnit - 1 );
        GL . BindTexture ( TextureTarget . Texture2D , textureUnit );

        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureWrapS , ( int ) wrapS );
        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureWrapT , ( int ) wrapT );
        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureMinFilter , ( int ) TextureMinFilter . Linear );
        GL . TexParameter ( TextureTarget . Texture2D , TextureParameterName . TextureMagFilter , ( int ) TextureMagFilter . Linear );

        StbImage . stbi_set_flip_vertically_on_load ( 1 );
        using FileStream stream = File . OpenRead ( path );
        ImageResult texture = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
        GL . TexImage2D ( TextureTarget . Texture2D , 0 , PixelInternalFormat . Rgba , texture . Width , texture . Height ,
                      0 , PixelFormat . Rgba , PixelType . UnsignedByte , texture . Data );
        }

    private void InitializeShaders ( )
        {
        const string headShader = @"
            #version 460 core
            layout(location = 0) in vec3 aPos;
            layout(location = 1) in vec2 aTexCoord;
            layout(location = 2) in vec2 aTexCoordFin;
            layout(location = 3) in vec2 aTexCoordFace;
            layout(location = 4) in vec2 aTexCoordEye;

            uniform mat4 projection;
            uniform mat4 view;
            uniform mat4 model;
            uniform mat4 headRotation;

            out vec2 texCoord;
            out vec2 texCoordFace;
            out vec2 texCoordFin;
            out vec2 texCoordEye;

            void main() {
                vec4 rotatedPos = headRotation * vec4(aPos, 1.0);
                gl_Position = projection * view * model * rotatedPos;
                texCoord = aTexCoord;
                texCoordFin = aTexCoordFin;
                texCoordFace = aTexCoordFace;
                texCoordEye = aTexCoordEye;
            }";

        const string vertexShader = @"
            #version 460 core
            layout(location = 0) in vec3 aPos;
            layout(location = 1) in vec2 aTexCoord;
            layout(location = 2) in vec2 aTexCoordFin;
            layout(location = 3) in vec2 aTexCoordFace;
            layout(location = 4) in vec2 aTexCoordEye;

            uniform mat4 projection;
            uniform mat4 view;
            uniform mat4 model;

            out vec2 texCoord;
            out vec2 texCoordFace;
            out vec2 texCoordFin;
            out vec2 texCoordEye;

            void main() {
                gl_Position = projection * view * model * vec4(aPos, 1.0);
                texCoord = aTexCoord;
                texCoordFin = aTexCoordFin;
                texCoordFace = aTexCoordFace;
                texCoordEye = aTexCoordEye;
            }";

        const string fragmentShader = @"
            #version 460 core
            out vec4 FragColor;

            in vec2 texCoord; 
            in vec2 texCoordFin;
            in vec2 texCoordFace;
            in vec2 texCoordEye; 

            uniform sampler2D textureBody;
            uniform sampler2D textureFin;
            uniform sampler2D textureFace;
            uniform sampler2D textureEye;
            uniform int textureId;
            uniform vec4 color;

            vec3 overlay(vec3 base, vec3 blend) {
                return vec3(
                    (base.r < 0.5) ? (2.0 * base.r * blend.r) : (1.0 - 2.0 * (1.0 - base.r) * (1.0 - blend.r)),
            (base.g < 0.5) ? (2.0 * base.g * blend.g) : (1.0 - 2.0 * (1.0 - base.g) * (1.0 - blend.g)),
                    (base.b < 0.5) ? (2.0 * base.b * blend.b) : (1.0 - 2.0 * (1.0 - base.b) * (1.0 - blend.b)));
            }

            void main() {
                vec4 texColor;

                if (textureId == 1) {
                    texColor = texture(textureBody, texCoord);
                } else if (textureId == 2) {
                    texColor = texture(textureFin, texCoordFin);
                } else if (textureId == 3) {
                    texColor = texture(textureFace, texCoordFace);
                } else if (textureId == 4) {
                    texColor = texture(textureEye, texCoordEye);
                } else {
                    texColor = vec4(1.0);
                }

                if (color.r >= 1.0 || color.r == 0.0) { 
                    FragColor = vec4(color.rgb * 2.5, 1.0);
                } else {
                    vec3 overlayColor = overlay(texColor.rgb, color.rgb);
                    FragColor = vec4(overlayColor * 0.55, texColor.a);
                }
            }";

        _shaderProgram = GL . CreateProgram ( );
        int vertexShaderId = CompileShader(ShaderType.VertexShader, vertexShader);
        _headShaderProgram = GL . CreateProgram ( );
        int headShaderId = CompileShader(ShaderType.VertexShader, headShader);
        int fragmentShaderId = CompileShader(ShaderType.FragmentShader, fragmentShader);

        GL . AttachShader ( _shaderProgram , vertexShaderId );
        GL . AttachShader ( _shaderProgram , fragmentShaderId );
        GL . LinkProgram ( _shaderProgram );
        GL . AttachShader ( _headShaderProgram , headShaderId );
        GL . AttachShader ( _headShaderProgram , fragmentShaderId );
        GL . LinkProgram ( _headShaderProgram );

        GL . DetachShader ( _headShaderProgram , headShaderId );
        GL . DetachShader ( _headShaderProgram , fragmentShaderId );
        GL . DeleteShader ( headShaderId );
        GL . DetachShader ( _shaderProgram , vertexShaderId );
        GL . DetachShader ( _shaderProgram , fragmentShaderId );
        GL . DeleteShader ( vertexShaderId );
        GL . DeleteShader ( fragmentShaderId );
        }

    private int CompileShader ( ShaderType type , string source )
        {
        int shader = GL.CreateShader(type);
        GL . ShaderSource ( shader , source );
        GL . CompileShader ( shader );
        return shader;
        }

    #endregion

    #region Инициализация буферов и геометрии

    private void InitializeBuffers ( )
        {
        Dictionary<string , (int start, int count)> partRanges = new ( )
            {
            // Создаем геометрию всех частей модели
            [ "Body" ] = (indices . Count, 0)
            };
        CreateBodyGeometry ( bodySegments , radialSegments );
        partRanges [ "Body" ] = (partRanges [ "Body" ] . start, indices . Count - partRanges [ "Body" ] . start);

        partRanges [ "TailFin" ] = (indices . Count, 0);
        CreateTailFin ( bodyWidth , bodyLength );
        partRanges [ "TailFin" ] = (partRanges [ "TailFin" ] . start, indices . Count - partRanges [ "TailFin" ] . start);

        partRanges [ "SingleVentralFin" ] = (indices . Count, 0);
        CreateSingleVentralFin ( bodyWidth , bodyLength );
        partRanges [ "SingleVentralFin" ] = (partRanges [ "SingleVentralFin" ] . start, indices . Count - partRanges [ "SingleVentralFin" ] . start);

        partRanges [ "VentralFins" ] = (indices . Count, 0);
        CreateVentralFins ( bodyWidth , bodyLength );
        partRanges [ "VentralFins" ] = (partRanges [ "VentralFins" ] . start, indices . Count - partRanges [ "VentralFins" ] . start);

        partRanges [ "DorsalFin" ] = (indices . Count, 0);
        CreateUltraRealisticDorsalFin ( bodyWidth , bodyLength );
        partRanges [ "DorsalFin" ] = (partRanges [ "DorsalFin" ] . start, indices . Count - partRanges [ "DorsalFin" ] . start);

        partRanges [ "PectoralFins" ] = (indices . Count, 0);
        CreatePectoralFins ( bodyWidth , bodyLength );
        partRanges [ "PectoralFins" ] = (partRanges [ "PectoralFins" ] . start, indices . Count - partRanges [ "PectoralFins" ] . start);

        partRanges [ "LowerJaw" ] = (indices . Count, 0);
        CreateLowerJawGeometry ( bodyWidth , bodyLength );
        partRanges [ "LowerJaw" ] = (partRanges [ "LowerJaw" ] . start, indices . Count - partRanges [ "LowerJaw" ] . start);

        partRanges [ "LowerJaw" ] = (indices . Count, 0);
        CreateLowerJawGeometry ( bodyWidth , bodyLength );
        partRanges [ "LowerJaw" ] = (partRanges [ "LowerJaw" ] . start, indices . Count - partRanges [ "LowerJaw" ] . start);

        partRanges [ "Teeth" ] = (indices . Count, 0);
        CreateTeethGeometry ( bodyWidth , bodyLength );
        partRanges [ "Teeth" ] = (partRanges [ "Teeth" ] . start, indices . Count - partRanges [ "Teeth" ] . start);

        partRanges [ "Head" ] = (indices . Count, 0);
        CreateHeadGeometry ( bodyWidth , bodyLength );
        partRanges [ "Head" ] = (partRanges [ "Head" ] . start, indices . Count - partRanges [ "Head" ] . start);

        partRanges [ "Eyes" ] = (indices . Count, 0);
        CreateDetailedEye ( new Vector3 ( bodyWidth * 0.3f , bodyWidth * 0.15f , bodyLength * 0.85f ) , bodyWidth * 0.16f , 24 );
        CreateDetailedEye ( new Vector3 ( -bodyWidth * 0.3f , bodyWidth * 0.15f , bodyLength * 0.85f ) , bodyWidth * 0.16f , 24 );
        partRanges [ "Eyes" ] = (partRanges [ "Eyes" ] . start, indices . Count - partRanges [ "Eyes" ] . start);

        partRanges [ "EyeHighlights" ] = (indices . Count, 0);
        CreateEyeHighlights ( bodyWidth , bodyLength );
        partRanges [ "EyeHighlights" ] = (partRanges [ "EyeHighlights" ] . start, indices . Count - partRanges [ "EyeHighlights" ] . start);

        partRanges [ "EyePupils" ] = (indices . Count, 0);
        CreateEyePupils ( bodyWidth , bodyLength );
        partRanges [ "EyePupils" ] = (partRanges [ "EyePupils" ] . start, indices . Count - partRanges [ "EyePupils" ] . start);

        partRanges [ "UpperTeeth" ] = (indices . Count, 0);
        CreateUpperTeethGeometry ( bodyWidth , bodyLength );
        partRanges [ "UpperTeeth" ] = (partRanges [ "UpperTeeth" ] . start, indices . Count - partRanges [ "UpperTeeth" ] . start);

        // Инициализация буферов только при первом создании
        if ( _salmonVao == 0 )
            {
            CreateBuffers ( );
            InitializeModelParts ( partRanges );
            }
        }

    private void CreateBuffers ( )
        {
        // Генерация VAO и буферов
        _salmonVao = GL . GenVertexArray ( );
        _salmonVbo = GL . GenBuffer ( );
        _salmonEbo = GL . GenBuffer ( );

        // Настройка VAO
        GL . BindVertexArray ( _salmonVao );

        // Настройка VBO (вершинный буфер)
        GL . BindBuffer ( BufferTarget . ArrayBuffer , _salmonVbo );
        GL . BufferData ( BufferTarget . ArrayBuffer ,
                     vertices . Count * Vertex . SizeInBytes ,
                     vertices . ToArray ( ) ,
                     BufferUsageHint . DynamicDraw );

        // Настройка EBO (индексный буфер)
        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _salmonEbo );
        GL . BufferData ( BufferTarget . ElementArrayBuffer ,
                     indices . Count * sizeof ( uint ) ,
                     indices . ToArray ( ) ,
                     BufferUsageHint . DynamicDraw );

        // Настройка атрибутов вершины
        int stride = Vertex.SizeInBytes;

        // Позиция (location = 0)
        GL . VertexAttribPointer ( 0 , 3 , VertexAttribPointerType . Float , false , stride , 0 );
        GL . EnableVertexAttribArray ( 0 );

        // TexCoordBody (location = 1)
        GL . VertexAttribPointer ( 1 , 2 , VertexAttribPointerType . Float , false , stride , 0 );
        GL . EnableVertexAttribArray ( 1 );

        // TexCoordFin (location = 2)
        GL . VertexAttribPointer ( 2 , 2 , VertexAttribPointerType . Float , false , stride , 0 );
        GL . EnableVertexAttribArray ( 2 );

        // TexCoordFace (location = 3)
        GL . VertexAttribPointer ( 3 , 2 , VertexAttribPointerType . Float , false , stride , 0 );
        GL . EnableVertexAttribArray ( 3 );

        // TexCoordEye (location = 4)
        GL . VertexAttribPointer ( 4 , 2 , VertexAttribPointerType . Float , false , stride , 0 );
        GL . EnableVertexAttribArray ( 4 );

        GL . BindVertexArray ( 0 );
        }

    private void InitializeModelParts ( Dictionary<string , (int start, int count)> partRanges )
        {
        _salmonParts . Clear ( );

        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "Body" ] . start , IndexCount = partRanges [ "Body" ] . count , Color = new Vector4 ( 0.59376f , 0.02f , 0.02f , 0.7f ) , IsVisible = false , TextureId = 1 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "TailFin" ] . start , IndexCount = partRanges [ "TailFin" ] . count , Color = new Vector4 ( 0.205f , 0.35f , 0f , 0.9f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "SingleVentralFin" ] . start , IndexCount = partRanges [ "SingleVentralFin" ] . count , Color = new Vector4 ( 0.59375f , 0.02f , 0.02f , 0.7f ) , IsVisible = false , TextureId = 3 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "VentralFins" ] . start , IndexCount = partRanges [ "VentralFins" ] . count , Color = new Vector4 ( 0.59375f , 0.02f , 0.02f , 0.7f ) , IsVisible = false , TextureId = 3 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "DorsalFin" ] . start , IndexCount = partRanges [ "DorsalFin" ] . count , Color = new Vector4 ( 0.59375f , 0.02f , 0.02f , 0.7f ) , IsVisible = false , TextureId = 3 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "PectoralFins" ] . start , IndexCount = partRanges [ "PectoralFins" ] . count , Color = new Vector4 ( 0.205f , 0.35f , 0f , 0.6f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "LowerJaw" ] . start , IndexCount = partRanges [ "LowerJaw" ] . count , Color = new Vector4 ( 0.25f , 0.36f , 0.33f , 0.95f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "LowerJaw" ] . start , IndexCount = partRanges [ "LowerJaw" ] . count , Color = new Vector4 ( 0.25f , 0.36f , 0.33f , 0.95f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "Teeth" ] . start , IndexCount = partRanges [ "Teeth" ] . count , Color = new Vector4 ( 1f , 0.99f , 0.95f , 0.95f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "Head" ] . start , IndexCount = partRanges [ "Head" ] . count , Color = new Vector4 ( 0.205f , 0.35f , 0f , 0.95f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "Eyes" ] . start , IndexCount = partRanges [ "Eyes" ] . count , Color = new Vector4 ( 0.99f , 0.91f , 0.3125f , 0.7f ) , IsVisible = false , TextureId = 4 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "EyeHighlights" ] . start , IndexCount = partRanges [ "EyeHighlights" ] . count , Color = new Vector4 ( 2.5f , 2.5f , 2.5f , 0.7f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "EyePupils" ] . start , IndexCount = partRanges [ "EyePupils" ] . count , Color = new Vector4 ( 0.0f , 0.0f , 0.0f , 0.7f ) , IsVisible = false , TextureId = 2 } );
        _salmonParts . Add ( new ModelPart { StartIndex = partRanges [ "UpperTeeth" ] . start , IndexCount = partRanges [ "UpperTeeth" ] . count , Color = new Vector4 ( 1f , 0.99f , 0.95f , 0.95f ) , IsVisible = false , TextureId = 2 } );
        }

    #endregion

    #region Анимация и обновление

    private float GetCombinedTurnAngle ( float t )
        {
        float turnFactor = -_turnAnimationProgress * _turnDirection;

        // Голова и передняя часть тела поворачиваются сильнее
        float headTurnFactor = MathHelper.Clamp(1.5f - (t * 1.5f), 0f, 1f);
        float bodyTurnAngle = turnFactor * _maxTurnAngle * headTurnFactor;

        // Хвост поворачивается в противоположную сторону
        float tailTurnFactor = MathHelper.Clamp((t - 0.5f) / 0.3f, 0, 1);
        float tailTurnAngle = -turnFactor * _maxTurnAngle * 1.8f * tailTurnFactor;

        // Комбинируем повороты головы и хвоста
        return MathHelper . Lerp ( bodyTurnAngle , tailTurnAngle , tailTurnFactor );
        }

    private void UpdateAnimation ( )
        {
        float deltaTime = 0.016f;
        UpdateLilies ( 0.016f ); // ~60 FPS
        UpdateBranches ( 0.016f );
        UpdateRocks ( 0.016f );
        UpdateLogs ( 0.016f );

        if ( _isInvulnerable )
            {
            _invulnerabilityTimer += deltaTime;
            _blinkTimer += deltaTime;

            if ( _blinkTimer >= BlinkInterval )
                {
                _blinkTimer = 0f;
                _isVisibleDuringBlink = !_isVisibleDuringBlink;
                }

            if ( _invulnerabilityTimer >= InvulnerabilityDuration )
                {
                _isInvulnerable = false;
                _isVisibleDuringBlink = true;
                }
            }

        // Проверка столкновений
        if ( !_isInvulnerable )
            {
            CheckCollisions ( );
            }

        // Блокировка глаз при смене полосы
        if ( _isChangingLane )
            {
            _areEyesLocked = true;
            }
        else if ( _areEyesLocked && _turnAnimationProgress < 0.1f )
            {
            _areEyesLocked = false;
            }

        // Обработка специальной анимации грудных плавников
        if ( _isChangingLane && !_isPectoralFinSpecialAnim )
            {
            _isPectoralFinSpecialAnim = true;
            _pectoralFinSpecialAnimTime = 0f;
            }
        else if ( !_isChangingLane && _isPectoralFinSpecialAnim )
            {
            _isPectoralFinSpecialAnim = false;
            }

        if ( _isPectoralFinSpecialAnim )
            {
            _pectoralFinSpecialAnimTime += 0.016f; // ~60 FPS
            if ( _pectoralFinSpecialAnimTime > PectoralFinAnimDuration )
                {
                _isPectoralFinSpecialAnim = false;
                }
            }

        if ( _isChangingLane )
            {
            _areVentralFinsLocked = true;
            _lockedVentralFinAngle = _laneChangeTailSwing * VentralFinLockPhaseFactor;
            }
        else if ( _areVentralFinsLocked && _turnAnimationProgress < 0.1f )
            {
            _areVentralFinsLocked = false;
            }
        // Обработка смены полосы
        if ( _isChangingLane )
            {
            if ( !_isLaneChangingAnimation )
                {
                _isLaneChangingAnimation = true;
                _laneChangeProgress = 0f;
                _isTailFinLocked = true;
                _lockedTailFinAngle = _laneChangeTailSwing;
                _laneChangeTailSwing *= 1.2f;
                }

            // Плавное увеличение прогресса
            _laneChangeProgress = MathHelper . Clamp ( _laneChangeProgress + ( 1.0f / LaneChangeDuration * 0.016f ) * ( _isWPressed ? 2.0f : 1.0f ) , 0f , 1f );

            // Плавное движение с ease-in/ease-out
            float easedProgress = SmoothStep(_laneChangeProgress);

            float headSpeedFactor;
            if ( _laneChangeProgress < 0.1f )
                {
                // Очень резкий старт (первые 10% анимации)
                headSpeedFactor = ( float ) Math . Pow ( _laneChangeProgress / 0.05f , 2.5f ) * 4f;
                }
            else
                {
                // Стандартное ускорение/замедление
                float t = MathHelper.Clamp((_laneChangeProgress - 0.1f) / 0.8f, 0f, 1f);
                headSpeedFactor = ( float ) Math . Pow ( 6 * t * ( 1 - t ) , 0.75f ) * 1.5f;
                }

            float targetX = MathHelper.Lerp(_lanePositions[_currentLane], _lanePositions[_targetLane], easedProgress);
            _currentXPosition = targetX;

            // Анимация поворота тела
            _turnAnimationProgress = _laneChangeProgress;
            _turnDirection = _targetLane > _currentLane ? 1 : -1;

            float headTurnSpeed = HeadTurnSpeed * 0.016f; // ~60 FPS

            // Обновляем прогресс поворота головы
            float targetHeadAngle = _maxTurnAngle * _turnDirection;

            _headTurnProgress = MathHelper . Clamp ( _headTurnProgress + ( headTurnSpeed / LaneChangeDuration ) * ( _isWPressed ? 2.0f : 1.0f ) , 0f , 1f );

            _currentHeadAngle = MathHelper . Lerp ( _currentHeadAngle , targetHeadAngle , HeadTurnSpeed * headSpeedFactor * 0.016f * ( _isWPressed ? 2.0f : 1.0f ) );

            float headTurnAngle = _currentHeadAngle * SmoothStep(_headTurnProgress);
            _headRotationMatrix = Matrix4 . CreateRotationY ( MathHelper . DegreesToRadians ( _currentHeadAngle * easedProgress ) );

            _laneChangeTailSwing *= _laneChangeSwingDecay;

            // Проверяем завершение движения
            if ( _laneChangeProgress >= 1.0f )
                {
                _currentLane = _targetLane;
                _isChangingLane = false;
                _isLaneChangingAnimation = false;
                _isTurningLeft = false;
                _isTurningRight = false;
                }
            }
        else if ( _turnAnimationProgress > 0 )
            {
            // Плавно завершаем анимацию поворота
            _turnAnimationProgress = MathHelper . Clamp ( _turnAnimationProgress - 0.05f * ( _isWPressed ? 2.0f : 1.0f ) , 0f , 1f );
            _headTurnProgress = MathHelper . Clamp ( _headTurnProgress - 0.05f * ( _isWPressed ? 2.0f : 1.0f ) , 0f , 1f );
            float headTurnAngle = _currentHeadAngle * SmoothStep(_headTurnProgress);
            _headRotationMatrix = Matrix4 . CreateRotationY ( MathHelper . DegreesToRadians ( headTurnAngle ) );

            // Когда анимация поворота почти закончилась, разблокируем хвостовой плавник
            if ( _turnAnimationProgress < 0.1f && _isTailFinLocked )
                {
                _isTailFinLocked = false;
                }
            }

        // Остальная логика анимации...
        float baseSpeed = 0.05f;
        _wiggleTime += ( _isWPressed ? baseSpeed * 2.0f : baseSpeed ) * WiggleSpeed;

        // Очищаем и пересоздаем анимированные части
        vertices . Clear ( );
        indices . Clear ( );

        // Создаем анимированные части модели
        CreateBodyGeometry ( bodySegments , radialSegments );
        CreateTailFin ( bodyWidth , bodyLength );
        CreateSingleVentralFin ( bodyWidth , bodyLength );
        CreateVentralFins ( bodyWidth , bodyLength );
        CreateUltraRealisticDorsalFin ( bodyWidth , bodyLength );
        CreatePectoralFins ( bodyWidth , bodyLength );

        // Включаем нужные части
        _salmonParts [ 0 ] . IsVisible = true; // Body
        _salmonParts [ 1 ] . IsVisible = true; // TailFin
        _salmonParts [ 2 ] . IsVisible = true; // SingleVentralFin
        _salmonParts [ 3 ] . IsVisible = true; // VentralFins
        _salmonParts [ 4 ] . IsVisible = true; // DorsalFin
        _salmonParts [ 5 ] . IsVisible = true; // PectoralFins
        _salmonParts [ 6 ] . IsVisible = true;
        _salmonParts [ 7 ] . IsVisible = true;
        _salmonParts [ 8 ] . IsVisible = true;
        _salmonParts [ 9 ] . IsVisible = true;
        _salmonParts [ 10 ] . IsVisible = true;
        _salmonParts [ 11 ] . IsVisible = true;
        _salmonParts [ 12 ] . IsVisible = true;
        _salmonParts [ 13 ] . IsVisible = true;

        // Обновляем буферы
        GL . BindBuffer ( BufferTarget . ArrayBuffer , _salmonVbo );
        GL . BufferSubData ( BufferTarget . ArrayBuffer , IntPtr . Zero ,
                        vertices . Count * Vertex . SizeInBytes ,
                        vertices . ToArray ( ) );

        GL . BindBuffer ( BufferTarget . ElementArrayBuffer , _salmonEbo );
        GL . BufferSubData ( BufferTarget . ElementArrayBuffer , IntPtr . Zero ,
                        indices . Count * sizeof ( uint ) ,
                        indices . ToArray ( ) );

        glControl1 . Invalidate ( );
        }

    #endregion

    #region Методы создания геометрии
    private void RenderPlane ( Matrix4 view )
        {
        GL . UseProgram ( _planeShaderProgram );
        GL . BindVertexArray ( _planeVao );

        Matrix4 planeModel = Matrix4 . CreateScale ( 1 , 1 , 1 );

        float time = (float)DateTime.Now.TimeOfDay.TotalSeconds;
        GL . Uniform1 ( GL . GetUniformLocation ( _planeShaderProgram , "_isWPressed" ) , _isWPressed ? 2.0f : 1.0f );
        GL . Uniform1 ( GL . GetUniformLocation ( _planeShaderProgram , "time" ) , time );
        GL . UniformMatrix4 ( GL . GetUniformLocation ( _planeShaderProgram , "projection" ) , false , ref _projection );
        GL . UniformMatrix4 ( GL . GetUniformLocation ( _planeShaderProgram , "view" ) , false , ref view );
        GL . UniformMatrix4 ( GL . GetUniformLocation ( _planeShaderProgram , "model" ) , false , ref planeModel );
        GL . Uniform4 ( GL . GetUniformLocation ( _planeShaderProgram , "color" ) , _planePart . Color );

        // Используем отдельный текстурный юнит для плоскости
        GL . ActiveTexture ( TextureUnit . Texture0 + TEXTURE_UNIT_PLANE );
        GL . BindTexture ( TextureTarget . Texture2D , TEXTURE_UNIT_PLANE );
        GL . Uniform1 ( GL . GetUniformLocation ( _planeShaderProgram , "planeTexture" ) , TEXTURE_UNIT_PLANE );

        GL . DrawElements ( PrimitiveType . Triangles , _planePart . IndexCount ,
            DrawElementsType . UnsignedInt , _planePart . StartIndex * sizeof ( uint ) );

        GL . BindVertexArray ( 0 );
        }

    private void CreateBodyGeometry ( int bodySegments , int radialSegments )
        {
        const float headTransitionStart = 0.0f;
        const float headTransitionEnd = 0.3f;
        const float hillStart = -0.1f;
        const float hillPeak = 0.25f;
        const float hillEnd = 0.72f;
        const float hillHeight = 0.75f;
        const float approachSmoothness = 2.5f;
        const float descentSmoothness = 2.2f;
        const float bellyStart = 0.25f;
        const float bellyEnd = 0.72f;
        const float bellyDepth = 1.375f;
        const float bellyWidth = 0.72f;
        const float sideFlattening = 1.375f;
        const float wrinkleAmount = 0.3f;
        const float wrinkleCount = 100f;
        const float wrinkleLengthScale = 1f;
        const float bellyWrinkleBoost = 1f;
        const float bodyFlexibility = 1.275f;
        const float maxSidewaysOffset = bodyWidth * 0.45f;

        for ( int ring = 0 ; ring <= bodySegments ; ring++ )
            {
            float t = (float)ring / bodySegments;

            float tailSwingEffect = 0f;
            if ( _isLaneChangingAnimation )
                {
                // Начинаем отклонение с 70% длины тела (только самый конец хвоста)
                float swingStart = ( _isWPressed ? 0.55f : 0.7f );
                if ( t > swingStart )
                    {
                    // Экспоненциальное нарастание к концу хвоста
                    float swingFactor = (t - swingStart) / (1 - swingStart);
                    swingFactor = MathF . Pow ( swingFactor , ( _isWPressed ? 9.0f : 4.5f ) ); // Резкое нарастание в конце

                    // Применяем максимальное отклонение
                    tailSwingEffect = _maxLaneChangeSwing * _laneChangeTailSwing * swingFactor;
                    }
                }

            // Обычное покачивание хвоста (если нужно)
            if ( t > 0.7f )
                {
                _tailSwingAmplitude = _isWPressed ? 1.5f : 1f;
                float tailFactor = (t - 0.7f) / 0.3f;
                tailSwingEffect += _tailSwingAmplitude * MathF . Sin ( tailFactor * MathHelper . Pi ) *
                                ( 1 - _turnAnimationProgress ) * -_turnDirection;
                }

            float z = bodyLength * (0.8f - t);

            // Вычисляем угол поворота для текущего сегмента тела
            float turnFactor = -_turnAnimationProgress * _turnDirection;

            // Голова и передняя часть тела поворачиваются сильнее
            float headTurnFactor = MathHelper.Clamp(1.5f - (t * 1.5f), 0f, 1f);
            float bodyTurnAngle = turnFactor * _maxTurnAngle * headTurnFactor;

            // Хвост поворачивается в противоположную сторону
            float tailTurnFactor = MathHelper.Clamp((t - 0.5f) / 0.3f, 0, 1);
            float tailTurnAngle = -turnFactor * _maxTurnAngle * 1.8f * tailTurnFactor;

            // Комбинируем повороты головы и хвоста
            float combinedTurnAngle = MathHelper.Lerp(bodyTurnAngle, tailTurnAngle, tailTurnFactor);

            // Создаем матрицу поворота для текущего сегмента
            Matrix4 rotation = Matrix4.CreateRotationY(MathHelper.DegreesToRadians(combinedTurnAngle));

            // Остальная анимация (волны и т.д.)
            float wavePhase = (1.8f * t * MathHelper.TwoPi) + (3.3f * (_isLaneChangingAnimation ? 0 : _wiggleTime));
            float wiggleOffset = MathF.Sin(wavePhase) * MaxWiggleAmplitude * maxSidewaysOffset;
            float verticalWiggle = MathF.Sin(wavePhase + MathHelper.PiOver2) * MaxWiggleAmplitude * maxSidewaysOffset * 0.3f;

            float microBouncePhase = _wiggleTime * 2.5f;
            float microBounce = MathF.Sin(microBouncePhase + (t * MathHelper.TwoPi * 0.2f)) * bodyWidth * 0.6f;

            float tailTransition = MathHelper.Clamp((t - 0.6f) / 0.2f, 0, 1);
            if ( tailTransition > 0 )
                {
                float tailWigglePhase = _wiggleTime * 1.95f;
                tailWiggleAmplitude = MaxWiggleAmplitude * 1.75f;

                Vector2 p0 = Vector2.Zero;
                Vector2 p1 = new(
                    MathF.Sin(tailWigglePhase) * tailWiggleAmplitude * 0.8f * maxSidewaysOffset,
                    -0.25f * bodyWidth);
                Vector2 p2 = new(
                    MathF.Sin(tailWigglePhase + MathHelper.PiOver2) * tailWiggleAmplitude * 1.5f * maxSidewaysOffset,
                    -0.6f * bodyWidth);
                Vector2 p3 = new(
                    MathF.Sin(tailWigglePhase + MathHelper.Pi) * tailWiggleAmplitude * 2.2f * maxSidewaysOffset,
                    -1.0f * bodyWidth);

                float tailPos = (t - 0.6f) / 0.4f;
                Vector2 bezierPoint = CalculateBezierPoint(tailPos, p0, p1, p2, p3);

                float smoothTransition = SmoothStep(tailTransition);
                wiggleOffset = MathHelper . Lerp ( wiggleOffset , bezierPoint . X , smoothTransition * 0.9f );
                verticalWiggle = MathHelper . Lerp ( verticalWiggle , bezierPoint . Y * 0.12f , smoothTransition * 0.85f );
                }

            if ( t > 0.6f )
                {
                float tailFactor = MathF.Pow((t - 0.6f) / 0.4f, 1.1f);
                wiggleOffset *= 1 + ( tailFactor * 2.2f );
                verticalWiggle *= 1 + ( tailFactor * 0.15f );
                }

            float widthCurve = 0.8f + (0.4f * MathF.Sin(t * MathHelper.Pi));
            float heightCurve = 0.7f + (0.5f * MathF.Sin(t * MathHelper.Pi));

            if ( t < headTransitionEnd )
                {
                float headT = (t - headTransitionStart) / (headTransitionEnd - headTransitionStart);
                float widthHeightFactor = widthCurve - (0.15f * headT * headT * headT * headT);
                widthCurve *= widthHeightFactor;
                heightCurve *= widthHeightFactor;
                }

            if ( t < headTransitionEnd / 2 )
                {
                float headT = (t - headTransitionStart) / ((headTransitionEnd / 2) - headTransitionStart);
                float widthHeightFactor = widthCurve - (0.05f * headT);
                widthCurve *= widthHeightFactor;
                heightCurve *= widthHeightFactor;
                }

            float hillHeightModifier = 0f;
            float hillWidthReduction = 0f;

            if ( t is > hillStart and < hillEnd )
                {
                float hillT;
                if ( t < hillPeak )
                    {
                    hillT = ( t - hillStart ) / ( hillPeak - hillStart );
                    float curve = MathF.Sin(hillT * MathHelper.PiOver2);
                    heightCurve += hillHeight * MathF . Pow ( curve , approachSmoothness );
                    widthCurve += 0.4f * MathF . Pow ( curve , approachSmoothness );
                    }
                else
                    {
                    hillT = ( t - hillPeak ) / ( hillEnd - hillPeak );
                    float curve = MathF.Cos(hillT * MathHelper.PiOver2);
                    heightCurve += hillHeight * MathF . Pow ( curve , descentSmoothness );
                    widthCurve += 0.4f * MathF . Pow ( curve , approachSmoothness );
                    }

                hillWidthReduction = MathHelper . Lerp ( 1.8f , 2.4f , hillHeightModifier / hillHeight );
                heightCurve += hillHeightModifier;
                }

            float bellyModifier = 1.0f;
            if ( t is > bellyStart and < bellyEnd )
                {
                float bellyT = (t - bellyStart) / (bellyEnd - bellyStart);
                float curve = SmoothStep(bellyT) * SmoothStep(1 - bellyT);
                bellyModifier = 1.0f - ( bellyDepth * curve );
                }

            for ( int radial = 0 ; radial < radialSegments ; radial++ )
                {
                float angle = (float)radial / radialSegments * MathHelper.TwoPi;
                float x = MathF.Cos(angle);
                float y = MathF.Sin(angle);

                float xOffset = wiggleOffset * (1 - MathF.Abs(y)) * bodyFlexibility;

                float flattenFactor = 1.0f + ((sideFlattening - 1.0f) * MathF.Pow(MathF.Abs(x), 2));
                float radialWidth = widthCurve / flattenFactor;
                float radialHeight = heightCurve;
                _ = 1.0f - ( hillWidthReduction * MathF . Pow ( MathF . Abs ( y ) , 2 ) );

                float angleModifier = MathF.Abs(angle);
                if ( angleModifier is > MathHelper . PiOver4 and < ( 3 * MathHelper . PiOver4 ) )
                    {
                    float symmetricCurve = MathF.Cos((angleModifier - MathHelper.PiOver2) * 2);
                    radialHeight *= 1.0f + ( 0.4f * symmetricCurve );
                    }

                if ( angleModifier is > ( 5 * MathHelper . PiOver4 ) or < ( -MathHelper . PiOver4 ) )
                    {
                    float lowerAngle = angleModifier > MathHelper.Pi ? angleModifier - (2 * MathHelper.Pi) : angleModifier;
                    float symmetricCurve = MathF.Abs(MathF.Sin(lowerAngle * 2));
                    radialHeight *= 1.0f - ( 0.3f * symmetricCurve );
                    }

                if ( t > 0.7f )
                    {
                    float tailT = (t - 0.7f) / 0.3f;
                    float tailFactor = 1.0f - (SmoothStep(tailT) * 0.5f);
                    radialWidth *= tailFactor;
                    radialHeight *= tailFactor;
                    }

                float bellyFactor = 1.0f;
                if ( y < 0 )
                    {
                    float yFactor = MathHelper.Clamp(-y * (1.0f / bellyWidth), 0, 1);
                    bellyFactor = MathHelper . Lerp ( 1.0f , bellyModifier , yFactor );
                    }
                Vector3 originalPos = new(x * bodyWidth * 0.5f * radialWidth ,( y * bodyWidth * 0.5f * radialHeight * bellyFactor ) + (_isWPressed == true ? 0.0f : ( verticalWiggle * ( 1 - MathF . Abs ( y ) ) ) + 0.5f) ,z);
                if ( t is > 0.1f and < 0.9f )
                    {
                    float wave = MathF.Sin(t * wrinkleLengthScale * MathHelper.Pi);
                    float radialPattern = MathF.Cos(angle * wrinkleCount);
                    float wrinkle = wrinkleAmount * wave * radialPattern;

                    if ( y < 0 )
                        {
                        wrinkle *= bellyWrinkleBoost;
                        }

                    originalPos . X += x * wrinkle * bodyWidth * 0.1f;
                    originalPos . Y += y * wrinkle * bodyWidth * 0.2f;
                    radialWidth *= 1f + ( wrinkle * 0.15f );
                    radialHeight *= 1f + ( wrinkle * 0.25f );
                    }

                Vector4 rotatedDir = rotation * new Vector4(originalPos, 0.0f); // W=0 игнорирует перенос
                Vector3 rotatedPos = rotatedDir.Xyz;

                if ( tailTransition > 0 )
                    {
                    float tailWigglePhase = _wiggleTime * 3f;
                    tailWiggleAmplitude = MaxWiggleAmplitude * ( _isWPressed ? 2.5f : 1.75f );

                    Vector2 p0 = Vector2.Zero;
                    Vector2 p1 = new(
                        MathF.Sin(tailWigglePhase) * tailWiggleAmplitude * 0.8f * maxSidewaysOffset,
                        -0.25f * bodyWidth);
                    Vector2 p2 = new(
                        MathF.Sin(tailWigglePhase + MathHelper.PiOver2) * tailWiggleAmplitude * 1.5f * maxSidewaysOffset,
                        -0.6f * bodyWidth);
                    Vector2 p3 = new(
                        MathF.Sin(tailWigglePhase + MathHelper.Pi) * tailWiggleAmplitude * 2.2f * maxSidewaysOffset,
                        -1.0f * bodyWidth);

                    float tailPos = (t - 0.6f) / 0.4f;
                    Vector2 bezierPoint = CalculateBezierPoint(tailPos, p0, p1, p2, p3);

                    float smoothTransition = SmoothStep(tailTransition);
                    Vector3 animatedPos = new(
                        rotatedPos.X + (bezierPoint.X * smoothTransition * 0.9f) + (xOffset * (1.0f / MathF.Exp(7 * (t - 0.6f)))),
                        rotatedPos.Y + (bezierPoint.Y * 0.12f * smoothTransition * 0.85f),
                        rotatedPos.Z
                    );

                    animatedPos . Y += _isWPressed == true ? 0.0f : microBounce * ( 0.3f + ( 0.7f * t ) );

                    vertices . Add ( new Vertex ( animatedPos ,
                        new Vector2 ( originalPos . X , originalPos . Y ) ,
                        Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );
                    }
                else
                    {
                    Vector3 pos;
                    if ( _isWPressed == true )
                        {
                        pos = new (
                        rotatedPos . X + xOffset + ( tailSwingEffect * ( 1 - MathF . Abs ( y ) ) * ( t > 0.7f ? 1 : 0 ) ) , // Только для хвоста
                        rotatedPos . Y ,
                        rotatedPos . Z
                    );
                        }
                    else
                        {
                        pos = new (
                        rotatedPos . X + xOffset + ( tailSwingEffect * ( 1 - MathF . Abs ( y ) ) * ( t > 0.7f ? 1 : 0 ) ) , // Только для хвоста
                        rotatedPos . Y + ( verticalWiggle * ( 1 - MathF . Abs ( y ) ) ) + ( microBounce * ( 0.3f + ( 0.7f * t ) ) ) + 0.5f ,
                        rotatedPos . Z
                    );
                        }
                    Vector2 texCoord = new(
                        x * bodyWidth * 0.5f * radialWidth,
                        y * bodyWidth * 0.5f * radialHeight * bellyFactor
                    );

                    vertices . Add ( new Vertex ( pos , texCoord , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );
                    }
                }
            }

        for ( int ring = 0 ; ring < bodySegments ; ring++ )
            {
            for ( int radial = 0 ; radial < radialSegments ; radial++ )
                {
                int current = (ring * radialSegments) + radial;
                int next = current + radialSegments;
                int nextRadial = (radial + 1) % radialSegments;

                indices . Add ( ( uint ) current );
                indices . Add ( ( uint ) ( next + nextRadial ) );
                indices . Add ( ( uint ) ( current + nextRadial ) );

                indices . Add ( ( uint ) current );
                indices . Add ( ( uint ) next );
                indices . Add ( ( uint ) ( next + nextRadial ) );
                }
            }
        }

    private void CreateHeadGeometry ( float width , float length )
        {
        const int headSegments = 1024;
        const float gillDetailIntensity = 0.8f;
        const int gillDetailCount = 16;
        const float eyeAreaDetail = 0.2f;

        float headForwardShift = width * 0.76f;
        float headUpwardShift = width * 0.17f;
        float foreheadSize = width * 0.1f;
        float foreheadStart = -0.9f;
        float foreheadEnd = 0.6f;
        float foreheadPower = 5.0f;
        float hookStart = 0.4f;
        float hookPeak = 0.9f;
        float hookTip = 1.0f;
        float upCurve = 0.1f * width;
        float downCurve = 0.25f * width;
        float hookThinness = 0.9f;
        _ = width * 0.55f;

        uint headStart = (uint)vertices.Count;

        for ( int lat = 0 ; lat <= headSegments ; lat++ )
            {
            float v = (float)lat / headSegments;
            float theta = v * MathHelper.Pi;

            for ( int lon = 0 ; lon <= headSegments ; lon++ )
                {
                float u = (float)lon / headSegments;
                float phi = u * MathHelper.TwoPi;

                float x = MathF.Cos(phi) * MathF.Sin(theta);
                float y = MathF.Sin(phi) * MathF.Sin(theta);
                float z = MathF.Cos(theta);

                float noseNarrowFactor = 0.5f + (z * 1.2f);
                float sideCompression = 1.6f - (MathF.Pow(MathF.Abs(x), 0.9f) * 1.4f * noseNarrowFactor);
                float verticalStretch = 1.7f - (y * y * 0.4f);
                float noseStretch = 1.0f + (z * 0.5f);
                float noseTaper = 1.3f - (z * 0.7f);
                float volumeCompensation = 1.0f / MathF.Sqrt(sideCompression * verticalStretch * noseTaper);

                float foreheadModifier = 1.0f;
                if ( y > 0 && z > foreheadStart && z < foreheadEnd )
                    {
                    float t = (z - foreheadStart) / (foreheadEnd - foreheadStart);
                    float curve = MathF.Pow(MathF.Sin(t * MathHelper.Pi), foreheadPower);
                    foreheadModifier += foreheadSize * curve;
                    }

                float hookModifier = 0.0f;
                if ( z > hookStart )
                    {
                    if ( z <= hookPeak )
                        {
                        float t = (z - hookStart) / (hookPeak - hookStart);
                        hookModifier = upCurve * ( ( 3 * t * t ) - ( 2 * t * t * t ) ) * hookThinness;
                        }
                    else
                        {
                        float t = (z - hookPeak) / (hookTip - hookPeak);
                        float easeIn = t * t * t;
                        hookModifier = ( upCurve - ( downCurve * easeIn ) ) * hookThinness;
                        }
                    }

                float gillEffect = 0f;
                if ( Math . Abs ( x ) > 0.5f && z > -0.5f && z < 0.3f )
                    {
                    float gillPos = (z + 0.5f) / 0.8f;
                    gillEffect = gillDetailIntensity * MathF . Sin ( gillPos * gillDetailCount * MathHelper . Pi ) * ( 1 - Math . Abs ( x ) );
                    }

                float eyeEffect = 0f;
                if ( y > 0.3f && z > -0.2f && z < 0.4f )
                    {
                    float eyeZone = 1f - Math.Min(Math.Abs(z - 0.1f) / 0.3f, Math.Abs(y - 0.5f) / 0.3f);
                    eyeEffect = eyeAreaDetail * Math . Max ( 0 , eyeZone );
                    }

                float yPos = width * 0.95f * y * verticalStretch * volumeCompensation * foreheadModifier;
                yPos = ( yPos * 0.35f ) + headUpwardShift + hookModifier + gillEffect + eyeEffect;

                Vector3 Face = new(
                    width * 0.5f * x * sideCompression * volumeCompensation * noseTaper,
                    yPos,
                    (length * 0.7f) + headForwardShift + (width * (0.9f * z * noseStretch))
                );
                Vector2 texFace = new(
                    width * 0.5f * x * sideCompression * volumeCompensation * noseTaper,
                    (length * 0.7f) + headForwardShift + (width * (0.9f * z * noseStretch))
                );

                // Применяем поворот головы
                if ( _areEyesLocked )
                    {
                    Vector4 rotatedPos = _headRotationMatrix * new Vector4(Face, 1.0f);
                    Face = rotatedPos . Xyz;
                    Face . X = -Face . X;
                    }

                vertices . Add ( new Vertex ( Face , Vector2 . Zero , texFace , Vector2 . Zero , Vector2 . Zero ) );
                }
            }

        for ( int lat = 0 ; lat < headSegments ; lat++ )
            {
            for ( int lon = 0 ; lon < headSegments ; lon++ )
                {
                uint current = headStart + (uint)((lat * (headSegments + 1)) + lon);
                uint next = current + ( headSegments + 1 );

                indices . Add ( current );
                indices . Add ( next + 1 );
                indices . Add ( current + 1 );

                indices . Add ( current );
                indices . Add ( next );
                indices . Add ( next + 1 );
                }
            }
        }

    private void CreateLowerJawGeometry ( float width , float length )
        {
        const int jawSegments = 1024;
        const float jawLineDetail = 0.8f;
        const float chinDetail = 0.2f;
        const float bodyTransitionStart = -1.0f;
        const float bodyTransitionEnd = -0.8f;

        uint jawStart = (uint)vertices.Count;
        float jawForwardShift = width * 0.7f;
        float jawDownwardShift = width * 0.15f;
        float jawThinness = 0.4f;
        float hookStart = 0.4f;
        float hookPeak = 0.9f;
        float hookTip = 1.0f;
        float upCurve = 0.08f * width;
        float downCurve = 0.2f * width;
        float baseThickness = width * 0.55f;
        float baseStartZ = -1.2f;
        float baseEndZ = 0.21f;
        float basePower = 1.5f;

        for ( int lat = 0 ; lat <= jawSegments ; lat++ )
            {
            float v = (float)lat / jawSegments;
            float theta = v * MathHelper.Pi;

            for ( int lon = 0 ; lon <= jawSegments ; lon++ )
                {
                float u = (float)lon / jawSegments;
                float phi = u * MathHelper.TwoPi;

                float x = MathF.Cos(phi) * MathF.Sin(theta);
                float y = -MathF.Abs(MathF.Sin(phi) * MathF.Sin(theta));
                float z = MathF.Cos(theta);

                float transitionFactor = 1f;
                if ( z is > bodyTransitionStart and < bodyTransitionEnd )
                    {
                    float t = (z - bodyTransitionStart) / (bodyTransitionEnd - bodyTransitionStart);
                    transitionFactor = 0.7f + ( 0.3f * SmoothStep ( t ) );
                    }
                y *= transitionFactor;

                float sideCompression = 1.6f - (MathF.Pow(MathF.Abs(x), 0.9f) * 1.4f);
                float verticalStretch = 1.4f - (y * y * 0.4f);
                float noseStretch = 1.0f + (z * 0.5f);
                float noseTaper = 1.3f - (z * 0.7f);
                float volumeCompensation = 1.0f / MathF.Sqrt(sideCompression * verticalStretch * noseTaper);

                float thicknessModifier = 0f;
                if ( z > baseStartZ && z < baseEndZ )
                    {
                    float t = (z - baseStartZ) / (baseEndZ - baseStartZ);
                    thicknessModifier = baseThickness * MathF . Pow ( MathF . Sin ( t * MathHelper . Pi ) , basePower );
                    }

                float hookModifier = 0.0f;
                if ( z > hookStart )
                    {
                    if ( z <= hookPeak )
                        {
                        float t = (z - hookStart) / (hookPeak - hookStart);
                        hookModifier = upCurve * ( ( 3 * t * t ) - ( 2 * t * t * t ) ) * jawThinness;
                        }
                    else
                        {
                        float t = (z - hookPeak) / (hookTip - hookPeak);
                        float easeIn = t * t * t;
                        hookModifier = ( upCurve - ( downCurve * easeIn ) ) * jawThinness;
                        }
                    }

                float jawLineEffect = 0f;
                if ( y < -0.4f && z > -0.5f && z < 0.5f )
                    {
                    jawLineEffect = jawLineDetail * MathF . Sin ( z * MathHelper . TwoPi * 2 ) * ( 1 - Math . Abs ( x ) );
                    }

                float chinEffect = 0f;
                if ( y < -0.6f && z > 0.2f && z < 0.8f )
                    {
                    chinEffect = chinDetail * ( 1 - ( Math . Abs ( z - 0.5f ) / 0.3f ) );
                    }

                float yPos = width * 0.5f * y * verticalStretch * volumeCompensation;
                yPos = ( yPos * 0.3f ) - jawDownwardShift - hookModifier + thicknessModifier + jawLineEffect + chinEffect;

                Vector3 Jaw = new(
                    width * 0.5f * x * sideCompression * volumeCompensation * noseTaper,
                    yPos,
                    (length * 0.7f) + jawForwardShift + (width * (0.9f * z * noseStretch))
                );
                Vector2 texJaw = new(
                    width * 0.5f * x * sideCompression * volumeCompensation * noseTaper,
                    (length * 0.7f) + jawForwardShift + (width * (0.9f * z * noseStretch)));

                // Применяем поворот головы
                if ( _areEyesLocked )
                    {
                    Vector4 rotatedPos = _headRotationMatrix * new Vector4(Jaw, 1.0f);
                    Jaw = rotatedPos . Xyz;
                    Jaw . X = -Jaw . X;
                    }

                vertices . Add ( new Vertex ( Jaw , Vector2 . Zero , texJaw , Vector2 . Zero , Vector2 . Zero ) );
                }
            }

        for ( int lat = 0 ; lat < jawSegments ; lat++ )
            {
            for ( int lon = 0 ; lon < jawSegments ; lon++ )
                {
                uint current = jawStart + (uint)((lat * (jawSegments + 1)) + lon);
                uint next = current + ( jawSegments + 1 );

                indices . Add ( current );
                indices . Add ( next + 1 );
                indices . Add ( current + 1 );

                indices . Add ( current );
                indices . Add ( next );
                indices . Add ( next + 1 );
                }
            }
        }

    private void CreateDetailedEye ( Vector3 center , float radius , int segments )
        {
        uint eyeStartIndex = (uint)vertices.Count;
        _ = ( uint ) vertices . Count;

        float eyeProtrusion = radius * 0.3f;
        float eyeAngle = MathHelper.PiOver4;
        int eyeDirection = center.X > 0 ? 1 : -1;
        _ = Matrix4 . CreateRotationY ( eyeAngle * eyeDirection );

        for ( int lat = 0 ; lat <= segments / 2 ; lat++ )
            {
            float theta = lat * MathHelper.Pi / segments;
            float sinTheta = MathF.Sin(theta);
            float cosTheta = MathF.Cos(theta);

            for ( int lon = 0 ; lon <= segments ; lon++ )
                {
                float phi = lon * 2 * MathHelper.Pi / segments;

                Vector3 offset = new(
                    radius * MathF.Cos(phi) * sinTheta,
                    radius * MathF.Sin(phi) * sinTheta,
                    (radius * cosTheta) + eyeProtrusion);

                // Применяем поворот глаза и головы
                Vector3 eyePos = center + offset;
                if ( _areEyesLocked )
                    {
                    Vector4 rotatedPos = _headRotationMatrix * new Vector4(center + offset, 1.0f);
                    eyePos = rotatedPos . Xyz;
                    // Корректируем позицию
                    eyePos . X = -eyePos . X;
                    }

                Vector2 texEye = new(
                    radius * MathF.Cos(phi) * sinTheta,
                    radius * MathF.Sin(phi) * sinTheta);

                vertices . Add ( new Vertex ( eyePos , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero , texEye ) );
                }
            }

        for ( int lat = 0 ; lat < segments / 2 ; lat++ )
            {
            for ( int lon = 0 ; lon < segments ; lon++ )
                {
                uint current = eyeStartIndex + (uint)((lat * (segments + 1)) + lon);
                uint next = current + (uint)(segments + 1);

                indices . Add ( current );
                indices . Add ( next + 1 );
                indices . Add ( current + 1 );

                indices . Add ( current );
                indices . Add ( next );
                indices . Add ( next + 1 );
                }
            }
        }

    private void CreateEyePupils ( float width , float length )
        {
        float eyeRadius = width * 0.16f;
        float pupilRadius = eyeRadius * 0.3f;

        // Убрано вращение головы для зрачков
        Vector3 rightEyePos = new(width * 0.3f, width * 0.15f, length * 0.85f);
        Vector3 leftEyePos = new(-width * 0.3f, width * 0.15f, length * 0.85f);


        if ( _areEyesLocked )
            {
            rightEyePos = ( _headRotationMatrix * new Vector4 ( rightEyePos , 1.0f ) ) . Xyz;
            leftEyePos = ( _headRotationMatrix * new Vector4 ( leftEyePos , 1.0f ) ) . Xyz;
            // Корректируем позицию
            rightEyePos . X = -rightEyePos . X;
            leftEyePos . X = -leftEyePos . X;
            }

        CreatePupil ( rightEyePos , eyeRadius , pupilRadius , true );
        CreatePupil ( leftEyePos , eyeRadius , pupilRadius , true );
        }

    private void CreatePupil ( Vector3 eyeCenter , float eyeRadius , float pupilRadius , bool isRightEye )
        {
        uint pupilStart = (uint)vertices.Count;
        int segments = 24;

        float centerU = isRightEye ? 0.25f : 0.75f;
        float centerV = 0.25f;
        float inset = -eyeRadius * 0.3f;

        Vector3 pupilCenter = GetSpherePoint(eyeCenter, eyeRadius - inset, centerU, centerV);

        vertices . Add ( new Vertex ( pupilCenter , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );

        for ( int i = 0 ; i < segments ; i++ )
            {
            float angle = i * MathHelper.TwoPi / segments;
            float u = centerU + (MathF.Cos(angle) * 0.15f);
            float v = centerV + (MathF.Sin(angle) * 0.1f);

            if ( !isRightEye )
                {
                u = 1.0f - u;
                }

            Vector3 point = GetSpherePoint(eyeCenter, eyeRadius - inset, u, v);
            vertices . Add ( new Vertex ( point , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );
            }

        for ( int i = 0 ; i < segments ; i++ )
            {
            indices . Add ( pupilStart );
            indices . Add ( pupilStart + ( uint ) i + 1 );
            indices . Add ( pupilStart + ( uint ) ( ( i + 1 ) % segments ) + 1 );
            }
        }

    private void CreateEyeHighlights ( float width , float length )
        {
        float eyeRadius = width * 0.16f;

        Vector3 rightEyePos = new(width * 0.3f, width * 0.15f, length * 0.85f);
        Vector3 leftEyePos = new(-width * 0.3f, width * 0.15f, length * 0.85f);

        if ( _areEyesLocked )
            {
            rightEyePos = ( _headRotationMatrix * new Vector4 ( rightEyePos , 1.0f ) ) . Xyz;
            leftEyePos = ( _headRotationMatrix * new Vector4 ( leftEyePos , 1.0f ) ) . Xyz;
            // Корректируем позицию
            rightEyePos . X = -rightEyePos . X;
            leftEyePos . X = -leftEyePos . X;
            }

        // Убрано вращение головы для бликов
        CreateEyeHighlight ( rightEyePos , eyeRadius , true );
        CreateEyeHighlight ( leftEyePos , eyeRadius , false );
        }

    private void CreateEyeHighlight ( Vector3 eyeCenter , float eyeRadius , bool isRightEye )
        {
        uint highlightStart = (uint)vertices.Count;
        int segments = 24;

        float centerU = 0.25f;
        float centerV = 0.5f;
        float highlightWidth = 0.15f;
        float highlightHeight = 0.1f;
        float extrusion = eyeRadius * 0.2f;

        if ( !isRightEye )
            {
            centerU = 1.0f - centerU;
            }

        Vector3 baseCenter = GetSpherePoint(eyeCenter, eyeRadius, centerU, centerV);
        Vector3 normal = (baseCenter - eyeCenter).Normalized();

        Vector3 highlightCenter = baseCenter + (normal * extrusion);
        vertices . Add ( new Vertex ( highlightCenter , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );

        for ( int i = 0 ; i < segments ; i++ )
            {
            float angle = i * MathHelper.TwoPi / segments;
            float u = centerU + (MathF.Cos(angle) * highlightWidth);
            float v = centerV + (MathF.Sin(angle) * highlightHeight);

            if ( !isRightEye )
                {
                u = 1.0f - u;
                }

            Vector3 basePoint = GetSpherePoint(eyeCenter, eyeRadius, u, v);
            Vector3 pointNormal = (basePoint - eyeCenter).Normalized();
            Vector3 extrudedPoint = basePoint + (pointNormal * extrusion * (0.7f + (0.3f * MathF.Cos(angle))));

            vertices . Add ( new Vertex ( extrudedPoint , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );
            }

        for ( int i = 0 ; i < segments ; i++ )
            {
            indices . Add ( highlightStart );
            indices . Add ( highlightStart + ( uint ) i + 1 );
            indices . Add ( highlightStart + ( uint ) ( ( i + 1 ) % segments ) + 1 );
            }
        }

    private void CreateTeethGeometry ( float width , float length )
        {
        uint teethStart = (uint)vertices.Count;
        const int teethSegments = 8;
        float toothHeight = width * 0.1f;
        float toothBaseRadius = width * 0.025f;

        float jawForwardShift = width * 0.7f;
        float jawDownwardShift = width * 0.15f;
        float baseThickness = width * 0.55f;
        float baseStartZ = -1.2f;
        float baseEndZ = 0.21f;
        float basePower = 1.5f;

        float[] teethPositions = { 0.95f, 0.9f, 0.85f, 0.75f, 0.65f, 0.55f, 0.45f };
        float[] teethWidthFactors = { 0f, 0.15f, 0.25f, 0.35f, 0.45f, 0.55f, 0.65f };

        for ( int i = 0 ; i < teethPositions . Length ; i++ )
            {
            CreateToothAtPosition ( width , length , teethPositions [ i ] , teethWidthFactors [ i ] ,
                jawForwardShift , jawDownwardShift , baseThickness , baseStartZ , baseEndZ , basePower ,
                toothHeight , toothBaseRadius , teethSegments , ref teethStart );
            }

        for ( int i = 0 ; i < teethPositions . Length ; i++ )
            {
            CreateToothAtPosition ( width , length , teethPositions [ i ] , -teethWidthFactors [ i ] ,
                jawForwardShift , jawDownwardShift , baseThickness , baseStartZ , baseEndZ , basePower ,
                toothHeight , toothBaseRadius , teethSegments , ref teethStart );
            }
        }

    private void CreateUpperTeethGeometry ( float width , float length )
        {
        uint teethStart = (uint)vertices.Count;
        const int teethSegments = 8;
        float toothHeight = width * 0.35f;
        float toothBaseRadius = width * 0.025f;

        float headForwardShift = width * 0.76f;
        float headUpwardShift = width * 0.17f;
        float baseThickness = width * 0.55f;
        float baseStartZ = -1.2f;
        float baseEndZ = 0.21f;
        float basePower = 1.5f;

        float[] basePositions = { 0.95f, 0.9f, 0.85f, 0.75f, 0.65f, 0.55f, 0.45f };
        float[] teethPositions = basePositions.Select(p => Math.Min(p * 1.32f, 1.0f)).ToArray();
        float[] teethWidthFactors = { 0f, 0.15f, 0.25f, 0.35f, 0.45f, 0.55f, 0.65f };

        float teethForwardOffset = width * 0f;

        for ( int i = 0 ; i < teethPositions . Length ; i++ )
            {
            CreateUpperToothAtPosition ( width , length , teethPositions [ i ] , teethWidthFactors [ i ] ,
                headForwardShift + teethForwardOffset , headUpwardShift , baseThickness , baseStartZ , baseEndZ , basePower ,
                toothHeight , toothBaseRadius , teethSegments , ref teethStart );
            }

        for ( int i = 0 ; i < teethPositions . Length ; i++ )
            {
            CreateUpperToothAtPosition ( width , length , teethPositions [ i ] , -teethWidthFactors [ i ] ,
                headForwardShift + teethForwardOffset , headUpwardShift , baseThickness , baseStartZ , baseEndZ , basePower ,
                toothHeight , toothBaseRadius , teethSegments , ref teethStart );
            }
        }

    private void CreateUpperToothAtPosition ( float width , float length , float z , float xFactor ,
float headForwardShift , float headUpwardShift , float baseThickness , float baseStartZ , float baseEndZ , float basePower ,
float toothHeight , float toothBaseRadius , int teethSegments , ref uint teethStart )
        {
        float phi = xFactor * MathHelper.Pi;
        float theta = MathHelper.PiOver2 * (1 - z);
        float x = xFactor >= 0 ? MathF.Cos(phi) * MathF.Sin(theta) : -MathF.Cos(phi) * MathF.Sin(theta);
        float y = MathF.Abs(MathF.Sin(phi) * MathF.Sin(theta));
        float zCoord = MathF.Cos(theta);

        float noseNarrowFactor = 0.5f + (zCoord * 1.2f);
        float sideCompression = 1.6f - (MathF.Pow(MathF.Abs(x), 0.9f) * 1.4f * noseNarrowFactor);
        float verticalStretch = 1.7f - (y * y * 0.4f);
        float noseStretch = 1.0f + (zCoord * 0.5f);
        float noseTaper = 1.3f - (zCoord * 0.7f);
        float volumeCompensation = 1.0f / MathF.Sqrt(sideCompression * verticalStretch * noseTaper);

        float thicknessModifier = 0f;
        if ( zCoord > baseStartZ && zCoord < baseEndZ )
            {
            float t = (zCoord - baseStartZ) / (baseEndZ - baseStartZ);
            thicknessModifier = baseThickness * MathF . Pow ( MathF . Sin ( t * MathHelper . Pi ) , basePower );
            }

        float yPos = width * 0.5f * y * verticalStretch * volumeCompensation;
        yPos = ( yPos * 0.35f ) + headUpwardShift + thicknessModifier;

        Vector3 basePos = new(
            width * 0.5f * x * sideCompression * volumeCompensation * noseTaper,
            yPos,
            (length * 0.7f) + headForwardShift + (width * (0.9f * zCoord * noseStretch))
        );

        if ( _areEyesLocked )
            {
            Vector4 rotatedPos = _headRotationMatrix * new Vector4(basePos, 1.0f);
            basePos = rotatedPos . Xyz;
            basePos . X = -basePos . X; // Корректируем позицию
            }

        float angle = MathHelper.DegreesToRadians(30f);
        Vector3 toothDirection = new Vector3(0f, -MathF.Cos(angle), -MathF.Sin(angle)).Normalized();

        basePos += toothDirection * toothBaseRadius;
        CreateTooth ( basePos , toothHeight , toothBaseRadius , toothDirection , teethSegments , ref teethStart );
        }

    private void CreateToothAtPosition ( float width , float length , float z , float xFactor ,
        float jawForwardShift , float jawDownwardShift , float baseThickness , float baseStartZ , float baseEndZ , float basePower ,
        float toothHeight , float toothBaseRadius , int teethSegments , ref uint teethStart )
        {
        float phi = xFactor * MathHelper.Pi;
        float theta = MathHelper.PiOver2 * (1 - z);
        float x = xFactor >= 0 ? MathF.Cos(phi) * MathF.Sin(theta) : -MathF.Cos(phi) * MathF.Sin(theta);
        float y = -MathF.Abs(MathF.Sin(phi) * MathF.Sin(theta));
        float zCoord = MathF.Cos(theta);

        float sideCompression = 1.6f - (MathF.Pow(MathF.Abs(x), 0.9f) * 1.4f);
        float verticalStretch = 1.4f - (y * y * 0.4f);
        float noseStretch = 1.0f + (zCoord * 0.5f);
        float noseTaper = 1.3f - (zCoord * 0.7f);
        float volumeCompensation = 1.0f / MathF.Sqrt(sideCompression * verticalStretch * noseTaper);

        float thicknessModifier = 0f;
        if ( zCoord > baseStartZ && zCoord < baseEndZ )
            {
            float t = (zCoord - baseStartZ) / (baseEndZ - baseStartZ);
            thicknessModifier = baseThickness * MathF . Pow ( MathF . Sin ( t * MathHelper . Pi ) , basePower );
            }

        float yPos = width * 0.5f * y * verticalStretch * volumeCompensation;
        yPos = ( yPos * 0.3f ) - jawDownwardShift + thicknessModifier;

        Vector3 basePos = new(
            width * 0.5f * x * sideCompression * volumeCompensation * noseTaper,
            yPos,
            (length * 0.7f) + jawForwardShift + (width * (0.9f * zCoord * noseStretch))
        );

        if ( _areEyesLocked )
            {
            Vector4 rotatedPos = _headRotationMatrix * new Vector4(basePos, 1.0f);
            basePos = rotatedPos . Xyz;
            basePos . X = -basePos . X; // Корректируем позицию
            }

        Vector3 toothDirection = -new Vector3(
            x * sideCompression * noseTaper,
            (y * verticalStretch) + (0.3f * (thicknessModifier / width)),
            zCoord * 0.7f
        ).Normalized();

        basePos += toothDirection * toothBaseRadius;
        CreateTooth ( basePos , toothHeight , toothBaseRadius , toothDirection , teethSegments , ref teethStart );
        }

    private void CreateTooth ( Vector3 basePos , float height , float baseRadius , Vector3 direction , int segments , ref uint startIndex )
        {
        uint centerIndex = startIndex;

        // Убрано вращение головы для зубов
        Vector3 tip = basePos + (direction * height);

        vertices . Add ( new Vertex ( tip , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );
        startIndex++;

        for ( int i = 0 ; i < segments ; i++ )
            {
            float angle = (float)i / segments * MathHelper.TwoPi;
            Vector3 tangent = Vector3.Cross(direction, Vector3.UnitY).Normalized();
            Vector3 bitangent = Vector3.Cross(direction, tangent).Normalized();

            Vector3 offset = (tangent * MathF.Cos(angle) * baseRadius) + (bitangent * MathF.Sin(angle) * baseRadius);
            Vector3 point = basePos + offset;

            vertices . Add ( new Vertex ( point , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero , Vector2 . Zero ) );
            startIndex++;
            }

        for ( int i = 0 ; i < segments ; i++ )
            {
            indices . Add ( centerIndex );
            indices . Add ( centerIndex + 1 + ( uint ) i );
            indices . Add ( centerIndex + 1 + ( uint ) ( ( i + 1 ) % segments ) );
            }
        }

    private void CreateUltraRealisticDorsalFin ( float width , float length )
        {
        if ( !TryGetHumpTopLine ( out Vector3 peakPoint , out List<Vector3> humpTopLine ) || humpTopLine . Count < 2 )
            {
            return;
            }

        const int SEGMENTS = 36;
        const int MAIN_FOLDS = 17;
        float MAX_FIN_HEIGHT = width * 1.375f;
        float Y_OFFSET = (width * 0.42f) + 0.5f;
        uint baseIndex = (uint)vertices.Count;

        // Параметры модификации
        const float LOWER_DROP_FACTOR = 0.6f;
        const float PEAK_DROP_BOOST = 0.75f;
        const float TURN_RESPONSIVENESS = 0.045f; // Чувствительность к повороту

        float tailStartPosition = 0.8f;
        int endIndex = (int)(humpTopLine.Count * tailStartPosition);
        int peakIndex = humpTopLine.FindIndex(p => p.Y == peakPoint.Y);

        // Создаем временный буфер для оригинальных вершин
        List<Vector3> originalVertices = [];

        for ( int i = 0 ; i <= SEGMENTS ; i++ )
            {
            float t = (float)i / SEGMENTS;

            // Получаем угол поворота для текущего сегмента
            float turnAngle = -GetCombinedTurnAngle(t) * TURN_RESPONSIVENESS;
            Matrix4 rotation = Matrix4.CreateRotationY(MathHelper.DegreesToRadians(-turnAngle));

            int bodyIndex = Math.Clamp((int)(t * (humpTopLine.Count - 1)), 0, endIndex);
            Vector3 basePoint = humpTopLine[bodyIndex];
            basePoint . Y -= Y_OFFSET;

            // Применяем поворот тела
            Vector4 rotatedBase = rotation * new Vector4(basePoint, 1.0f);
            basePoint = rotatedBase . Xyz;

            // Волновая анимация
            float wavePhase = (_wiggleTime * 3f) + (t * MathHelper.Pi * 3f);
            float waveOffset = MathF.Sin(wavePhase) * MaxWiggleAmplitude * width * 0.65f * (1 - (t * 0.5f));

            // Вычисляем высоту
            float heightFactor = CalculateHeightFactor(t, peakIndex, endIndex, 0.625f, 0.5f);

            // Верхняя точка (остается без изменений)
            Vector3 crest = new(
                basePoint.X + waveOffset,
                Math.Max(0, basePoint.Y + (MAX_FIN_HEIGHT * heightFactor)),
                basePoint.Z
            );
            originalVertices . Add ( crest );

            // Создаем складки с волновой анимацией
            for ( int f = 1 ; f <= MAIN_FOLDS ; f++ )
                {
                float foldT = (float)f / (MAIN_FOLDS + 1);
                float foldWidth = width * (0.1f + (foldT * 0.15f)) * heightFactor;

                Vector3 foldPoint = new(
                    basePoint.X + ((f % 2 == 0 ? 1 : -1) * foldWidth) + (waveOffset * 0.7f),
                    basePoint.Y + (MAX_FIN_HEIGHT * (0.3f + (0.5f * foldT)) * heightFactor),
                    basePoint.Z + (width * 0.02f * MathF.Sin(t * 20) * (1 - heightFactor))
                );
                originalVertices . Add ( foldPoint );
                }
            }

        // Модифицируем только нижние точки
        for ( int i = 0 ; i <= SEGMENTS ; i++ )
            {
            float t = (float)i / SEGMENTS;
            int baseVertexIndex = i * (MAIN_FOLDS + 1);

            // Верхняя точка без изменений
            AddVertexSafe ( originalVertices [ baseVertexIndex ] );

            // Модифицируем складки
            for ( int f = 1 ; f <= MAIN_FOLDS ; f++ )
                {
                Vector3 originalPoint = originalVertices[baseVertexIndex + f];

                // Интенсивность опускания
                float dropIntensity = LOWER_DROP_FACTOR * (f / (float)MAIN_FOLDS);

                // Усиление в районе пиков
                if ( Math . Abs ( t - ( ( float ) peakIndex / endIndex ) ) < 0.25f )
                    {
                    dropIntensity *= PEAK_DROP_BOOST;
                    }

                // Применяем опускание
                Vector3 modifiedPoint = new(
                    originalPoint.X,
                    originalPoint.Y - (dropIntensity * MAX_FIN_HEIGHT),
                    originalPoint.Z
                );

                AddVertexSafe ( modifiedPoint );
                }
            }

        // Индексация (без изменений)
        int pointsPerSegment = 1 + MAIN_FOLDS;
        for ( int i = 0 ; i < SEGMENTS ; i++ )
            {
            uint current = baseIndex + (uint)(i * pointsPerSegment);
            uint next = current + (uint)pointsPerSegment;

            if ( next + MAIN_FOLDS >= vertices . Count )
                {
                continue;
                }

            for ( int f = 0 ; f < MAIN_FOLDS ; f++ )
                {
                if ( current + ( uint ) f + 1 >= vertices . Count || next + ( uint ) f + 1 >= vertices . Count )
                    {
                    continue;
                    }

                AddTriangle ( indices , current + ( uint ) f , next + ( uint ) f , current + ( uint ) ( f + 1 ) );
                AddTriangle ( indices , next + ( uint ) f , next + ( uint ) ( f + 1 ) , current + ( uint ) ( f + 1 ) );
                }
            }
        }

    private float CalculateHeightFactor ( float t , int peakIndex , int endIndex , float headReduction , float tailReduction )
        {
        float positionFactor = (float)((int)(t * endIndex) - peakIndex) / (endIndex - peakIndex);

        return positionFactor <= 0 ? 0.3f + ( 0.7f * ( 1.0f + positionFactor ) ) : 1.0f - ( 0.7f * positionFactor );
        }

    private bool TryGetHumpTopLine ( out Vector3 peakPoint , out List<Vector3> humpTopLine )
        {
        peakPoint = Vector3 . Zero;
        humpTopLine = [ ];
        float maxY = 0;
        float humpLoweringFactor = 0.6f;

        int safeBodySegments = Math.Min(bodySegments, vertices.Count / Math.Max(1, radialSegments));

        for ( int ring = 0 ; ring <= safeBodySegments ; ring++ )
            {
            float t = (float)ring / safeBodySegments;
            float maxRingY = 0;
            float currentZ = 0;

            // Получаем угол поворота для текущего сегмента тела
            float turnAngle = GetCombinedTurnAngle(t);
            Matrix4 rotation = Matrix4.CreateRotationY(MathHelper.DegreesToRadians(turnAngle));

            for ( int radial = 0 ; radial < radialSegments ; radial++ )
                {
                int index = (ring * radialSegments) + radial;
                if ( index < vertices . Count )
                    {
                    // Применяем поворот к позиции вершины
                    Vector4 rotatedPos = rotation * new Vector4(vertices[index].Pos, 1.0f);
                    float rotatedY = rotatedPos.Y;

                    if ( rotatedY > maxRingY )
                        {
                        maxRingY = rotatedY;
                        currentZ = rotatedPos . Z;
                        }
                    }
                }

            if ( t is > 0.01f and < 1f )
                {
                float center = 0.245f;
                float humpFactor = 1f - (Math.Abs(t - center) / 0.1f);
                humpFactor = MathHelper . Clamp ( humpFactor , 0.225f , 1 );
                maxRingY *= 1 - ( humpFactor * ( 1 - humpLoweringFactor ) );
                }

            // Создаем точку с учетом поворота
            Vector4 topPoint = rotation * new Vector4(0, maxRingY, currentZ, 1.0f);
            humpTopLine . Add ( topPoint . Xyz );

            if ( maxRingY > maxY )
                {
                maxY = maxRingY;
                peakPoint = topPoint . Xyz;
                }
            }
        return humpTopLine . Count > 0;
        }

    private void CreateTailFin ( float width , float length , float zOffset = 3f )
        {
        const float scaleFactor = 3.4f;

        int tailStartIndex = bodySegments * radialSegments;
        if ( tailStartIndex >= vertices . Count || radialSegments < 4 )
            {
            return;
            }

        List<Vector3> tailRing = vertices.Skip(tailStartIndex).Take(radialSegments).Select(v => v.Pos).ToList();
        Vector3 tailCenter = tailRing.Aggregate(Vector3.Zero, (sum, v) => sum + v) / tailRing.Count;
        tailCenter . Z += zOffset;
        float maxRadius = tailRing.Max(v => (v - tailCenter).Xy.Length);
        float maxstaticRadius = bodyWidth * 0.33f;

        float finLength = length * 0.1f * scaleFactor;
        int finSegments = radialSegments;
        int upperSegmentCount = finSegments / 2;
        float forkStart = -0.005f;

        const int MAIN_FOLDS = 1;
        const int MICRO_FOLDS = 1;
        const float FOLD_DEPTH = 0.15f;
        const float FOLD_WIDTH = 0.25f;

        uint finStartIndex = (uint)vertices.Count;

        float turnAmplitudeBoost = 1f + (Math.Abs(_turnAnimationProgress * _turnDirection) * 3f);
        float tailWigglePhase = _wiggleTime * 3f;
        float swingBoost = 1.5f;
        float tailWiggleAmplitude = (_isWPressed ? 1.428571428571428f : 1f) * MaxWiggleAmplitude * 1.65f * turnAmplitudeBoost * swingBoost;
        float microTwitch = 1.5f;

        // Если хвостовой плавник заблокирован, используем фиксированный угол
        if ( _isTailFinLocked )
            {
            // Фиксированное положение с усиленной амплитудой
            tailWigglePhase = _lockedTailFinAngle * TailFinLockPhaseFactor;
            tailWigglePhase += _laneChangeTailSwing * 0.5f;
            tailWiggleAmplitude = MaxWiggleAmplitude * LockedTailFinAmplitudeBoost;

            // Добавляем небольшую "дрожь" для натуральности
            microTwitch = MathF . Sin ( _wiggleTime * 30f ) * 0.05f;
            }
        else if ( _isLaneChangingAnimation )
            {
            // Более плавное растяжение с учетом направления
            float stretchDirection = Math.Sign(-_laneChangeTailSwing);

            for ( int i = tailStartIndex ; i < vertices . Count ; i++ )
                {
                Vertex vert = vertices[i];
                // Добавляем небольшое вертикальное смещение для объема
                vert . Pos . Y += ( vert . Pos . Y - tailCenter . Y ) * 0.02f * stretchDirection;
                vertices [ i ] = vert;
                }
            }

        // Хвост должен двигаться в противоположную сторону от поворота
        if ( _turnDirection != 0 && !_isTailFinLocked ) // Только если не заблокирован
            {
            tailWigglePhase += _turnAnimationProgress * MathHelper . Pi * _turnDirection;
            }

        float secondaryWave = MathF.Cos(_wiggleTime * 15.3f) * 0.1f;

        foreach ( Vector3 vert in tailRing )
            {
            vertices . Add ( new Vertex ( vert , Vector2 . Zero , new Vector2 ( vert . X , vert . Z ) , Vector2 . Zero , Vector2 . Zero ) );
            }

        for ( int ring = 1 ; ring <= upperSegmentCount ; ring++ )
            {
            float t = (float)ring / upperSegmentCount;
            Vector2 bezierPoint = CalculateBezierPoint(t,
                Vector2.Zero,
                new Vector2(
                    MathF.Sin((tailWigglePhase * 0.8f) + secondaryWave) * tailWiggleAmplitude * 2.5f,
                    -0.2f * width),
                new Vector2(
                    MathF.Sin(tailWigglePhase + MathHelper.PiOver2 + (secondaryWave * 0.3f)) * tailWiggleAmplitude,
                    -0.5f * width),
                new Vector2(
                    MathF.Sin(tailWigglePhase + MathHelper.Pi + (secondaryWave * 0.5f)) * tailWiggleAmplitude * 1.5f,
                    -0.8f * width));

            float horizontalWiggle = bezierPoint.X * (1 + (microTwitch * t * 0.3f));
            float verticalWiggle = bezierPoint.Y * 0.2f;
            float forkProgress = (t - forkStart) / (1 - forkStart);
            float lobeWidth = maxRadius * 0.9f * scaleFactor * forkProgress;
            float lobestaticWidth = maxstaticRadius * 0.9f * scaleFactor * forkProgress;
            float edgeRipple = MathF.Sin((t * MathHelper.TwoPi * 4f) + (_wiggleTime * 4f)) * 0.01f;

            for ( int i = 0 ; i < finSegments ; i++ )
                {
                Vector3 baseVert = tailRing[i] - tailCenter;

                Vector3 finVert = new(
                    (baseVert.X * (1 - (forkProgress * 0.15f))) + (horizontalWiggle * 1.1f),
                    baseVert.Y + (baseVert.Y > 0 ? lobestaticWidth : -lobestaticWidth) +
                        (verticalWiggle * 0.05f) +
                        (edgeRipple * ((i % 3) - 0.5f)),
                    tailCenter.Z - (finLength * (forkStart + (forkProgress * 0.4f)))
                );
                finVert += tailCenter;

                uint baseIndex = (uint)vertices.Count;
                vertices . Add ( new Vertex ( finVert , Vector2 . Zero , new Vector2 ( finVert . X , finVert . Z ) , Vector2 . Zero , Vector2 . Zero ) );

                for ( int f = 1 ; f <= MAIN_FOLDS ; f++ )
                    {
                    float foldT = (float)f / (MAIN_FOLDS + 1);
                    float foldFactor = MathF.Sin(foldT * MathHelper.Pi);
                    float foldOffset = FOLD_DEPTH * foldFactor;

                    Vector3 foldDir = new Vector3(
                        MathF.Cos(i * MathHelper.TwoPi / finSegments),
                        MathF.Sin(i * MathHelper.TwoPi / finSegments),
                        0).Normalized();

                    Vector3 foldVert = finVert + (foldDir * foldOffset * width * FOLD_WIDTH);

                    float foldWave = MathF.Sin((_wiggleTime * 3f) + (t * 10) + f) * 0.02f;
                    foldVert += foldDir * foldWave * width;

                    vertices . Add ( new Vertex ( foldVert , Vector2 . Zero , new Vector2 ( foldVert . X , foldVert . Z ) , Vector2 . Zero , Vector2 . Zero ) );

                    for ( int mf = 1 ; mf <= MICRO_FOLDS ; mf++ )
                        {
                        float microT = (float)mf / (MICRO_FOLDS + 1);
                        Vector3 microFoldVert = Vector3.Lerp(finVert, foldVert, microT);

                        float microWave = MathF.Sin((_wiggleTime * 4f) + (t * 12) + (f * 2) + mf) * 0.01f;
                        microFoldVert += foldDir * microWave * width * 0.3f;

                        vertices . Add ( new Vertex ( microFoldVert , Vector2 . Zero ,
                            new Vector2 ( microFoldVert . X , microFoldVert . Z ) , Vector2 . Zero , Vector2 . Zero ) );
                        }
                    }
                }
            }

        int pointsPerSegment = 1 + (MAIN_FOLDS * (1 + MICRO_FOLDS));
        for ( int ring = 0 ; ring < upperSegmentCount ; ring++ )
            {
            for ( int point = 0 ; point < finSegments ; point++ )
                {
                uint currentBase = finStartIndex + (uint)((ring * finSegments * pointsPerSegment) + (point * pointsPerSegment));
                uint nextBase = currentBase + (uint)(finSegments * pointsPerSegment);
                uint nextPoint = currentBase + (uint)((point + 1) % finSegments * pointsPerSegment);
                uint nextPointNextRing = nextBase + (uint)((point + 1) % finSegments * pointsPerSegment);

                if ( nextBase >= vertices . Count )
                    {
                    continue;
                    }

                AddTriangle ( indices , currentBase , nextBase , nextPoint );
                AddTriangle ( indices , nextBase , nextPointNextRing , nextPoint );

                for ( int f = 0 ; f < MAIN_FOLDS ; f++ )
                    {
                    uint foldOffset = (uint)(f * (1 + MICRO_FOLDS));
                    uint foldCurrent = currentBase + foldOffset;
                    uint foldNext = nextBase + foldOffset;

                    if ( foldCurrent + 1 >= vertices . Count || foldNext + 1 >= vertices . Count )
                        {
                        continue;
                        }

                    AddTriangle ( indices , foldCurrent , foldNext , foldCurrent + 1 );
                    AddTriangle ( indices , foldNext , foldNext + 1 , foldCurrent + 1 );
                    }
                }
            }
        }

    private void CreatePectoralFins ( float width , float length )
        {
        // Базовые параметры
        float finLength = width * 0.8f;
        float finWidth = width * 0.3f;
        float attachmentX = width * 0.3f;
        float attachmentY = -width * 0.2f;
        float attachmentZ = length * 0.85f;

        // Правый плавник
        CreatePectoralFin ( width , length , 1 ,
                         new Vector3 ( attachmentX , attachmentY , attachmentZ ) ,
                         finLength , finWidth );

        // Левый плавник
        CreatePectoralFin ( width , length , -1 ,
                         new Vector3 ( -attachmentX , attachmentY , attachmentZ ) ,
                         finLength , finWidth );
        }

    private void CreateVentralFins ( float width , float length )
        {
        float wiggleTime = (_wiggleTime + MathHelper.Pi) * 1.8f;

        // Явное дрожание при смене полосы
        float shakeEffect = 0f;
        if ( _isChangingLane )
            {
            _areVentralFinsLocked = true;
            _lockedVentralFinAngle = _laneChangeTailSwing * 0.7f;
            shakeEffect = VentralFinShakeAmplitude * MathF . Sin ( _wiggleTime * VentralFinShakeSpeed );
            }
        else if ( _areVentralFinsLocked )
            {
            _areVentralFinsLocked = false;
            }

        Vector3 rightAttachment = GetAnimatedAttachmentPoint(width, length, 0.08f);
        Vector3 leftAttachment = GetAnimatedAttachmentPoint(width, length, -0.08f);

        // Передаем параметры дрожания
        CreateVentralFin ( width , length , 1 , rightAttachment , wiggleTime , 2.5f , shakeEffect );
        CreateVentralFin ( width , length , -1 , leftAttachment , wiggleTime , 2.5f , shakeEffect );
        }

    private Vector3 GetAnimatedAttachmentPoint ( float width , float length , float xOffset )
        {
        // Находим ближайшую точку на теле для крепления плавника
        float t = 0.35f; // Позиция вдоль тела (0-1)
        int ringIndex = (int)(t * bodySegments);
        ringIndex = Math . Clamp ( ringIndex , 0 , bodySegments - 1 );

        // Получаем угол поворота для текущего сегмента тела
        float turnAngle = GetCombinedTurnAngle(t);
        Matrix4 rotation = Matrix4.CreateRotationY(MathHelper.DegreesToRadians(turnAngle));

        // Находим нижнюю точку на текущем кольце тела
        Vector3 basePoint = Vector3.Zero;
        float minY = float.MaxValue;

        for ( int radial = 0 ; radial < radialSegments ; radial++ )
            {
            int index = (ringIndex * radialSegments) + radial;
            if ( index < vertices . Count )
                {
                Vector3 pos = vertices[index].Pos;
                if ( pos . Y < minY )
                    {
                    minY = pos . Y;
                    basePoint = pos;
                    }
                }
            }

        // Применяем поворот тела к точке крепления
        Vector4 rotatedPoint = rotation * new Vector4(basePoint, 1.0f);
        basePoint = rotatedPoint . Xyz;

        // Добавляем смещение по X с учетом поворота
        if ( xOffset > 0 )
            {
            basePoint . X += ( ( float ) Math . Pow ( _turnAnimationProgress , 2 ) * Math . Sign ( xOffset ) * Math . Sign ( _laneChangeTailSwing ) ) + ( 1.5f * Math . Sign ( _laneChangeTailSwing ) * _turnAnimationProgress );
            }
        else
            {
            basePoint . X -= ( ( float ) Math . Pow ( _turnAnimationProgress , 2 ) * Math . Sign ( xOffset ) * Math . Sign ( _laneChangeTailSwing ) ) - ( 1.5f * Math . Sign ( _laneChangeTailSwing ) * _turnAnimationProgress );
            }
        // Анимационные эффекты
        float wavePhase = (2.5f * t * MathHelper.TwoPi) + _wiggleTime;
        float verticalWiggle = MathF.Sin(wavePhase + MathHelper.PiOver2) *
                              MaxWiggleAmplitude * width * 0.3f * 0.3f;

        float microBouncePhase = _wiggleTime * 2.5f;
        float microBounce = MathF.Sin(microBouncePhase + (t * MathHelper.TwoPi * 0.2f)) *
                           bodyWidth * 0.6f;

        return new Vector3 (
            basePoint . X ,
            basePoint . Y + ( ( verticalWiggle + microBounce ) * 0.25f ) + ( _turnAnimationProgress * width * 0.5f ) + 0.75f ,
            basePoint . Z + ( _turnAnimationProgress * width * 2f )
        );
        }

    private void CreatePectoralFin ( float width , float length , int side ,
                                  Vector3 attachmentPoint , float finLength , float finWidth )
        {
        attachmentPoint = FindFinAttachmentPoint ( width , length , side );

        const int segments = 24;
        const int radialFolds = 17;
        const int microFolds = 17;
        const int layers = 2;

        finLength = width * 0.8f;
        finWidth = width * 0.3f;

        float animationSpeed = 2.5f;
        float maxSpreadAngle = MathHelper.Pi * 0.25f;
        float waveIntensity = width * 0.25f;
        float bendIntensity = 0.7f;

        float spreadPhase = _wiggleTime * 2.7f * animationSpeed;
        float wavePos = _wiggleTime * 3f * animationSpeed;

        Vector3 upDirection = Vector3.UnitY;
        Vector3 finForward = new Vector3(side, 0, -1).Normalized();

        uint baseIndex = (uint)vertices.Count;

        float baseWave = MathF.Sin(_wiggleTime * 2.5f) * 0.3f;

        // Специальная анимация - быстрые вертикальные колебания
        float specialAnim = 0f;
        if ( _isPectoralFinSpecialAnim )
            {
            float animProgress = _pectoralFinSpecialAnimTime / PectoralFinAnimDuration;
            float intensity = 1f - (animProgress * animProgress); // Плавное затухание
            specialAnim = MathF . Sin ( _wiggleTime * PectoralFinAnimSpeed ) *
                         PectoralFinAnimAmplitude * intensity;
            }

        attachmentPoint . X = -attachmentPoint . X;
        vertices . Add ( new Vertex ( attachmentPoint , Vector2 . Zero , new Vector2 ( attachmentPoint . X , attachmentPoint . Z ) , Vector2 . Zero , Vector2 . Zero ) );

        List<Vector3> tempVertices = [];
        List<Vector3> tempNormals = [];
        List<bool> visiblePoints = [];

        for ( int layer = 0 ; layer <= layers ; layer++ )
            {
            _ = layer / ( float ) layers;

            for ( int i = 0 ; i <= segments ; i++ )
                {
                float t = (float)i / segments;
                float angle = MathHelper.PiOver4 * (0.3f + (t * 0.7f));

                float spreadFactor = (MathF.Sin(spreadPhase) * 0.5f) + 0.5f;
                float currentSpreadAngle = maxSpreadAngle * spreadFactor * (1 - (t * 0.2f));

                Vector3 basePoint = attachmentPoint + new Vector3(
                    side * finLength * MathF.Sin(angle + currentSpreadAngle) * 0.8f,
                    (-finWidth * t * 0.6f) + (baseWave * finWidth * (1 - t)),
                    -finLength * MathF.Cos(angle + currentSpreadAngle) * 0.8f
                );

                // Добавляем специальную анимацию
                basePoint . Y += specialAnim * finWidth * 0.5f * ( 1 - t );

                // Небольшой наклон вперед/назад
                basePoint . Z += MathF . Sin ( t * MathHelper . Pi ) * finLength * 0.1f * baseWave;

                float waveOffset = MathF.Sin(wavePos + (t * MathHelper.TwoPi * 2.5f)) * waveIntensity;

                Vector3 p0 = basePoint;
                Vector3 p1 = basePoint + (finForward * finLength * 0.3f) + (upDirection * waveIntensity * bendIntensity);
                Vector3 p2 = basePoint + (finForward * finLength * 0.7f) - (upDirection * waveIntensity * bendIntensity);
                Vector3 p3 = basePoint + (finForward * finLength);

                p1 += upDirection * waveOffset * 1.2f;
                p2 += upDirection * waveOffset * 1.2f;

                Vector3 point = CalculateBezierPoint(p0, p1, p2, p3, t);

                Vector3 tangent = CalculateBezierTangent(p0, p1, p2, p3, t);
                Vector3 binormal = Vector3.Cross(tangent, finForward);
                Vector3 normal = Vector3.Cross(binormal, tangent).Normalized() * 1.5f;

                point += new Vector3 (
                    side * width * 0.02f * MathF . Sin ( ( _wiggleTime * 5f ) + ( t * 10 ) ) ,
                    width * 0.01f * MathF . Sin ( ( _wiggleTime * 4.5f ) + ( t * 8 ) ) ,
                    width * 0.01f * MathF . Cos ( ( _wiggleTime * 3.8f ) + ( t * 6 ) )
                );

                tempVertices . Add ( point );
                tempNormals . Add ( normal );
                visiblePoints . Add ( IsPointOutsideBody ( point , width , length ) );

                for ( int f = 1 ; f <= radialFolds ; f++ )
                    {
                    float foldFactor = (float)f / (radialFolds + 1);
                    float foldIntensity = (1f - (t * 0.5f)) * (0.8f + (0.2f * MathF.Sin((f * 2) + (_wiggleTime * 4f))));

                    Vector3 foldOffset = binormal * (f % 2 == 0 ? 1 : -1) * width * 0.04f * foldFactor;
                    float foldWave = MathF.Sin((wavePos * 1.5f) + (t * 20) + f) * width * 0.02f;

                    Vector3 foldPoint = point + (foldOffset * foldIntensity) + (normal * foldWave);

                    Vector3 foldNormal = Vector3.Lerp(
                        normal,
                        new Vector3(side * 0.6f, -0.6f, -0.4f).Normalized(),
                        foldFactor * 0.5f
                    );

                    tempVertices . Add ( foldPoint );
                    tempNormals . Add ( foldNormal );
                    visiblePoints . Add ( IsPointOutsideBody ( foldPoint , width , length ) );

                    for ( int mf = 1 ; mf <= microFolds ; mf++ )
                        {
                        float microFactor = mf / (float)(microFolds + 1);
                        Vector3 microPoint = Vector3.Lerp(point, foldPoint, microFactor);

                        float microWave = MathF.Sin((wavePos * 2f) + (t * 25) + f + mf) * width * 0.005f;
                        microPoint += normal * microWave;

                        tempVertices . Add ( microPoint );
                        tempNormals . Add ( Vector3 . Lerp ( normal , foldNormal , microFactor ) );
                        visiblePoints . Add ( IsPointOutsideBody ( microPoint , width , length ) );
                        }
                    }
                }
            }

        AddFinEdgeDetails ( tempVertices , tempNormals , visiblePoints , width , length , segments , 1 + ( radialFolds * ( 1 + microFolds ) ) );

        Dictionary<uint, uint> indexMap = [];
        uint newIndex = baseIndex + 1;

        for ( uint i = 0 ; i < tempVertices . Count ; i++ )
            {
            if ( visiblePoints [ ( int ) i ] )
                {
                vertices . Add ( new Vertex (
                    tempVertices [ ( int ) i ] ,
                    Vector2 . Zero ,
                    new Vector2 ( tempVertices [ ( int ) i ] . X , tempVertices [ ( int ) i ] . Z ) ,
                    Vector2 . Zero ,
                    Vector2 . Zero
                ) );
                indexMap [ i ] = newIndex++;
                }
            }

        int pointsPerSegment = 1 + (radialFolds * (1 + microFolds));
        for ( int layer = 0 ; layer < layers ; layer++ )
            {
            uint layerOffset = (uint)(layer * (segments + 1) * pointsPerSegment);

            for ( int i = 0 ; i < segments ; i++ )
                {
                uint current = layerOffset + (uint)(i * pointsPerSegment);
                uint next = current + (uint)pointsPerSegment;

                if ( i < segments - 1 &&
                    visiblePoints [ ( int ) current ] &&
                    visiblePoints [ ( int ) next ] &&
                    visiblePoints [ ( int ) ( current + 1 ) ] &&
                    visiblePoints [ ( int ) ( next + 1 ) ] )
                    {
                    indices . Add ( baseIndex );
                    indices . Add ( indexMap [ current ] );
                    indices . Add ( indexMap [ next ] );

                    if ( layer > 0 )
                        {
                        uint prevCurrent = current - (uint)((segments + 1) * pointsPerSegment);
                        uint prevNext = next - (uint)((segments + 1) * pointsPerSegment);

                        if ( visiblePoints [ ( int ) prevCurrent ] && visiblePoints [ ( int ) prevNext ] )
                            {
                            ConnectDetailedFolds ( indices , indexMap [ prevCurrent ] , indexMap [ current ] ,
                                            indexMap [ next ] , indexMap [ prevNext ] , microFolds + 1 );
                            }
                        }

                    for ( int f = 0 ; f < radialFolds ; f++ )
                        {
                        uint foldOffset = (uint)(f * (1 + microFolds));
                        uint foldCurrent = current + foldOffset;
                        uint foldNext = next + foldOffset;

                        if ( visiblePoints [ ( int ) foldCurrent ] && visiblePoints [ ( int ) foldNext ] &&
                            visiblePoints [ ( int ) ( foldCurrent + 1 ) ] && visiblePoints [ ( int ) ( foldNext + 1 ) ] )
                            {
                            AddSafeTriangle ( indices , indexMap [ foldCurrent ] , indexMap [ foldNext ] , indexMap [ foldCurrent + 1 ] );
                            AddSafeTriangle ( indices , indexMap [ foldNext ] , indexMap [ foldNext + 1 ] , indexMap [ foldCurrent + 1 ] );
                            }
                        }
                    }
                }
            }
        }

    private void CreateVentralFin ( float width , float length , int side , Vector3 attachmentPoint ,
                                float wiggleTime , float animationSpeed , float shakeEffect )
        {
        const int segments = 24;
        const int radialFolds = 5;
        const int layers = 2;
        _ = width * 0.25f; // Увеличиваем интенсивность волн

        // Параметры анимации
        _ = wiggleTime * 3.5f;
        float wavePhase = wiggleTime * 5.4f;
        _ = wiggleTime * 5.4f;

        // Геометрия плавника
        float finLength = width * 2.2f; // Чуть длиннее для выразительности
        float finWidth = width * 0.85f; // Шире для лучшей видимости

        uint baseIndex = (uint)vertices.Count;
        vertices . Add ( new Vertex ( attachmentPoint , Vector2 . Zero ,
            new Vector2 ( attachmentPoint . X , attachmentPoint . Z ) , Vector2 . Zero , Vector2 . Zero ) );

        List<Vector3> tempVertices = [];

        List<bool> visiblePoints = [];
        _ = new Vector3 ( side , 0 , -1 ) . Normalized ( );

        for ( int layer = 0 ; layer <= layers ; layer++ )
            {
            _ = layer / ( float ) layers;

            for ( int i = 0 ; i <= segments ; i++ )
                {
                float t = (float)i / segments;
                float angle = MathHelper.PiOver4 * (0.3f + (t * 0.7f));

                // Интенсивное дрожание при смене полосы
                float currentShake = shakeEffect * (1 - (t * 0.3f)); // Уменьшаем к кончику

                // Базовое положение
                Vector3 point = attachmentPoint + new Vector3(
                    side * finLength * MathF.Sin(angle) * 0.6f,
                    -finWidth * t * 0.7f,
                    -finLength * MathF.Cos(angle) * 0.9f
                );

                // Явное дрожание
                point += new Vector3 (
                    side * currentShake * width * 0.15f * MathF . Sin ( ( wavePhase * 2 ) + ( t * 15 ) ) ,
                    currentShake * width * 0.1f * MathF . Cos ( ( wavePhase * 1.5f ) + ( t * 12 ) ) ,
                    currentShake * width * 0.05f * MathF . Sin ( ( wavePhase * 3 ) + ( t * 18 ) )
                );

                // Волновая анимация
                point += new Vector3 (
                    side * width * 0.05f * MathF . Sin ( wavePhase + ( t * 10 ) ) ,
                    width * 0.03f * MathF . Cos ( ( wavePhase * 1.2f ) + ( t * 8 ) ) ,
                    width * 0.01f * MathF . Sin ( ( wavePhase * 0.8f ) + ( t * 6 ) )
                );

                // Добавляем точку
                tempVertices . Add ( point );
                visiblePoints . Add ( true );

                // Складки с усиленным эффектом
                for ( int f = 1 ; f <= radialFolds ; f++ )
                    {
                    float foldFactor = (float)f / (radialFolds + 1);
                    Vector3 foldPoint = point + new Vector3(
                        side * width * 0.04f * (f % 2 == 0 ? 1 : -1) * foldFactor,
                        width * 0.03f * foldFactor,
                        width * 0.01f * foldFactor
                    );

                    // Усиленное дрожание для складок
                    foldPoint += new Vector3 (
                        side * currentShake * width * 0.1f * MathF . Sin ( ( wavePhase * 3 ) + ( t * 20 ) + f ) ,
                        currentShake * width * 0.07f * MathF . Cos ( ( wavePhase * 2 ) + ( t * 15 ) + f ) ,
                        currentShake * width * 0.03f * MathF . Sin ( ( wavePhase * 4 ) + ( t * 25 ) + f )
                    );

                    tempVertices . Add ( foldPoint );
                    visiblePoints . Add ( true );
                    }
                }
            }

        // Генерация индексов (аналогично оригинальному методу)
        for ( uint i = 0 ; i < tempVertices . Count ; i++ )
            {
            vertices . Add ( new Vertex ( tempVertices [ ( int ) i ] , Vector2 . Zero ,
                new Vector2 ( tempVertices [ ( int ) i ] . X , tempVertices [ ( int ) i ] . Z ) ,
                Vector2 . Zero , Vector2 . Zero ) );
            }

        // Индексация треугольников
        int pointsPerSegment = 1 + radialFolds;
        for ( int layer = 0 ; layer < layers ; layer++ )
            {
            uint layerOffset = (uint)(layer * (segments + 1) * pointsPerSegment);

            for ( int i = 0 ; i < segments ; i++ )
                {
                uint current = layerOffset + (uint)(i * pointsPerSegment);
                uint next = current + (uint)pointsPerSegment;

                indices . Add ( baseIndex );
                indices . Add ( baseIndex + current );
                indices . Add ( baseIndex + next );

                for ( int f = 0 ; f < radialFolds ; f++ )
                    {
                    indices . Add ( baseIndex + current + ( uint ) f );
                    indices . Add ( baseIndex + next + ( uint ) f );
                    indices . Add ( baseIndex + current + ( uint ) f + 1 );

                    indices . Add ( baseIndex + next + ( uint ) f );
                    indices . Add ( baseIndex + next + ( uint ) f + 1 );
                    indices . Add ( baseIndex + current + ( uint ) f + 1 );
                    }
                }
            }
        }

    private void CreateSingleVentralFin ( float width , float length )
        {
        if ( !TryGetBodyBottomLine ( out List<Vector3> bodyBottomLine ) || bodyBottomLine . Count < 2 )
            {
            return;
            }

        const int segments = 36;
        const int mainFolds = 17;
        float maxFinHeight = width * 1.35f;
        float yOffset = (-width * 0.27f) - 0.5f;
        uint baseIndex = (uint)vertices.Count;

        int startIndex = (int)(bodyBottomLine.Count * 0.4f);
        int endIndex = bodyBottomLine.Count - 1;
        int peakIndex = startIndex + ((endIndex - startIndex) / 3);

        float ventralWigglePhase = _wiggleTime * 10f;
        float ventralWiggleAmplitude = MaxWiggleAmplitude * width * 0.025f;
        float tailWigglePhase = _wiggleTime * 3f;
        float tailWiggleAmplitude = MaxWiggleAmplitude * (_isWPressed ? 2.214285714285713f : 1.55f);

        for ( int i = 0 ; i <= segments ; i++ )
            {
            float t = (float)i / segments;

            float combinedTurnAngle = GetCombinedTurnAngle(t);
            Matrix4 rotation = Matrix4.CreateRotationY(MathHelper.DegreesToRadians(combinedTurnAngle));

            int bodyIndex = Math.Clamp(startIndex + (int)(t * (endIndex - startIndex)), startIndex, endIndex);
            Vector3 basePoint = bodyBottomLine[bodyIndex];
            basePoint . Y -= yOffset - 0.5f;

            // Применяем поворот к базовой точке плавника
            Vector4 rotatedDir = rotation * new Vector4(basePoint, 1.0f);
            basePoint = rotatedDir . Xyz;

            float tailFactor = MathHelper.Clamp((t - 0.6f) / 0.4f, 0, 1);
            float tailSwing = MathF.Sin(tailWigglePhase + (tailFactor * MathHelper.Pi)) *
                            tailWiggleAmplitude * (width * 0.45f);

            // Комбинируем анимацию плавника и хвоста
            float wiggleOffset = (MathF.Sin(ventralWigglePhase + (t * MathHelper.Pi * 3f)) *
                               ventralWiggleAmplitude * (1 - (t * 0.5f))) +
                               (tailSwing * tailFactor);

            // Применяем поворот к анимации виляния
            _ = rotation * new Vector4 ( wiggleOffset , 0 , 0 , 0 );

            float tailTransition = MathHelper.Clamp((t - 0.6f) / 0.2f, 0, 1);
            Vector2 bezierPoint = Vector2.Zero;

            if ( tailTransition > 0 )
                {
                Vector2 p0 = Vector2.Zero;
                Vector2 p1 = new(
                    MathF.Sin(tailWigglePhase) * tailWiggleAmplitude * 0.8f * (width * 0.45f),
                    -0.25f * width);
                Vector2 p2 = new(
                    MathF.Sin(tailWigglePhase + MathHelper.PiOver2) * tailWiggleAmplitude * 1.5f * (width * 0.45f),
                    -0.6f * width);
                Vector2 p3 = new(
                    MathF.Sin(tailWigglePhase + MathHelper.Pi) * tailWiggleAmplitude * 2.2f * (width * 0.45f),
                    -1.0f * width);

                float tailPos = (t - 0.6f) / 0.4f;
                bezierPoint = CalculateBezierPoint ( tailPos , p0 , p1 , p2 , p3 );
                }

            float combinedXOffset = MathHelper.Lerp(
                wiggleOffset,
                bezierPoint.X * 0.9f,
                tailTransition * 0.9f);
            _ = ( float ) ( bodyIndex - peakIndex ) / ( endIndex - peakIndex );

            float heightFactor;
            if ( bodyIndex <= peakIndex )
                {
                float normalizedPos = (float)(bodyIndex - startIndex) / (peakIndex - startIndex);
                heightFactor = 0.3f + ( 0.7f * normalizedPos );
                }
            else
                {
                float normalizedPos = (float)(bodyIndex - peakIndex) / (endIndex - peakIndex);
                heightFactor = 1f - ( 0.7f * normalizedPos );
                }

            Vector3 crest = new(
                combinedXOffset,
                basePoint.Y - (maxFinHeight * heightFactor),
                basePoint.Z
            );
            AddVertexSafe ( crest );

            for ( int f = 1 ; f <= mainFolds ; f++ )
                {
                float foldT = (float)f / (mainFolds + 1);
                float foldWidth = width * (0.08f + (foldT * 0.15f)) * heightFactor;

                float foldWiggle = MathF.Sin(ventralWigglePhase + (t * MathHelper.Pi * 3f) + (f * 0.5f)) *
                                 width * 0.03f * (1 - (tailTransition * 0.2f));

                Vector3 foldPoint = new(
                    ((f % 2 == 0 ? 1 : -1) * foldWidth) + (combinedXOffset * 0.7f) + foldWiggle,
                    basePoint.Y - (maxFinHeight * (0.2f + (0.6f * foldT)) * heightFactor),
                    basePoint.Z + (width * 0.02f * MathF.Sin(t * 20) * (1 - heightFactor))
                );

                // Применяем поворот к точкам складок
                Vector4 rotatedFold = rotation * new Vector4(foldPoint, 1.0f);
                foldPoint = rotatedFold . Xyz;

                AddVertexSafe ( foldPoint );
                }
            }

        int pointsPerSegment = 1 + mainFolds;
        for ( int i = 0 ; i < segments ; i++ )
            {
            uint current = baseIndex + (uint)(i * pointsPerSegment);
            uint next = current + (uint)pointsPerSegment;

            if ( next + mainFolds >= vertices . Count )
                {
                continue;
                }

            for ( int f = 0 ; f < mainFolds ; f++ )
                {
                if ( current + ( uint ) f + 1 >= vertices . Count || next + ( uint ) f + 1 >= vertices . Count )
                    {
                    continue;
                    }

                AddTriangle ( indices , current + ( uint ) f , next + ( uint ) f , current + ( uint ) ( f + 1 ) );
                AddTriangle ( indices , next + ( uint ) f , next + ( uint ) ( f + 1 ) , current + ( uint ) ( f + 1 ) );
                }
            }

        AddFinDetailsSafe ( baseIndex , segments , pointsPerSegment , width );
        }

    private bool TryGetBodyBottomLine ( out List<Vector3> bodyBottomLine )
        {
        bodyBottomLine = [ ];
        float minY = float.MaxValue;

        const float liftStart = 0f;
        const float liftEnd = 1f;
        const float bellyLiftHeight = 0.5f;
        const float bellyLiftPower = 7f;

        int safeBodySegments = Math.Min(bodySegments, vertices.Count / Math.Max(1, radialSegments));

        for ( int ring = 0 ; ring <= safeBodySegments ; ring++ )
            {
            float t = (float)ring / safeBodySegments;
            float minRingY = float.MaxValue;
            float currentZ = 0;

            // Получаем угол поворота для текущего сегмента тела
            float turnAngle = GetCombinedTurnAngle(t);
            Matrix4 rotation = Matrix4.CreateRotationY(MathHelper.DegreesToRadians(turnAngle));

            for ( int radial = 0 ; radial < radialSegments ; radial++ )
                {
                int index = (ring * radialSegments) + radial;
                if ( index < vertices . Count )
                    {
                    // Применяем поворот к позиции вершины
                    Vector4 rotatedPos = rotation * new Vector4(vertices[index].Pos, 1.0f);
                    float rotatedY = rotatedPos.Y;

                    minRingY = Math . Min ( minRingY , rotatedY );
                    currentZ = rotatedPos . Z; // Z также меняется при повороте
                    }
                }

            if ( t is > liftStart and < liftEnd )
                {
                float liftT = (t - liftStart) / (liftEnd - liftStart);
                float curve = MathF.Sin(liftT * MathHelper.Pi);
                minRingY *= 1 - ( bellyLiftHeight * MathF . Pow ( curve , bellyLiftPower ) );
                }

            minRingY = MathHelper . Clamp ( minRingY , -bodyWidth * 0.8f , bodyWidth * 0.8f );

            // Создаем точку с учетом поворота
            Vector4 bottomPoint = rotation * new Vector4(0, minRingY, currentZ, 1.0f);
            bodyBottomLine . Add ( bottomPoint . Xyz );

            if ( minRingY < minY )
                {
                minY = minRingY;
                }
            }
        return bodyBottomLine . Count > 0;
        }

    #endregion

    #region Вспомогательные методы

    private Vector2 CalculateBezierPoint ( float t , Vector2 p0 , Vector2 p1 , Vector2 p2 , Vector2 p3 )
        {
        float u = 1 - t;
        float tt = t * t;
        float uu = u * u;
        float uuu = uu * u;
        float ttt = tt * t;

        Vector2 p = uuu * p0;
        p += 3 * uu * t * p1;
        p += 3 * u * tt * p2;
        p += ttt * p3;

        return p;
        }

    private Vector3 CalculateBezierPoint ( Vector3 p0 , Vector3 p1 , Vector3 p2 , Vector3 p3 , float t )
        {
        float u = 1 - t;
        float tt = t * t;
        float uu = u * u;
        float uuu = uu * u;
        float ttt = tt * t;

        return ( uuu * p0 )
               + ( 3 * uu * t * p1 )
               + ( 3 * u * tt * p2 )
               + ( ttt * p3 );
        }

    private Vector3 CalculateBezierTangent ( Vector3 p0 , Vector3 p1 , Vector3 p2 , Vector3 p3 , float t )
        {
        float u = 1 - t;
        float uu = u * u;
        float tu = t * u;
        float tt = t * t;

        Vector3 tangent = (3 * uu * (p1 - p0))
                          + (6 * tu * (p2 - p1))
                          + (3 * tt * (p3 - p2));

        return tangent . Normalized ( );
        }

    private float SmoothStep ( float t )
        {
        t = MathHelper . Clamp ( t , 0 , 1 );
        return t * t * ( 3f - ( 2f * t ) );
        }

    private Vector3 GetSpherePoint ( Vector3 center , float radius , float u , float v )
        {
        float phi = u * MathHelper.TwoPi;
        float theta = (0.5f - v) * MathHelper.Pi;

        float cosTheta = MathF.Cos(theta);
        float sinTheta = MathF.Sin(theta);

        return center + new Vector3 (
            radius * MathF . Cos ( phi ) * cosTheta ,
            radius * MathF . Sin ( phi ) * cosTheta ,
            radius * sinTheta
        );
        }

    private void AddVertexSafe ( Vector3 vertex )
        {
        if ( !float . IsNaN ( vertex . X ) && !float . IsNaN ( vertex . Y ) && !float . IsNaN ( vertex . Z ) )
            {
            vertices . Add ( new Vertex ( vertex , Vector2 . Zero , Vector2 . Zero , new Vector2 ( vertex . X , vertex . Z ) , Vector2 . Zero ) );
            }
        }

    private void AddFinDetailsSafe ( uint baseIndex , int segments , int pointsPerSegment , float width )
        {
        Random rand = new(42);
        int detailsCount = Math.Min(segments * 2, 50);

        for ( int i = 0 ; i < detailsCount ; i++ )
            {
            int segment = rand.Next(0, segments - 1);
            uint current = baseIndex + (uint)(segment * pointsPerSegment);

            if ( current + ( uint ) pointsPerSegment >= vertices . Count )
                {
                continue;
                }

            int pointInSegment = 1 + rand.Next(0, segments - 1);
            Vector3 basePoint = vertices[(int)(current + pointInSegment)].Pos;

            Vector3 detail = basePoint + new Vector3(
                (float)(rand.NextDouble() - 0.5) * width * 0.02f,
                (float)rand.NextDouble() * width * 0.01f,
                (float)(rand.NextDouble() - 0.5) * width * 0.02f
            );

            AddVertexSafe ( detail );
            }
        }

    private void AddFinEdgeDetails ( List<Vector3> vertices , List<Vector3> normals , List<bool> visiblePoints ,
                                 float width , float length , int segments , int pointsPerSegment )
        {
        Random rand = new(42);
        int details = segments * 3;

        for ( int i = 0 ; i < details ; i++ )
            {
            int segment = rand.Next(0, segments - 1);
            int idx = segment * pointsPerSegment;

            if ( idx >= vertices . Count - 1 )
                {
                continue;
                }

            if ( visiblePoints [ idx ] || visiblePoints [ idx + 1 ] )
                {
                for ( int j = 0 ; j < 2 ; j++ )
                    {
                    if ( visiblePoints [ idx + j ] )
                        {
                        Vector3 point = vertices[idx + j];
                        point += new Vector3 (
                            ( float ) ( rand . NextDouble ( ) - 0.5 ) * width * 0.015f ,
                            ( float ) ( rand . NextDouble ( ) - 0.5 ) * width * 0.01f ,
                            ( float ) ( rand . NextDouble ( ) - 0.5 ) * width * 0.005f
                        );

                        vertices . Add ( point );
                        normals . Add ( normals [ idx + j ] );
                        visiblePoints . Add ( IsPointOutsideBody ( point , width , length ) );
                        }
                    }
                }
            }
        }

    private bool IsPointOutsideBody ( Vector3 point , float width , float length )
        {
        float bodyRadiusAtZ = GetBodyRadiusAtZ(point.Z, width, length);
        float distanceFromCenter = MathF.Sqrt((point.X * point.X) + (point.Y * point.Y));
        return distanceFromCenter > bodyRadiusAtZ * 1.05f;
        }

    private float GetBodyRadiusAtZ ( float z , float width , float length )
        {
        float normalizedZ = (z - (length * 0.7f)) / (length * 0.3f);
        normalizedZ = MathHelper . Clamp ( normalizedZ , 0 , 1 );

        float radius = width * 0.5f * (0.8f + (0.4f * MathF.Sin(normalizedZ * MathHelper.Pi)));

        float sideCompression = 1.6f - (1.4f * MathF.Pow(0.5f, 0.9f));
        return radius / sideCompression;
        }

    private void ConnectDetailedFolds ( List<uint> indices , uint a , uint b , uint c , uint d , int detailLevel )
        {
        for ( int i = 0 ; i < detailLevel ; i++ )
            {
            if ( a + ( uint ) i < vertices . Count &&
                b + ( uint ) i < vertices . Count &&
                c + ( uint ) i < vertices . Count &&
                d + ( uint ) i < vertices . Count )
                {
                AddSafeTriangle ( indices , a + ( uint ) i , b + ( uint ) i , c + ( uint ) i );
                AddSafeTriangle ( indices , a + ( uint ) i , c + ( uint ) i , d + ( uint ) i );
                }
            }
        }

    private void AddSafeTriangle ( List<uint> indices , uint a , uint b , uint c )
        {
        if ( a != b && a != c && b != c )
            {
            indices . Add ( a );
            indices . Add ( b );
            indices . Add ( c );
            }
        }

    private void AddTriangle ( List<uint> indices , uint a , uint b , uint c )
        {
        if ( a != b && a != c && b != c &&
            a < vertices . Count && b < vertices . Count && c < vertices . Count )
            {
            indices . Add ( a );
            indices . Add ( b );
            indices . Add ( c );
            }
        }

    private Vector3 FindFinAttachmentPoint ( float width , float length , int side )
        {
        float baseX = side * width * 0.15f;
        float baseY = -width * 0.2f;
        float baseZ = (length * 0.7f) + (width * 0.85f);

        // Применяем поворот головы к точке крепления
        Vector4 rotatedPoint = _headRotationMatrix * new Vector4(baseX, baseY, baseZ, 1.0f);
        return rotatedPoint . Xyz;
        }

    #endregion

    #region Обработчики событий

    private void GlControl_Resize ( object sender , EventArgs e )
        {
        GL . Viewport ( 0 , 0 , glControl1 . Width , glControl1 . Height );
        UpdateProjectionMatrix ( );
        glControl1 . Invalidate ( );
        }

    private void UpdateProjectionMatrix ( )
        {
        _projection = Matrix4 . CreatePerspectiveFieldOfView (
            MathHelper . DegreesToRadians ( 60 ) ,
            ( float ) glControl1 . ClientSize . Width / glControl1 . ClientSize . Height ,
            0.1f ,
            500f
        );
        }

    // Возвращает список линий, которые перекрывает бревно
    private List<int> GetOccupiedLanes ( Log log )
        {
        List<int> lanes = new List<int>();
        float leftEdge = log.Position.X - LogWidth/2;
        float rightEdge = log.Position.X + LogWidth/2;

        for ( int i = 0 ; i < _lanePositions . Length ; i++ )
            {
            float laneCenter = _lanePositions[i];
            if ( leftEdge <= laneCenter + LaneWidth / 2 &&
                rightEdge >= laneCenter - LaneWidth / 2 )
                {
                lanes . Add ( i );
                }
            }
        return lanes;
        }

    private bool CheckLogCollision ( Log log , Vector3 salmonPos )
        {
        // Реальные размеры бревна с учётом масштаба
        float logRadius = log.Scale * 4.75f;
        float logHalfLength = log.Scale * 27.5f; // 55f / 2

        // Переводим в локальные координаты бревна
        Vector3 localPos = salmonPos - log.Position;

        // Поворачиваем обратно, если бревно rotated
        if ( log . Rotation != 0 )
            {
            float cos = MathF.Cos(-log.Rotation);
            float sin = MathF.Sin(-log.Rotation);
            float x = localPos.X * cos - localPos.Z * sin;
            float z = localPos.X * sin + localPos.Z * cos;
            localPos = new Vector3 ( x , localPos . Y , z );
            }

        // Проверка коллизии с "капсулой" (цилиндр + полусферы на концах)
        float distanceFromCenter = MathF.Sqrt(localPos.X * localPos.X + localPos.Y * localPos.Y);

        // Если точка дальше чем радиус + допуск - точно нет коллизии
        if ( distanceFromCenter > logRadius + bodyWidth / 2 )
            return false;

        // Проверка вдоль длины бревна
        if ( Math . Abs ( localPos . Z ) <= logHalfLength )
            {
            // Внутри цилиндрической части
            return true;
            }
        else if ( Math . Abs ( localPos . Z ) <= logHalfLength + logRadius )
            {
            // Проверка сферических концов
            float endDist = MathF.Sqrt(
        (Math.Abs(localPos.Z) - logHalfLength) * (Math.Abs(localPos.Z) - logHalfLength) +
        distanceFromCenter * distanceFromCenter);

            return endDist <= logRadius + bodyWidth / 2;
            }

        return false;
        }

    private void CheckCollisions ( )
        {
        if ( _isInvulnerable ) return;

        // Позиция носа лосося (передняя часть)
        Vector3 salmonNosePosition = new Vector3(
    _currentXPosition,
    0,
    _noseOffset);

        float salmonCollisionRadius = bodyWidth * 0.5f;
        float checkDistance = _noseOffset + 55f;

        foreach ( Log log in _logs . Where ( l => l . IsActive ) )
            {
            // Параметры бревна

            if ( CheckLogCollision ( log , salmonNosePosition ) )
                {
                LogHandleCollision ( log );
                return;
                }
            }

        foreach ( Rock rock in _rocks . Where ( r =>
            r . IsActive &&
            r . Lane != -1 &&  // Исключаем краевые камни
            Math . Abs ( r . Position . Z - salmonNosePosition . Z ) < checkDistance ) )
            {
            // Размеры камня с учетом масштаба
            float effectiveRockLength = rock.Scale * 20f * 0.5f; // Половина длины
            float effectiveRockWidth = rock.Scale * 8f;          // Ширина (радиус * 2)

            // Проверка перекрытия по Z (длина)
            bool zCollision = Math.Abs(salmonNosePosition.Z - rock.Position.Z) <
                 (salmonCollisionRadius + effectiveRockLength);

            // Проверка перекрытия по X (ширина)
            bool xCollision = Math.Abs(salmonNosePosition.X - rock.Position.X) <
                 (salmonCollisionRadius + effectiveRockWidth);

            if ( zCollision && xCollision )
                {
                HandleCollision ( );
                return; // Прекращаем проверку после первого столкновения
                }
            }
        }

    private void LogHandleCollision ( Log collidedLog = null )
        {
        _isInvulnerable = true;
        _invulnerabilityTimer = 0f;
        _blinkTimer = 0f;
        _isVisibleDuringBlink = true;

        // Определяем доступные линии (не занятые этим бревном)
        List<int> availableLanes = new List<int> { 0, 1, 2 };

        if ( collidedLog != null )
            {
            var occupiedLanes = GetOccupiedLanes(collidedLog);
            availableLanes = availableLanes . Except ( occupiedLanes ) . ToList ( );
            }

        // Если все линии перекрыты, выбираем любую (крайний случай)
        if ( availableLanes . Count == 0 )
            {
            availableLanes = new List<int> { 0 , 1 , 2 };
            }

        // Выбираем случайную доступную линию
        int newLane = availableLanes[_random.Next(availableLanes.Count)];

        // Начинаем анимацию перемещения
        _currentLane = newLane;
        _currentXPosition = _lanePositions [ newLane ];

        // Отключаем все флаги поворота
        _isChangingLane = false;
        _turnAnimationProgress = 0f;
        _headTurnProgress = 0f;
        _currentHeadAngle = 0f;
        _headRotationMatrix = Matrix4 . Identity;
        }

    private void HandleCollision ( )
        {
        // Активируем неуязвимость
        _isInvulnerable = true;
        _invulnerabilityTimer = 0f;
        _blinkTimer = 0f;
        _isVisibleDuringBlink = true;

        // Выбираем случайную линию из оставшихся двух
        int newLane;
        do
            {
            newLane = _random . Next ( 0 , 3 ); // 0, 1 или 2
            } while ( newLane == _currentLane ); // Повторяем, пока не получим другую линию

        // Начинаем анимацию перемещения
        _currentLane = newLane;
        _currentXPosition = _lanePositions [ newLane ];

        // Отключаем все флаги поворота
        _isChangingLane = false;
        _turnAnimationProgress = 0f;
        _headTurnProgress = 0f;
        _currentHeadAngle = 0f;
        _headRotationMatrix = Matrix4 . Identity;
        }

    private void GlControl_KeyDown ( object sender , KeyEventArgs e )
        {
        if ( _isChangingLane ) return;

        switch ( e . KeyCode )
            {
            case System . Windows . Forms . Keys . D when _currentLane > 0: // Вправо
                _targetLane = _currentLane - 1;
                _isChangingLane = true;
                _isTurningRight = true;
                _isTurningLeft = false;
                _tailSwingDirection = 1f;
                _laneChangeTailSwing = _maxLaneChangeSwing;
                break;

            case System . Windows . Forms . Keys . A when _currentLane < 2: // Влево
                _targetLane = _currentLane + 1;
                _isChangingLane = true;
                _isTurningLeft = true;
                _isTurningRight = false;
                _tailSwingDirection = -1f;
                _laneChangeTailSwing = -_maxLaneChangeSwing;
                break;

            case System . Windows . Forms . Keys . W:
                _isWPressed = true;
                break;
            }
        }

    private void GlControl_KeyUp ( object sender , KeyEventArgs e )
        {
        if ( e . KeyCode == System . Windows . Forms . Keys . W )
            {
            _isWPressed = false;
            }
        else if ( e . KeyCode == System . Windows . Forms . Keys . A )
            {
            _isTurningLeft = false;
            }
        else if ( e . KeyCode == System . Windows . Forms . Keys . D )
            {
            _isTurningRight = false;
            }
        }

    private void GlControl_Paint ( object sender , PaintEventArgs e )
        {
        // 1. Рендерим отражение в текстуру
        RenderToTexture ( reflectionFBO , true );

        // 2. Рендерим преломление в текстуру
        RenderToTexture ( refractionFBO , false );

        // 3. Основной рендеринг сцены с водой
        RenderMainScene ( );

        glControl1 . SwapBuffers ( );
        }
    private void RenderToTexture ( int fbo , bool isReflection )
        {
        GL . BindFramebuffer ( FramebufferTarget . Framebuffer , fbo );
        GL . Viewport ( 0 , 0 , glControl1 . Width , glControl1 . Height );
        GL . Clear ( ClearBufferMask . ColorBufferBit | ClearBufferMask . DepthBufferBit );

        // Настраиваем матрицу вида для отражения/преломления
        Matrix4 view = isReflection ?
    Matrix4.LookAt(new Vector3(0, 40, -30), new Vector3(0, 0, 14.5f), Vector3.UnitY) *
    Matrix4.CreateScale(1, -1, 1) :
    _view;

        // Рендерим все объекты кроме воды
        RenderSceneObjects ( view , isReflection );
        }
    private void RenderSceneObjects ( Matrix4 view , bool isReflection )
        {
        GL . Clear ( ClearBufferMask . ColorBufferBit | ClearBufferMask . DepthBufferBit );

        // Рендерим плоскость
        RenderPlane ( view );

        GL . Enable ( EnableCap . DepthTest );
        GL . DepthFunc ( DepthFunction . Less );

        // Рендерим бревна и камни
        RenderLogs ( view );
        RenderRocks ( view );

        // Рендерим лосося с учетом отражения
        if ( !_isInvulnerable || _isVisibleDuringBlink )
            {
            Matrix4 model = Matrix4.CreateRotationY(_rotationAngleY) *
                 Matrix4.CreateTranslation(_currentXPosition, 0, 0);

            if ( isReflection )
                {
                model *= Matrix4 . CreateScale ( 1 , -1 , 1 ); // Инвертируем для отражения
                }

            // Устанавливаем прозрачность если в режиме неуязвимости
            if ( _isInvulnerable )
                {
                GL . Enable ( EnableCap . Blend );
                GL . BlendFunc ( BlendingFactor . SrcAlpha , BlendingFactor . OneMinusSrcAlpha );

                // Уменьшаем альфа-канал для эффекта призрака
                foreach ( var part in _salmonParts )
                    {
                    part . Color . W = 0.5f; // Полупрозрачность
                    }
                }
            else
                {
                // Восстанавливаем нормальную прозрачность
                foreach ( var part in _salmonParts )
                    {
                    part . Color . W = part == _salmonParts [ 0 ] ? 0.7f : 0.95f; // Исходные значения
                    }
                }
            // Используем основной шейдер для тела и плавников
            GL . UseProgram ( _shaderProgram );

            GL . UniformMatrix4 ( GL . GetUniformLocation ( _shaderProgram , "projection" ) , false , ref _projection );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _shaderProgram , "view" ) , false , ref view );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _shaderProgram , "model" ) , false , ref model );

            // Привязываем текстуры для лосося
            GL . ActiveTexture ( TextureUnit . Texture0 );
            GL . BindTexture ( TextureTarget . Texture2D , 1 ); // textureBody

            GL . ActiveTexture ( TextureUnit . Texture1 );
            GL . BindTexture ( TextureTarget . Texture2D , 2 ); // textureFin

            GL . ActiveTexture ( TextureUnit . Texture2 );
            GL . BindTexture ( TextureTarget . Texture2D , 3 ); // textureFace

            GL . ActiveTexture ( TextureUnit . Texture3 );
            GL . BindTexture ( TextureTarget . Texture2D , 4 ); // textureEye

            // Устанавливаем uniform-переменные для текстур
            GL . Uniform1 ( GL . GetUniformLocation ( _shaderProgram , "textureBody" ) , 0 );
            GL . Uniform1 ( GL . GetUniformLocation ( _shaderProgram , "textureFin" ) , 1 );
            GL . Uniform1 ( GL . GetUniformLocation ( _shaderProgram , "textureFace" ) , 2 );
            GL . Uniform1 ( GL . GetUniformLocation ( _shaderProgram , "textureEye" ) , 3 );

            GL . BindVertexArray ( _salmonVao );

            foreach ( ModelPart? part in _salmonParts . Take ( 6 ) )
                {
                if ( !part . IsVisible )
                    {
                    continue;
                    }

                GL . Uniform4 ( GL . GetUniformLocation ( _shaderProgram , "color" ) , part . Color );
                GL . Uniform1 ( GL . GetUniformLocation ( _shaderProgram , "textureId" ) , part . TextureId );
                GL . DrawElements ( PrimitiveType . Triangles , part . IndexCount ,
                               DrawElementsType . UnsignedInt , part . StartIndex * sizeof ( uint ) );
                }

            GL . UseProgram ( _headShaderProgram );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _headShaderProgram , "projection" ) , false , ref _projection );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _headShaderProgram , "view" ) , false , ref view );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _headShaderProgram , "model" ) , false , ref model );
            GL . UniformMatrix4 ( GL . GetUniformLocation ( _headShaderProgram , "headRotation" ) , false , ref _headRotationMatrix );

            GL . ActiveTexture ( TextureUnit . Texture0 );
            GL . BindTexture ( TextureTarget . Texture2D , 1 ); // textureBody

            GL . ActiveTexture ( TextureUnit . Texture1 );
            GL . BindTexture ( TextureTarget . Texture2D , 2 ); // textureFin

            GL . ActiveTexture ( TextureUnit . Texture2 );
            GL . BindTexture ( TextureTarget . Texture2D , 3 ); // textureFace

            GL . ActiveTexture ( TextureUnit . Texture3 );
            GL . BindTexture ( TextureTarget . Texture2D , 4 ); // textureEye

            GL . Uniform1 ( GL . GetUniformLocation ( _headShaderProgram , "textureBody" ) , 0 );
            GL . Uniform1 ( GL . GetUniformLocation ( _headShaderProgram , "textureFin" ) , 1 );
            GL . Uniform1 ( GL . GetUniformLocation ( _headShaderProgram , "textureFace" ) , 2 );
            GL . Uniform1 ( GL . GetUniformLocation ( _headShaderProgram , "textureEye" ) , 3 );

            GL . BindVertexArray ( _salmonVao );

            for ( int i = 6 ; i < _salmonParts . Count ; i++ )
                {
                ModelPart part = _salmonParts[i];
                if ( !part . IsVisible )
                    {
                    continue;
                    }

                GL . Uniform4 ( GL . GetUniformLocation ( _headShaderProgram , "color" ) , part . Color );
                GL . Uniform1 ( GL . GetUniformLocation ( _headShaderProgram , "textureId" ) , part . TextureId );
                GL . DrawElements ( PrimitiveType . Triangles , part . IndexCount ,
                               DrawElementsType . UnsignedInt , part . StartIndex * sizeof ( uint ) );
                }
            if ( _isInvulnerable )
                {
                GL . Disable ( EnableCap . Blend );
                }
            }

        // Рендерим кувшинки и ветки
        RenderLilies ( view );
        RenderBranches ( view );
        }
    private void RenderMainScene ( )
        {
        GL . BindFramebuffer ( FramebufferTarget . Framebuffer , 0 );
        GL . Viewport ( 0 , 0 , glControl1 . Width , glControl1 . Height );
        GL . Clear ( ClearBufferMask . ColorBufferBit | ClearBufferMask . DepthBufferBit );

        // Рендерим все объекты с основной камерой
        RenderSceneObjects ( _view , false );

        // Рендерим воду с эффектами
        RenderWaterWithEffects ( );
        }
    private void RenderWaterWithEffects ( )
        {
        float time = (float)DateTime.Now.TimeOfDay.TotalSeconds;
        Matrix4 waterModel = Matrix4.CreateScale(1, 1, 1);
        GL . Enable ( EnableCap . Blend );
        GL . BlendFunc ( BlendingFactor . SrcAlpha , BlendingFactor . OneMinusSrcAlpha );
        GL . DepthMask ( false );

        GL . UseProgram ( _waterShaderProgram );
        GL . BindVertexArray ( _waterVao );

        // Привязываем текстуры отражения и преломления
        GL . ActiveTexture ( TextureUnit . Texture10 );
        GL . BindTexture ( TextureTarget . Texture2D , reflectionTexture );
        GL . ActiveTexture ( TextureUnit . Texture11 );
        GL . BindTexture ( TextureTarget . Texture2D , refractionTexture );

        // Привязываем основную текстуру воды
        GL . ActiveTexture ( TextureUnit . Texture0 + TEXTURE_UNIT_WATER );
        GL . BindTexture ( TextureTarget . Texture2D , TEXTURE_UNIT_WATER );
        GL . Uniform1 ( GL . GetUniformLocation ( _waterShaderProgram , "waterTexture" ) , TEXTURE_UNIT_WATER );

        // Устанавливаем uniform-переменные
        GL . Uniform1 ( GL . GetUniformLocation ( _waterShaderProgram , "time" ) , time );
        GL . Uniform1 ( GL . GetUniformLocation ( _waterShaderProgram , "_wiggleTime" ) , _wiggleTime );
        GL . Uniform1 ( GL . GetUniformLocation ( _waterShaderProgram , "wakeCenterX" ) , _currentXPosition );
        GL . Uniform1 ( GL . GetUniformLocation ( _waterShaderProgram , "tailWiggleAmplitude" ) , tailWiggleAmplitude );
        GL . UniformMatrix4 ( GL . GetUniformLocation ( _waterShaderProgram , "projection" ) , false , ref _projection );
        GL . UniformMatrix4 ( GL . GetUniformLocation ( _waterShaderProgram , "view" ) , false , ref _view );
        GL . UniformMatrix4 ( GL . GetUniformLocation ( _waterShaderProgram , "model" ) , false , ref waterModel );
        GL . Uniform4 ( GL . GetUniformLocation ( _waterShaderProgram , "waterColor" ) , _waterPart . Color );
        GL . Uniform1 ( GL . GetUniformLocation ( _waterShaderProgram , "reflectionTexture" ) , 10 );
        GL . Uniform1 ( GL . GetUniformLocation ( _waterShaderProgram , "refractionTexture" ) , 11 );

        GL . DrawElements ( PrimitiveType . Triangles , _waterPart . IndexCount ,
            DrawElementsType . UnsignedInt , _waterPart . StartIndex * sizeof ( uint ) );

        GL . BindVertexArray ( 0 );
        GL . DepthMask ( true );
        GL . Disable ( EnableCap . Blend );
        }

    #endregion
    }
} - не меняй сам код но проведи рефакторинг измени все комментарии так буд-то их писал я, приведи весь код к clang format LLVM, сделай единообразное оформление и удали функции или переменные которые нигде не используются, чтобы отступы и пробелы везде подчинялись единому правилу