Bei Blender bin ich bei dir.... letztlich habe ich mich da aber auch nicht wirklich versucht. Aber selbst bei Hitfilm muss ich die filosofie erst mal verstehen.
Ich habe
hier und
hier mal Bewegungen die mit Sinus Funktionen gesteuert werden - besser: berechnet werden.
Mit einem Würfel habe ich angefangen mit OpenGL zu programmieren in Echtzeit. OpenGl funktioniert im Prinzip wie Blender nur alles ist in Echtzeit und muss halt programmiert werden.
Mein bestes Objekt war dann ein ganzes Planetensystem mit Sonne im Zentrum und die Planeten hatten Phasen und sogar noch Monde, die sich um die Planeten bewegten - und alles beleuchtete die Sonne. Das sah gut aus. das Planetensystem konnte man ebenfalls aus allen Richtungen betrachten. Allerdings war das auch mein letztes Projekt mit OpenGL in Echtzeit.
Falls es jemand interessiert, kann ich es mitsamt dem Quelltext zuschicken, allerdings erst, wenn ich wieder in D bin.
So jetzt bin ich in D
Wer sich dafür interessiert, dem kann ich eine Email mit Anhang (Quell- und Exe-Datei) schicken. Die persönlichen Nachrichten lassen keine Anhänge zu.
Hier der Quelltext des "Planetensystems":
#define GRAPHIC_XS 650
#define GRAPHIC_YS 650
#define FRAMES 20
#include "mm_fram_opengl.cpp"
double r,X,Z;
int i,k,l;
double yangle,yangle1,yangle2,yangle3,yangle4;// globale variable
GLfloat yanglep[10][10];
double xangle;
double zangle;
void reshape(int w,int h)
{
glViewport(0,0,(GLsizei) w,(GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0,(GLfloat) w/(GLfloat) h,1.0,20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0,0.0,5.0,0.0,0.0,0.0,0.0,1.0,0.0);
}
void drawtriangle(float *v1, float *v2, float *v3)
{
glBegin(GL_TRIANGLES);// zeichnet Dreieck
glNormal3fv(v1);//Normalenvektor des 1. Punktes
glVertex3fv(v1);//Koordinaten x,x,z des 1. Punktes
glNormal3fv(v2);
glVertex3fv(v2);
glNormal3fv(v3);
glVertex3fv(v3);
glEnd();
}
void normalize (float v[3])
{
//Normalisieren des Normalenvektors einer Fläche
GLfloat d= sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
if (d==0.0){return;}
v[0]/=d;
v[1]/=d;
v[2]/=d;
}
void normcrossprod(float v1[3],float v2[3],float out[3])
{ //Bildung des Vektorproduktes aus den Vektoren v1,v2
out[0]=v1[1]*v2[2]-v1[2]*v2[1];
out[1]=v1[2]*v2[0]-v1[0]*v2[2];
out[2]=v1[0]*v2[1]-v1[1]*v2[0];
normalize(out);
// im Vektor out steht der Normalenvektor der Fläche nx,ny,nz
}
void subdivide (float *v1, float *v2, float *v3, long depth)
{ //Bildung dreier neuer Dreieckpunkte v12,v23,v31 aus v1,v2,v3
// Die Punkte liegen in der Mitte zwischen den alten Punkten
GLfloat v12[3],v23[3],v31[3];
GLint i;
if (depth == 0)
{
drawtriangle (v1,v2,v3);
return;
}
for (i=0;i<3;i++)
{
v12
=(v1[i]+v2[i])/2.0;
v23[i]=(v2[i]+v3[i])/2.0;
v31[i]=(v3[i]+v1[i])/2.0;
}
normalize(v12); //Normalisierung
normalize(v23);
normalize(v31);
subdivide(v1,v12,v31,depth-1);// Hier werden die vier neuen Dreiecke gebildet
subdivide(v2,v23,v12,depth-1);
subdivide(v3,v31,v23,depth-1);
subdivide(v12,v23,v31,depth-1);
}
//------------------------------------------------------------
void Init(void)// muss sein
{
ud1.Set(-20);// Vorgabewerte für Parameter für Einstellbox sonst null gesetzt
ud2.Set(20);
ud3.Set(10);
ud4.Set(10);
ud5.Set(10);
ud6.Set(10);
glMatrixMode(GL_PROJECTION);// nachfolgende Befehle beziehen sich auf "projektion"
glLoadIdentity();// vorgabewerte
glFrustum(-3,3,-3,3,-17.2,70);// links, rechts, oben, unten, vorn, hinten
//glFrustum(-1,1,-1,1,7.2,40);// links, rechts, oben, unten, vorn, hinten
glMatrixMode(GL_MODELVIEW);// nachfolgende Befehle beziehen sich auf "modelview"
glEnable(GL_DEPTH_TEST);//tiefentest
glEnable(GL_LIGHTING);// beleuchtung
glEnable(GL_CULL_FACE);// ?
glEnable(GL_LIGHT0);// Licht null anschalten
glClearColor(0.0,0.0,0.0,0.0);
glShadeModel(GL_FLAT);
printf("1: x-Winkel 2: z-Winkel 3: Winkelschritt in 1/100 °\n");// info im terminal
for (k=0;k<10;k++)
{
for (k=0;k<10;k++){yanglep[k][l]=0.0;}
};
}
//-----------------------------------
//------------------------------------------------------------------------------------------------------------
void CalculateFrame(void)//wird immer (!) im Zeittakt aufgerufen (100 mal pro sec)
{ // für parameteränderungen
xangle=ud1.Get();//aktuelle werte aus Einstellbox
zangle=ud2.Get();
yangle+=ud3.Get()/1000;// y-winkel wird verändert
while(yangle>=360) yangle-=360;
yangle+=ud3.Get()/1000;// y-winkel wird verändert
yanglep[0][0]=yangle;//Rotation der Sonne
yanglep[1][0]=yangle*25;//Rotation des Merkur
yanglep[2][0]=yangle*15;//Rotation der Venus
yanglep[3][0]=yangle*10;//Rotation der Erde
yanglep[3][1]=yangle*30;//Rotation des Erdmondes
yanglep[4][0]=yangle*8;//Rotation des Mars
yanglep[4][1]=yangle*150;//Rotation des 1.Marsmondes
yanglep[4][2]=yangle*100;//Rotation des 2.Marsmondes
yanglep[5][0]=yangle*4;//Rotation des Jupiter
yanglep[5][1]=yangle*40;//Rotation des 1.Jupitermond
yanglep[5][2]=yangle*30;//Rotation des 2.Jupitermond
yanglep[5][3]=yangle*20;//Rotation des 3.Jupitermond
yanglep[5][4]=yangle*15;//Rotation des 4.Jupitermond
yangle1+=ud4.Get()/200;// y1-winkel wird verändert
while(yangle1>=360) yangle1-=360;
yangle1+=ud4.Get()/200;// y1-winkel wird verändert
yangle2+=ud5.Get()/300;// y1-winkel wird verändert
while(yangle2>=360) yangle2-=360;
yangle2+=ud5.Get()/300;// y2-winkel wird verändert
yangle3+=ud6.Get()/400;// y3-winkel wird verändert
while(yangle3>=360) yangle3-=360;
yangle3+=ud6.Get()/400;// y3-winkel wird verändert
}
//------------------------------------------------------------------------------------------------------------
void DrawFrame(void)//zeichnet das Objekt statisch
{
static GLfloat fMaterialColor[18][4] =
{
{1.0f, 0.0f, 0.0f, 1.0f}, {1.0f, 1.0f, 0.8f, 0.0f},//Sonne
{1.f, 1.f, 0.0f, 0.0f}, {1.0f, 0.8f, 0.0f, 0.0f},//Merkur Venus
{0.5f, 0.6f, 1.0f, 1.0f}, {0.5f, 0.8f, 0.5f, 0.0f},//Erde Mond
{1.0f, 0.5f, 0.5f, 1.0f}, {0.5f, 0.5f, 0.5f, 0.0f},//Mars 1. Mond
{0.0f, 0.0f, 1.0f, 1.0f}, {1.0f, 0.0f, 1.0f, 0.0f},//2. Mond Jupiter
{1.0f, 1.0f, 1.0f, 1.0f}, {1.0f, 1.0f, 1.0f, 0.0f},//1.und 2. Mond
{1.0f, 1.0f, 1.0f, 1.0f}, {1.0f, 1.0f, 1.0f, 0.0f},//3. und 4. Mond
{1.0f, 0.0f, 1.0f, 1.0f}, {0.0f, 1.0f, 1.0f, 0.0f},
{1.0f, 0.0f, 1.0f, 1.0f}, {0.0f, 1.0f, 1.0f, 0.0f},
};
int cidx=1; //Farbtabellenindex
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glLoadIdentity();
glRotated(xangle, 1.0, 0, 0.0); // Objekt rotieren
glRotated(zangle, 0, 0, 1); // Objekt rotieren
glRotated(-yanglep[0][0], 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.07,60,30); //Sonne
glPopMatrix();
//1. Planet Merkur
glPushMatrix();
glLoadIdentity();
glRotatef(xangle, 1.0, 0, 0.0); // Objekt rotieren
glRotatef(zangle, 0, 0, 1); // Objekt rotieren
glRotatef(-yanglep[1][0], 0.0, 1.0, 0.0);
glTranslatef(0.15,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.015,20,15);
glPopMatrix();
//2. Planet Venus
glPushMatrix();
glLoadIdentity();
glRotated(xangle, 1.0, 0, 0.0); // Objekt rotieren
glRotated(zangle, 0, 0, 1); // Objekt rotieren
glRotated(-yanglep[2][0], 0.0, 1.0, 0.0);
glTranslatef(0.3,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.018,20,15);
glPopMatrix();
//3. Planet Erde
glPushMatrix();
glLoadIdentity();
glRotated(xangle, 1.0, 0, 0.0); // Objekt rotieren
glRotated(zangle, 0, 0, 1); // Objekt rotieren
glRotated(-yanglep[3][0], 0.0, 1.0, 0.0);
glTranslatef(0.5,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.022,40,8);
//1. mond
//glPushMatrix();
glTranslatef(0.00,0.0,0.0);
glRotatef(-yanglep[3][1], 0.0, 1.0, 0.0);
glTranslatef(0.09,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.01,30,8);
glPopMatrix();
//4. Planet Mars
glPushMatrix();
glLoadIdentity();
glRotated(xangle, 1.0, 0, 0.0); // Objekt rotieren
glRotated(zangle, 0, 0, 1); // Objekt rotieren
glRotated(-yanglep[4][0], 0.0, 1.0, 0.0);
glTranslatef(0.7,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.018,20,8);
//1. mond
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glRotatef(-yanglep[4][1], 0.0, 1.0, 0.0);
glTranslatef(0.04,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.005,10,8);
glPopMatrix();
//2. Mond
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glRotatef(-yanglep[4][2], 0.0, 1.0, 0.0);
glTranslatef(0.05,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.005,10,8);
glPopMatrix();
//Schluss der Monde
glTranslatef(0.0,0.0,0.0);
glPopMatrix();
//5. Planet Jupiter
glPushMatrix();
glLoadIdentity();
glRotated(xangle, 1.0, 0, 0.0); // Objekt rotieren
glRotated(zangle, 0, 0, 1); // Objekt rotieren
glRotated(-yanglep[5][0], 0.0, 1.0, 0.0);
glTranslatef(1.0,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.04,40,30);
//1. mond
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glRotatef(-yanglep[5][1], 0.0, 1.0, 0.0);
glTranslatef(0.08,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.01,10,8);
glPopMatrix();
//2. Mond
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glRotatef(-yanglep[5][2], 0.0, 1.0, 0.0);
glTranslatef(0.09,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.01,10,8);
glPopMatrix();
//3. Mond
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glRotatef(-yanglep[5][3], 0.0, 1.0, 0.0);
glTranslatef(0.10,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.01,10,8);
glPopMatrix();
//4. Mond
glTranslatef(0.0,0.0,0.0);
glRotatef(-yanglep[5][4], 0.0, 1.0, 0.0);
glTranslatef(0.11,0.0,0.0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, fMaterialColor[cidx++]);
glutSolidSphere(0.01,10,8);
glPopMatrix();
//Schluss der Monde
glTranslatef(0.0,0.0,0.0);
glPopMatrix();
}
//----------------------------
Alles klar?