Skalierung von 3d Objekten Borland Developer 5

M

Mantrax

Grünschnabel
Hi,

Ich habe jetzt schon etliche Seiten und Foren durchsucht, jedoch dazu noch nichts gefunden.
Also mein Problem ist folgendes:
Ich habe ein Programm geschrieben, in dem man verschiedenen Punkte zeichnen lassen kann. Diese kann man dann zu einem Körper verbinden lassen, welcher auf Wunsch rotieren kann. DIe Umrechnung von 2D auf 3D funktioniert auch. Nun möchte ich aber noch solche Körper (also einfach 3 und 4Ecke) skalieren, nur ich finde keinen passenden Algorithmus...

Meine Frage ist, kennt jemand von euch einen solchen Algorithmus zur Skalierung für den Borland Developer****? Und, kann ich eigentlich auch den Algorithmus von C++ nehmen oder muss ich da mit viel Aufwand noch Sachen umschreiben****?

Für den Algorithmus und Hilfe wäre ich sehr dankbar! =D

Willi
 
Also du hast ein Programm geschrieben wo man irgendwo hin klickt und aus diesem Punkt eine 3D Koordinate berechnet
wird, welche dann als ein neues Vertex für das Objekt gilt******
Wie zeigst du die 3D Objekte an? Mit OpenGL? Wenn ja, dann gibt es da eine scalef() Funktion.

Wenn du aber die Koordinaten selber skalieren willst,
dann würde ich sagen, du verschiebst das Objekt in den Koordinatenursprung
und multiplizierst die X, Y und Z Werte jedes Vertice mit dem Faktor deiner Skalierung. Danach verschiebste das Objekt wieder an seine ursprüngliche Position. Eigentlich gar net so schwer.
Sehr praktisch ist es wenn du die Koordinaten der einzelnen Vertices relativ zum Objektmittelpunkt hast, dann kannste dir das Verschieben sparen oder andere Berechnungen...

Dafür könntest du ne einfache Funktion schreiben.
C++: 
struct Vertex {
	float	X;
	float	Y;
	float	Z;
};

void	Scale(Vertex &_Vertex, float _FactorX, float _FactorY, float _FactorZ) {
	_Vertex.X	*= _FactorX;
	_Vertex.Y	*= _FactorY;
	_Vertex.Z	*= _FactorZ;
}
Wenn ich dich also richtig verstanden habe, müsste dass ein Lösungsansatz für dich sein.

Zu der anderen Frage: Theoretisch und praktisch müsstest du jeden Algorithmus nehmen können. Am Algorithmus selber kann sich ja oft gar nix ändern um die Funktion zu gewährleisten. Du musst den Algo nur in deiner verwendeten Programmiersprache umsetzen.
 
Zuletzt bearbeitet von einem Moderator:
Ich habe nochmal nachgeschaut... Also ich gebe verschiedene 3d Koordinaten ein, welche ich zu einem Objekt verbinden lassen kann... Also wäre es nur eine einfache und punktweise Skalierung.
Angezeigt werden die Objekte einfach über die "Ausführfunktion" vom Borland Developer Studio, dass ist kein OpenGL.
Danke für deinen Algorithmus, aber was genau macht dieser Vertex-Befehl****? Berechnet der den ABstand zum Koord.ursprung****?

Vielen Dank!
 
Leider beide... Ich habe nämlich kaum Ahnung von Programmierung und bringe mir das sozusagen etwas selbst bei =D
 
Mh okay.

Also Datenstrukturen kannste dir wie ein Kontainer vorstellen in dem beliebig viele Variablen und auch andere Datenstrukturen deklariert werden können.
In C++ würden dann noch die Klassen dazukommen.

Also ne Struktur legst du so an:
C++: 
struct *Strukturname* {
	// Hier die Variabendeklarationen ohne Vorinitialisierung
}
Den Strukturnamen kannste selber vergeben (Nach C-Regeln).

Auf die Variablen in der Struktur greifst du dann über den "."-Operator zu wie oben in meinem Beispiel.
Das praktische an strukturen ist halt, dass du ein Packet an verschiedenen Datentypen zentral in einem Element hast.
So dass mal an GANZ KLEINE Einführung in Strukturen.

