hardware support problem (again)

Hi!

I’m learning to write simple C++/OpenGL applications.
My computer is based on AthlonXP 2500+ (Barton) and ATi Radeon 9600PRO graphic card.
When I’m running my programs CPU is busy in 65-80% !!! That means that I don’t have any hardware support.
Also I have different computer - based on AthlonXP 1700+ and nVidia GForce4MX and when I’m running my samples on that machine the CPU is busy in only (max) 20%. :confused: :confused:
What the hell is going on?
I can’t find any informations about that problem anywere (even on ATi website).
Please help
Regards

Martin
POLAND

Assuming you’ve already tried the current drivers from ATI and gone over the settings, you might also want to try: http://www.omegadrivers.net/
…but I don’t know if it’ll help any. I’ve used their driver with an older Radeon - it worked fine, but in my case I didn’t see any noticable improvement.

Have you narrowed down what code makes it go out to the system?

Well… this is my simple program (sorry for polish comments in code):

  
#define WIN32_LEAN_AND_MEAN			#include "stdafx.h"
#include <windows.h>					// standardowy plik nag&#322;ówkowy Windows
#include <gl/glaux.h>

////// Zmienne globalne
float angle = 0.0f;						// bie&#380;&#261;cy k&#261;t obrotu
HDC g_HDC;								// globalny kontekst urz&#261;dzenia
bool fullScreen = false;				// true = tryb pe&#322;noekranowy; false = tryb okienkowy
				

////// Zmienne o&#347;wietlenia
//float ambientLight[] = { 0.3f, 0.5f, 0.8f, 1.0f };	// &#347;wiat&#322;o otoczenia
float ambientLight[] = { 0.5f, 0.5f, 0.5f, 1.0f };
float diffuseLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };	// &#347;wiat&#322;o rozproszone
float lightPosition[] = { 0.0f, -1.0f, 0.0f, 0.0f };	// po&#322;o&#380;enie &#378;ród&#322;a &#347;wiat&#322;a

////// Zmienne materia&#322;u
//float matAmbient[] = { 1.0f, 0.0f, 0.0f, 1.0f };
//float matDiff[] = { 1.0f, 1.0f, 1.0f, 1.0f};

// Inicjuje
// opis: inicjuje OpenGL
void Initialize()
{
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		// czarny kolor t&#322;a

	glShadeModel(GL_SMOOTH);					// cieniowanie g&#322;adkie
	glEnable(GL_DEPTH_TEST);					// w&#322;&#261;cza bufor g&#322;&#281;bi
	glEnable(GL_CULL_FACE);						// ukrywanie tylnych stron wielok&#261;tów
	glFrontFace(GL_CCW);						// czyli o porz&#261;dku wierzcho&#322;ków przeciwnym 
                                                                        // do kierunku ruchu wskazówek zegara

	glEnable(GL_LIGHTING);						// w&#322;&#261;cza o&#347;wietlenie

	// konfiguruje w&#322;a&#347;ciwo&#347;ci materia&#322;u dla &#378;ród&#322;a LIGHT0
	//glMaterialfv(GL_FRONT, GL_AMBIENT, matAmbient);
	//glMaterialfv(GL_FRONT, GL_DIFFUSE, matDiff);

	// konfiguruje &#378;ród&#322;o &#347;wiat&#322;a GL_LIGHT0
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);		// sk&#322;adowa otoczenia
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);		// sk&#322;adowa rozproszona
	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);	// po&#322;o&#380;enie &#378;ród&#322;a &#347;wiat&#322;a

	// w&#322;&#261;cza &#378;ród&#322;o &#347;wiat&#322;a
	glEnable(GL_LIGHT0);
}

