Also Impulse sind ja bekanntlich Vektoren, bestehend aus Betrag, Richtung und Orientierung... Wie kann ich jetzt diesen Drei-Dimensionalen Vektor addieren? Mein Problem ist folgendes: Ich brauche möglichst was universelles, was ich für alle Winkel von 0 bis 360 einsetzen kann für horizontalen und vertikalen Winkel...
[edit] übrigens das struct sie so aus:

typedef struct angle3d_s
{
float x;
float y;
} angle3d_t;

typedef struct impulse_s
{
angle3d_t direction;
int strength; // Orientation is a '-' in this...
} impulse_t;

wie waers du nimm einfach nen ganz normalen vektor? also 3 float x, y, z
die beschreiben eine richtung, eine laenge und was du mit orientierung meinst ist mir net so ganz klar...
und addieren kann man die ganz simpel.

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

okay, es ist leider nicht ganz so einfach tron...
Zur Erinnerung:
Es gibt 1. Skalare, 2. Vektoren und andere Größenformen...
Skalare und Vektoren sind wohl die, die am meisten in der Physik vorkommen:
Skalare sind direkt einzelne Einheiten, Vektoren sind Einheiten, die aus drei Elementen bestehen, die wiederum Skalare sind: 1. Richtung ( Grad ), 2. Orientierung ( vorwärts/rückwärts ) und 3. der Betrag.

Mein Problem ist jetzt folgendes:
Ich habe ein Objekt im leeren Raum: Das Objekt hat bereits einen Impuls erfahren (der aber zur einfachheit sozusagen dauerhaft auf ihn einwirkt und aus dem jede hunderstel sekunde die Position des Körpers im Raum neu errechnet wird) Jetzt will ich aber sozusagen einen anderen Körper auf den einen Körper einwirken lassen (sprich: Ein neuer Impuls wirkt ein) Damit jetzt der korrekte neue Impuls berechnet wird, müssen der bereits vorhandene Impuls mit dem neuen Impuls addiert bzw. subtrahiert werden.

Deshalb die Frage: Wie zum Geier addiere ich zwei Vektoren?

Ehem, hat da jemand Vektoren falsch verstanden oder will da jemand ganz andere Vektoren einsetzen?
Die drei Skalare innerhalb eines Vektors sind schließlich nicht Winkel, Richtung und so weiter, sondern eben, hmm... Achsenabschnitte. Für jede Achse halt. Dann geht das ja auch mit der Addierung ganz einfach, der neue Vektor heißt dann: c = (a1 + a2 | b1 + b2 | a3 + b3 )
Nix mit Winkeln und so weiter. Hast du also einen Impuls, dann brauchst du nur den neuen Impuls hinzuzuaddieren und schon hast du den resultierenden Impuls (und damit deine neue Bewegung). Richtung der Bewegung ergibt sich aus den Achsenabschnitten, Betrag ergibt sich aus der Länge des Vektors (sqrt(x² + y² + z²)), Winkel gibt's dabei nicht.

TheTinySteini
Coder Poke646
"Don't Panic" - Hitchhiker's Guide to the Galaxy

jo apfelkorn, die normal vektor addition is vollkommen ausreichend, du musst die vektoren nich in winkeln + betrag darstellen.
Vector imp1(20,3,1),imp2(0,2,5);
Vector resultierenderImp = imp1+imp2;

das is alles was du brauchst

Another1

...relaxing..atm =)
... und Schweiz suckt!

da falls du die Winkelschreibweise benutzt .... *g*
(VectorAngle(angle1)*length(l1))+(VectorAngle(angle2)*length(l2))+

Being in john Malkovich
.....

vielleicht ganz hilfreich .. www.flipcode.com/geometry

okay, ich habe sogenannte "Bounce Vectors", wie auf paulchens seite beschrieben.

Kann mir trotzdem jetzt jemand sagen, wie ich die Impulse jetzt addiere, rechnerisch? Ich möchte nämlich keinesfalls geometrische Vektoren darstellen, sondern einfach nur den Impuls, der jetzt auf das Objekt einwirkt, und dazu brauch ich nunmal die "Bounce Vectors".