Zur Funktion:
Bei der Funktion übergibst du die Referenz einer Datenstruktur an die Funktion.
Eine Referenz ist sozusagen ein Zeiger auf den Speicherbereich der Datenstruktur im Arbeitsspeicher.
Wenn du einer Funktion den Variablenwert übergibst, dann kannst du in der Funktion den Wert nur zur Verarbeitung innerhalb der Funktion
verändern. In der Aufrufenden Funktion bleibt dieser jedoch gleich. Da kommt dann die Rferenz ins Spiel.
In meiner Scale-Funktion siehst du ja z.B. folgende Zeile

C++: 
_Vertex.X	*= _FactorX;

Das bedeutet nichts anderes als:
Multipliziere Vertex.X mit _FactorX und weise es Vertex.X wieder zu.
Man könnte auch schreiben.

C++: 
_Vertex.X	= _Vertex.X * _FactorX;
Würde genau dassselbe ergeben.

So also da du die Struktur "Vertex" als Referenz übergeben hast werden die Originalwerte von der Funktion verändert.
Damit spare ich mir das rückgeben der neuen Vertexkoordinaten in der Funktion.

Funktion ohne Vertex-Referenz.
C++: 
// Ich hab grad gesehen, dass ich oben einen kleinen Fehler gemacht habe.
// In der Funktion muss es "_Vertex.X" heißen und nicht "Vertex.X" usw.
Vertex	Scale(Vertex _Vertex, float _FactorX, float _FactorY, float _FactorZ) {
	_Vertex.X	= _Vertex.X * _FactorX;
	_Vertex.Y	= _Vertex.Y * _FactorY;
	_Vertex.Z	= _Vertex.Z * _FactorZ;
	
	return _Vertex;
}
 
Zuletzt bearbeitet von einem Moderator:
Ein praktisches Beispiel:
Wir haben ein Dreieckpolygon (Also 3 Vertices)
Die 3 Vertices bilden das Objekt (in dem Fall ein einfaches 3D Dreieck)
Dieses Dreieck wollen wir auf die halbe größe skalieren also ist der Faktor 0.5

C++: 
struct Vertex {
	float	X;
	float	Y;
	float	Z;
};

void	Scale(Vertex &_Vertex, float _FactorX, float _FactorY, float _FactorZ) {
	_Vertex.X	= _Vertex.X * _FactorX;
	_Vertex.Y	= _Vertex.Y * _FactorY;
	_Vertex.Z	= _Vertex.Z * _FactorZ;
}

int main() {
	Vertex	Vertex1;	// Punkt 1 des Polygons
	Vertex	Vertex2;	// Punkt 2 des Polygons
	Vertex	Vertex3;	// Punkt 3 des Polygons
	
	// Polygonkoordinaten setzen
	// Punkt 1: oben mittig
	Vertex1.X	= 0.0;
	Vertex1.Y	= 1.0;
	Vertex1.Z	= -2.0;
	
	// Punkt 2: unten rechts
	Vertex2.X	= 2.0;
	Vertex2.Y	= -0.5;
	Vertex2.Z	= 1.0;
	
	// Punkt 3: unten links
	Vertex3.X	= -1.5;
	Vertex3.Y	= -1.0;
	Vertex3.Z	= 0.0;
	
	// Skalieren
	void	Scale(&Vertex1, 0.5, 0.5, 0.5);	// skaliert Vertex 1
	void	Scale(&Vertex2, 0.5, 0.5, 0.5);	// skaliert Vertex 2
	void	Scale(&Vertex3, 0.5, 0.5, 0.5);	// skaliert Vertex 3
	
	/*
		Die neuen Koordinaten (um den Faktor 0.5 skaliert) sind nun folgende
		
		Vertex1.X	= 0.0;
		Vertex1.Y	= 0.5;
		Vertex1.Z	= -1.0;
		
		Vertex2.X	= 1.0;
		Vertex2.Y	= -0.25;
		Vertex2.Z	= 0.5;
		
		Vertex3.X	= -0.75;
		Vertex3.Y	= -0.5;
		Vertex3.Z	= 0.0;
	*/

	return 0;
}
 
Zuletzt bearbeitet von einem Moderator:
Aha =D Okay, Vielen Dank! jetzt hab ich es, denke ich mal, verstanden.

Vielen Dank nochmal für deine Hilfe!

Gruß Willi
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück