doublebuffering in 16bit flimmert?

[appriv]

Ich hab probleme mit 16bit modus und doublebuffering.
Das demo2 von der scene-demo competition und auch rlyhs minilib flickern extrem im 16bit modus, während 8bit funktioniert.
Mein port von der levelone game engine flickert ebenfalls im 16bit modus (verwendet minilib).

Jemand eine idee woran das liegt?
Gibt es irgendwie eine Beschreibung von der Hardware,
also nicht bloss ne auflistung von registern?

g Alex

 

[appriv]

Mit SDL siehts auch nicht besser aus.
Wenn nach einem Flipscreen 10ms warte, dann ist der Screenupdate vorbei und das unschöne flickern ist weg.

Jemand eine idee zu diesem thema? Ist doublebuffer in 16bit buggy?

 

[systemchaos]

Liegt es vielleicht daran, dass du dein DisplaySurface nicht "säuberst" bevor du ein neues Bild aufbaust?

Bei mir hat auch alles geflickert wie wahnsinnig, jedoch nur unter 8 und 16 BPP. Unter 24 ging alles wunderbar. (Ich teste unter Windows weil unter Linux meine Karte nicht richtig erkannt wird ... 3d läuft 1a und 2d stinkt zum himmel. Macht dem Code ja nix *g ... aßer "system("PAUSE");" vielleicht ... aber das bekommst du schon hin)

Ich erkläre dir nun wie der Code unten funktioniert. Wenn du es startest (natürlich linkst/inkludest du SDL) funktioniert alles wunderbar. Dann kannst du mal die "DISPLAY_RESET" Zeile auskommentieren und den Delay auf 500ms setzen um das ganze besser sehen zu können.

Erste Einstellung: Die Box wird kleiner und größer, nichts besonderes.

Zweite Einstellung: Die Box wird kleiner und größer unzwar direkt ohne "Animation". Woran liegt das? Da der screen nicht gesäubert wurde sind die größten Boxen auf Surface1 und Surface2 geblieben. Die Animation geht weiter, die Boxen werden kleiner aber es wird nix refreshd und somit bleiben die größten übrig. Nun wechselt das Surface1 mit 2 und man sieht erst die größte und dann die 2t größte die auf dem 2tem surface gemalt wurde ... ...

Ich weiß nicht ob das die Lösung für dein Problem ist aber es ist das Einzige was mir einfällt, ich lerne selbst grade SDL seit keiner halben Woche *g ... aber es könnte gut möglich sein.

#include "SDL.h"
#include <stdlib.h>

int g_intFPS = 0;

Uint32 FPSTimer(Uint32 interval, void *param);

int main(int argc, char* argv[])
{

	const int SCREEN_WIDTH = 800;
	const int SCREEN_HEIGHT = 600;

	SDL_TimerID FPSTimerID = NULL;
	SDL_Surface* DisplaySurface = NULL;
	SDL_Rect rect;
	SDL_Rect disp;

	Uint32 rectColor;
	Uint32 dispColor;
	Uint8* kbarray;

	int increment = 1;
	int i;

	SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
	atexit(SDL_Quit);

	DisplaySurface = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 16, SDL_FULLSCREEN | SDL_DOUBLEBUF | SDL_HWACCEL | SDL_HWSURFACE);

	FPSTimerID = SDL_AddTimer(1000, FPSTimer, NULL);
	
	rectColor = SDL_MapRGB(DisplaySurface->format, 255, 0, 0);
	dispColor = SDL_MapRGB(DisplaySurface->format, 255, 255, 255);

	disp.x = 0;
	disp.y = 0;
	disp.w = SCREEN_WIDTH;
	disp.h = SCREEN_HEIGHT;

	rect.x = 200;
	rect.y = 150;
	rect.w = 400;
	rect.h = 300;

	do
	{
		SDL_PumpEvents();
		kbarray = SDL_GetKeyState(NULL);

		if (rect.x > 300 || rect.x < 200)
		{
			increment = increment * -1;
		}

		rect.x = rect.x + increment;
		rect.y = rect.y + increment;
		rect.w = rect.w - increment * 2;
		rect.h = rect.h - increment * 2;

		SDL_FillRect(DisplaySurface, &disp, dispColor); //DISPLAY_RESET
		SDL_FillRect(DisplaySurface, &rect, rectColor); //Neu zeichnen.
		SDL_Delay(16);
		SDL_Flip(DisplaySurface);
		/*
		Zum ansehen.

		Fehlerhaft: Kommerntiert die DISPLAY_RESET Zeile aus und setzt den
					Delay auf 500ms (um das Flackern in Zeitlupe zu sehen)

		Korrekt:	Delay auf 16ms und die DISPLAY_RESET Zeile _nicht_
					auskommentieren.
		*/
		
		g_intFPS = g_intFPS + 1;
	} while(kbarray[SDLK_ESCAPE] == 0);

	SDL_RemoveTimer(FPSTimerID);
	SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER);

	//scanf("%i", &i);
	system("PAUSE");

	SDL_Quit();
	return(0);
}

Uint32 FPSTimer(Uint32 interval, void *param)
{
	printf("FPS: %i \n\r", g_intFPS);
	g_intFPS = 0;
	return interval;
}

 

[appriv]

Danke fürn post.
So was wie dein SDL_Delay einbau hattte ich auch probiert.
Nur mit delay 10ms.
Damit bekomme ich das so halbwegs weg.
Das witzige bei der Sache ist,
das es mit der Minimal lib auch zu so einen Effekt kommt,
allerdings steht in der minimal lib auch bei 16bit modus dabei,
das es nur einen screenpointer gibt.

Nur ein Screenpointer -> kein echtes doublebuffering.

Ich portiere gerade eine komplette gameengine auf gp2x,
wenn du gerade dabei bist mit sdl und games proggen,
hättest du lust bei mir mit zu machen und dich
an ein paar example programmen austoben? schick mir ne pm.

 

[systemchaos]

Danke fürn post.
So was wie dein SDL_Delay einbau hattte ich auch probiert.
Nur mit delay 10ms. (...)

Sorry, du hast mich missverstanden. Es geht nicht um den Delay ... es geht um das Löschen des ScreenSurfaces bevor du anfängst das Bild neu aufzubauen. Der Delay sollte verändert werden um den Effekt besser zu erkennen.

Ich portiere gerade eine komplette gameengine auf gp2x,
wenn du gerade dabei bist mit sdl und games proggen,
hättest du lust bei mir mit zu machen und dich
an ein paar example programmen austoben? schick mir ne pm.

Sorry, ich bin recht arm dran als AzuBi und will mit meinem Game an etwas Geld kommen. So kommt es, dass ich inzwischen die Idee mit dem GP2x verworfen habe und SDL auch nicht mehr lerne. Bin da jetzt einmal durch und sehe, dass man da mit relativ viel Mühe wenig reißen kann.

Ich mein, eine Animation besteht für mich aus mind 5 Bildern jeweils in 8 Richtungen. Dann das ganze mal 4 Aktionen ... gehen, laufen, schießen, idle ...

Andere kleidung? Omg, das ganze nochmal. Nein, Danke.

Bin nun wieder an dem Punkt wo ich angefangen habe, Managed DirectX9. Und ich denke, dass ich dort auch bleibe denn meine Spielidee ist nun nicht mehr nur eine Idee ... es ist eine Ansammlung von Ideen über Ideen, der Hauptcharakter des Spiels ist nun zu 50% fertig und bestht aus 10.000 Polygonen, ca 4.000 Vertices. Das ist, wie gesagt, nur die Hälfte der Arbeit, nun kommen die Texturen, danach die Animationen und wenn ich das Vieh mit C# und DirectX bewegen und steuern kann, dann kann ich mit dem Rest loslegen.

Du siehst, keine Zeit für SDL und Portierungen.

Ich wünsche dir aber Viel Erfolg und hoffe das man dein Game auch einfach unter Linux zocken kann, wenn es fertig ist.

[edit] Äh, Windows. Unter Linux geht bei mir die 2D Beschleunigung nicht ^^ ...

 

[appriv]

Die 10ms drücken die fps runter,
das Auge sieht länger ein Frame, und das "Darüber" Kopieren des neuen Frames macht dann weniger Flimmer-Irritationen fürs Auge.

Momentan bin ich mit dem Output zufrieden, sagen wir mal.. ich kann damit leben.

Ein Demo werd ich bald vorstellen.

g Alex