人間が読める角度の回転行列をスクラッチから作成するには

opengl math matrix 3d


私が3Dプログラミングをする上で常に妨げになっているのは、数学の仕組みを理解できていないことです。メソッドや関数を使ったプログラミングの流れの中では、数学的には問題なく理解できるのですが、数学的な表記法では、頭と尻尾のどちらが正しいのかが分からないのです。

私はウェブサイトを読んだり、これを説明しようとしている研究機関のビデオを見たりしてきましたが、彼らはすべて数学的表記法を使用しており、私は単にそれに迷うだけで、私の心は何か理解できるものにそれを翻訳しません。私には欠陥があるのかもしれません。

また、誰かのコードを使うだけでは興味がないのですが、その背後にある仕組みやロジックを理解したいのです。誰かのコードを使うのもいいですが、本当に仕組みを理解したいのです。

質問

数学的表記なしで、表記法/関数/疑似コードをプログラミングするだけで、3つの軸すべてに沿って行列変換を実装する方法を簡単に説明できますか?

理想的には、私が持っている四角形/三角形のコレクションを回転させるために、glRotateに似た3軸の角度を定義できるメソッド/オブジェクトを書くための材料/理解が必要です。(私は、私のためにそれを行うためにOpenGL関数にアクセスすることなく、キューブ形状の3D回転をプログラムしようとしています。)

私が何をした?

私は数学のこつを得るために90度の変換関数を作成しようとしましたが、理論的には最も簡単であるはずの適切な行列の作成にまったく失敗しました。私の失敗した試みはhttp://jsfiddle.net/bLfg0tj8/5/ですべての栄光を見ることができます

Vec3 = function(x,y,z) {
    this.x = x;
    this.y = y;
    this.z = z;
}
Matrix = function Matrix() {
    this.matrixPoints = new Array();    
    this.rotationPoint = new Vec3(0,0,0);
    this.rotationAngle = 90;
}
Matrix.prototype.addVector = function(vector) {
    this.matrixPoints.push(vector);
}
Matrix.prototype.setRotationPoint = function(vector) {
    this.rotationPoint = vector; 
}
Matrix.prototype.setRotationAngle = function(angle) {
    this.rotationAngle = angle;
}
Matrix.prototype.populate = function() {
    translateToOrigin =     [[1,0,0-this.rotationPoint.x],
                                  [0,1,0-this.rotationPoint.y],
                                  [0,0,0-this.rotationPoint.z]];
    rotationMatrix =         [[0,-1,0],
                                  [0,1,0],
                                  [0,0,1]];
    translateEnd =         [[1,0,this.rotationPoint.x],
                                  [0,1,this.rotationPoint.y],
                                  [0,0,this.rotationPoint.z]];
    currentColumn = 0;
    currentRow = 0;
    this.combomatrix = this.mergeMatrices(this.mergeMatrices(translateEnd,rotationMatrix),
                                          translateToOrigin);
}
Matrix.prototype.transform = function() {
    newmatrix = new Array();
    for(c = 0;c<this.matrixPoints.length;c++) {
        newmatrix.push(this.applyToVertex(this.matrixPoints[c]));
    }
    return newmatrix;
}
Matrix.prototype.applyToVertex = function(vertex) {
    ret = new Vec3(vertex.x,vertex.y,vertex.z);
    ret.x = ret.x + this.combomatrix[0][0] * vertex.x +
            this.combomatrix[0][1] * vertex.y +
            this.combomatrix[0][2] * vertex.z;
    
    ret.y = ret.y + this.combomatrix[1][0] * vertex.x +
            this.combomatrix[1][1] * vertex.y +
            this.combomatrix[1][2] * vertex.z;
    
    ret.z = ret.z + this.combomatrix[2][0] * vertex.x +
            this.combomatrix[2][1] * vertex.y +
            this.combomatrix[2][2] * vertex.z;
    return ret;
}
Matrix.prototype.mergeMatrices = function(lastStep, oneInFront) {
    step1 = [[0,0,0],[0,0,0],[0,0,0]];
    step1[0][0] =   lastStep[0][0] * oneInFront[0][0] + 
                    lastStep[0][1] * oneInFront[1][0] + 
                    lastStep[0][2] * oneInFront[2][0];
    
    step1[0][1] =   lastStep[0][0] * oneInFront[0][1] + 
                    lastStep[0][1] * oneInFront[1][1] + 
                    lastStep[0][2] * oneInFront[2][1];
    
    step1[0][2] =   lastStep[0][0] * oneInFront[0][2] + 
                    lastStep[0][1] * oneInFront[1][2] + 
                    lastStep[0][2] * oneInFront[2][2];
    //============================================================
    step1[1][0] =   lastStep[1][0] * oneInFront[0][0] + 
                    lastStep[1][1] * oneInFront[1][0] + 
                    lastStep[1][2] * oneInFront[2][0];
    
    step1[1][1] =   lastStep[1][0] * oneInFront[0][1] + 
                    lastStep[1][1] * oneInFront[1][1] + 
                    lastStep[1][2] * oneInFront[2][1];
    
    step1[1][2] =   lastStep[1][0] * oneInFront[0][2] + 
                    lastStep[1][1] * oneInFront[1][2] + 
                    lastStep[1][2] * oneInFront[2][2];
    //============================================================
    step1[2][0] =   lastStep[2][0] * oneInFront[0][0] + 
                    lastStep[2][1] * oneInFront[1][0] + 
                    lastStep[2][2] * oneInFront[2][0];
    
    step1[2][1] =   lastStep[2][0] * oneInFront[0][1] + 
                    lastStep[2][1] * oneInFront[1][1] + 
                    lastStep[2][2] * oneInFront[2][1];
    
    step1[2][2] =   lastStep[2][0] * oneInFront[0][2] + 
                    lastStep[2][1] * oneInFront[1][2] + 
                    lastStep[2][2] * oneInFront[2][2];
    return step1;
}
Matrix.prototype.getCurrentMatrix = function() {
    return this.matrixPoints;
}
myvectors = [new Vec3(50,50,0), new Vec3(20,80,0), new Vec3(80, 80, 0)];

