C # Получение строк матриц

Question

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

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

Нам дали это как начало;

public Matrix4by4 RotationInverse()
{
     //GetRow is a method you'll need to create yourself
     return new Matrix4by4(GetRow(0), GetRow(1), GetRow(2), GetRow(3));
}

, где мыдолжны создать метод GetRow сами.

Вот код для моего метода Matrix4by4

        public static Matrix4by4 operator *(Matrix4by4 lhs, Matrix4by4 rhs)
        {
            Matrix4by4 rv = Identity;

            //vector.w = 1.0f; //Forcing the W component to 1 for translation Matrix. As Unity is converting a Vector4 to a Vector3 implicitly, the W component is set to 0 by default.
                             //With a translation component, the W component must be 1.

            rv.values[0, 0] = lhs.values[0, 0] * rhs.values[0, 0] + lhs.values[0, 1] * rhs.values[1 ,0] + lhs.values[0, 2] * rhs.values[2, 0] + lhs.values[0, 3] * rhs.values[3, 0];
            rv.values[1, 0] = lhs.values[1, 0] * rhs.values[0, 0] + lhs.values[1, 1] * rhs.values[1, 0] + lhs.values[1, 2] * rhs.values[2, 0] + lhs.values[1, 3] * rhs.values[3, 0];
            rv.values[2, 0] = lhs.values[2, 0] * rhs.values[0, 0] + lhs.values[2, 1] * rhs.values[1, 0] + lhs.values[2, 2] * rhs.values[2, 0] + lhs.values[2, 3] * rhs.values[3, 0];
            rv.values[3, 0] = lhs.values[3, 0] * rhs.values[0, 0] + lhs.values[3, 1] * rhs.values[1, 0] + lhs.values[3, 2] * rhs.values[2, 0] + lhs.values[3, 3] * rhs.values[3, 0];

            rv.values[0, 1] = lhs.values[0, 0] * rhs.values[0, 1] + lhs.values[0, 1] * rhs.values[1, 1] + lhs.values[0, 2] * rhs.values[2, 1] + lhs.values[0, 3] * rhs.values[3, 1];
            rv.values[1, 1] = lhs.values[1, 0] * rhs.values[0, 1] + lhs.values[1, 1] * rhs.values[1, 1] + lhs.values[1, 2] * rhs.values[2, 1] + lhs.values[1, 3] * rhs.values[3, 1];
            rv.values[2, 1] = lhs.values[2, 0] * rhs.values[0, 1] + lhs.values[2, 1] * rhs.values[1, 1] + lhs.values[2, 2] * rhs.values[2, 1] + lhs.values[2, 3] * rhs.values[3, 1];
            rv.values[3, 1] = lhs.values[3, 0] * rhs.values[0, 1] + lhs.values[3, 1] * rhs.values[1, 1] + lhs.values[3, 2] * rhs.values[2, 1] + lhs.values[3, 3] * rhs.values[3, 1];

            rv.values[0, 2] = lhs.values[0, 0] * rhs.values[0, 2] + lhs.values[0, 1] * rhs.values[1, 2] + lhs.values[0, 2] * rhs.values[2, 2] + lhs.values[0, 3] * rhs.values[3, 2];
            rv.values[1, 2] = lhs.values[1, 0] * rhs.values[0, 2] + lhs.values[1, 1] * rhs.values[1, 2] + lhs.values[1, 2] * rhs.values[2, 2] + lhs.values[1, 3] * rhs.values[3, 2];
            rv.values[2, 2] = lhs.values[2, 0] * rhs.values[0, 2] + lhs.values[2, 1] * rhs.values[1, 2] + lhs.values[2, 2] * rhs.values[2, 2] + lhs.values[2, 3] * rhs.values[3, 2];
            rv.values[3, 2] = lhs.values[3, 0] * rhs.values[0, 2] + lhs.values[3, 1] * rhs.values[1, 2] + lhs.values[3, 2] * rhs.values[2, 2] + lhs.values[3, 3] * rhs.values[3, 2];

            rv.values[0, 3] = lhs.values[0, 0] * rhs.values[0, 3] + lhs.values[0, 1] * rhs.values[1, 3] + lhs.values[0, 2] * rhs.values[2, 3] + lhs.values[0, 3] * rhs.values[3, 3];
            rv.values[1, 3] = lhs.values[1, 0] * rhs.values[0, 3] + lhs.values[1, 1] * rhs.values[1, 3] + lhs.values[1, 2] * rhs.values[2, 3] + lhs.values[1, 3] * rhs.values[3, 3];
            rv.values[2, 3] = lhs.values[2, 0] * rhs.values[0, 3] + lhs.values[2, 1] * rhs.values[1, 3] + lhs.values[2, 2] * rhs.values[2, 3] + lhs.values[2, 3] * rhs.values[3, 3];
            rv.values[3, 3] = lhs.values[3, 0] * rhs.values[0, 3] + lhs.values[3, 1] * rhs.values[1, 3] + lhs.values[3, 2] * rhs.values[2, 3] + lhs.values[3, 3] * rhs.values[3, 3];

            return rv;
        }

У меня есть Identity Matrix, в которую я передаю новую матрицу каждый раз

        public static Matrix4by4 Identity
        {
            get
            {
                return new Matrix4by4(
                    new Vector4(1, 0, 0, 0),
                    new Vector4(0, 1, 0, 0),
                    new Vector4(0, 0, 1, 0),
                    new Vector4(0, 0, 0, 1));
            }
        }

И у меня естьметод, который инвертирует перевод

public Matrix4by4 TranslationInverse()
{
   Matrix4by4 rv = Identity;

   rv.values[0,3] = -values[0,3];
   rv.values[1,3] = -values[1,3];
   rv.values[2,3] = -values[2,3];

   return rv;
}

Несколько часов пытался разобраться, но мне не повезло.

Answer 1

Матричный класс называется Matrix4x4 в Unity3D, вот ссылка http://docs.unity3d.com/ScriptReference/Matrix4x4.html

Вы можете извлекать vector4 с помощью GetRow и устанавливать их обратно, например, с помощью SetRow, например, можно получить полный цикл туда и обратно:

    Vector4 row0=matrix.GetRow(0);
    Vector4 row1=matrix.GetRow(1);
    Vector4 row2=matrix.GetRow(2);
    Vector4 row3=matrix.GetRow(3);
    matrix.SetRow(0,row0);
    matrix.SetRow(1,row1);
    matrix.SetRow(2,row2);
    matrix.SetRow(3,row3);

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

редактировать: так как вы упомянули, что ваш класс Matrix4by4 действительно пользовательский, но вы не опубликовали его код, мы можем предположить, что у него есть внутреннее поле 2d матрицы, называемое значениями.В этом случае ваш метод getRow будет выглядеть примерно так:

public Vector4 GetRow(int rowIndex)
{
return new Vector4(values[0,rowIndex],
values[1,rowIndex]
values[2,rowIndex]
values[3,rowIndex]);
}