Winkel ist ja schon klar... da wählen wir den Mittelwert der beiden Winkel...aber wie mach ich das mit dem Betrag?

mannmannmann....
nochmal GAAAANNNZZZ langsam:
du benutzt vektoren in der sogennanten polarkoordinaten-form, also 2 winkel und ein betrag
die guten alten vektoren aus 3 skalaren beschreiben DEN SELBEN RAUM
aber ihr vorteil ist ganz klar: mit ihnen kann man einfacher rechnen

btw: mit winkel mitteln beim addieren ist es nicht getan
bsp:
(0°, 0°, 3) + (90°, 0°, 4) = (53.13°, 0°, 5)
oder mit normalen vektoren:
(3, 0, 0) + (0, 4, 0) = (3, 4, 0)
(an welcher stelle die zahlen stehen haengt davon ab, wie du die rotationen und dein koordinatensystem festlegst)

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

Zitat:

apfelkorn postete
okay, ich habe sogenannte "Bounce Vectors", wie auf paulchens seite beschrieben.

1. es heisst 'bound vector', also ortsvektor
2. impulse sind 'free vector' also freier vektor

die position eines koerpers ist ein ortsvektor (mit dem Urspung als bezugspunkt)
aber der impuls dieses koerpers ist ein freier vektor, er beschreibt die richtung und wie stark der impuls ist.

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

Naja, apfelkorn geht vermutlich nach dem Motto: Warum einfach, wenn's auch kompliziert geht...

TheTinySteini
Coder Poke646
"Don't Panic" - Hitchhiker's Guide to the Galaxy

bounce vektor, bound vektor... egal, ihr wisst was gemeint ist :)

ich bin ja offen für vorschläge: wie kann ich denn nun diesen freien vektor zu einem anderen addieren? Is mir egal ob ichs umwandel in einen ortsgebundenen vektor, hauptsache ihr sagt mir, wie ich es denn umwandeln kann... Das addieren von ortsgebundenen vektoren wurde ja jetzt schon zur genüge erklärt :)

p.s.: eine gute sache hat dieser thread ja... wir lernen alle mehr über vektoren