function drawVectors(vectors,color) {
    for(c=0;c<vectors.length;c++) {
        document.getElementById("whoa").innerHTML += '<div style="color:'+color+';position:absolute;left:'+vectors[c].x+'px; top:'+vectors[c].y+'px;z-index:'+vectors[c].z+';">('+c+').</div>';
    }
}
matrix = new Matrix();
for(c=0;c<myvectors.length;c++) {
    matrix.addVector(myvectors[c]);
}
matrix.setRotationPoint(new Vec3(50,70,0));
matrix.populate();
somematrix = matrix.transform();
drawVectors(matrix.getCurrentMatrix(),"lime"); // draw current matrix that was hand coded
drawVectors([matrix.rotationPoint],'white'); // draw rotation point
drawVectors(somematrix,"red"); // transformed matrix... somehow two points merge
<div id="whoa" style="position:relative;top:50px;left:150px;background-color:green;color:red;width:400px;height:300px;">
    &nbsp;
</div>

緑のテキストは元の三角形、白い点は中心点、赤い点は変換に失敗した点です(中心点の周りに整列していないためだと思います)。チュートリアルでは、行列を結合して行列にする方法を考えていたのですが、どこかで失敗してしまったようです。

私が言ったように、数学の表記法を理解して話すことは本当に難しいです。しかも、ほとんどの先生が説明を飛ばしているのが救いではありません。行列の掛け算をするときには、掛け算を続けるのではなく、それぞれのステップを足し算する必要があることを理解するのに2時間かかりました。説明のためのイェーイ。

私が一緒に仕事をしたり、一緒に仕事をしたい実際的な例

にある波面objファイルからロードされたキューブがあります。

x = 50
y = 100
z = 200

立方体は四角形といくつかのUVマッピングを使って描かれています。ここでは問題ありません。すべてのテクスチャが正しく表示され、美しくレンダリングされます。

これらは、四角形を使用して描かれたキューブの各 "面 "の位置座標です。

// Front face
-1.0, -1.0,  1.0,
 1.0, -1.0,  1.0,
 1.0,  1.0,  1.0,
-1.0,  1.0,  1.0,

// Back face
-1.0, -1.0, -1.0,
-1.0,  1.0, -1.0,
 1.0,  1.0, -1.0,
 1.0, -1.0, -1.0,

