Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

-- Vector3 CalculateSteering(float dt, Vector3 targetPosition) { -- if (plane.Target !=…

  1. User

    -- Vector3 CalculateSteering(float dt, Vector3 targetPosition) { -- if (plane.Target != null && targetPlane.Health == 0) { -- return new Vector3(); -- }

        -- var error = targetPosition - plane.Rigidbody.position;
        -- error = Quaternion.Inverse(plane.Rigidbody.rotation) * error;   //transform into local space
    
        -- var errorDir = error.normalized;
        -- var pitchError = new Vector3(0, error.y, error.z).normalized;
        -- var rollError = new Vector3(error.x, error.y, 0).normalized;
        -- var yawError = new Vector3(error.x, 0, error.z).normalized;
    
        -- var targetInput = new Vector3();
    
        -- var pitch = Vector3.SignedAngle(Vector3.forward, pitchError, Vector3.right);
        -- if (-pitch < pitchUpThreshold) pitch += 360f;
        -- targetInput.x = pitch;
    
        -- if (Vector3.Angle(Vector3.forward, errorDir) < fineSteeringAngle) {
            -- var yaw = Vector3.SignedAngle(Vector3.forward, yawError, Vector3.up);
            -- targetInput.y = yaw * yawFactor;
        -- } else {
            -- var roll = Vector3.SignedAngle(Vector3.up, rollError, Vector3.forward);
            -- targetInput.z = roll * rollFactor;
        -- }
    
        -- targetInput.x = Mathf.Clamp(targetInput.x, -1, 1);
        -- targetInput.y = Mathf.Clamp(targetInput.y, -1, 1);
        -- targetInput.z = Mathf.Clamp(targetInput.z, -1, 1);
    
        -- var input = Vector3.MoveTowards(lastInput, targetInput, steeringSpeed * dt);
        -- lastInput = input;
    
        -- return input;
    -- }
    

    как работает эта функция? как из вектора необходимого самолета направления в ГЛОБАЛЬНОЙ системе координат получается вектор локально относительно самолета

  2. Assistant

    Эта функция называется CalculateSteering и предназначена для вычисления управляющего вектора самолета в зависимости от целевой позиции. Давайте рассмотрим поэтапно, как она работает:

    1. Проверка условия выхода:

      • Функция проверяет, если у самолета есть цель (plane.Target != null) и если здоровье целевой плоскости равно нулю (targetPlane.Health == 0). Если это условие истинно, возвращается новый нулевой вектор Vector3(), что означает отсутствие необходимости в корректировке управления.
    2. Расчет ошибки позиции:

      • Вычисляется ошибка позиции между целевой позицией targetPosition и позицией самолета plane.Rigidbody.position:
        var error = targetPosition - plane.Rigidbody.position;
        
      • Затем ошибка переводится в локальную систему координат самолета с помощью преобразования кватерниона:
        error = Quaternion.Inverse(plane.Rigidbody.rotation) * error;
        
    3. Нормализация ошибки по различным осям:

      • Ошибка направления (errorDir) нормализуется для общего использования.
      • Ошибка по тангажу (pitchError) определяется векторами y и z.
      • Ошибка по крену (rollError) определяется векторами x и y.
      • Ошибка по рысканью (yawError) определяется векторами x и z.
    4. Определение целевого управляющего вектора:

      • Используется Vector3.SignedAngle для вычисления угла между векторами, который:
        • Вычисляет тангаж (pitch):
          var pitch = Vector3.SignedAngle(Vector3.forward, pitchError, Vector3.right);
          
        • Угол корректируется, если он меньше определенного порога.
        • Если угол между направлением вперед и ошибкой меньше, чем заданный порог (fineSteeringAngle), корректируется рысканье (yaw).
        • Иначе используется крен (roll).
    5. Ограничение и сглаживание значений:

      • Значения targetInput по всем осям ограничиваются между -1 и 1.
      • Используется Vector3.MoveTowards для сглаживания изменения управляющего вектора с учетом lastInput и скорости управления steeringSpeed на шаг интегрирования dt.
    6. Возврат управляющего вектора:

      • Обновляется lastInput для использования в будущих вычислениях.
      • Функция возвращает результат - управляющий вектор input, который используется для управления движением самолета локально относительно самолета.

    Вкратце, функция преобразует целевую позицию в локальную систему координат самолета, вычисляет ошибки положении и углы по осям, рассчитывает необходимые корректировки управления и возвращает вектор для управляющих воздействий для достижения целевой позиции.

  3. User

    объясни подробнее 'Затем ошибка переводится в локальную систему координат самолета с помощью преобразования кватерниона" как это происходит

  4. Assistant

    Концепция преобразования позиции из глобальной системы координат в локальную систему координат объекта, такого как самолет, является важной частью решений в области трехмерной графики и физического моделирования. Это осуществляется с использованием кватернионов, которые представляют вращение в трехмерном пространстве. Давайте рассмотрим этот процесс более подробно.

    Преобразование в локальную систему координат

    Код, отвечающий за данное преобразование, выглядит следующим образом:

    error = Quaternion.Inverse(plane.Rigidbody.rotation) * error;
    

    Шаги преобразования:

    1. Преобразование кватерниона:

      • plane.Rigidbody.rotation — это кватернион, представляющий текущее вращение самолета в глобальной системе координат.
      • Чтобы перевести вектор ошибки error в локальную систему координат самолета, мы используем Quaternion.Inverse(plane.Rigidbody.rotation). Это инвертированный кватернион, который "отменяет" текущее вращение самолета, effectively aligning the aircraft's local coordinate system with the global coordinate axes.
    2. Умножение кватернионом:

      • Вектор в 3D-пространстве можно повернуть умножением на кватернион. Когда мы умножаем вектор ошибки error на инвертированный кватернион, это поворачивает error из глобальной системы координат в локальную систему координат самолета.
      • Математически, если (q) — это кватернион, представляющий текущее вращение, а (q^{-1}) — его инверсия, то умножение вектора (v) выполняется как (v' = q^{-1} \cdot v), где (v') — вектор в локальной системе.
    3. В результате:

      • После умножения, вектор error теперь представлен в локальной системе координат самолета. Это означает, что вектор теперь определяет, в каком направлении относительно нынешней ориентации самолета находится цель.

    Пример:

    Допустим, самолет хочет двигаться в направлении цели, которая находится прямо перед ним в глобальном пространстве. Если самолет повернут в сторону, вектор цели в локальной системе должен указывать на исправление курса. Например, если цель находится на +Z в глобальной системе, она будет находиться на +X или -X в локальной, в зависимости от текущего вращения самолета.

    Почему это важно:

    Перевод вектора в локальную систему координат позволяет более интуитивно определять, какие управляющие воздействия необходимо применить. Вместо управления с использованием значений из глобальной системы, где смысл вращения и движения может быть менее очевиден, локальная система координат делает управление более удобным и интуитивно понятным, исходя непосредственно из ориентации самолета.

  5. User

    а почему именно инвертированный

  6. Assistant

    Использование инвертированного кватерниона в преобразовании координат необходимо, чтобы "отменить" текущее вращение объекта и тем самым перевести вектор из глобальной в локальную систему координат объекта. Давайте углубимся в это объяснение:

    Зачем нужна инверсия

    1. Логика вращения между системами координат:

      • Когда объект вращается в пространстве, его локальная система координат также вращается. Чтобы трансформировать вектор из глобальной системы в локальную систему объекта, нужно учесть это вращение.
      • Применение текущего вращения объекта трансформировало бы локальный вектор в глобальную систему, но нам нужно обратное.
    2. Инверсия как "обратное" вращение:

      • Инвертирование кватерниона вращения фактически отменяет это вращение, возвращая объект в его исходное положение. Это позволяет перемещать объекты из одной системы координат в другую.
      • Если бы мы просто применили кватернион (без инверсии), мы повернули бы вектор относительно исходного положения, но наша цель — определить положение вектора относительно локальной системы координат, данным текущим вращением объекта.

    Вычислительный процесс:

    • Кватернион вращения: ( q ) — это кватернион, описывающий текущее вращение объекта.
    • Инвертированный кватернион: ( q^{-1} ) — отменяет это вращение.
    • Умножение: Когда мы умножаем вектор цели на ( q^{-1} ), мы "отматываем" текущее вращение, чтобы интерпретировать цель в контексте ориентации объекта.

    Пример:

    Представьте, что самолет вращен так, что нос смотрит в сторону. Чтобы понять, где цель в системе координат самолета (например, "влево" или "вправо" от его носа), вам нужно "отменить" поворот этого самолета, чтобы посмотреть, где цель оказалась бы, если бы самолет не был повернут.

    Важность инверсии:

    Инверсия необходима для точного определения позиции или направления в локальной системе координат. Без этой трансформации управление на основе таких векторов было бы ошибочным, поскольку они были бы интерпретированы неправильно — например, самолет мог бы повернуться не в ту сторону, думая, что цель на другой стороне, чем она есть на самом деле.

    Итак, инвертированный кватернион используется, чтобы правильно интерпретировать взаимоположение и ориентацию между объектами в их текущем контексте вращения.

  7. User

    давай для понятности представим на 2д векторах. допустим самолет летит под 45 градусов относительно мира, п овернуть ему надо на 180 относительно мира.

    получается ему надо повернуть на 135 градусов, объясни на этом примере работу моего кода

  8. Assistant

    Давайте рассмотрим эту ситуацию в 2D, используя аналогию с векторами и углами, поскольку это может помочь легче понять, как работает механика вращения в 3D.

    Исходные данные

    • Самолет летит под углом 45 градусов относительно мировых координат, то есть его локальная "вперед" ось направлена на 45 градусов.
    • Цель находится на 180 градусов в мировых координатах (то есть прямиком назад относительно мировых координат).

    Задача

    Необходимо определить, на какой угол нужно повернуть самолет, чтобы он "смотрел" на цель, при этом вычисления проводятся в локальной системе координат самолета.

    Применение кода

    1. Целевая позиция и позиция самолета:

      • Пусть вектор ошибки в глобальных координатах — это разница между целевой позицией и позицией самолета (в данном случае направление "назад" по мировым координатам).
    2. Перевод ошибки в локальную систему координат:

      • Так как самолет повернут на 45 градусов относительно мира, мы используем инверсию этого вращения. В 2D это соответствует повороту в обратную сторону: на -45 градусов, чтобы преобразовать направление векторной ошибки в систему координат самолета.
    3. Расчет угла в локальных координатах:

      • После инверсии текущего вращения самолета (в нашем случае поворот на -45 градусов):
        • Исходный вектор ошибки ("назад", или 180 градусов в мировых) поворачивается на -45 градусов.
        • Этот поворот на -45 градусов перемещает вектор в локальные координаты самолета. Теперь вектор, который был на 180 градусов в отношении мира, после инверсии смещается на 135 градусов в локальных координатах.
    4. Полученный локальный угол:

      • Таким образом, теперь самолет считает, что цель находится на 135 градусов в его собственной системе координат.
      • Это соответствует повороту его на 135 градусов в локальной системе координат, чтобы направить самолет точно на цель.

    Заключение

    В примере с самолётом мы использовали концепцию "отмены" текущего вращения самолёта с помощью инверсии, чтобы узнать, где находится цель относительно его текущего направления. На основе этого понимания, корректировка управления самолёта идет в локальных координатах, где вычисления становятся интуитивными и привязанными к его ориентации.

  9. User

    не понял

  10. Assistant

    Хорошо, давайте попробуем разобрать этот пример еще более подробно и понятно, шаг за шагом.

    Исходная ситуация

    1. Начальное состояние самолета:

      • Самолет летит под углом 45 градусов относительно мировых координат. Это означает, что его направление или "вперед" в локальной системе координат самолета находится под углом 45 градусов в системе координат мира.
    2. Позиция цели:

      • Цель находится позади самолета на 180 градусов по отношению к мировым координатам (прямо против направления полета по мировым осям).

    Задача

    Определить, как самолету повернуть в своей локальной системе координат, чтобы он смотрел на цель.

    Шаги вычислений

    1. Вычисление вектора ошибки в мировых координатах:

      • Вектор ошибки — это разница между текущим положением самолета и целью, выраженная в мировых координатах. В нашем сценарии это просто означает направление от самолета к цели, то есть "прямо назад" или +180 градусов.
    2. Перевод вектора ошибки в локальную систему самолета:

      • Так как самолет смотрит под углом 45 градусов в мировых координатах, его локальное направление "вперед" смещено относительно мировых осей.
      • Чтобы выяснить, где находится цель относительно локальных осей самолета, нужно компенсировать это смещение. Для этого мы используем инверсию текущего вращения.
    3. Использование инверсии вращения:

      • Инверсия угла вращения в 2D будет выглядеть как противоположный угол. То есть, если самолет повернут на 45 градусов, инверсией будет поворот на -45 градусов (или, эквивалентно, на 315 градусов вперед).
      • Применяя это к вектору направления цели (+180 градусов), мы поворачиваем его обратно на -45 градусов: (180 - 45 = 135).
    4. Результат:

      • В итоге, в локальной системе координат самолета, цель оказывается под углом 135 градусов. Это соответствует необходимости поворота на 135 градусов в локальных координатах самолета, чтобы самолет считал, что его нос направлен точно на цель.

    Заключение

    Используя инверсию текущего поворота самолета через преобразования кватерниона (аналогично простому обратному повороту на 45 градусов в 2D), мы можем перевести цель из мировых координат в локальные координаты самолета. Это упрощает расчеты и позволяет понять, как самолету следует повернуть относительно собственного направления, чтобы нацелиться на цель. Таким образом, инверсия является необходимым шагом для перехода между этими системами координат.

  11. User

    а в коде

  12. Assistant

    Давайте переведем объяснение на язык кода, чтобы сделать его более понятным. Мы рассмотрим аналогичный подход у вас в 3D, но свяжем это с 2D-примером, который мы обсуждали.

    Кодовый сценарий

    1. Исходные данные:

      • Целевая позиция targetPosition и текущее положение самолета (plane.Rigidbody.position).
      • Текущее вращение самолета: plane.Rigidbody.rotation.
    2. Ошибка в глобальной системе координат:

      var error = targetPosition - plane.Rigidbody.position;
      

      Это вектор, указывающий от самолета к цели в глобальной системе координат.

    3. Преобразование в локальную систему координат:

      error = Quaternion.Inverse(plane.Rigidbody.rotation) * error;
      

      Этот шаг аналогичен повороту вектора ошибки на инвертированный угол текущего вращения самолета.

      • В 3D кватернионы представляют вращение, и инверсированный кватернион "отменяет" это вращение. Это условная эквивалентность нашему шагу в 2D, где мы используем угол в противоположном направлении.
      • Как в нашем примере, когда вы вращаете вектор (рассматриваемый как позицию цели) на -45 градусов, это преобразует его так, что самолет может понимать нужное направление в своих локальных координатах.
    4. Распаковывание результата:

    После этого локального преобразования мы рассмотрим результаты на примере расчетов углов:

    • Для тангажа, рысканья и крена самолет использует полученный вектор error в своей локальной системе для вычисления необходимых коррекций управления.
    1. Логика проверки и управления: Например, в коде:

      var pitch = Vector3.SignedAngle(Vector3.forward, pitchError, Vector3.right);
      

      Это вычисляет угол между направлением вперед в локальной системе координат самолета и ошибкой по тангажу. Далее управляется поворотом самолета, чтобы выровнять его на цель.

    Заключение

    Таким образом, код использует инвертированный кватернион для перевода вектора из глобальной системы в локальную, чтобы самолет мог понять, какие изменения ему нужно внести в свою ориентацию для достижения целевой позиции. Это преобразование интерпретирует глобальное направление цели относительно текущей ориентации самолета в пространстве.