FPS zu niedrig suche Ideen

[Die erinnerung]

Hallo. Ich schreibe gerade ein Spiel mit DirectX9.
Ich habe nur ein Problem und das wäre, dass das Spiel nicht flüssig läuft.

Ich hatte schon zwei Ansätze:

Der erste war folgender:
Ich habe alle Vertices und Indices in jeweils einem globalen Vector gespeichert. Und bin dann meine Chunks durchgegangen und die haben dann einfach ihre selbst erzeugten hinten dran gehängt. Die FPS war gut, aber Änderungen dauern ewig!

Code hierzu:

//Vector-Operationsüberladungen

//Fügt zwei Vectoren zusammen
template <class T> std::vector<T> operator+(const std::vector<T>& Vektor1, const std::vector<T>& Vektor2)
{
    std::vector<T> SammelVektor( Vektor1 );
    SammelVektor.insert(SammelVektor.end(),Vektor2.begin(), Vektor2.end());
    return SammelVektor;
}

//Addiert den Wert val zu allen Vektorelementen hinzu
template <class T> std::vector<T> operator+(const std::vector<T>& Vector, T val)
{
	std::vector<T> Ergebnis( Vector );

	int size = Ergebnis.size();

	for(int i = 0; i < size; i++)
	{
		Ergebnis[i] += val;
	}

	return Ergebnis;
}

//Andere Stelle

//Die Funktion, die die Vertices und Indices auf den GrafikRAM speichert und die Chunks durchgeht
void World::set_Vertices()
{
	if(updated)
	{
		vertices.clear();
		indices.clear();

		for(int i = 0; i < 64; i++)
		{
			for(int j = 0; j < 16; j++)
			{
				for(int k = 0; k < 64; k++)
				{
					Chunk* chunk = &chunks[i][j][k];

					chunk->get_Vertices();

					vertices = chunk->vertices + vertices;

					indices = indices + (short)chunk->indices.size();
					indices = indices + chunk->indices;
				}
			}
		}

		bool empty = vertices.empty() || indices.empty();

		if(empty)
		{
			vertices.push_back(CUSTOMVERTEX());
			indices.push_back(0);
		}

		// create a vertex buffer interface called v_buffer
		d3ddev->CreateVertexBuffer(sizeof(CUSTOMVERTEX) * vertices.size(),
									0,
									CUSTOMFVF,
									D3DPOOL_MANAGED,
									&v_buffer,
									NULL);

		void* pVoid;    // a void pointer

		// lock v_buffer and load the vertices into it
		v_buffer->Lock(0, 0, (void**)&pVoid, 0);
		memcpy(pVoid, vertices.data(), sizeof(CUSTOMVERTEX) * vertices.size());
		v_buffer->Unlock();

		// create an index buffer interface called i_buffer
		d3ddev->CreateIndexBuffer(sizeof(short) * indices.size(),
									0,
									D3DFMT_INDEX16,
									D3DPOOL_MANAGED,
									&i_buffer,
									NULL);

		// lock i_buffer and load the indices into it
		i_buffer->Lock(0, 0, (void**)&pVoid, 0);
		memcpy(pVoid, indices.data(), sizeof(short) * indices.size());
		i_buffer->Unlock();

		if(empty)
		{
			anz_vertices = 0;
			anz_triangles = 0;
		}
		else
		{
			anz_vertices = vertices.size();
			anz_triangles = indices.size() / 3;
		}

		updated = false;
	}
}

//andere Stelle
void Chunk::get_Vertices()
{
	if(updated)
	{
		generate_Vertices();

		updated = false;
	}
}