// Top face
-1.0,  1.0, -1.0,
-1.0,  1.0,  1.0,
 1.0,  1.0,  1.0,
 1.0,  1.0, -1.0,

// Bottom face
-1.0, -1.0, -1.0,
 1.0, -1.0, -1.0,
 1.0, -1.0,  1.0,
-1.0, -1.0,  1.0,

// Right face
 1.0, -1.0, -1.0,
 1.0,  1.0, -1.0,
 1.0,  1.0,  1.0,
 1.0, -1.0,  1.0,

// Left face
-1.0, -1.0, -1.0,
-1.0, -1.0,  1.0,
-1.0,  1.0,  1.0,
-1.0,  1.0, -1.0

だから、これはすべて素晴らしい動作をします。しかし、この立方体をx軸に沿って90度、z軸に沿って45度回転させたい場合はどうでしょうか?glRotateを使うことができません。なぜなら、データをtesselatorオブジェクトに渡した時点で、openglの関数を使って行列変換をすることができないからです。

データの保存方法は以下の通りです。

WaveFrontObject()
   |
   |-> Groups(String groupname)
        |
        |-> Faces()
              |
              |-> Vertex(float x, float y, float z)[] 
              |-> Float UVmap[] corresponding to each vertex
              |-> drawFace() // Draws the face as a quad or triangle

そこで、私が与えた上記の座標のそれぞれは、波面オブジェクトの面として、グループ「立方体」に格納されています。

キューブがテッセレータに追加されると、ワールド内の正しい座標に変換され、正常にレンダリングされます。

しかし、それは常に同じようにレンダリングされます。斜めにレンダリングしたい場合は、この時点で別の波面オブジェクトを作らなければなりません。私の見解では、それはいくつかの数学で解決することができるときに行うには狂気である。

答えに必要

  1. 翻訳行列を作る方法をステップバイステップで説明し、私に数学を説明しようとする試み。
  2. 面内の四角形・三角形に並進行列を適用する方法を説明しています。

    x=50.5 y=100.5 z=200.5

  3. 説明に沿って、いくつかの例や疑似コードを用意しました。

説明に使われているプログラミング言語は、Cファミリーである限り、あまり関係ありません。

数学的な表記/話し方には近づかないようにしてください。αβ、θが何なのか知らない、x軸、y軸、z軸が何なのかは知っている。角度が何であるかは知っていますが、数学者が見つけた名前は知りません。

数学の名前を使いたい場合は、3Dの世界/コードの中に何があるのか、どのように形成/計算されているのかを説明してください。

のようなメソッド/オブジェクトを作りたいだけです。

Matrix.transformVertices(vertices[], 90deg x, 45 deg y, 0 deg z);



Answer 1 Spektre


だから問題は本当に4x4の同種変換行列を理解することです

数学の背後にあるものがなければ、残るのは幾何学的な表現や意味だけで、それは人間の抽象化や理解にとってはるかに優れています。

1.それでは、4x4マトリックスとは何ですか?

いくつかの直交座標系を表現したもので、それで構成されています。

  1. 3 つの基底ベクトル(各軸に1つ)赤、緑、青

    したがって、赤、緑、青のベクトルが互いに垂直である場合、座標系は直交します。それらが単位ベクトルでもある場合、それは正規直交です(たとえば、単位行列のように)。

  2. 原点グレー

  3. 射影および同種側(行列のマークされていない下部)

    この部分は、従って、均質でなければならない用いる点、一度だけで、回転及び平行移動を可能にするために存在すること形態の手段 (x,y,z,w=1) 点とするため (x,y,z,w=0) 方向についてベクトル。それがちょうど (x,y,z) 場合、行列は 3x3 になり、変換には不十分です。幾何学的に説明が難しい投影は使用しません。

このレイアウトはOpenGL表記からのもので、転置された表現もあります(ベクトルは列ではなく行です)。

では、この座標系との間の任意の点をどのように変換するか。

g=M*l;
l=Inverse(M)*g;

where:

  • M は変換行列
  • lM ローカル座標系ポイント(LCS)
  • g はグローバル座標系ポイント(GCS)です

転置バージョン(DirectX)の場合:

l=M*g;
g=Inverse(M)*l;