// DrawCube
// opis: rysuje sze&#347;cian na podanej pozycji
//		 w bie&#380;&#261;cym uk&#322;adzie wspó&#322;rz&#281;dnych
void DrawCube(float xPos, float yPos, float zPos)
{
	glPushMatrix();
		glScalef(1.5f, 1.0f, 0.5f);
		glTranslatef(xPos, yPos, zPos);
		glBegin(GL_POLYGON);
			glNormal3f(0.0f, 1.0f, 0.0f);	// górna &#347;ciana
			glVertex3f(0.5f, 0.5f, 0.5f);	
			glVertex3f(0.5f, 0.5f, -0.5f);
			glVertex3f(-0.5f, 0.5f, -0.5f);
			glVertex3f(-0.5f, 0.5f, 0.5f);
		glEnd();
		glBegin(GL_POLYGON);
			glNormal3f(0.0f, 0.0f, 1.0f);	// przednia &#347;ciana
			glVertex3f(0.5f, 0.5f, 0.5f);	
			glVertex3f(-0.5f, 0.5f, 0.5f);
			glVertex3f(-0.5f, -0.5f, 0.5f);
			glVertex3f(0.5f, -0.5f, 0.5f);
		glEnd();
		glBegin(GL_POLYGON);
			glNormal3f(1.0f, 0.0f, 0.0f);	// prawa &#347;ciana
			glVertex3f(0.5f, 0.5f, 0.5f);	
			glVertex3f(0.5f, -0.5f, 0.5f);
			glVertex3f(0.5f, -0.5f, -0.5f);
			glVertex3f(0.5f, 0.5f, -0.5f);
		glEnd();
		glBegin(GL_POLYGON);
			glNormal3f(-1.0f, 0.0f, 0.0f);	// lewa &#347;ciana
			glVertex3f(-0.5f, 0.5f, 0.5f);	
			glVertex3f(-0.5f, 0.5f, -0.5f);
			glVertex3f(-0.5f, -0.5f, -0.5f);
			glVertex3f(-0.5f, -0.5f, 0.5f);
		glEnd();
		glBegin(GL_POLYGON);
			glNormal3f(0.0f, -1.0f, 0.0f);	// dolna &#347;ciana
			glVertex3f(-0.5f, -0.5f, 0.5f);
			glVertex3f(-0.5f, -0.5f, -0.5f);
			glVertex3f(0.5f, -0.5f, -0.5f);
			glVertex3f(0.5f, -0.5f, 0.5f);	
		glEnd();
		glBegin(GL_POLYGON);
			glNormal3f(0.0f, 0.0f, -1.0f);	// tylna &#347;ciana
			glVertex3f(0.5f, -0.5f, -0.5f);
			glVertex3f(-0.5f, -0.5f, -0.5f);
			glVertex3f(-0.5f, 0.5f, -0.5f);
			glVertex3f(0.5f, 0.5f, -0.5f);	
		glEnd();
	glPopMatrix();
}


// Render
// opis: rysuje scen&#281;
void Render()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		// opró&#380;nia bufory ekranu i g&#322;&#281;bi
	glLoadIdentity();										// resetuje macierz modelowania

	angle = angle + 0.1f;					// zwi&#281;ksza licznik k&#261;ta obrotu
	if (angle >= 360.0f)					
		angle = 0.0f;

	glTranslatef(0.0f, 0.0f, -3.0f);		// wykonuje przekszta&#322;cenia
	glRotatef(angle, 1.0f, 0.0f, 0.0f);
	glRotatef(angle, 0.0f, 1.0f, 0.0f);
	glRotatef(angle, 0.0f, 0.0f, 1.0f);

	float matAmbient[]={1.0f, 0.0f, 0.0f, 1.0f};
	float matDiff[]={0.35f, 0.35f, 0.35f, 1.0f};
	glMaterialfv(GL_FRONT, GL_AMBIENT, matAmbient);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, matDiff);
	DrawCube(0.0f, 0.0f, -1.0f);				// rysuje sze&#347;cian

	float matAmbient1[]={0.0f, 1.0f, 1.0f, 1.0f};
	float matDiff1[]={1.0f, 1.0f, 1.0f, 1.0f};
	glMaterialfv(GL_FRONT, GL_AMBIENT, matAmbient1);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, matDiff1);
	auxSolidSphere(0.5);

	glFlush();

	SwapBuffers(g_HDC);			// prze&#322;&#261;cza bufory
}

// funkcja okre&#347;laj&#261;ca format pikseli
void SetupPixelFormat(HDC hDC)
{
	int nPixelFormat;					// indeks formatu pikseli

	static PIXELFORMATDESCRIPTOR pfd = {
		sizeof(PIXELFORMATDESCRIPTOR),	// rozmiar struktury
		1,								// domy&#347;lna wersja
		PFD_DRAW_TO_WINDOW |			// grafika w oknie
		PFD_SUPPORT_OPENGL |			// grafika OpenGL 
		PFD_DOUBLEBUFFER,				// podwójne buforowanie
		PFD_TYPE_RGBA,					// tryb kolorów RGBA 
		32,								// 32-bitowy opis kolorów
		0, 0, 0, 0, 0, 0,				// nie specyfikuje bitów kolorów
		0,								// bez buforu alfa
		0,								// nie specyfikuje bitu przesuni&#281;cia
		0,								// bez bufora akumulacji
		0, 0, 0, 0,						// ignoruje bity akumulacji
		16,								// 16-bit bufor z
		0,								// bez bufora powielania
		0,								// bez buforów pomocniczych
		PFD_MAIN_PLANE,					// g&#322;ówna p&#322;aszczyzna rysowania
		0,								// zarezerwowane
		0, 0, 0 };						// ignoruje maski warstw

	nPixelFormat = ChoosePixelFormat(hDC, &pfd);	// wybiera najbardziej zgodny format pikseli 

	SetPixelFormat(hDC, nPixelFormat, &pfd);		// okre&#347;la format pikseli dla danego kontekstu urz&#261;dzenia
}

// procedura okienkowa
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	static HGLRC hRC;					// kontekst tworzenia grafiki
	static HDC hDC;						// kontekst urz&#261;dzenia
	int width, height;					// szeroko&#347;&#263; i wysoko&#347;&#263; okna

	switch(message)
	{
		case WM_CREATE:					// okno jest tworzone

			hDC = GetDC(hwnd);			// pobiera kontekst urz&#261;dzenia dla okna
			g_HDC = hDC;
			SetupPixelFormat(hDC);		// wywo&#322;uje funkcj&#281; okre&#347;laj&#261;c&#261; format pikseli

         // tworzy kontekst tworzenia grafiki i czyni go bie&#380;&#261;cym
			hRC = wglCreateContext(hDC);
			wglMakeCurrent(hDC, hRC);

			return 0;
			break;

		case WM_CLOSE:					// windows is closing

			// deselect rendering context and delete it
			wglMakeCurrent(hDC, NULL);
			wglDeleteContext(hRC);

			// send WM_QUIT to message queue
			PostQuitMessage(0);

			return 0;
			break;

		case WM_SIZE:
			height = HIWORD(lParam);		// retrieve width and height
			width = LOWORD(lParam);

			if (height==0)					// unika dzielenie przez 0
			{
				height=1;					
			}

			glViewport(0, 0, width, height);		// nadaje nowe wymiary oknu OpenGL
			glMatrixMode(GL_PROJECTION);			// wybiera macierz rzutowania
			glLoadIdentity();						// resetuje macierz rzutowania

			// wyznacza proporcje obrazu
			gluPerspective(54.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f);

			glMatrixMode(GL_MODELVIEW);				// wybiera macierz modelowania
			glLoadIdentity();						// resetuje macierz modelowania

			return 0;
			break;

		default:
			break;
	}

	return (DefWindowProc(hwnd, message, wParam, lParam));
}

// punkt, w którym rozpoczyna si&#281; wykonywanie aplikacji
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASSEX windowClass;		// klasa okna
	HWND	   hwnd;			// uchwyt okna
	MSG		   msg;				// komunikat
	bool	   done;			// znacznik zako&#324;czenia aplikacji
	DWORD	   dwExStyle;						// rozszerzony styl okna
	DWORD	   dwStyle;						// styl okna
	RECT	   windowRect;

	// zmienne pomocnicze
	int width = 800;
	int height = 600;
	int bits = 32;

	//fullScreen = TRUE;

	windowRect.left=(long)0;						// struktura okre&#347;laj&#261;ca rozmiary okna
	windowRect.right=(long)width;						
	windowRect.top=(long)0;							
	windowRect.bottom=(long)height;						

	// definicja klasy okna
	windowClass.cbSize			= sizeof(WNDCLASSEX);
	windowClass.style			= CS_HREDRAW | CS_VREDRAW;
	windowClass.lpfnWndProc		= WndProc;
	windowClass.cbClsExtra		= 0;
	windowClass.cbWndExtra		= 0;
	windowClass.hInstance		= hInstance;
	windowClass.hIcon			= LoadIcon(NULL, IDI_APPLICATION);	// domy&#347;lna ikona
	windowClass.hCursor			= LoadCursor(NULL, IDC_ARROW);		// domy&#347;lny kursor
	windowClass.hbrBackground	= NULL;								// bez t&#322;a
	windowClass.lpszMenuName	= NULL;								// bez menu
	windowClass.lpszClassName	= "MojaKlasa";
	windowClass.hIconSm			= LoadIcon(NULL, IDI_WINLOGO);		// logo Windows

	// rejestruje klas&#281; okna
	if (!RegisterClassEx(&windowClass))
		return 0;

	if (fullScreen)								// tryb pe&#322;noekranowy?
	{
		DEVMODE dmScreenSettings;					// tryb urz&#261;dzenia
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
		dmScreenSettings.dmSize = sizeof(dmScreenSettings);	
		dmScreenSettings.dmPelsWidth = width;			// szeroko&#347;&#263; ekranu
		dmScreenSettings.dmPelsHeight = height;			// wysoko&#347;&#263; ekranu
		dmScreenSettings.dmBitsPerPel = bits;				// bitów na piksel
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

		// 
		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		{
			// prze&#322;&#261;czenie trybu nie powiod&#322;o si&#281;, z powrotem tryb okienkowy
			MessageBox(NULL, "Prze&#322;&#261;czenie trybu wyswietlania nie powiod&#322;o si&#281;", NULL, MB_OK);
			fullScreen=FALSE;	
		}
	}

	if (fullScreen)								// tryb pe&#322;noekranowy?
	{
		dwExStyle=WS_EX_APPWINDOW;					// rozszerzony styl okna
		dwStyle=WS_POPUP;						// styl okna
		ShowCursor(FALSE);						// ukrywa kursor myszy
	}
	else
	{
		dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;			// definicja klasy okna
		dwStyle=WS_OVERLAPPEDWINDOW;					// styl okna
	}

	AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);		// koryguje rozmiar okna

	// tworzy okno
	hwnd = CreateWindowEx(NULL,									// styl rozszerzony
						  "MojaKlasa",			// nazwa klasy							// class name
						  "Marcin Pilaczy&#324;ski-proste o&#347;wietlenie-OpenGL",		// app name
						  dwStyle | WS_CLIPCHILDREN |
						  WS_CLIPSIBLINGS,
						  0, 0,								// wspó&#322;rz&#281;dne x,y
						  windowRect.right - windowRect.left,
						  windowRect.bottom - windowRect.top, // szeroko&#347;&#263;, wysoko&#347;&#263;
						  NULL,									// uchwyt okna nadrz&#281;dnego
						  NULL,									// uchwyt menu
						  hInstance,							// instancja aplikacji
						  NULL);								// no extra params

	// sprawdza, czy utworzenie okna nie powiod&#322;o si&#281; (wtedy warto&#347;&#263; hwnd równa NULL)
	if (!hwnd)
		return 0;

	ShowWindow(hwnd, SW_SHOW);			// wy&#347;wietla okno
	UpdateWindow(hwnd);					// aktualizuje okno

	done = false;						// inicjuje zmienn&#261; warunku p&#281;tli
	Initialize();						// inicjuje OpenGL

	// p&#281;tla przetwarzania komunikatów
	while (!done)
	{
		PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);

		if (msg.message == WM_QUIT)		// aplikacja otrzyma&#322;a komunikat WM_QUIT?
		{
			done = true;				// je&#347;li tak, to ko&#324;czy dzia&#322;anie
		}
		else
		{
			Render();

			TranslateMessage(&msg);		// t&#322;umaczy komunikat i wysy&#322;a do systemu
				DispatchMessage(&msg);
		}
	}

	if (fullScreen)
	{
		ChangeDisplaySettings(NULL,0);					// przywraca pulpit
		ShowCursor(TRUE);						// i wska&#378;nik myszy
	}

	return msg.wParam;
}

Originally posted by <Martin>:
When I’m running my programs CPU is busy in 65-80% !!! That means that I don’t have any hardware support.

I dont think so. Software rendering usally requires 100% CPU time. My guess is that on one system v-sync is enabled while it’s not on the other machine.

Using the CPU load to determine the efficiency of an OpenGL implementation isnt a good idea anyway because an implementation may already pre-render the next frame and/or use tripple buffering and so forth…

And if you find your lighting looks weird, that is because you use glScale and didn’t set glEnable(GL_NORMALIZE).
For a cube you could use one GL_QUADS primitive with all six sides instead of six individual GL_POLYGON.

OK - thanks for information.
Regards