Du bist nicht angemeldet.

Werbeanzeige

CW_Kovok

Alter Hase

  • »CW_Kovok« ist der Autor dieses Themas

Beiträge: 836

Wohnort: nähe Bonn

Beruf: Schüler

  • Private Nachricht senden

1

11.07.2006, 20:38

Vektorklasse

Moin,

ich schreibe gerade zum etwa 12. mal meine Mathebibliotheck neu. Ich möchte sie mit SSE bzw AMD 3DNow(zumidest ein bischen damit rumspielen) bestücken.
Jetzt meine Frage: Wäre es große Verschwendung die Vektorklasse direkt mit x,y,z,w zu implementieren, oder ist das ein vertretbarer Speicherverbrauch. Denn wenn ich es nur mit x, y und z mache, bekomme ich später andere Probleme.

Also entweder:

C-/C++-Quelltext

1
2
3
4
5
6
7
class Vector
{
public:
    
    float x,y,z;
    ...
}

oder:

C-/C++-Quelltext

1
2
3
4
5
6
7
class Vector
{
public:
    
    float x,y,z,w;
    ...
}


Der Vorteil bei 1 ist ganz klar der geringere Speicherverprauch, aber SSE etc arbeitet meistens ja mit 4*32 bit, weßhalb ich sie vorher umwandeln müsste.

Die Variante 2 frisst einfach eine große Menge speicher.

Ich habe mich im inet umgesehen und jeder rät was anderes. Jetzt hoffe ich hier noch ein paar konstruktive Meinungen zu finden, drehe nämlich langsam durch

Kovok
Was es alles gibt, das ich nich brauche - Aristoteles

Steven77

Alter Hase

Beiträge: 515

Wohnort: Münster - Gievenbeach

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

11.07.2006, 21:13

Mach mehrere Klassen: Zweidimensionale, dreidimensionale und vierdimensionale Vektoren.
So würde ich es zumindest machen.

CW_Kovok

Alter Hase

  • »CW_Kovok« ist der Autor dieses Themas

Beiträge: 836

Wohnort: nähe Bonn

Beruf: Schüler

  • Private Nachricht senden

3

11.07.2006, 21:15

2D sowieso, nur weiß ich nich wie ich zum beispiel die 3D Vektoren mit SSE vereinbaren oll, denn das umcasten dauert einfach zu lange
Was es alles gibt, das ich nich brauche - Aristoteles

Anonymous

unregistriert

4

11.07.2006, 21:19

Hier mal was Code aus nem Projekt von mir und nem Freund:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
// ###########################################################################

// Datei:        vector.hpp

// ###########################################################################

// Autor:        Patrick Ullmann

// Erstellt:     15.06.2006

// Änderungen:   15.06.2006/Patrick: Datei erstellt

// ###########################################################################

// Beschreibung: Hilfsstruktur und -Funktionen für Vektoren


#if !defined(__vector_h__)
#define __vector_h__

// I N C L U D E S ###########################################################

#include "common.hpp" // Generelle mathematische Definitionen und Operationen


// M A K R O S ###############################################################

    // TODO: Template-Makros einfügen


// D E F I N I T I O N E N ###################################################

namespace krass
{
namespace math
{
    // Forward-Deklaration für die Klasse 'vector'.

class vector;
} // Namespace: math

} // Namespace: krass


// F U N K T I O N E N #######################################################

    // Vergleichsoperatoren

bool operator == (const krass::math::vector& left, const krass::math::vector& right);
bool operator != (const krass::math::vector& left, const krass::math::vector& right);

    // Arithmetische Operatoren

krass::math::vector operator + (const krass::math::vector& left, const krass::math::vector& right);
krass::math::vector operator + (const krass::math::vector& left, float right);
krass::math::vector operator - (const krass::math::vector& left, const krass::math::vector& right);
krass::math::vector operator - (const krass::math::vector& left, float right);
krass::math::vector operator * (const krass::math::vector& left, const krass::math::vector& right);
krass::math::vector operator * (const krass::math::vector& left, float right);
krass::math::vector operator / (const krass::math::vector& left, const krass::math::vector& right);
krass::math::vector operator / (const krass::math::vector& left, float right);

namespace krass
{
namespace math
{
    // Berechnung der Länge eines Vektors.

float   vector_length               (const vector& vector);
    // Berechnung der Länge eines Vektors zum Quadrat.

float   vector_length_square        (const vector& vector);
    // Normalisierung eines Vektors.

vector  vector_normalize            (const vector& vector);
    // Normalisierung eines Vektors mit Epsilon.

vector  vector_normalize_extended   (const vector& vector);
    // Berechnung des Kreuzprodukt.

vector  vector_cross_product        (const vector& left, const vector& right);
    // Berechnung des Punktprodukt.

float   vector_dot_product          (const vector& left, const vector& right);
    // Berechnung des Winkels zwischen zwei Vektoren.

float   vector_angle                (const vector& left, const vector& right);
    // Lineare Interpolation zwischen zwei Positionsvektoren mit übergebenen Interpolationsfaktor

vector  vector_interpolate_coords   (const vector& left, const vector& right, float value);
    // Lineare Interpolation zwischen zwei normalisierten Richtungsvektoren mit übergebenen Interpolationsfaktor

vector  vector_interpolate_normal   (const vector& left, const vector& right, float value);
    // Berechnung des Minimums zweier Vektoren (Komponentenweises Minimum)

vector  vector_min                  (const vector& left, const vector& right);
    // Berechnung des Maximums zweier Vektoren (Komponentenweises Maximum)

vector  vector_max                  (const vector& left, const vector& right);
    // Berechnung eines normalisierten Vektors mit Zufallswerten.

vector  vector_random               (void);
} // Namespace: math

} // Namespace: krass


// S T R U K T U R E N #######################################################

namespace krass
{
namespace math
{
class vector
{
public:
        // Constructor, Copyconstructor und Destructor

    vector  (void);
    vector  (float value);
    vector  (const float* value);
    vector  (const float (&value)[3]);    
    vector  (float x, float y, float z);
    vector  (const vector& other);
    ~vector (void);

        // Arithmetische Operatoren

    vector operator - (void) const;

        // Zuweisungsoperatoren

    const vector& operator  =   (const vector& other);
    const vector& operator +=   (const vector& other);
    const vector& operator +=   (float value);
    const vector& operator -=   (const vector& other);
    const vector& operator -=   (float value);
    const vector& operator *=   (const vector& other);
    const vector& operator *=   (float value);
    const vector& operator /=   (const vector& other);
    const vector& operator /=   (float value);

public:
        // Achsen

    float   x;  // X-Achse

    float   y;  // Y-Achse

    float   z;  // Z-Achse

};

} // Namespace: math

} // Namespace: krass


#endif // Include Guard

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
// ###########################################################################

// Datei:        vector.cpp

// ###########################################################################

// Autor:        Patrick Ullmann

// Erstellt:     15.06.2006

// Änderungen:   15.06.2006/Patrick: Datei erstellt

//               16.06.2006/Michael: operator ==, operator /= und operator != 

//                                   wurden optimiert.

// ###########################################################################

// Beschreibung: Hilfsstruktur und -Funktionen für Vektoren


// I N C L U D E S ###########################################################

#include "vector.hpp"

// F U N K T I O N E N #######################################################