これは、転置された直交回転行列もそれ自身の逆であるためです

OpenGL transform matrix

2.それを視覚化する方法

はい、マトリックス番号を描くことができますが、特に数値が変化している場合は、最初の見た目では意味がありません。上の画像のように軸ベクトルを描きます。各軸は、 origin から原点への線 origin + line_size*axis_vector

3.それを構築する方法

軸ベクトルと原点を計算し、それらを行列内に配置するだけです。直交性を保証するためにクロス積を利用します(ただし、正しい方向を使用するように乗数の順序に注意してください)

4.効果

  • 回転は軸を回転させることで行われるので、パラメトリック円の方程式で各軸を計算することができます...
  • スケーリングはアキサイズにスケールファクタを掛けて行われます。
  • 歪曲は非垂直軸を使用しているだけです。

5.ローテーション

ほとんどの場合、インクリメンタルローテーションが使用されます。以下の2つのタイプがあります。

  • ローカル回転 M'=M*rotation_matrix 、飛行機や車やプレイヤーを制御するようにローカル座標軸を中心に回転します...ほとんどのエンジン/ゲームはこれらを使用せず、オイラー角で偽造します。これは安価な解決策です(多くの癖があります)と問題)OpenGLを使用しているほとんどの人はこれが可能であることさえ知らず、むしろ glRotate/glTranslate 呼び出しのリストをスタックするため...

  • グローバル回転 M'=Inverse(Inverse(M)*rotation_matrix) グローバル座標系の軸を中心に回転します。

ここで、 rotation_matrix は標準の回転変換行列です。

異なる行列レイアウト(転置)を持っている場合、ローカル回転とグローバル回転は逆の方法で計算されます...

次のような 3 つの角度から rotation_matrix を計算することもできます。

rotation_matrix=rotation_around_x(ax)*rotation_around_y(ay)*rotation_around_z(az);

Wikiの回転行列を参照してください。 Basic rotations からの3D Rx,Ry,Rz が必要です。ご覧のとおり、これらは実際には単なる単位円パラメトリック方程式です。乗算の順序により、角度がターゲット位置に収束する方法が変わります。これはオイラー角と呼ばれ、私は使用しません(代わりにステップ変更を統合します。これは、単純なことは言うまでもなく、適切に行われれば制限はありません)。

必要に応じて、比較的簡単にオイラー角に変換することができます。

6. glRotate

あなたがしたい場合 glRotate をそれが軸を中心に回転なので、あなたはありません3つの角度によって代わりに四元数を使用する必要があります!回避策があります:

  1. その軸の変換行列 N を作成する
  2. 次に、行列 M をそれに変換します
  3. N を角度で回転
  4. 次に、 MN からグローバル座標に変換します。

または、代わりにRodrigues_rotation_formulaを使用できます

この場合にMatrixをMatrixに変換するには、軸をポイントとして変換し、原点をそのままにしますが、 N の原点は(0,0,0)でなければなりません!!! または、変換されたベクトルは代わりに w=0 でなければなりません。

7.使用法

変形は累積的なものであることを意味します。

  • p'=M1*M2*M3*M4*p; M=M1*M2*M3*M4; p'=M*p と同じです。p '= M * p

したがって,変換する点が多い場合は,すべての変換を 1 つの行列に事前計算して,それだけを使用します.点を後続のすべての行列に乗算する必要はありません。これで概念がわかりました。

3 つの座標系が必要です。

  • カメラ C
  • せかい
  • オブジェクト O (各オブジェクトには独自の行列があります)

したがって、 8 つの頂点を持つ立方体がある場合 p0,...,p7 は、オブジェクトのローカル座標からカメラのローカル座標への各ポイントの変換を実行する必要があります。一部のgfx apiはその一部を実行するため、必要なものだけを適用するため、本当に必要です。

  • p(i)'=inverse(C)*unit*M*p(i);

変換は累積的なものであり,単位行列は何も変化しません.

  • Q=inverse(C)*M; p(i)'=Q*p(i);

したがって、描画する前に、描画されたオブジェクトの Q を計算し、オブジェクトの各点 p(i) を取り、変換された p(i)' を計算して、変換されたものを描画/使用します... p(i)' はローカルカメラ座標系にあります(画面のx、y)ですが、そこには遠近法がないため、描画する前に、任意の投影行列を追加し、最後に z 座標で除算することもできます...投影も累積されるため、 Q の内側にも配置できます。

