Вычисление текстурных координат

Доброго времени суток.

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

У меня есть некоторые идеи на это счёт:

/// <summary>
      /// Вычисление текстурных координат полигона
      /// </summary>
      /// <param name="v1"> мировые координаты вершин треугольной грани,   </param>
      /// <param name="v2"> перечисленные в порядке </param>
      /// <param name="v3"> против часовой стрелки </param>
      /// <param name="scaleCoeff"> коэффициент масштабирования </param>
      /// <param name="t1"> текстурные </param>
      /// <param name="t2"> координаты </param>
      /// <param name="t3"> грани</param>
      public static void CalculatePolygonTextureCoordinates(
        Vector v1, Vector v2, Vector v3,
        float scaleCoeff,
        out Vector t1, out Vector t2, out Vector t3)
      {

        //Вычисляем нормаль треугольника:
        Vector n = Vector.NormalVector(v1, v2, v3);
        n = Vector.NormalizeVector(n);

        //Матрица масштабирования
        //|1|0|0|
        //|0|1|0|
        //|0|0|1|
        Matrix3 scale = new Matrix3();
        //-------------------------------------------------------------------------------------
        //Вычислим углы между плоскостью полигона и плоскостями XY,XZ,YZ
        //-------------------------------------------------------------------------------------

        float angX = (float)Vector.CalculateAngle(n, new Vector(1, 0, 0));
        float angY = (float)Vector.CalculateAngle(n, new Vector(0, 1, 0));
        float angZ = (float)Vector.CalculateAngle(n, new Vector(0, 0, 1));

        //Вычисляем матрицу поворота
        Matrix3 rotate = Matrix3.CreateRotateMatrix(angX, angY, angZ);

        //Инициализируем масштабирующую матрицу
        scale.R[0, 0] = scaleCoeff;
        scale.R[1, 1] = scaleCoeff;
        scale.R[2, 2] = scaleCoeff;

        //-------------------------------------------------------------------------------------
        //Вычисляем ТК:
        //-------------------------------------------------------------------------------------
        Vector vt; //Трансформированная вершина
        vt = Matrix3.Transform(rotate, v1);
        vt = Matrix3.Transform(scale, vt);
        t1 = new Vector(vt.x, vt.y, 0);

        vt = Matrix3.Transform(rotate, v2);
        vt = Matrix3.Transform(scale, vt);
        t2 = new Vector(vt.x, vt.y, 0);

        vt = Matrix3.Transform(rotate, v3);
        vt = Matrix3.Transform(scale, vt);
        t3 = new Vector(vt.x, vt.y, 0);

Собственно причём тут координаты вершин. Так вот, предположим, что текстурные координаты - это особенным образом трансформированные мировые координаты вершин. И чтобы связать их с мировыми координатами, я сначала связываю их с локальными координатами объекта, а потом, используя афинные преобразования, привожу тк к мировым.

Пример объекта, масштабированного после поворота, с текстурой наложенной приведённым способом, но без масштабирующего коэффициента:

Рисуем:

for (int i = 0; i < listBarriers.Count; i++)
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D, listBarriers[i].cover[0].texObj);
Gl.glBegin(Gl.GL_TRIANGLES);
for (int j = 0; j < listBarriers[i].facesCount; j++)
                {
float x1, x2, x3, y1, y2, y3, z1, z2, z3;
                   // вытакскиваем координаты треугольника (полигона)
                   x1 = listBarriers[i].vertex[0, listBarriers[i].faces[0, j]];
                   x2 = listBarriers[i].vertex[0, listBarriers[i].faces[1, j]];
                   x3 = listBarriers[i].vertex[0, listBarriers[i].faces[2, j]];
                   y1 = listBarriers[i].vertex[1, listBarriers[i].faces[0, j]];
                   y2 = listBarriers[i].vertex[1, listBarriers[i].faces[1, j]];
                   y3 = listBarriers[i].vertex[1, listBarriers[i].faces[2, j]];
                   z1 = listBarriers[i].vertex[2, listBarriers[i].faces[0, j]];
                   z2 = listBarriers[i].vertex[2, listBarriers[i].faces[1, j]];
                   z3 = listBarriers[i].vertex[2, listBarriers[i].faces[2, j]];

                      Vector v1 = new Vector(x1, y1, z1);
                      Vector v2 = new Vector(x2, y2, z2);
                      Vector v3 = new Vector(x3, y3, z3);

TextureScaling.CalculatePolygonTextureCoordinates(
                        v1,
                        v2,
                        v3,
                        scaleCoeff,//Как рассчитать?
                        out t1, out t2, out t3);

                        Gl.glTexCoord2f(t1.x, t1.y);
                        Gl.glVertex3f(x1, y1, z1);

                        Gl.glTexCoord2f(t2.x, t2.y);
                        Gl.glVertex3f(x2, y2, z2);

                        Gl.glTexCoord2f(t3.x, t3.y);
                        Gl.glVertex3f(x3, y3, z3);

}
Gl.glEnd();
}

Есть ли какой - нибудь алгоритм вычисления масштабирующего коэффициента?

И быть может кто-нибудь пыталсь реализовать или реализовал эту задачу?

Буду благодарен за внимание.