Amateurfilm-Forum

Titel:Tutarial - 4HD für die UNI-ENGINE
[UNI-ENGINE ist eine Software-Eigenentwicklung für bewegte Objekte in Videos]

Beschreibung: Bewegte Objekte, die in das Video eigefügt werden sollen, werden in einem Video von anderen Objekten des Videos verdeckt.
Das Tutorial im Anhang beschreibt die diese Methode mit der UNI-ENGINE

Der Sichtbarkeitsbereich des Objektes lässt sich auf drei Arten festlegen:
1. Mit einem Mausklick (mittlerer button) wird jeweils links, rechts, oben und unten eine gerade Linie gezogen.
2. Soll eine Begrenzung sich dem Objekt im Video anpassen (im Beispiel hier der Horizont) wird approximiert durch mehrere Mausklicke.
3. Wie 2. nur folgt der Sichtbarkeitsbereich einer Tracking-Spur

Näheres dazu im Anhang.

Infos zur Entstehung:
Kamera:sony HD

Schnittsoftware:sony vegas
Sonstige Software:UNI-ENGINE; UNI-CUT


Länge: < 1min

Für Kritik und Anregungen bin ich sehr dankbar.

(das Video sollte in HD angesehen werden)
Stream:

Ja sicher, ich benutze auch Sony Vegas. Allerdings war ich mit dem chroma Keyer nicht besonders zufrieden. Möglicherweise fehlen mir da auch die Erfahrungen.

Die Philosophie der UNI-ENGINE ist auch eine andere:

1. Primär geht es mir um die freie Bewegung von Objekten auf mathematisch-physikalischen Bahnen.
2. Alle Funktionen sollen auf einer Oberfläche sichtbar sein.
3. Die Bewegungen sollen einfach und überschaubar programmiert werden können.

Aus einfachen Bewegungen sind im Laufe der letzten Zeit immer mehr Funktionen hinzugekommen. Das füllt natürlich die Oberfläche.

Alpha Kanäle werden nicht benötigt, die werden im Programm simmuliert.

Natürlich kann man die Landschaft auch mit einer Maske ausschneiden - hier der Himmel. Aber wenn ich den Bereich selbst festlege, geht das bei mir schneller.

Objekte, wie die Orange im Beispiel, schneide ich mit der UNI-CAT aus, ebenfalls eine Eigenentwicklung, da hat mich sony vegas auch enttäuscht.

Zitat von »wabu«

Zum einen Respekt zu dieser Arbeit.

Ich glaube für mich, das die Einarbeitungszeit sehr hoch ist.

Mit einer sauberen Maske, die in diesem Motiv machbar ist kann das Verdecken geregelt werden.

Die mathematische Beschreibung einer Bewegung ist schon interessant - insbesondere wenn sie hier eingebaut ist.

Danke für den Hinweis!

Ich habe im nächsten Tutorial die mathematische Funktion der Objektbewegung beschrieben, damit man sich eine Vorstellung davon machen kann, welche Bewegungen möglich sind.

Im allgemeinen reichen parabolische Ortsbewegungen für die meisten Fälle aus. Kubische Funktionen sind schon spezielle Anwendungen für Bewegssimulationen im 3D-Raum.

Die Einarbeitungszeit erscheint mir bei anderen Programmen, die ich kenne, viel höher zu sein. Ich benutze sony vegas und Blender und verzweifle immer wieder, wenn ich etwas Bestimmtes suchen oder machen will, zumal das mein Hobby ist und ich nicht täglich damit arbeite.

Zitat von »wabu«

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.

Zitat von »achim01«

Zitat von »wabu«

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?

Zitat von »joey23«

Ich gebe zu, dass ich nicht ansatzweise begreife, wie dieses Tool zu verstehen ist. Wo ist der Vorteil gegenüber zB After Effects, bei dem ich die genannten Animationen mit gefühlten 3 Klicks per WYSIWYG erstellen kann? Warum sollte ich mich mit dieser GUI befassen wollen, was habe ich davon?

Es geht hier nicht um einen Film. Das ist ein Programm in Echtzeit.

Die Frage war: Wie kann ich ein Objekt in 3D Programmieren, das ich dann auch in einen Film einsetzen kann.

Das kann man mit Blender oder...oder aber auch mit OpenGL machen. Was aber dahinter steckt ist die Programmierung in OpenGL. Dafür ist das Beispiel da.

Wen das interessiert, dem kann ich gern die .exe Datei schicken, dann hat er ein rotierendes Planetensystem auf seinem Bildschirm.
Wenn ich Zeit habe, mache ich mal ein Screen Capture davon.

So läuft das obige Programm:

hier klicken - sun rotiert


Und hier kann sun.exe heruntergeladen werden:

Hier herunterladen und mit Klick starten


Über eine Rückmeldung ob es läuft, würde ich mich freuen.