[編集1] C ++の例

//$$---- Form CPP ----
//---------------------------------------------------------------------------
// apart from math.h include you can ignore this machine generated VCL related code
#include <vcl.h>
#pragma hdrstop
#include "win_main.h"
#include <math.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TMain *Main; // pointer to main window ...
//---------------------------------------------------------------------------
// Here is the important stuff some math first
//---------------------------------------------------------------------------
const double deg=M_PI/180.0;
double divide(double x,double y);
void  matrix_mul       (double *c,double *a,double *b); // c[16] = a[16] * b[16]
void  matrix_mul_vector(double *c,double *a,double *b); // c[ 4] = a[16] * b[ 4]
void  matrix_subdet    (double *c,double *a);           // c[16] = all subdets of a[16]
double matrix_subdet   (          double *a,int r,int s);//      = subdet(r,s) of a[16]
double matrix_det      (          double *a);           //       = det of a[16]
double matrix_det      (          double *a,double *b); //       = det of a[16] and subdets b[16]
void  matrix_inv       (double *c,double *a);           // c[16] = a[16] ^ -1
//---------------------------------------------------------------------------
double divide(double x,double y)
        {
        if (!y) return 0.0;
        return x/y;
        }
void  matrix_mul       (double *c,double *a,double *b)
        {
        double q[16];
        q[ 0]=(a[ 0]*b[ 0])+(a[ 1]*b[ 4])+(a[ 2]*b[ 8])+(a[ 3]*b[12]);
        q[ 1]=(a[ 0]*b[ 1])+(a[ 1]*b[ 5])+(a[ 2]*b[ 9])+(a[ 3]*b[13]);
        q[ 2]=(a[ 0]*b[ 2])+(a[ 1]*b[ 6])+(a[ 2]*b[10])+(a[ 3]*b[14]);
        q[ 3]=(a[ 0]*b[ 3])+(a[ 1]*b[ 7])+(a[ 2]*b[11])+(a[ 3]*b[15]);
        q[ 4]=(a[ 4]*b[ 0])+(a[ 5]*b[ 4])+(a[ 6]*b[ 8])+(a[ 7]*b[12]);
        q[ 5]=(a[ 4]*b[ 1])+(a[ 5]*b[ 5])+(a[ 6]*b[ 9])+(a[ 7]*b[13]);
        q[ 6]=(a[ 4]*b[ 2])+(a[ 5]*b[ 6])+(a[ 6]*b[10])+(a[ 7]*b[14]);
        q[ 7]=(a[ 4]*b[ 3])+(a[ 5]*b[ 7])+(a[ 6]*b[11])+(a[ 7]*b[15]);
        q[ 8]=(a[ 8]*b[ 0])+(a[ 9]*b[ 4])+(a[10]*b[ 8])+(a[11]*b[12]);
        q[ 9]=(a[ 8]*b[ 1])+(a[ 9]*b[ 5])+(a[10]*b[ 9])+(a[11]*b[13]);
        q[10]=(a[ 8]*b[ 2])+(a[ 9]*b[ 6])+(a[10]*b[10])+(a[11]*b[14]);
        q[11]=(a[ 8]*b[ 3])+(a[ 9]*b[ 7])+(a[10]*b[11])+(a[11]*b[15]);
        q[12]=(a[12]*b[ 0])+(a[13]*b[ 4])+(a[14]*b[ 8])+(a[15]*b[12]);
        q[13]=(a[12]*b[ 1])+(a[13]*b[ 5])+(a[14]*b[ 9])+(a[15]*b[13]);
        q[14]=(a[12]*b[ 2])+(a[13]*b[ 6])+(a[14]*b[10])+(a[15]*b[14]);
        q[15]=(a[12]*b[ 3])+(a[13]*b[ 7])+(a[14]*b[11])+(a[15]*b[15]);
        for(int i=0;i<16;i++) c[i]=q[i];
        }
void  matrix_mul_vector(double *c,double *a,double *b)
        {
        double q[3];
        q[0]=(a[ 0]*b[0])+(a[ 1]*b[1])+(a[ 2]*b[2])+(a[ 3]);
        q[1]=(a[ 4]*b[0])+(a[ 5]*b[1])+(a[ 6]*b[2])+(a[ 7]);
        q[2]=(a[ 8]*b[0])+(a[ 9]*b[1])+(a[10]*b[2])+(a[11]);
        for(int i=0;i<3;i++) c[i]=q[i];
        }
void  matrix_subdet    (double *c,double *a)
        {
        double   q[16];
        int     i,j;
        for (i=0;i<4;i++)
         for (j=0;j<4;j++)
          q[j+(i<<2)]=matrix_subdet(a,i,j);
        for (i=0;i<16;i++) c[i]=q[i];
        }
double matrix_subdet    (         double *a,int r,int s)
        {
        double   c,q[9];
        int     i,j,k;
        k=0;                            // q = sub matrix
        for (j=0;j<4;j++)
         if (j!=s)
          for (i=0;i<4;i++)
           if (i!=r)
                {
                q[k]=a[i+(j<<2)];
                k++;
                }
        c=0;
        c+=q[0]*q[4]*q[8];
        c+=q[1]*q[5]*q[6];
        c+=q[2]*q[3]*q[7];
        c-=q[0]*q[5]*q[7];
        c-=q[1]*q[3]*q[8];
        c-=q[2]*q[4]*q[6];
        if (int((r+s)&1)) c=-c;       // add signum
        return c;
        }
double matrix_det       (         double *a)
        {
        double c=0;
        c+=a[ 0]*matrix_subdet(a,0,0);
        c+=a[ 4]*matrix_subdet(a,0,1);
        c+=a[ 8]*matrix_subdet(a,0,2);
        c+=a[12]*matrix_subdet(a,0,3);
        return c;
        }
double matrix_det       (         double *a,double *b)
        {
        double c=0;
        c+=a[ 0]*b[ 0];
        c+=a[ 4]*b[ 1];
        c+=a[ 8]*b[ 2];
        c+=a[12]*b[ 3];
        return c;
        }
void  matrix_inv       (double *c,double *a)
        {
        double   d[16],D;
        matrix_subdet(d,a);
        D=matrix_det(a,d);
        if (D) D=1.0/D;
        for (int i=0;i<16;i++) c[i]=d[i]*D;
        }
//---------------------------------------------------------------------------
// now the object representation
//---------------------------------------------------------------------------
const int pnts=8;
double pnt[pnts*3]=     // Vertexes for 100x100x100 cube centered at (0,0,0)
    {
    -100.0,-100.0,-100.0,
    -100.0,+100.0,-100.0,
    +100.0,+100.0,-100.0,
    +100.0,-100.0,-100.0,
    -100.0,-100.0,+100.0,
    -100.0,+100.0,+100.0,
    +100.0,+100.0,+100.0,
    +100.0,-100.0,+100.0,
    };
const int facs=6;
int fac[facs*4]=        // faces (index of point used) no winding rule
    {
    0,1,2,3,
    4,5,6,7,
    0,1,5,4,
    1,2,6,5,
    2,3,7,6,
    3,0,4,7,
    };
double rep[16]=        // 4x4 transform matrix of object (unit from start) at (0,0,+100)
    {
    1.0,0.0,0.0,  0.0,
    0.0,1.0,0.0,  0.0,
    0.0,0.0,1.0,100.0,
    0.0,0.0,0.0,1.0,
    };
double eye[16]=        // 4x4 transform matrix of camera at (0,0,-150)
    {
    1.0,0.0,0.0,   0.0,
    0.0,1.0,0.0,   0.0,
    0.0,0.0,1.0,-150.0,
    0.0,0.0,0.0,1.0,
    };
