3d Programmierung kleine Frage

[Procrash]

Ich hätte da mal eine Frage zur 3D Programmierung die ich momentan in C machen will. Generell soll ein Würfel 3 Dimensional dargestellt werden und anschließend um die X-Achse gedreht werden. Soweit noch alles klar.
Ich hab mir auch schon ein Büchlein drüber besorgt aber ich werde einfach nicht schlau draus

Wenn ich annehme das die Z Achse in den Bildschirm hineingeht und sozusagen mit steigendem Z meine Punkte kleiner werden also in den Bildschirm hineinragen so kann man doch folgendes mit dem Strahlensatz sagen oder?

-------------------| <- Das ist mein Punkt
---------------|~|
----------||
-----|||
-||~~~~~~|
____________________

----------^ Das ist meine Schirmfläche
^---d-----

somit wäre X=x1/Z
und Y=y1/Z

unter der Voraussetzung das d=1 ist

in einem kleinen Büchlein habe ich nun ein paar Formeln für die Drehungen gefunden die auch richtig zu sein scheinen

Drehung um die X-Achse

X=X
Y=Y*cos winkel-z*sin winkel
Z=Y*sin winkel+z*cos winkel

Drehung um die Y-Achse

X=X*cos Winkel+Z*sin Winkel
Y=Y
Z=Z*cos Winkel-x*sin Winkel

Drehung um die Z-Achse

X=cos Winkel-Y*sin Winkel
Y=x*sin Winekl+y*cos Winkel
Z=Z

So sobald ich um die Z-Achse drehe funktioniert mein kleines C Programm einwandfrei. Das heißt der W+rfel ist um 45 Grad gedreht auf dem Bildschirm dargestellt. Drehe ich allerdings um die X-Achse zeichnet er mir total Wirre Linien und ich weiß nicht warum...

Vielleicht will sich ja einer von euch meinem Problem annehmen. Ich weiß dafür gibts mittlerweile OpenGL und Co oder Direct 3D aber ich programmiere das Ding unter Linux mit der LibVGA und es sollte mehr oder weniger ein Versuch sein ein bischen hinter die Kulissen von OpenGL bzw Direct 3D zu blicken...

Übrigens im angehängten Quellcode habe ich ein Array Linkedpoints erstellt das eingibt welcher Punkt mit Welchem Punkt verbunden Gezeichnet wird...

#include <stdio.h>
#include <vga.h>
#include <math.h>

struct linklist
{
int a;
int b;
};
struct point3d
{
double x;
double y;
double z;
};

int main(void)
{

int i;
char c;

struct point3d points[8];
struct point3d points2[8];

struct point3d center;
struct linklist linkedpoints[12];

linkedpoints[0].a=0;
linkedpoints[0].b=1;

linkedpoints[1].a=0;
linkedpoints[1].b=2;

linkedpoints[2].a=1;
linkedpoints[2].b=3;

linkedpoints[3].a=4;
linkedpoints[3].b=5;

linkedpoints[4].a=7;
linkedpoints[4].b=5;

linkedpoints[5].a=2;
linkedpoints[5].b=3;

linkedpoints[6].a=6; //6
linkedpoints[6].b=7; //7

linkedpoints[7].a=6; //6
linkedpoints[7].b=4; //4

linkedpoints[8].a=3; //3
linkedpoints[8].b=7; //7

linkedpoints[9].a=1; //1
linkedpoints[9].b=5; //5

linkedpoints[10].a=0; //0
linkedpoints[10].b=4; //4

linkedpoints[11].a=2; //2
linkedpoints[11].b=6; //6

points[0].x=-100;
points[0].y=-100;
points[0].z=100;

points[1].x=100;
points[1].y=-100;
points[1].z=100;

points[2].x=-100;
points[2].y=100;
points[2].z=100;

points[3].x=100;
points[3].y=100;
points[3].z=100;

center.x=(1024)/2;
center.y=768/2;
//center.z=0.5;

/*
p[4] p[5]
v v
/---------/
p[0] > /_________/| p[1]
| | |
p[6] >| _______ | / p[7]
|/---------/
p[2] ^ p[3]^
*/
// ------------------------------------------
points[4].x=-100;
points[4].y=-100;
points[4].z=200;

points[5].x=100;
points[5].y=-100;
points[5].z=200;

points[6].x=-100;
points[6].y=100;
points[6].z=200;

points[7].x=100;
points[7].y=100;
points[7].z=200;

int count2;
for (count2=0;count2<8;count2++)
{
points2[count2]=points[count2];//.x*(1/points[count2].z);
//points2[count2].y=points[count2]//.y*(1/points[count2].z);
//points2[count2].z=points[count2]//.z*(1/points[count2].z);

}

if (vga_init()) return 1;
if (vga_setmode(G1024x768x256)) return(1);

vga_setpalette(200,255,255,255);
vga_setpalette(199,255,0,0);

int grad;
int step=0;
grad=0;

do
{
step=0;
do
{
if (step==0) {vga_setcolor(200);} else {vga_setcolor(0);}

int count3;

for (count3=0;count3<12;count3++)
{

vga_waitretrace();
double x,y,x2,y2;
int xi,yi,x2i,y2i;
x=center.x+points2[linkedpoints[count3].a].x*(100/points2[linkedpoints[count3].a].z);
y=center.y+points2[linkedpoints[count3].a].y*(100/points2[linkedpoints[count3].a].z);
x2=center.x+points2[linkedpoints[count3].b].x*(100/points2[linkedpoints[count3].b].z);
y2=center.y+points2[linkedpoints[count3].b].y*(100/points2[linkedpoints[count3].b].z);
xi=abs(x);
yi=abs(y);
x2i=abs(x2);
y2i=abs(y2);
vga_drawline(x,y,x2,y2);

}
if (step==0) c=vga_getch();

step++;
} while (step<2);

int count;

grad=grad+45;

for (count=0;count<8;count++)
{
// X-Achse

points2[count].y=(points[count].y)*(cos((double) ((M_PI/180)*grad)))-(points[count].z)*(sin((double) ((M_PI/180)grad)));
points2[count].z=(points[count].y)(sin((double) ((M_PI/180)*grad)))+(points[count].z)*(cos((double) ((M_PI/180)*grad)));

// Z-Achse
/*
points2[count].x=(points[count].x)*(cos((double) ((M_PI/180)*grad)))-(points[count].y)*(sin((double) ((M_PI/180)grad)));
points2[count].y=(points[count].x)(sin((double) ((M_PI/180)*grad)))+(points[count].y)*(cos((double) ((M_PI/180)*grad)));
*/

// Y-ACHSE
/*
points2[count].x=(points[count].x)*(cos((double) ((M_PI/180)*grad)))+(points[count].z)*(sin((double) ((M_PI/180)grad)));
points2[count].z=(points[count].z)(cos((double) ((M_PI/180)*grad)))-(points[count].x)*(sin((double) ((M_PI/180)*grad)));
*/
}

if (grad>360) {grad=0;}

} while (c!='a');

return 0;
}

[AJ]

Kleiner Tipp, benutz mal die Code-Tags, da wird der Quellcode schön formatiert dargestellt. (gleich unter den Smilies sind die Tags zu finden, die du einfügen kannst)

Zu deinem Thema:
Leider kann ich dir da nicht konkret weiterhelfen, aber ich schätze im Spiele- und Grafikforum könnte man dir weiterhelfen. Die sind was Grafik angeht recht fitt.

Wenn einer der Moderatoren so nett ist und dich verschiebt, dann brauchst auch nicht extra einen neuen Thread anlegen ;).