namespace krass
{
namespace math
{
// ///////////////////////////////////////////////////////////////////////////

// PUBLIC Constructor

// 

// ///////////////////////////////////////////////////////////////////////////

vector::vector (void) : x(0.0f), y(0.0f), z(0.0f)
{
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC Constructor

// 

// ///////////////////////////////////////////////////////////////////////////

vector::vector (float value) : x(value), y(value), z(value)
{
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC Constructor

// 

// ///////////////////////////////////////////////////////////////////////////

vector::vector (const float* value) : x(value[0]), y(value[1]), z(value[2])
{
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC Constructor

// 

// ///////////////////////////////////////////////////////////////////////////

vector::vector (const float (&value)[3]) : x(value[0]), y(value[1]), z(value[2])
{
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC Constructor

// 

// ///////////////////////////////////////////////////////////////////////////

vector::vector (float x, float y, float z) : x(x), y(y), z(z)
{
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC Copyconstructor

// 

// ///////////////////////////////////////////////////////////////////////////

vector::vector (const vector& other) : x(other.x), y(other.y), z(other.z)
{
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC Destructor

// 

// ///////////////////////////////////////////////////////////////////////////

vector::~vector (void)
{
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Erstellt eine invertierte Kopie des Vektors und gibt diese wieder.

// ///////////////////////////////////////////////////////////////////////////

vector vector::operator - (void) const
{
        // Invertierte Vektorkopie erstellen und zurück geben

    return (vector (-x, -y, -z));
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Zuweisungsoperator

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator = (const vector& other)
{
    x   = other.x;  // X-Achse

    y   = other.y;  // Y-Achse

    z   = other.z;  // Z-Achse


        // Sich selbst wiedergeben

    return (*this);
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Additionszuweisungsoperator mit einem anderen Vektor

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator += (const vector& other)
{
    x   += other.x; // X-Achse

    y   += other.y; // Y-Achse

    z   += other.z; // Z-Achse


        // Sich selbst wiedergeben

    return (*this);
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Additionszuweisungsoperator mit einem Wert

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator += (float value)
{
        // Additionszuweisungsoperator für Vektoren aufrufen

    return ((*this) += vector (value, value, value));
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Subtraktionszuweisungsoperator mit einem anderen Vektor

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator -= (const vector& other)
{
    x   -= other.x; // X-Achse

    y   -= other.y; // Y-Achse

    z   -= other.z; // Z-Achse


        // Sich selbst wiedergeben

    return (*this);
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Subtraktionszuweisungsoperator mit einem Wert

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator -= (float value)
{
        // Subtraktionszuweisungsoperator für Vektoren aufrufen

    return ((*this) -= vector (value, value, value));
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Multiplikationszuweisungsoperator mit einem anderen Vektor

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator *= (const vector& other)
{
    x   *= other.x; // X-Achse

    y   *= other.y; // Y-Achse

    z   *= other.z; // Z-Achse


        // Sich selbst wiedergeben

    return (*this);
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Multiplikationszuweisungsoperator mit einem Wert

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator *= (float value)
{
        // Multiplikationszuweisungsoperator für Vektoren aufrufen

    return ((*this) *= vector (value, value, value));
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Divisionszuweisungsoperator mit einem anderen Vektor

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator /= (const vector& other)
{
    x   /= other.x; // X-Achse

    y   /= other.y; // Y-Achse

    z   /= other.z; // Z-Achse


        // Sich selbst wiedergeben

    return (*this);
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Divisionszuweisungsoperator mit einem Wert

// ///////////////////////////////////////////////////////////////////////////

const vector& vector::operator /= (float value)
{
        // Multiplikationszuweisungsoperator für Vektoren aufrufen (Kehrwert!!!!)

    return ((*this) *= (1/value));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung der Länge eines Vektors.

// ///////////////////////////////////////////////////////////////////////////

float vector_length (const vector& vector)
{
        // Länge des Vektors errechnen und die Wurzel ziehen.

    return (sqrt<float> (vector_length_square (vector)));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung der Länge eines Vektors zum Quadrat.

// ///////////////////////////////////////////////////////////////////////////

float vector_length_square (const vector& vector)
{
        // Länge des Vektors errechnen.

    return (vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Normalisierung eines Vektors.

// ///////////////////////////////////////////////////////////////////////////

vector vector_normalize (const vector& vector)
{
        // Vektor normalisieren.

    return (vector / sqrt<float> (vector.x * vector.x + vector.y * vector.y + vector.z * vector.z));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Normalisierung eines Vektors mit Epsilon.

// ///////////////////////////////////////////////////////////////////////////

vector vector_normalize_extended (const vector& vector)
{
        // Vektor normalisieren mit Epsilon.

    return (vector / (sqrt<float> (vector.x * vector.x + vector.y * vector.y + vector.z * vector.z) + epsilon<float>::value));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung des Kreuzprodukt.

// ///////////////////////////////////////////////////////////////////////////

vector vector_cross_product (const vector& left, const vector& right)
{
        // Kreuzprodukt anhand der beiden übergebenen Vektoren berechnen.

    return (vector (left.y * right.z - left.z * right.y, left.z * right.x - left.x * right.z, left.x * right.y - left.y * right.x));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung des Punktprodukt.

// ///////////////////////////////////////////////////////////////////////////

float vector_dot_product (const vector& left, const vector& right)
{
        // Punktprodukt anhand der beiden übergebenen Vektoren berechnen.

    return (left.x * right.x + left.y * right.y + left.z * right.z);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung des Winkels zwischen zwei Vektoren.

// ///////////////////////////////////////////////////////////////////////////

float vector_angle (const vector& left, const vector& right)
{
        // Übergebene Vektoren normalisieren mit Epsilon, Punktprodukt berechnen und den Winkel berechnen.

    return (acos<float> (vector_dot_product (vector_normalize_extended (left), vector_normalize_extended (right))));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Lineare Interpolation zwischen zwei Positionsvektoren mit übergebenen Interpolationsfaktor

// ///////////////////////////////////////////////////////////////////////////

vector vector_interpolate_coords (const vector& left, const vector& right, float value)
{
        // Die beiden Positionsvektoren mit dem Interpolationsfaktor linear Interpolieren.

    return (left + value * (right - left));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Lineare Interpolation zwischen zwei normalisierten Richtungsvektoren mit übergebenen Interpolationsfaktor

// ///////////////////////////////////////////////////////////////////////////

vector vector_interpolate_normal (const vector& left, const vector& right, float value)
{
        // Die beiden normalisierten Richtungsvektoren mit dem Interpolationsfaktor linear Interpolieren

        // und das Ergebnis normalisieren.

    return (vector_normalize (vector_interpolate_coords (left, right, value)));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung des Minimums zweier Vektoren (Komponentenweises Minimum)

// ///////////////////////////////////////////////////////////////////////////

vector vector_min (const vector& left, const vector& right)
{
        // Komponentenweise das Minimum der beiden Vektoren berechnen

    return (vector (min<float> (left.x, right.x), min<float> (left.y, right.y), min<float> (left.z, right.z)));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung des Maximums zweier Vektoren (Komponentenweises Maximum)

// ///////////////////////////////////////////////////////////////////////////

vector vector_max (const vector& left, const vector& right)
{
        // Komponentenweise das Maximum der beiden Vektoren berechnen.

    return (vector (max<float> (left.x, right.x), max<float> (left.y, right.y), max<float> (left.z, right.z)));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Berechnung eines normalisierten Vektors mit Zufallswerten.

// ///////////////////////////////////////////////////////////////////////////

vector vector_random (void)
{
        // Zufallswerte berechnen und Vektor normalisieren.

    return (vector_normalize (vector (random<float> (-1.0f, 1.0f), random<float> (-1.0f, 1.0f), random<float> (-1.0f, 1.0f))));
}

} // Namespace: math

} // Namespace: krass


// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Vergleichsoperator

// ///////////////////////////////////////////////////////////////////////////

bool operator == (const krass::math::vector& left, const krass::math::vector& right)
{
        // Achsen prüfen auf Gleichheit

    return (left.x == right.x && left.y == right.y && left.z == right.z);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Vergleichsoperator

// ///////////////////////////////////////////////////////////////////////////

bool operator != (const krass::math::vector& left, const krass::math::vector& right)
{
        // Die Vergleichsoperation durchführen und das Ergebnis invertieren

    return (!(left == right));
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Additionsoperator zwischen zwei Vektoren

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator + (const krass::math::vector& left, const krass::math::vector& right)
{
        // Additionszuweisungsoperator aufrufen

    return (krass::math::vector (left) += right);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Additionsoperator zwischen einem Vektor und einem Wert

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator + (const krass::math::vector& left, float right)
{
        // Additionszuweisungsoperator aufrufen

    return (krass::math::vector (left) += right);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Subtraktionsoperator zwischen zwei Vektoren

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator - (const krass::math::vector& left, const krass::math::vector& right)
{
        // Subtraktionszuweisungsoperator aufrufen

    return (krass::math::vector (left) -= right);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Subtraktionsoperator zwischen einem Vektor und einem Wert

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator - (const krass::math::vector& left, float right)
{
        // Subtraktionszuweisungsoperator aufrufen

    return (krass::math::vector (left) -= right);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Multiplikationsoperator zwischen zwei Vektoren

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator * (const krass::math::vector& left, const krass::math::vector& right)
{
        // Multiplikationszuweisungsoperator aufrufen

    return (krass::math::vector (left) *= right);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Multiplikationsoperator zwischen einem Vektor und einem Wert

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator * (const krass::math::vector& left, float right)
{
        // Multiplikationszuweisungsoperator aufrufen

    return (krass::math::vector (left) *= right);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Divisionsoperator zwischen zwei Vektoren

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator / (const krass::math::vector& left, const krass::math::vector& right)
{
        // Divisionszuweisungsoperator aufrufen

    return (krass::math::vector (left) /= right);
}

// ///////////////////////////////////////////////////////////////////////////

// GLOBAL 

// 

// Divisionsoperator zwischen einem Vektor und einem Wert

// ///////////////////////////////////////////////////////////////////////////

krass::math::vector operator / (const krass::math::vector& left, float right)
{
        // Divisionszuweisungsoperator aufrufen

    return (krass::math::vector (left) /= right);
}
Easy, schnell und gut ist ;)

Was will man mehr? So bau ich und mein Kumpel (dem ich sogesehen alles beigebracht habe) es jedenfalls auf.

5

11.07.2006, 21:23

Hey nix da guck besser mal deine PMs an :D
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

CW_Kovok

Alter Hase

  • »CW_Kovok« ist der Autor dieses Themas

Beiträge: 836

Wohnort: nähe Bonn

Beruf: Schüler

  • Private Nachricht senden

6

11.07.2006, 21:27

so in etwa hatte ich meine Vektorklasse bis jetzt auch, aber wie würdest du das mit SSE verbinden?
Was es alles gibt, das ich nich brauche - Aristoteles

Anonymous

unregistriert

7

11.07.2006, 21:58

CW_Kovok
sqrt<float> ist schon eine von mir überladene Funktion die auf ISSE arbeitet.

Wenn man jetzt noch per SSE normalisieren will, dann kann man ja folgendes machen:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// /////////////////////////////////////////////////////////////////////////// 

// GLOBAL 

// 

// Normalisierung eines Vektors. 

// /////////////////////////////////////////////////////////////////////////// 

vector vector_normalize (const vector& vector) 
{ 
        // Soll ISSE benutzt werden?

    if (use_isse)
    {
        // normalisiere mit ISSE

        return (normalisierter_vector);
    }

        // Vektor normalisieren. 

    return (vector / sqrt<float> (vector.x * vector.x + vector.y * vector.y + vector.z * vector.z)); 
}
Lohnt sich aber dort für unsere Fälle kein bisschen. unser sqrt<T> ist uns flott genug.

CW_Kovok

Alter Hase

  • »CW_Kovok« ist der Autor dieses Themas

Beiträge: 836

Wohnort: nähe Bonn

Beruf: Schüler

  • Private Nachricht senden

8

11.07.2006, 22:02

also am besten SSE für vectoren Klassen? Ich verwende es bis jetzt nur in der Matrixklasse. Da ist es ja kein Problem. Ärgerlich ist es trotzdem...
Was es alles gibt, das ich nich brauche - Aristoteles

Anonymous

unregistriert

9

11.07.2006, 22:06

CW_Kovok
Moment mal. Von "Nur in Vektorklassen" habe ich nichts gesagt.

Du kannst Dein ISSE überall benutzen wie Du Lustig bist! Aber solltest Dich fragen ob es Sinn macht.

Bei uns hat es nix gebracht, nur bei der Matrizenmultiplikation und paar "Sonderfälle". Aber wie z. B. hier in dieser Vektorklasse, waren uns die Zentel Millisekunden herzlichst egal - ABER: Wir können noch ISSE reinbauen, nur: Es lohnt sich für uns noch nicht.

Daher erst der Rat: Bevor Du wieder Haufenweise Klassen schreibst die am Ende sowieso wieder durch etwas "besseres" ersetzt werden und Du Arbeit in den Sand drückst, erstmal eine Klasse ordentlich machen (z. B. Vektor, kannst auch oben die nehmen) dann die nächste bist der komplette Mathebereich abgeschlossen ist. Erst dann solltest Du tiefgründige Optimierungen mit ISSE vollziehen.

Denn am Ende stehste wieder blöd da und denkst Dir "Klasse, alles für die Katz und darf wieder alles neuschreiben". usw. usw. usw.

Kennst das Spiel ja. Erstmal anständig, dann erst "verbessern".

CW_Kovok

Alter Hase

  • »CW_Kovok« ist der Autor dieses Themas

Beiträge: 836

Wohnort: nähe Bonn

Beruf: Schüler

  • Private Nachricht senden

10

11.07.2006, 22:09

naja normalerweise mach ich das auch so, nur meine mathelib schreib ich alle 3 wochen neu, einfach weil es spaß macht. Ich werde es einfach mal so lassen und gucken was für eine geschwindigkeit am ende raus kommt.
Was es alles gibt, das ich nich brauche - Aristoteles

Werbeanzeige