//---------------------------------------------------------------------------
// this is how to draw it
//---------------------------------------------------------------------------
void obj(double *pnt,int pnts,int *fac,int facs,double *rep,double *ieye)
    {
    // variables for drawing
    int i;
    double p0[3],p1[3],p2[3],p3[3],m[16],d;
    // gfx api variables (change to your stuff) Main is the main form of this application
    TCanvas *scr=Main->bmp->Canvas;
    double xs2=Main->ClientWidth/2,ys2=Main->ClientHeight/2;
    double v=xs2*tan(30.0*deg); // 60 degree viewing angle perspective projection

    matrix_mul(m,ieye,rep);             // cumulate all needed transforms

    for (i=0;i<facs*4;)                 // go through all faces
        {
        // convert all points of face
        matrix_mul_vector(p0,m,&pnt[fac[i]*3]); i++;
        matrix_mul_vector(p1,m,&pnt[fac[i]*3]); i++;
        matrix_mul_vector(p2,m,&pnt[fac[i]*3]); i++;
        matrix_mul_vector(p3,m,&pnt[fac[i]*3]); i++;
        // here goes perspective divide by z coordinate if needed
        d=divide(v,p0[2]); p0[0]*=d; p0[1]*=d;
        d=divide(v,p1[2]); p1[0]*=d; p1[1]*=d;
        d=divide(v,p2[2]); p2[0]*=d; p2[1]*=d;
        d=divide(v,p3[2]); p3[0]*=d; p3[1]*=d;
        // here is viewport transform (just translate (0,0) to middle of screen in this case
        p0[0]+=xs2; p0[1]+=ys2;
        p1[0]+=xs2; p1[1]+=ys2;
        p2[0]+=xs2; p2[1]+=ys2;
        p3[0]+=xs2; p3[1]+=ys2;
        // draw quad
        // I use VCL GDI TCanvas you use what you have ...
        // and wireframe only to keep this simple (no Z buffer,winding culling,...)
        scr->Pen->Color=clAqua;     // perimeter wireframe
        scr->MoveTo(p0[0],p0[1]);
        scr->LineTo(p1[0],p1[1]);
        scr->LineTo(p2[0],p2[1]);
        scr->LineTo(p3[0],p3[1]);
        scr->LineTo(p0[0],p0[1]);
//      scr->Pen->Color=clBlue;     // face cross to visualy check if I correctly generate the fac[]
//      scr->MoveTo(p0[0],p0[1]);
//      scr->LineTo(p2[0],p2[1]);
//      scr->MoveTo(p1[0],p1[1]);
//      scr->LineTo(p3[0],p3[1]);
        }
    }
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void TMain::draw()
    {
    if (!_redraw) return;
    bmp->Canvas->Brush->Color=clBlack;
    bmp->Canvas->FillRect(TRect(0,0,xs,ys));

    // compute inverse of camera need to compute just once for all objects
    double ieye[16];
    matrix_inv(ieye,eye);
    // draw all objects
    obj(pnt,pnts,fac,facs,rep,ieye);

    Main->Canvas->Draw(0,0,bmp);
    _redraw=false;
    }
//---------------------------------------------------------------------------
__fastcall TMain::TMain(TComponent* Owner) : TForm(Owner)
    {
    // window constructor you can ignore this ... (just create a backbuffer bitmap here)
    bmp=new Graphics::TBitmap;
    bmp->HandleType=bmDIB;
    bmp->PixelFormat=pf32bit;
    pyx=NULL;
    }
//---------------------------------------------------------------------------
void __fastcall TMain::FormDestroy(TObject *Sender)
    {
    // window destructor release memory ... also ignoe this
    if (pyx) delete pyx;
    delete bmp;
    }
//---------------------------------------------------------------------------
void __fastcall TMain::FormResize(TObject *Sender)
    {
    // on resize event ... just resize/redraw backbuffer also can ignore this
    xs=ClientWidth;  xs2=xs>>1;
    ys=ClientHeight; ys2=ys>>1;
    bmp->Width=xs;
    bmp->Height=ys;
    if (pyx) delete pyx;
    pyx=new int*[ys];
    for (int y=0;y<ys;y++) pyx[y]=(int*) bmp->ScanLine[y];
    _redraw=true;
    }
//---------------------------------------------------------------------------
void __fastcall TMain::FormPaint(TObject *Sender)
    {
    // repaint event can ignore
    _redraw=true;
    }
//---------------------------------------------------------------------------
void __fastcall TMain::tim_redrawTimer(TObject *Sender)
    {
    // timer event to animate the cube ...
    _redraw=true;

    // rotate the object to see it in motion
    double ang,c,s;

    ang=5.0*deg; c=cos(ang); s=sin(ang);    // rotate baround z by 5 degrees per timer step
    double rz[16]= { c, s, 0, 0,
                    -s, c, 0, 0,
                     0, 0, 1, 0,
                     0, 0, 0, 1 };

    ang=1.0*deg; c=cos(ang); s=sin(ang);    // rotate baround x by 1 degrees per timer step
    double rx[16]= { 1, 0, 0, 0,
                     0, c, s, 0,
                     0,-s, c, 0,
                     0, 0, 0, 1 };
    matrix_mul(rep,rep,rz);
    matrix_mul(rep,rep,rx);

    draw();
    }
//---------------------------------------------------------------------------

こんな感じです。

cube example

そして、後ろ姿のカリングをしたGIF動画。

animation

[notes]

あなたがより多くの質問がある場合は、私をコメントしてください...

[編集2]しばしば必要となる基本的な3Dベクトル操作

クロス/ドット積や絶対値のようなベクトル演算の計算方法がわからない場合は、こちらを参照してください。

// cross product: W = U x V
W.x=(U.y*V.z)-(U.z*V.y)
W.y=(U.z*V.x)-(U.x*V.z)
W.z=(U.x*V.y)-(U.y*V.x)
// dot product: a = (U.V)
a=U.x*V.x+U.y*V.y+U.z*V.z
// abs of vector a = |U|
a=sqrt((U.x*U.x)+(U.y*U.y)+(U.z*U.z))

ここに私のC++のベクトル数学があります。

static double vector_tmp[3];
double divide(double x,double y) { if ((y>=-1e-30)&&(y<=+1e-30)) return 0.0; return x/y; }
double* vector_ld(double x,double y,double z)          { double *p=vector_tmp; p[0]=x; p[1]=y; p[2]=z; return p;}
double* vector_ld(double *p,double x,double y,double z) {                      p[0]=x; p[1]=y; p[2]=z; return p;}
void  vector_copy(double *c,double *a)         { for(int i=0;i<3;i++) c[i]=a[i];       }
void  vector_abs(double *c,double *a)          { for(int i=0;i<3;i++) c[i]=fabs(a[i]); }
void  vector_one(double *c,double *a)
        {
        double l=divide(1.0,sqrt((a[0]*a[0])+(a[1]*a[1])+(a[2]*a[2])));
        c[0]=a[0]*l;
        c[1]=a[1]*l;
        c[2]=a[2]*l;
        }
void  vector_len(double *c,double *a,double l)
        {
        l=divide(l,sqrt((a[0]*a[0])+(a[1]*a[1])+(a[2]*a[2])));
        c[0]=a[0]*l;
        c[1]=a[1]*l;
        c[2]=a[2]*l;
        }
void  vector_neg(double *c,double *a)          { for(int i=0;i<3;i++) c[i]=-a[i];      }
void  vector_add(double *c,double *a,double *b) { for(int i=0;i<3;i++) c[i]=a[i]+b[i]; }
void  vector_sub(double *c,double *a,double *b) { for(int i=0;i<3;i++) c[i]=a[i]-b[i]; }
void  vector_mul(double *c,double *a,double *b) // cross
        {
        double   q[3];
        q[0]=(a[1]*b[2])-(a[2]*b[1]);
        q[1]=(a[2]*b[0])-(a[0]*b[2]);
        q[2]=(a[0]*b[1])-(a[1]*b[0]);
        for(int i=0;i<3;i++) c[i]=q[i];
        }
void  vector_mul(double *c,double *a,double  b) { for(int i=0;i<3;i++) c[i]=a[i]*b; }
void  vector_mul(double *c,double  a,double *b) { for(int i=0;i<3;i++) c[i]=a*b[i]; }
double vector_mul(         double *a,double *b) { double c=0; for(int i=0;i<3;i++) c+=a[i]*b[i]; return c; } // dot
double vector_len(double *a) { return sqrt((a[0]*a[0])+(a[1]*a[1])+(a[2]*a[2])); }
double vector_len2(double *a) { return (a[0]*a[0])+(a[1]*a[1])+(a[2]*a[2]); }

[編集3]キーボードによるカメラとオブジェクトの制御のためのローカル回転

これは最近多くのことを尋ねられているように、ここではデモと私のいくつかの例の答えを示しています。