Funktion optimieren?

Hi,

mein freund meinte, das man an dieser Funktion noch einiges Optimieren kann, aber was???

float *ConvertMatrixToFloatArray (float* Output, const CMatrix &Matrix)
{
	if (Output)
	{
		Output[ 0] = Matrix._11;
		Output[ 1] = Matrix._12;
		Output[ 2] = Matrix._13;
		Output[ 3] = Matrix._14;

		Output[ 4] = Matrix._21;
		Output[ 5] = Matrix._22;
		Output[ 6] = Matrix._23;
		Output[ 7] = Matrix._24;

		Output[ 8] = Matrix._31;
		Output[ 9] = Matrix._32;
		Output[10] = Matrix._33;
		Output[11] = Matrix._34;

		Output[12] = Matrix._41;
		Output[13] = Matrix._42;
		Output[14] = Matrix._43;
		Output[15] = Matrix._44;
	}

	static float result[16];

	result[ 0] = Matrix._11;
	result[ 1] = Matrix._12;
	result[ 2] = Matrix._13;
	result[ 3] = Matrix._14;

	result[ 4] = Matrix._21;
	result[ 5] = Matrix._22;
	result[ 6] = Matrix._23;
	result[ 7] = Matrix._24;

	result[ 8] = Matrix._31;
	result[ 9] = Matrix._32;
	result[10] = Matrix._33;
	result[11] = Matrix._34;

	result[12] = Matrix._41;
	result[13] = Matrix._42;
	result[14] = Matrix._43;
	result[15] = Matrix._44;

	return (result);
}

Bashar

Die Frage kann man nicht beantworten, ohne CMatrix zu kennen. Glücklicherweise hat Optimizer(?) die vor ein paar Tagen auszugsweise gepostet
Ist da nicht eine union drin, die diese _11 _12 etc. Geschichte mit einem float[4][4]-Array überlagert? Man könnte dieses Array durch einen (float*)-Cast direkt nutzen, ohne erst alles aufwändig (zudem in ein static-Array ... ) zu kopieren.

meine CMatrix:

class CMatrix
{
public:
	float	_11, _12, _13, _14;
	float	_21, _22, _23, _24;
	float	_31, _32, _33, _34;
	float	_41, _42, _43, _44;
};

Bashar schrieb:

Die Frage kann man nicht beantworten, ohne CMatrix zu kennen. Glücklicherweise hat Optimizer(?) die vor ein paar Tagen auszugsweise gepostet

ähm, ne.

Bashar

wenn's deine eigene ist, dann designe sie doch so, dass die Konvertierung schmerzlos vonstatten geht. Um nicht zu sagen, unnötig ist. Jetzt mal unter absichtlicher Verletzung des Standards:

inline float* convert(CMatrix& m) {
  return reinterpret_cast<float*>(&m);
}

Funktioniert theoretisch nur, wenn der Compiler gutgelaunt ist und wenn die Mondphase richtig steht, glücklicherweise ist das oft genug für praktische Anwendungen

Optimizer: Auch keine D3D-Matrixklasse? Mir war so

Ich hab da ne Idee, die aber nicht stimmen muss: bist du sicher, dass du die Matrix einmal in das übergebene Feld opieren willst und einmal in das statische Feld? Nicht, das sowas schon reichen würde:

float *ConvertMatrixToFloatArray (float* Output, const CMatrix &Matrix)
{
    if (Output)
    {
        Output[ 0] = Matrix._11;
        Output[ 1] = Matrix._12;
        Output[ 2] = Matrix._13;
        Output[ 3] = Matrix._14;

        Output[ 4] = Matrix._21;
        Output[ 5] = Matrix._22;
        Output[ 6] = Matrix._23;
        Output[ 7] = Matrix._24;

        Output[ 8] = Matrix._31;
        Output[ 9] = Matrix._32;
        Output[10] = Matrix._33;
        Output[11] = Matrix._34;

        Output[12] = Matrix._41;
        Output[13] = Matrix._42;
        Output[14] = Matrix._43;
        Output[15] = Matrix._44;
    }

    return Output;
}

Nein, ich habe lediglich mal irgendwo geschrieben, dass es keinen Grund gibt, eigene Matrixfunktionen zu schreiben, weil es gute in der D3DX-Erweiterung gibt.

aber nicht für OpenGL oder andere APIs oder z.B. eigenen kram

@der_Held
und was wenn Output NULL ist?

Dann wird NULL zurückgegeben.

geil: kurz kann man knicken.

Bashar

Verstehst du meinen Vorschlag nicht, findest du ihn Sch****, oder warum ignorierst du ihn?

Geo

Ohne Matrix zu optimieren könnte man schreiben:

float *ConvertMatrixToFloatArray (float* Output, const CMatrix &Matrix) 
{ 
  static float result[16];
  if (!Output) Output = result; 
  float* fptr = Output;

  *fptr++ = Matrix._11; 
  *fptr++ = Matrix._12; 
  *fptr++ = Matrix._13; 
  *fptr++ = Matrix._14; 

  *fptr++ = Matrix._21; 
  *fptr++ = Matrix._22; 
  *fptr++ = Matrix._23; 
  *fptr++ = Matrix._24; 

  *fptr++ = Matrix._31; 
  *fptr++ = Matrix._32; 
  *fptr++ = Matrix._33; 
  *fptr++ = Matrix._34; 

  *fptr++ = Matrix._41; 
  *fptr++ = Matrix._42; 
  *fptr++ = Matrix._43; 
  *fptr   = Matrix._44; 

  return Output; 
}

Shade Of Mine

Geo schrieb:

Ohne Matrix zu optimieren könnte man schreiben:

und was ist daran optimiert?

das Output=result; hat auch nicht die gewünschte Wirkung...

Geo

1. Die Codegröße ist optimiert.

2. Output=result; hat die (hier) gewünschte Wirkung.

Bashar schrieb:

Verstehst du meinen Vorschlag nicht, findest du ihn Sch****, oder warum ignorierst du ihn?

casts sind langsam! sagt jetzt nicht das ist UNSINN! TGGC hats bewiesen! Und lame Funktionen kann man für games nicht gebrauchen!

Christoph

iSAK schrieb:

casts sind langsam! sagt jetzt nicht das ist UNSINN! TGGC hats bewiesen! Und lame Funktionen kann man für games nicht gebrauchen!

Es ist ja so bequem, wenn man auf Autoritäten (?) verweist, anstelle selbst nachzudenken...

Bashar

cd9000: Das ist offensichtlich ein Fake.

Christoph

Bashar schrieb:

cd9000: Das ist offensichtlich ein Fake.

Danke für diesen Hinweis.

Deswegen habe ich keine Gegenargumente oder Links gebracht.

hier der beweis oh ihr großen meister:

http://www.c-plusplus.net/forum/viewtopic.php?t=53847&highlight=trash

Shade Of Mine

Geo schrieb:

2. Output=result; hat die (hier) gewünschte Wirkung.

Ah, obfuscated. Jetzt hab ichs verstanden...

@iSAK:
*lol*

float <-> int ist lahm, aber auch nur relativ

Bashars Variante finde ich am besten, vorausgesetzt man ersetzt den cast durch ne ordentliche Konvertierung.