void Chunk::generate_Vertices()
{
	vertices.clear();
	indices.clear();

	for(int i = 0; i < 8; i++)
	{
		for(int j = 0; j < 8; j++)
		{
			for(int k = 0; k < 8; k++)
			{
				Block* block = blocks[i][j][k].block;

				if(!block->is_opaque() || !block->is_solid())
				{
					for(int l = 0; l < 6; l++)
					{
						block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), l, &vertices,
							&indices, block->get_Texture_ID(l));
					}
				}
				else
				{
					if(j != 0)
					{
						Block* block_tmp = blocks[i][j - 1][k].block;

						if(!block_tmp->is_opaque() || !block_tmp->is_solid())
						{
							block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 0, &vertices,
							&indices, block->get_Texture_ID(0));
						}
					}
					else
					{
						block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 0, &vertices,
							&indices, block->get_Texture_ID(0));
					}

					if(i != 7)
					{
						Block* block_tmp = blocks[i + 1][j][k].block;

						if(!block_tmp->is_opaque() || !block_tmp->is_solid())
						{
							block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 1, &vertices,
							&indices, block->get_Texture_ID(1));
						}
					}
					else
					{
						block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 1, &vertices,
							&indices, block->get_Texture_ID(1));
					}

					if(k != 7)
					{
						Block* block_tmp = blocks[i][j][k + 1].block;

						if(!block_tmp->is_opaque() || !block_tmp->is_solid())
						{
							block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 2, &vertices,
							&indices, block->get_Texture_ID(2));
						}
					}
					else
					{
						block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 2, &vertices,
							&indices, block->get_Texture_ID(2));
					}

					if(i != 0)
					{
						Block* block_tmp = blocks[i - 1][j][k].block;

						if(!block_tmp->is_opaque() || !block_tmp->is_solid())
						{
							block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 3, &vertices,
							&indices, block->get_Texture_ID(3));
						}
					}
					else
					{
						block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 3, &vertices,
							&indices, block->get_Texture_ID(3));
					}

					if(k != 0)
					{
						Block* block_tmp = blocks[i][j][k - 1].block;

						if(!block_tmp->is_opaque() || !block_tmp->is_solid())
						{
							block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 4, &vertices,
							&indices, block->get_Texture_ID(4));
						}
					}
					else
					{
						block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 4, &vertices,
							&indices, block->get_Texture_ID(4));
					}

					if(j != 7)
					{
						Block* block_tmp = blocks[i][j + 1][k].block;

						if(!block_tmp->is_opaque() || !block_tmp->is_solid())
						{
							block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 5, &vertices,
							&indices, block->get_Texture_ID(5));
						}
					}
					else
					{
						block->get_side((float)(pos[0] + i), (float)(pos[1] + j), (float)(pos[2] + k), 5, &vertices,
							&indices, block->get_Texture_ID(5));
					}
				}
			}
		}
	}
}

//andere Stelle

virtual void Block::get_side(float x, float y, float z, unsigned int direction, std::vector<CUSTOMVERTEX>* vertices,
		std::vector<short>* indices, unsigned short texture_id)
	{
		if((direction >= 6) || (texture_id >= (TEXTURES_PER_SIDE * TEXTURES_PER_SIDE)))
			return;

		const float texture_x = (texture_id % TEXTURES_PER_SIDE) * texture_size;
		const float texture_y = (texture_id / TEXTURES_PER_SIDE) * texture_size;
		const float texture_x_end = texture_x + texture_size;
		const float texture_y_end = texture_y + texture_size;

		CUSTOMVERTEX pos1, pos2, pos3, pos4;

		switch(direction)
		{
		case 0:		//oben (y+)
			pos1 = CUSTOMVERTEX(x + 0.5f, y + 0.5f, z + 0.5f, 0.0f, 1.0f, 0.0f, texture_x, texture_y_end);
			pos2 = CUSTOMVERTEX(x + 0.5f, y + 0.5f, z - 0.5f, 0.0f, 1.0f, 0.0f, texture_x, texture_y);
			pos3 = CUSTOMVERTEX(x - 0.5f, y + 0.5f, z + 0.5f, 0.0f, 1.0f, 0.0f, texture_x_end, texture_y_end);
			pos4 = CUSTOMVERTEX(x - 0.5f, y + 0.5f, z - 0.5f, 0.0f, 1.0f, 0.0f, texture_x_end, texture_y);
			break;
		case 1:		//rechts (x+)
			pos1 = CUSTOMVERTEX(x + 0.5f, y + 0.5f, z + 0.5f, 1.0f, 0.0f, 0.0f, texture_x_end, texture_y);
			pos2 = CUSTOMVERTEX(x + 0.5f, y - 0.5f, z + 0.5f, 1.0f, 0.0f, 0.0f, texture_x_end, texture_y_end);
			pos3 = CUSTOMVERTEX(x + 0.5f, y + 0.5f, z - 0.5f, 1.0f, 0.0f, 0.0f, texture_x, texture_y);
			pos4 = CUSTOMVERTEX(x + 0.5f, y - 0.5f, z - 0.5f, 1.0f, 0.0f, 0.0f, texture_x, texture_y_end);
			break;
		case 2:		//vorne (z+)
			pos1 = CUSTOMVERTEX(x + 0.5f, y + 0.5f, z + 0.5f, 0.0f, 0.0f, 1.0f, texture_x, texture_y);
			pos2 = CUSTOMVERTEX(x - 0.5f, y + 0.5f, z + 0.5f, 0.0f, 0.0f, 1.0f, texture_x_end, texture_y);
			pos3 = CUSTOMVERTEX(x + 0.5f, y - 0.5f, z + 0.5f, 0.0f, 0.0f, 1.0f, texture_x, texture_y_end);
			pos4 = CUSTOMVERTEX(x - 0.5f, y - 0.5f, z + 0.5f, 0.0f, 0.0f, 1.0f, texture_x_end, texture_y_end);
			break;
		case 3:		//links (x-)
			pos1 = CUSTOMVERTEX(x - 0.5f, y + 0.5f, z + 0.5f, -1.0f, 0.0f, 0.0f, texture_x, texture_y);
			pos2 = CUSTOMVERTEX(x - 0.5f, y + 0.5f, z - 0.5f, -1.0f, 0.0f, 0.0f, texture_x_end, texture_y);
			pos3 = CUSTOMVERTEX(x - 0.5f, y - 0.5f, z + 0.5f, -1.0f, 0.0f, 0.0f, texture_x, texture_y_end);
			pos4 = CUSTOMVERTEX(x - 0.5f, y - 0.5f, z - 0.5f, -1.0f, 0.0f, 0.0f, texture_x_end, texture_y_end);
			break;
		case 4:		//hinten (z-)
			pos1 = CUSTOMVERTEX(x + 0.5f, y + 0.5f, z - 0.5f, 0.0f, 0.0f, -1.0f, texture_x_end, texture_y);
			pos2 = CUSTOMVERTEX(x + 0.5f, y - 0.5f, z - 0.5f, 0.0f, 0.0f, -1.0f, texture_x_end, texture_y_end);
			pos3 = CUSTOMVERTEX(x - 0.5f, y + 0.5f, z - 0.5f, 0.0f, 0.0f, -1.0f, texture_x, texture_y);
			pos4 = CUSTOMVERTEX(x - 0.5f, y - 0.5f, z - 0.5f, 0.0f, 0.0f, -1.0f, texture_x, texture_y_end);
			break;
		case 5:		//unten (y-)
			pos1 = CUSTOMVERTEX(x + 0.5f, y - 0.5f, z + 0.5f, 0.0f, -1.0f, 0.0f, texture_x_end, texture_y_end);
			pos2 = CUSTOMVERTEX(x - 0.5f, y - 0.5f, z + 0.5f, 0.0f, -1.0f, 0.0f, texture_x, texture_y_end);
			pos3 = CUSTOMVERTEX(x + 0.5f, y - 0.5f, z - 0.5f, 0.0f, -1.0f, 0.0f, texture_x_end, texture_y);
			pos4 = CUSTOMVERTEX(x - 0.5f, y - 0.5f, z - 0.5f, 0.0f, -1.0f, 0.0f, texture_x, texture_y);
			break;
		}

		vec_custom_it it1 = find(vertices->begin(), vertices->end(), pos1);

		if(it1 == vertices->end())
		{
			vertices->push_back(pos1);
		}

		vec_custom_it it2 = find(vertices->begin(), vertices->end(), pos2);

		if(it2 == vertices->end())
		{
			vertices->push_back(pos2);
		}

		vec_custom_it it3 = find(vertices->begin(), vertices->end(), pos3);

		if(it3 == vertices->end())
		{
			vertices->push_back(pos3);
		}

		vec_custom_it it4 = find(vertices->begin(), vertices->end(), pos4);

		if(it4 == vertices->end())
		{
			vertices->push_back(pos4);
		}

		it1 = find(vertices->begin(), vertices->end(), pos1);
		it2 = find(vertices->begin(), vertices->end(), pos2);
		it3 = find(vertices->begin(), vertices->end(), pos3);
		it4 = find(vertices->begin(), vertices->end(), pos4);

		int size = indices->size();

		indices->resize(size + 6);

		indices->operator[](size++) = (short)(it2 - vertices->begin());
		indices->operator[](size++) = (short)(it4 - vertices->begin());
		indices->operator[](size++) = (short)(it3 - vertices->begin());

		indices->operator[](size++) = (short)(it2 - vertices->begin());
		indices->operator[](size++) = (short)(it3 - vertices->begin());
		indices->operator[](size++) = (short)(it1 - vertices->begin());
	}