Also ich persönlich würde ja deinen esoterischen Vektor mit Winkeln und so in einen vernünftigen, normalen Vektor umwandeln, die beiden Vektoren addieren, und dann (wenn's denn _unbedingt_ sein muß) zurückverwandeln. Sicher, keine besonders schöne Lösung, aber mit Winkeln in 3D zu rechnen ist _ätzendst_.

cu,
Prefect

Widelands - Gemütliche Aufbaustrategie, Free Software
Noch ein Blog - Lerne, wie die Welt wirklich ist, aber vergiss niemals, wie sie sein sollte.

aber wenn man ne halbwegs vernünftige 3d-engine basteln will unumgänglich...

apfelkorn, nimm ganz normale vektoren... ich arbeite auch an einer 3d-engine und wuerde nicht im (alp)traum daran denken, vektoren in polarkoordinatenform zu benutzen!

ich vermute mal, dass du quake zu den <zitat>halbwegs vernünftige[n] 3d-engine[s]</zitat> zaehlst und JC hat auch ganz normale vektoren benutzt.
so definert herr carmack persoenlich einen vektor:
typedef float vec_t;
typedef vec_t vec3_t[3]; // aus dem quake 1 sourcecode

ganz einfach: 3 floats - fuer jede raumrichtung eine - das genuegt
mit denen kann man auch ganz simpel rechnen und bricht sich nicht sonstwas ab wie bei den polarkoordinaten

zur inspiration meine vektor-klasse:
#ifndef Vector_h
#define Vector_h

#include <math.h>
#include "Types.h"

class Vector
{
public:
inline Vector();
inline Vector(Float);
inline Vector(Float, Float, Float);
inline Vector(const Float*);

inline Float Length() const;
inline Float Length2() const;
inline Vector& Normalize();
inline Vector Normalized() const;
inline Vector& Set(Float, Float, Float);

inline Vector operator + (const Vector&) const;
inline Vector operator - () const;
inline Vector operator - (const Vector&) const;
inline Float operator * (const Vector&) const;
inline Vector operator * (Float) const;
inline Vector operator / (Float) const;
inline Vector operator ^ (const Vector&) const;

inline Vector& operator = (const Vector&);
inline Vector& operator += (const Vector&);
inline Vector& operator -= (const Vector&);
inline Vector& operator *= (Float);
inline Vector& operator /= (Float);

inline Bool operator == (const Vector&) const;
inline Bool operator != (const Vector&) const;

inline Float& operator [] (const UInt);

inline operator Float* ();

friend inline Vector operator * (Float, const Vector&);

union
{
Float mVector[3];
struct
{
Float x;
Float y;
Float z;
};
};
};

inline Vector::Vector() : x(0.0f), y(0.0f), z(0.0f)
{
// x = y = z = 0.0f; // generates more efficent code on BCC
}

inline Vector::Vector(Float pScalar) : x(pScalar), y(pScalar), z(pScalar)
{}

inline Vector::Vector(Float pX, Float pY, Float pZ) : x(pX), y(pY), z(pZ)
{}

inline Vector::Vector(const Float* pVector) :
x(pVector[0]),
y(pVector[1]),
z(pVector[2])
{}

inline Float Vector::Length() const
{
return sqrt((x * x) + (y * y) + (z * z));
}

inline Float Vector::Length2() const
{
return (x * x) + (y * y) + (z * z);
}

inline Vector& Vector::Normalize()
{
if (x || y || z)
{
Float l = Length();
x /= l;
y /= l;
z /= l;
}
return *this;
}

inline Vector Vector::Normalized() const
{
return Vector(*this).Normalize();
}

inline Vector& Vector::Set(Float pX, Float pY, Float pZ)
{
x = pX;
y = pY;
z = pZ;
return *this;
}

inline Vector Vector::operator + (const Vector& pVector) const
{
return Vector(x + pVector.x, y + pVector.y, z + pVector.z);
}

inline Vector Vector::operator - () const
{
return Vector(-x, -y, -z);
}

inline Vector Vector::operator - (const Vector& pVector) const
{
return Vector(x - pVector.x, y - pVector.y, z - pVector.z);
}

inline Float Vector::operator * (const Vector& pVector) const
{
return (x * pVector.x) + (y * pVector.y) + (z * pVector.z);
}

inline Vector Vector::operator * (Float pScalar) const
{
return Vector(x * pScalar, y * pScalar, z * pScalar);
}

inline Vector Vector::operator / (Float pScalar) const
{
return Vector(x / pScalar, y / pScalar, z / pScalar);
}

inline Vector Vector::operator ^ (const Vector& pVector) const
{
return
Vector
(
(y * pVector.z) - (z * pVector.y),
(z * pVector.x) - (x * pVector.z),
(x * pVector.y) - (y * pVector.x)
);
}

inline Vector& Vector::operator = (const Vector& pVector)
{
x = pVector.x;
x = pVector.y;
x = pVector.z;
return *this;
}

inline Vector& Vector::operator += (const Vector& pVector)
{
x += pVector.x;
y += pVector.y;
z += pVector.z;
return *this;
}

inline Vector& Vector::operator -= (const Vector& pVector)
{
x -= pVector.x;
y -= pVector.y;
z -= pVector.z;
return *this;
}

inline Vector& Vector::operator *= (Float pVector)
{
x *= pVector;
y *= pVector;
z *= pVector;
return *this;
}

inline Vector& Vector::operator /= (Float pScalar)
{
x /= pScalar;
y /= pScalar;
z /= pScalar;
return *this;
}

inline Bool Vector::operator == (const Vector& pVector) const
{
return (x == pVector.x) && (y == pVector.y) && (z == pVector.z);
}

inline Bool Vector::operator != (const Vector& pVector) const
{
return (x != pVector.x) || (y != pVector.y) || (z != pVector.z);
}

inline Float& Vector::operator [] (UInt pIndex)
{
return mVector[pIndex];
}

inline Vector::operator Float* ()
{
return mVector;
}

inline Vector operator * (Float pScalar, const Vector& pVector)
{
return
Vector
(
pVector.x * pScalar,
pVector.y * pScalar,
pVector.z * pScalar
);
}

#endif

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

Tron, meinst du nicht, dass du da _etwas_ übertreibst? Ich bezweifle ernsthaft, dass du wirklich alle Funktionen brauchst, die du da in die Klasse gepackt hast. Das führt doch eher zu immer wieder anderem Code, eher unstrukturiertem Programmieren und so weiter... und * und ^ für Dotproduct und Crossproduct zu verwenden halte ich für gewagt, da würde ich lieber vernünftige Namen vergeben. Die Gefahr is doch ziemlich groß, dass da Verwechslungen auftreten.

TheTinySteini
Coder Poke646
"Don't Panic" - Hitchhiker's Guide to the Galaxy

hmm... ne, finde ich nicht
ich halte meinen code eigentlich fuer sehr strukturiert (ausser dass das board alle einrueckungen frisst *grrrr*)

ich verwende die meissten methoden (denke ich doch...), welche wuerdest du weglassen?

das mit * und ^ ist geschmackssache, ich arbeite gern mit infix-operatoren, daher finde ich das sehr elegant
mir missfallen solche praefix-konstrukte wie dot(cross(a, b), c)
da schreibe ich lieber (a ^ b) * c

ich bin fuer kritik offen, aber dann machen wir doch lieber 'nen extra thread: die perfekte vektorklasse (;
btw: ich weiss, dass meine klasse noch einige macken hat, z.b. sollte == und != mit 'nem epsilon pruefen

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

hm... okay, ich geb auf :)

Tron:
Es ist besser, wenn du Vectoren nicht als Klassen benutzen würdest !!! (habt alle nen HL WAHHHN !) Die Verwaltung dauert dann nämlich länger ... du kannst auch so inline funks proggen !

Apfelkorn warum denn das ?
schau wenn du einene Impuls machen willst dann rechnest du zB einfach das :

Vector veloadd;

veloadd = Normalize(impcenter - origin); // richtungsvector
veloadd = veloadd * (factor * max((1.0-(Length(impcenter - origin)/radius))),0) * frametime;

// impcenter ist das Zentrum des Impulses
// origin ist der Mittelpunkt des Körpers
// factor -> sowas wie gravity vom Impuls
// radius ist die Reichweite, des impulses
// frametime macht das ganze Zeitabhängig

wenn das mit dem richtungsvector nicht hinhaut kannst du das ja immernoch per angles machen ....naja das dürfte aber auch so klappen
so und das sollte es auch schon gewesen sein !!

Being in john Malkovich
.....

Der Text ist zu kurz -> tja das passiert, wenn man seine NAchrichten nicht löschen kann

Being in john Malkovich
.....

Zitat:

anothergb02 postete
Tron:
Es ist besser, wenn du Vectoren nicht als Klassen benutzen würdest !!! (habt alle nen HL WAHHHN !) Die Verwaltung dauert dann nämlich länger ... du kannst auch so inline funks proggen !

was ist daran besser es nicht als klasse zu machen (mal abgesehen davon dass in c++ structs auch klassen sind)
natuerlich koennte ich meine vektoren als nackte structs definieren und operatoren global ueberladen, aber wozu wenn mir ein syntax geboten wird, der das viel eleganter kapselt.

welche verwaltung dauert laenger? das ist ein uebles geruecht ueber oo und kommt von solchen leuten die alle methoden virtuell machen.
anbei: nicht jeder virtuelle funktionsaufruf muss ueber die v-table aufgeloest werden, wenn zur kompilierzeit der typ feststeht, dann kann ein ganz normaler funktionsaufruf erfolgen, die methode kann dann sogar inline sein!

ich kann dir gerne mal einige assemblerlistings meiner vektorklasse zeigen, ich glaube kaum, dass du das mit normalen c besser hinbekommst. (ich vermute eher es kommt genau das selbe dabei raus)

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett