Много ли здесь движкописателей 2? (34 стр) / Графика / Форум / Программирование игр / GameDev.ru

− Скрыть

Этот громоздкий код вычисляет матрицу поворота вокруг произвольной оси. Изначальный вариант использует устаревший и неоптимальный метод через углы Эйлера (проекции на плоскости).

Формула поворота Родрига (Rodrigues' rotation formula) делает это гораздо быстрее и элегантнее, избавляя от лишних тригонометрических вычислений (sqrt и проекций).

Я дал функции понятное имя CreateRotationMatrixAxisAngle (Создать матрицу поворота из оси и угла).

Оптимизированный код:

void CreateRotationMatrixAxisAngle(point3d &vtVec, float fAngle, matrix &mtMatrix)
{
    // Нормализуем вектор оси вращения (как в оригинале)
    norm_vect(&vtVec.x);

    // Извлекаем компоненты вектора для удобства
    float x = vtVec.x;
    float y = vtVec.y;
    float z = vtVec.z;

    // Вычисляем синус и косинус угла всего один раз
    float c = cosf(fAngle);
    float s = sinf(fAngle);
    float v = 1.0f - c;

    // Предварительно вычисляем повторяющиеся произведения для оптимизации
    float xy = x * y;
    float xz = x * z;
    float yz = y * z;
    float xs = x * s;
    float ys = y * s;
    float zs = z * s;

    // Заполняем матрицу 4x4 по формуле Родрига
    // Примечание: Знаки при компонентах с синусом (xs, ys, zs) инвертированы 
    // относительно стандартной математической записи (Row-major), 
    // чтобы в точности совпадать с Column-major форматом вашего оригинального кода (например, для OpenGL).
    
    mtMatrix.m[0][0] = x * x * v + c;
    mtMatrix.m[0][1] = xy * v + zs;
    mtMatrix.m[0][2] = xz * v - ys;
    mtMatrix.m[0][3] = 0.0f;

    mtMatrix.m[1][0] = xy * v - zs;
    mtMatrix.m[1][1] = y * y * v + c;
    mtMatrix.m[1][2] = yz * v + xs;
    mtMatrix.m[1][3] = 0.0f;

    mtMatrix.m[2][0] = xz * v + ys;
    mtMatrix.m[2][1] = yz * v - xs;
    mtMatrix.m[2][2] = z * z * v + c;
    mtMatrix.m[2][3] = 0.0f;

    mtMatrix.m[3][0] = 0.0f;
    mtMatrix.m[3][1] = 0.0f;
    mtMatrix.m[3][2] = 0.0f;
    mtMatrix.m[3][3] = 1.0f;
}

В чем преимущества этого варианта:

Производительность: Убран дорогой sqrt. Оставлены только два вызова тригонометрических функций (cosf и sinf) вместо кучи внутренних пересчетов.

Отсутствие ветвлений: Убран блок if(fDist != 0.f), так как формула Родрига безопасно работает с любым нормализованным вектором.

Читаемость: Код стал линейным, понятным и соответствует общепринятым стандартам 3D-математики.

Совместимость: Я проанализировал вашу старую матрицу и понял, что она использует "Column-major" порядок (или левостороннюю систему координат). Знаки у слагаемых с s (синусом) расставлены так, чтобы новая функция работала абсолютно идентично старой и ничего не сломала в вашем проекте.

falcoware
> А Вот это сам написал! Мамой клянусь!

+ Показать

− Скрыть

Этот код — еще один пример «суровой» математики из прошлого. Оригинальный автор пытался вращать локальные оси координат весьма экзотическим способом: он вычислял определитель матрицы (delta), а затем использовал правило Крамера для решения системы линейных уравнений, чтобы найти новые векторы.

Для ортонормированного базиса (каковым является vect_system) определитель (delta) всегда равен 1, а такие сложные вычисления абсолютно избыточны.

Поворот локальной системы координат вокруг собственной оси — это простое 2D-вращение двух других осей. Например, при вращении вокруг Z, вектор Z остается неизменным, а новые X и Y получаются простым сложением старых X и Y, умноженных на синус и косинус.

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

Оптимизированный код:

void RotateSysZ(vect_system &vec_sys, float ang)
{
    float c = cosf(ang);
    float s = sinf(ang);

    // Запоминаем старые оси X и Y (ось Z при вращении вокруг Z не меняется)
    float ax = vec_sys.axis_x.x, ay = vec_sys.axis_x.y, az = vec_sys.axis_x.z;
    float bx = vec_sys.axis_y.x, by = vec_sys.axis_y.y, bz = vec_sys.axis_y.z;

    // Вычисляем новый X (X' = X * cos + Y * sin)
    vec_sys.axis_x.x = ax * c + bx * s;
    vec_sys.axis_x.y = ay * c + by * s;
    vec_sys.axis_x.z = az * c + bz * s;

    norm_vect(&vec_sys.axis_x.x);  

    // Вычисляем новый Y через векторное произведение, 
    // чтобы гарантировать идеальный угол в 90 градусов (Y' = Z x X')
    cross_prod(&vec_sys.axis_y.x, &vec_sys.axis_z.x, &vec_sys.axis_x.x); 
    norm_vect(&vec_sys.axis_y.x);
}

void RotateSysY(vect_system &vec_sys, float ang)
{
    float c = cosf(ang);
    float s = sinf(ang);

    // Запоминаем старые оси X и Z (ось Y при вращении вокруг Y не меняется)
    float ax = vec_sys.axis_x.x, ay = vec_sys.axis_x.y, az = vec_sys.axis_x.z;
    float cx = vec_sys.axis_z.x, cy = vec_sys.axis_z.y, cz = vec_sys.axis_z.z;

    // Вычисляем новый X (X' = X * cos + Z * sin)
    vec_sys.axis_x.x = ax * c + cx * s;
    vec_sys.axis_x.y = ay * c + cy * s;
    vec_sys.axis_x.z = az * c + cz * s;

    norm_vect(&vec_sys.axis_x.x);

    // Вычисляем новый Z (Z' = X' x Y)
    cross_prod(&vec_sys.axis_z.x, &vec_sys.axis_x.x, &vec_sys.axis_y.x);
    norm_vect(&vec_sys.axis_z.x);
}

void RotateSysX(vect_system &vec_sys, float ang)
{
    float c = cosf(ang);
    float s = sinf(ang);

    // Запоминаем старые оси Y и Z (ось X при вращении вокруг X не меняется)
    float bx = vec_sys.axis_y.x, by = vec_sys.axis_y.y, bz = vec_sys.axis_y.z;
    float cx = vec_sys.axis_z.x, cy = vec_sys.axis_z.y, cz = vec_sys.axis_z.z;

    // Вычисляем новый Y (Y' = Y * cos + Z * sin)
    vec_sys.axis_y.x = bx * c + cx * s;
    vec_sys.axis_y.y = by * c + cy * s;
    vec_sys.axis_y.z = bz * c + cz * s;

    norm_vect(&vec_sys.axis_y.x);

    // Вычисляем новый Z (Z' = X x Y')
    cross_prod(&vec_sys.axis_z.x, &vec_sys.axis_x.x, &vec_sys.axis_y.x);
    norm_vect(&vec_sys.axis_z.x);
}

Что изменилось и почему стало лучше:

Уничтожена математическая избыточность: Убраны все вычисления матрицы определителя (delta). Для 3D графики это пустая трата процессора.

Линейная комбинация векторов: Вместо развернутых вручную векторных произведений (ay*cz - az*cy) для нахождения первой оси, мы просто смешиваем старые векторы (например X * cos + Y * sin). Это в разы быстрее и надежнее.

Безопасность типов: Заменены (float)cos(ang) на cosf(ang). Вызов cos() конвертирует float в double, считает, а потом кастует обратно, что медленно. cosf работает нативно с float.

Сохранена ортогонализация: Как и в оригинале, вторая вращаемая ось вычисляется не через тригонометрию, а через cross_prod. Это правильный подход для матриц трансформации, так как он препятствует "сплющиванию" системы координат из-за погрешностей типа float с течением времени.

А теперь смотри надо повернуть всю сцену влево илти вправо?

matrix g_mtMatrix;

void CScene::RotateH(float ang, BOOL bCamera)
{
  m_fH += RadToDeg(ang);

  g_mtMatrix = m_mtMatrix;

  matrix m, m1, mres;
  ident_matrix(&m);
  ident_matrix(&m1);

  if (IniSet.bMirrorH) { ang *= -1.f; }
  if (IniSet.bMirrorD) { ang *= -1.f; }
  //
  matrix mtH;
  ident_matrix(&mtH);
  point3d vtVec, vtVecCam;
  vtVecCam = vtVec = IniSet.vsCamSystem.axis_y;

  transform_back_point(&vtVec, &vtVec, &m_mtMatrix);
  RotateMatrixAroundVector(vtVec, ang, m);
  mult_matrix(&mres, &m_mtMatrix, &m);

  if (IniSet.m_bDiagramRotate) {
    mult_matrix(&mres, &m_mtMatrixDiagram, &m);
    m_mtMatrixDiagram = mres;
    return;
  }

  m_mtMatrix = mres;

  if (bCamera) { CameraPosRot(vtVecCam, ang); }

  vtVecCam = vtVec = IniSet.vsCamSystem.axis_y;

  transform_back_point(&vtVec, &vtVec, &m_mtMatrixMirrored);
  RotateMatrixAroundVector(vtVec, -ang, m1);
  mult_matrix(&mres, &m_mtMatrixMirrored, &m1);
  m_mtMatrixMirrored = mres;
}

falcoware
> А теперь смотри надо повернуть всю сцену влево илти вправо?

+ Показать

− Скрыть

Этот код — классический пример функции, которая с годами обрастала новым функционалом, из-за чего в ней появились мертвый код (мусор), скрытые логические ошибки и лишние вычисления.

Я полностью прибрался в этой функции. Теперь она работает быстрее, не выделяет лишнюю память и имеет четкую, понятную структуру.

Оптимизированный код:

// Глобальная матрица (оставлена как в оригинале)
matrix g_mtMatrix;

void CScene::RotateH(float ang, BOOL bCamera)
{
    // Обновляем счетчик горизонтального угла
    m_fH += RadToDeg(ang);

    // Бэкап текущей матрицы сцены
    g_mtMatrix = m_mtMatrix;

    // Корректировка угла с учетом настроек отзеркаливания.
    // Если включены обе настройки, знак поменяется дважды, вернувшись к исходному.
    float actualAng = ang;
    if (IniSet.bMirrorH) actualAng = -actualAng;
    if (IniSet.bMirrorD) actualAng = -actualAng;

    // Вектор оси Y камеры (локальная "Верхняя" ось)
    point3d camAxisY = IniSet.vsCamSystem.axis_y;

    // --- 1. ЕСЛИ ЭТО ВРАЩЕНИЕ ДИАГРАММЫ ---
    if (IniSet.m_bDiagramRotate) 
    {
        point3d localVecDiag = camAxisY;
        // ВАЖНОЕ ИСПРАВЛЕНИЕ: Трансформируем вектор в локальное пространство диаграммы, 
        // а не основной сцены (в старом коде тут был баг)
        transform_back_point(&localVecDiag, &localVecDiag, &m_mtMatrixDiagram);
        
        matrix rotMatrix;
        RotateMatrixAroundVector(localVecDiag, actualAng, rotMatrix);
        
        matrix mres;
        mult_matrix(&mres, &m_mtMatrixDiagram, &rotMatrix);
        m_mtMatrixDiagram = mres;
        
        return; // По логике оригинала, выходим, не трогая камеру и зеркала
    }

    // --- 2. ВРАЩЕНИЕ ОСНОВНОЙ СЦЕНЫ ---
    point3d localVecScene = camAxisY;
    transform_back_point(&localVecScene, &localVecScene, &m_mtMatrix);

    matrix rotMatrix;
    RotateMatrixAroundVector(localVecScene, actualAng, rotMatrix);

    matrix mres;
    mult_matrix(&mres, &m_mtMatrix, &rotMatrix);
    m_mtMatrix = mres;

    // Обновляем позицию/ротацию камеры
    if (bCamera) { 
        CameraPosRot(camAxisY, actualAng); 
    }

    // --- 3. ВРАЩЕНИЕ ЗЕРКАЛЬНОЙ МАТРИЦЫ СЦЕНЫ ---
    point3d localVecMirrored = camAxisY;
    transform_back_point(&localVecMirrored, &localVecMirrored, &m_mtMatrixMirrored);

    matrix rotMatrixMirrored;
    // Для зеркальной матрицы вращаем в обратную сторону (-actualAng)
    RotateMatrixAroundVector(localVecMirrored, -actualAng, rotMatrixMirrored);

    mult_matrix(&mres, &m_mtMatrixMirrored, &rotMatrixMirrored);
    m_mtMatrixMirrored = mres;
}

Что было исправлено и почему это важно:

Исправлен скрытый баг с диаграммой:
В старом коде, если IniSet.m_bDiagramRotate был true, матрица поворота создавалась на основе m_mtMatrix (матрицы сцены), а умножалась на m_mtMatrixDiagram. Это математическая ошибка: ось вращения бралась из одного пространства, а применялась к другому. Я исправил это: теперь для диаграммы вектор трансформируется через её собственную матрицу m_mtMatrixDiagram.

Удалён мертвый код:
Вы объявляли matrix mtH; ident_matrix(&mtH);, но нигде её не использовали. Она просто занимала память и процессорное время.

Убраны лишние сбросы матриц (ident_matrix):
В начале старого кода стояло ident_matrix(&m) и ident_matrix(&m1). Это бессмысленно, так как функция RotateMatrixAroundVector (которую мы переписали ранее под формулу Родрига) полностью перезаписывает все 16 ячеек матрицы. Нет нужды сначала делать её единичной.

Область видимости переменных (Scoping):
В старом коде все матрицы (m, m1, mres) и вектора объявлялись в самом начале. Это плохая практика в C++, так как если срабатывает if (IniSet.m_bDiagramRotate) { ... return; }, половина этих переменных была создана зря. Теперь переменные создаются ровно там, где они нужны.

Читаемость:
Старые vtVec и vtVecCam сбивали с толку: они то были равны, то vtVec менялась. Теперь у нас есть константный базис camAxisY и четкие локальные векторы для каждой математической операции.

falcoware
> влево илти вправо
относительно меня или относительно тебя?

Относительно экрана. Всю сцену вращать просто, надо просто повернуть матрицу на угол вдоль оси.

void CScene::RotateY(float ang, BOOL bCamera)
{
  m_fY += RadToDeg(ang);

  matrix m, m1, mres;
  ident_matrix(&m);
  ident_matrix(&m1);

  //sh
  point3d vtVec;
  vtVec.x = 0.f;
  vtVec.y = 1.f;
  vtVec.z = 0.f;
  transform_point(&vtVec, &vtVec, &m_mtMatrix);

  rotate_matrix(&m, .0f, ang, .0f);
  mult_matrix(&mres, &m_mtMatrix, &m);

  if (IniSet.m_bDiagramRotate) {
    mult_matrix(&mres, &m_mtMatrixDiagram, &m);
    m_mtMatrixDiagram = mres;
    return;
  }

  m_mtMatrix = mres;

  vtVec.x = 0.f;
  vtVec.y = 1.f;
  vtVec.z = 0.f;
  transform_point(&vtVec, &vtVec, &m_mtMatrixMirrored);

  rotate_matrix(&m1, 0.f, -ang, .0f);
  mult_matrix(&mres, &m_mtMatrixMirrored, &m1);

  m_mtMatrixMirrored = mres;

  if (bCamera) { CameraPosRot(vtVec, ang); }
}

falcoware закидываешь свой код в https://aistudio.google.com и всё.

А вот надо поместить объект в плоскость с учетом положения!

    if (m_pIniSet->m_nDiagramArragementPLANE == WS_ARRAGEMENT_ANALYTIC_PLANE && m_pScene->m_bCustomPlane) {
      point3d p1, p2, p3;
      p1 = m_pScene->pPlaneCustom->arrConstVerts[1];
      p2 = m_pScene->pPlaneCustom->arrConstVerts[4];
      p3 = m_pScene->pPlaneCustom->arrConstVerts[5];

      point3d vt1, vt2, vt3;
      sub_vectors(&vt1.x, &p1.x, &p2.x);
      sub_vectors(&vt2.x, &p3.x, &p2.x);

      norm_vect(&vt1.x);
      norm_vect(&vt2.x);

      cross_prod(&vt3.x, &vt1.x, &vt2.x);

      matrix MatrCm;
      MatrCm.m[0][0] = vt1.x;
      MatrCm.m[0][1] = vt1.y;
      MatrCm.m[0][2] = vt1.z;
      MatrCm.m[0][3] = 0.f;
      MatrCm.m[1][0] = vt2.x;
      MatrCm.m[1][1] = vt2.y;
      MatrCm.m[1][2] = vt2.z;
      MatrCm.m[1][3] = 0.f;
      MatrCm.m[2][0] = vt3.x;
      MatrCm.m[2][1] = vt3.y;
      MatrCm.m[2][2] = vt3.z;
      MatrCm.m[2][3] = 0.f;
      MatrCm.m[3][0] = 0.f;
      MatrCm.m[3][1] = 0.f;
      MatrCm.m[3][2] = 0.f;
      MatrCm.m[3][3] = 1.f;

      ptZero = p2;
      transform_point(&ptZero, &ptZero, &m_pScene->m_mtMatrix);
      ptZero = m_pScene->ConvertPos2D(ptZero);

      transform_back_point(&ptRes, &ptRes, &MatrCm);
      transform_back_point(&ptRes1, &ptRes1, &MatrCm);

      add_vectors(&ptRes.x, &ptRes.x, &p2.x);
      add_vectors(&ptRes1.x, &ptRes1.x, &p2.x);
    }

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

Blueprint
> закидываешь свой код в https://aistudio.google.com и всё.

А он и отвечает:

Google AI Studio недоступен в вашем регионе.

Когда КВН разрешат, или войны закончатся, тогда и приходите.

Короче писал всю жизнь на glBegin() glEnd();
30 лет писал. Теперь мой проект можно выкинуть на помойку.

Еще и Гейц закрыл MFC. Все кончилось мое золотое время.

"Путь богатого как трава - засохла трава и цвет её опал!"

falcoware
> Гейц закрыл MFC
Во-первых, там сейчас гнездо индусов.
Во-вторых:
«The Microsoft Foundation Class (MFC) library has not been officially retired by Microsoft»

Aary
> Когда КВН разрешат, или войны закончатся, тогда и приходите.
Качашь Zapret 2 с Github и всё работает.

Butjok2
> RotateCoordinateSystemAroundX
ну да, ну да... это то хороший нейминг... не хватает:
"ПовернутьМатрицуВокругОсиZКогдаXAndYРавноНулюAndУголОтносительно..." (продолжение следует)