//Beim Rendern wird dann einfach alles im v-buffer auf einmal gerendert

Der zweite war folgender:
Ich habe jedem Chunk einen v_buffer und i_buffer gegeben und lasse alle einzeln rendern, falls sie gefüllt sind. Dann geht die FPS aber in die Knie.

Code hierzu:

void World::set_Vertices()
{
	if(updated)
	{
		vertices.clear();
		indices.clear();

		int count = 0;

		for(int i = 0; (i < 64) && (count <= MAX_CHUNKS); i++)
		{
			for(int j = 0; (j < 16) && (count <= MAX_CHUNKS); j++)
			{
				for(int k = 0; (k < 64) && (count <= MAX_CHUNKS); k++)
				{
					Chunk* chunk = &chunks[i][j][k];

					if(chunk->updated)
					{
						count++;

						chunk->get_Vertices();
					}
				}
			}
		}

		if(count <= MAX_CHUNKS)
			updated = false;
	}
}

//andere Stelle

class Chunk
{
private:
	Block_Container blocks[8][8][8];
	bool updated;
	std::vector<CUSTOMVERTEX> vertices;
	std::vector<short> indices;

public:
	LPDIRECT3DVERTEXBUFFER9 v_buffer;
	LPDIRECT3DINDEXBUFFER9 i_buffer;
	int anz_vertices, anz_triangles;
	bool render;

	// Noch ein bisschen mehr...
};

//andere Stelle:

void Chunk::generate_Vertices()
{
	vertices.clear();
	indices.clear();

	for(int i = 0; i < 8; i++)
	{
		for(int j = 0; j < 8; j++)
		{
			for(int k = 0; k < 8; k++)
			{
				//Gleicher Code wie oben
			}
		}
	}

	render = !(vertices.empty() || indices.empty());

	if(render)
	{
		// create a vertex buffer interface called v_buffer
		d3ddev->CreateVertexBuffer(sizeof(CUSTOMVERTEX) * vertices.size(),
									0,
									CUSTOMFVF,
									D3DPOOL_MANAGED,
									&v_buffer,
									NULL);

		void* pVoid;    // a void pointer

		// lock v_buffer and load the vertices into it
		v_buffer->Lock(0, 0, (void**)&pVoid, 0);
		memcpy(pVoid, vertices.data(), sizeof(CUSTOMVERTEX) * vertices.size());
		v_buffer->Unlock();

		// create an index buffer interface called i_buffer
		d3ddev->CreateIndexBuffer(sizeof(short) * indices.size(),
									0,
									D3DFMT_INDEX16,
									D3DPOOL_MANAGED,
									&i_buffer,
									NULL);

		// lock i_buffer and load the indices into it
		i_buffer->Lock(0, 0, (void**)&pVoid, 0);
		memcpy(pVoid, indices.data(), sizeof(short) * indices.size());
		i_buffer->Unlock();

		anz_vertices = vertices.size();
		anz_triangles = indices.size() / 3;
	}
}

//andere Stelle

void render_frame(void)
{
	try
	{
		// clear the window to a deep blue
		d3ddev->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);

		d3ddev->BeginScene();    // begins the 3D scene

		// select which vertex format we are using
		d3ddev->SetFVF(CUSTOMFVF);

		for(int i = 0; i < 64; i++)
		{
			for(int j = 0; j < 16; j++)
			{
				for(int k = 0; k < 64; k++)
				{
					Chunk* chunk = &welt->chunks[i][j][k];

					if(chunk->render)
					{
						// select the vertex buffer to display
						d3ddev->SetStreamSource(0, chunk->v_buffer, 0, sizeof(CUSTOMVERTEX));
						d3ddev->SetIndices(chunk->i_buffer);

						// set the texture
						d3ddev->SetTexture(0, texture);

							// SET UP THE PIPELINE

							D3DXMATRIX matView;    // the view transform matrix

							D3DXMatrixLookAtLH(&matView,
												&camera.cam_pos,	// the camera position
												&camera.look_at,	// the look-at position
												&camera.up_dir);	// the up direction

							d3ddev->SetTransform(D3DTS_VIEW, &matView);    // set the view transform to matView

							D3DXMATRIX matProjection;     // the projection transform matrix

							D3DXMatrixPerspectiveFovLH(&matProjection,
														D3DXToRadian(45),    // the horizontal field of view
														(FLOAT)SCREEN_WIDTH / (FLOAT)SCREEN_HEIGHT, // aspect ratio
														NEAR_PLANE,    // the near view-plane
														FAR_PLANE);    // the far view-plane

							d3ddev->SetTransform(D3DTS_PROJECTION, &matProjection);    // set the projection

						// copy the vertex buffer to the back buffer
						d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, chunk->anz_vertices, 0, chunk->anz_triangles);
					}
				}
			}
		}

		d3ddev->EndScene();    // ends the 3D scene

		d3ddev->Present(NULL, NULL, NULL, NULL);   // displays the created frame on the screen
	}
	catch(...)
	{
		MessageBox(hWnd, L"Unbekannter Fehler", L"Fehler bei render_frame", MB_OK);
	}
}

Könnt ihr mir helfen?

Jegliche Optimierungen sind erwünscht.

EDIT:

70.000 Beitag in Spiele-/Grafikprogrammierung

[knivil]

void* pVoid;    // a void pointer

[TyRoXx]

operator + so zu überladen ist eine ganz schlechte Idee. Ganz schlecht. Sehr verwirrend.
Außerdem ist der Operator zum Zusammenführen von vector en furchtbar ineffizient, weil er jedes Mal Speicher anfordert und umkopiert.

Ausnahmen sind nicht grundlos von std::exception abgeleitet und haben eine what() -Methode für eine kurze Fehlerbeschreibung. Ganz abgesehen davon, dass ich da nichts sehe, das werfen könnte (außer bad_alloc , aber das will man auch gar nicht fangen). Lass das catch weg, der Debugger kann dir viel besser zeigen, was passiert ist.

