PDA

View Full Version : hardware support problem (again)



08-04-2004, 05:29 AM
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

hotte
08-04-2004, 06:05 AM
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?

08-04-2004, 06:16 AM
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&amp;#322;ówkowy Windows
#include <gl/glaux.h>

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


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

////// Zmienne materia&amp;#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&amp;#322;a

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

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

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

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

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

// DrawCube
// opis: rysuje sze&amp;#347;cian na podanej pozycji
// w bie&amp;#380;&amp;#261;cym uk&amp;#322;adzie wspó&amp;#322;rz&amp;#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 &amp;#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 &amp;#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 &amp;#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 &amp;#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 &amp;#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 &amp;#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&amp;#281;
void Render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // opró&amp;#380;nia bufory ekranu i g&amp;#322;&amp;#281;bi
glLoadIdentity(); // resetuje macierz modelowania

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

glTranslatef(0.0f, 0.0f, -3.0f); // wykonuje przekszta&amp;#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&amp;#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&amp;#322;&amp;#261;cza bufory
}

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

static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), // rozmiar struktury
1, // domy&amp;#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&amp;#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&amp;#322;ówna p&amp;#322;aszczyzna rysowania
0, // zarezerwowane
0, 0, 0 }; // ignoruje maski warstw

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

SetPixelFormat(hDC, nPixelFormat, &amp;pfd); // okre&amp;#347;la format pikseli dla danego kontekstu urz&amp;#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&amp;#261;dzenia
int width, height; // szeroko&amp;#347;&amp;#263; i wysoko&amp;#347;&amp;#263; okna

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

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

// tworzy kontekst tworzenia grafiki i czyni go bie&amp;#380;&amp;#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&amp;#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&amp;#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&amp;#347;laj&amp;#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&amp;#347;lna ikona
windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); // domy&amp;#347;lny kursor
windowClass.hbrBackground = NULL; // bez t&amp;#322;a
windowClass.lpszMenuName = NULL; // bez menu
windowClass.lpszClassName = "MojaKlasa";
windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO); // logo Windows

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

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

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

if (fullScreen) // tryb pe&amp;#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(&amp;windowRect, dwStyle, FALSE, dwExStyle); // koryguje rozmiar okna

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

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

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

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

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

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

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

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

return msg.wParam;
}

08-04-2004, 09:34 AM
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...

Relic
08-04-2004, 10:10 PM
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.

08-04-2004, 10:45 PM
OK - thanks for information.
Regards