catch(...)
    {
        MessageBox(hWnd, L"Unbekannter Fehler", L"Fehler bei render_frame", MB_OK);
    }

[Die erinnerung]

@knivil:

Das habe ich so aus einem DirectX-Tutorial.

@TyRoXx:

Genau deshlab bin ich hier. Wie kann ich das effiktiver machen?

[knivil]

Schon mal 'nen Profiler benutzt?

[Die erinnerung]

Nein!

Profiler kenn ich (noch) nicht!

[cooky451]

Das wird knapp mit der Woche.

[TyRoXx]

Ein Anfang:

for(int i = 0; i < 64; i++)
        {
            for(int j = 0; j < 16; j++)
            {
                for(int k = 0; k < 64; k++)
                {
                    Chunk* chunk = &chunks[i][j][k];

                    chunk->get_Vertices();

                    //vertices = chunk->vertices + vertices;
					vertices.insert(vertices.end(), chunk->vertices.begin(), chunk->vertices.end());

                    //indices = indices + (short)chunk->indices.size();
					add_to_each_element(indices, static_cast<short>(chunk->indices.size()));

                    //indices = indices + chunk->indices;
					indices.insert(indices.end(), chunk->indices.begin(), chunk->indices.end());
                }
            }
        }

Wie viele Vertex Buffer sind das denn bei der zweiten Version bzw. wie viele Chunks?

Ich finde die Ausschnitte zu unübersichtlich, um qualifizierte Einschätzungen bzgl. der Performance abzugeben. Stell das ganze Projekt doch bei Github oder so rein, dann kann jeder selbst herumprobieren und effektiv die Probleme suchen.
Das Projekt ist sicher spannend, aber als Anfänger übernimmst du dich ein wenig, fürchte ich. Und wenn das ganze auf deiner Festplatte rumliegt, kann dir kaum jemand helfen.

[rapso]

wenn version 1 schnell rendert, version 2 schnell updated, dann mach eine version dazwischen, die relativ schnell rendert und relativ schnell updated.

ach ja, normalerweise sollte man einen profiler benutzen, vielleicht reicht irgendwo schon ein 'reserve' und das problem ist geloest, aber ohne profiler sind solche dinge nur auf gut glueck rauszufinden.

ein profiler den du versuchen koenntest waere codeanalyst von amd (ja der funzt auch auf intel cpus).

[hustbaer]

knivil schrieb:

void* pVoid;    // a void pointer

void* pVoid;    // a void pointer // a comment

[rapso]

hustbaer schrieb:

knivil schrieb:

void* pVoid;    // a void pointer

void* pVoid;    // a void pointer // a comment

// trollt

[Die erinnerung]

Es sind 64 * 16 * 64 (= 65 536) Chunks. Aber ich lasse nur die Rendern, bei denen auch was drin ist und troztdem müsste die FPS immernoch bei min. 30 liegen, wenn alles gerendert werden muss.

Und beide Versionen zusammen schweißen, geht nicht! Leiß einfach mal, was die Versionen für anätze haben. Ich kann nicht alle Chunks rendern und doch alle zusammenfügen.

@hustbaer, knivil und rapso:

Wäre doch irgendwie komisch, wenns ein int -Pointer wäre, oder?

[TyRoXx]

Die erinnerung schrieb:

Und beide Versionen zusammen schweißen, geht nicht! Leiß einfach mal, was die Versionen für anätze haben. Ich kann nicht alle Chunks rendern und doch alle zusammenfügen.

Natürlich geht das. Du könntest mehrere Chunks in einem Vertex Buffer zusammenfassen.

[Die erinnerung]

Das wäre eine Idee. Ich probiere jetzt aber erst das andere aus.

EDIT: Wie viele Chunks sollte ich zusammen fassen?

[rapso]

Die erinnerung schrieb:

Und beide Versionen zusammen schweißen, geht nicht! Leiß einfach mal, was die Versionen für anätze haben. Ich kann nicht alle Chunks rendern und doch alle zusammenfügen.

erstmal nachdenken, dann posten, wirkt sonst so nach dunning kruger

@hustbaer, knivil und rapso:

Wäre doch irgendwie komisch, wenns ein int -Pointer wäre, oder?

ich hoffe du es ist nur dein humor der da spricht und du hast ein dazulernfaehiges wesen. es ist nicht schlim fehler zu machen, es ist nur schlim sie nochmal zu machen.

Die erinnerung schrieb:

Das wäre eine Idee. Ich probiere jetzt aber erst das andere aus.

EDIT: Wie viele Chunks sollte ich zusammen fassen?

so dass es am besten laeuft -> konfigurierbar machen und konfigurationen durchtesten bis du die beste findest. ansonsten erwarte von jedem eine andere lottozahl, da niemand ausser dir feststellen kann, welcher wert am schnellsten laeuft.

[Die erinnerung]

Ok ich probiere es dann mal

Und kann mir jemand beim optimieren vom Code in den einzelnen Chunks zum erzeugen der Vertices helfen?

[hustbaer]

Die erinnerung schrieb:

@hustbaer, knivil und rapso:

Wäre doch irgendwie komisch, wenns ein int -Pointer wäre, oder?

Wäre aber viel kuhler wenn er einen sprechenden Namen hätte. vertexBufferData oder lockedVertices oder irgendsowas.

Und ein Kommentar, wo drin steht dass ein void-Pointer ein void-Pointer ist, ist wirklich komplett sinnfrei.

Weitere Verbesserungsvorschläge (ich hab mir mal nur das eine Beispiel rausgegriffen):

// Iteration 1: bessere Namen + Scope für den Zeiger:

	{
		void* lockedVertices = 0;
		vertexBuffer->Lock(0, 0, &lockedVertices, 0); 
		memcpy(lockedVertices, vertices.data(), sizeof(CUSTOMVERTEX) * vertices.size()); 
		vertexBuffer->Unlock();
	}

	// Iteration 2: Auslagern von Lock/Unlock in eine Helperklasse (die dann Fehlercodes prüft,
	//     ggf. Exceptions wirft oder read()/write() in NOPs verwandelt wenn was schief gegangen ist - je nachdem was mehr Sinn macht)

	{
		VertexBufferLock vbl(vertexBuffer, D3DLOCK_DISCARD);
		vbl.write(0, vertices.data(), sizeof(CUSTOMVERTEX) * vertices.size());
	}

	// Iteration 3: Auslagern in eine Helper-Funktion

	UpdateVertexBuffer(vertexBuffer, vertices);

Iteration 4 wäre dann CreateVertexBuffer + UpdateVertexBuffer in eine eigene Hilfsfunktion rauszuziehen.

uswusf.

[Die erinnerung]

Das macht den Code doch nicht schneller. Eher langsamer! (Ich bin mir sicher, aber nicht 100%)

[nachtfeuer]

Schreibs in Assembler, nimm SSE und versuchs auf Integerbasis umzusetzen, mach mach Loopunrolling, vermeide zuviele If-Vergleiche, switches und Jumps, achte auf Registerabhängigkeiten und Datenalignement, benutze Cacheperformance, such dir einen anderen Algorithmus, mehr Parallelität...

hm...unterhalte ich mich jetzt schon mit compilern?...ach egal

[hustbaer]

Die erinnerung schrieb:

Das macht den Code doch nicht schneller. Eher langsamer! (Ich bin mir sicher, aber nicht 100%)

Naja... es gibt schon Fälle wo was dadurch schneller wird, aber eher wird es minimal langsamer oder bleibt gleich.

Darum geht's aber nicht.

Es macht nämlich dich beim Programmieren schneller. Das Programm übersichtlicher. Einfach alles besser.