PDA

Archiv verlassen und diese Seite im Standarddesign anzeigen : Woher kann ich rausfinden ob OpenGL die Grafikkarte nutzt?


Lord Nikon
2003-11-21, 15:27:38
Hi,
auf meinem Athlon XP 1600+ mit GeForce4 Ti läuft ein Programm von mir 3x so schnell wie auf dem Schulrechner.
Der Schulrechner hat eine Matrox und einen P4 1500 Mhz. Schon wenn ich vorgebene Koordinaten die ich aus dem Vektor per Schleife auslese und dann mit glBegin(GL_POINTS) darstellen will ist der Schulrechner 3 Sekunden langsamer , während bei mir dies sofort ohne Verzögerung dargestellt wird. Wird keine Hardwarebeschleunigung in OpenGL bei Matrox Karten genutzt oder woher kommt dieser Große Unterschied ?

glBegin(GL_POINTS);
for (int i=0;i<vektor.size()-1;i++)
{
glVertex2d(vektor[i].x1,vektor[i].y1);
glVertex2d(vektor[i].x2,vektor[i].y2);
}
glEnd();

Xmas
2003-11-21, 23:43:40
GLubyte* vendor = glGetString(GL_VENDOR);

Ist der Vendor "Microsoft" oder ähnlich, wird Softwareemulation verwendet. Ansonsten ist die Karte (für diese Operation) einfach nur langsam. Es kann durchaus sein dass Dreiecke schneller sind als Lines oder Points.

Lord Nikon
2003-11-22, 11:30:57
thx für die Antwort. Points verwende ich zur Mandelbrot Darsellung , deshalb kann kann ich keine Dreiecke nehmen.
Dieser Unterschied besteht wenn ich in ein Gebilde reinzoome.Wenn ich , dass erste Mal das Bild Darstellen will , dauert das 8 Sekunden mit dem klassischen Algorithmus. Kostet es viel Zeit , wenn ich die jewahlige Zufallsfarbe (speicher den R , G und B Wert) und die Korrdinaten der imaginären Achse und der reelen Achse für jeden Schleifendurchlauf speicher ? Ansonsten wäre es gut zu wissen , wie ich die Geschwindigkeit optimieren könnte.
EDIT:
Das speichern kostet 7 Sekunden im Program

Gast
2003-11-23, 01:14:02
Die Mandelbrot Menge kann man heutzutage im Pixel Shader berechnen ;)
Aber davon ab, hab ich nicht wirklich Ahnung, wie Du vorgehst. Wofür die Punkte?
Du wirst doch nicht für jeden Pixel einen GL_POINT setzen...würde die Geschwindigkeit erklären...aber dann müßte in Deiner Schleife ja die Farbe gesetzt werden, also wohl doch nicht.
Falls doch, hör auf damit und schreib den Kram in eine Textur.

Lord Nikon
2003-11-23, 11:02:18
Original geschrieben von Gast
Wofür die Punkte?
Du wirst doch nicht für jeden Pixel einen GL_POINT setzen...würde die Geschwindigkeit erklären...aber dann müßte in Deiner Schleife ja die Farbe gesetzt werden, also wohl doch nicht.
Falls doch, hör auf damit und schreib den Kram in eine Textur.
Ähmm , ich setze für jeden Pixel einen Punkt. Die Farbe nehme ich aus Zufallswerten für R G B und speichere diese in einem Array. Kannst du näher erklären , wie ich das in eine Textur speichere?
Hier mein bisheriger Code:

void TForm1::ZeichneGrafik()
{ korr a;
const char * vendor = glGetString(GL_VENDOR);
mem->Lines->Add(vendor);
Randomize();
wglMakeCurrent(
wglGetCurrentDC(),
wglGetCurrentContext());
// Imaginär und Reele Zahlen
// Die Variable c ist nun eine konstante komplexe Zahl
//und unser z ist ebenfalls komplex
// Bei der Iteration müssen wir mit irgendeinem z anfangen
// und wir fangen am Besten mit z=0 an, z wird quadriert und c addiert
// nach den Regeln von oben. Das Ergbenis setzen wir jetzt als neues z ein
// und machen dieselbe Rechnung usw. usw., eine Iteration eben.

glMatrixMode(GL_PROJECTION); // Aktuelle Matrix setztn


glLoadIdentity();

glOrtho(-5.5,5.5,5.5,-5.5,-38.0,38.0);
// glOrtho(0,160,490,0,-38.0,38.0);
/*void glOrtho( GLdouble left,
GLdouble right,
GLdouble bottom,
GLdouble top,
GLdouble zNear,
GLdouble zFar )

*/
glClearColor(0.0f,0.0f,0.0f,0.0f);

glClear(GL_COLOR_BUFFER_BIT|
GL_DEPTH_BUFFER_BIT);
glEnable(GL_NORMALIZE);
glEnable(GL_DEPTH_TEST);

glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable( GL_POINT_SMOOTH);
glHint( GL_POINT_SMOOTH_HINT , GL_NICEST );

glDisable(GL_CULL_FACE);




double x, y; // ' Laufvariablen
double x1, y1, x2, y2; // ' Mandelbrot-Ausschnitts-Koordinaten
int depth ; // Berechnungstiefe
int d; // Laufvariable für Tiefe
double dx, dy ; // Schrittweite pro Pixel
double px, py; // aktuelle Weltkoordinate
double u, v; // Berechnungsvariablen
double ax, ay ; // Berechnungsvariablen
double r[255];
double g[255];
double b[255];
int zahler=0;

// 255 Zufallsfarben erzeugen
for ( zahler = 0;zahler<255;zahler++)
{
r[zahler]=random(11)/10.0;
g[zahler]=random(11)/10.0;
b[zahler]=random(11)/10.0;

}
// mem->Lines->SaveToFile("f:\\FARBEN.txt");
// Ausschnitt der Grafik
x1 = -2.0 ;
y1 = -1.6 ;
x2 = 1 ;
y2 = 1.6 ;
depth = 255; // maximal 255 (sonst mehr Zufallsfarben erzeugen!)
dx = (x2 - x1) /3.5 ;
dy = (y2 - y1) / 3.5 ;
// Erzeugung des Bitmap
for ( y = -5.5 ;y<=8.5;y=y+0.01) //5.5

for ( x = -5.5;x<=8.5;x=x+0.01) //-5.5
{


px = x1 + x * dx ;
py = y1 + y * dy ;
d = 0 ;
ax = 0 ;
ay = 0 ;
do
{
u = ax * ax - ay * ay + px;
v = 2 * ax * ay + py ;
ax = u ;
ay = v ;


d += 1 ;
a.rr=r[d];
a.gg=g[d];
a.bb=b[d];
a.xx=ax;
a.ii=v;
test.push_back(a);


}
while ( ((ax * ax + ay * ay )<4) && (d<depth));
}


// Fertiges Bitmap darstellen

mem->Lines->Add(test.size());
mem->Lines->Add(test.capacity());

if (rg->ItemIndex==0)
{
glBegin(GL_POINTS);
}
if (rg->ItemIndex==1)
{ Auswahl=1;
glBegin(GL_LINES);
}
for (int i=0;i<test.size()-1;i++)
{
glColor3f(test[i].rr,test[i].gg,test[i].bb);
glVertex2d(test[i].xx,test[i].ii);
glColor3f(test[i+1].rr,test[i+1].gg,test[i].bb);
glVertex2d(test[i+1].xx,test[i+1].ii);
}


glEnd();



mem->Lines->Add("Bild wird jetzt dargestellt");

glFlush();
glFinish();
SwapBuffers(wglGetCurrentDC());

Gast
2003-11-23, 14:20:16
Aha, also doch ;)
Ich hau hier einfach mal rein, was ich zu dem Thema mal verbockt hatte:

#define mandelImageWidth 250
#define mandelImageHeight 250
GLubyte mandelImage[mandelImageHeight][mandelImageWidth][3];

static GLdouble zoomFactor = 1.0;
static GLdouble zoomFactorx = 250 / mandelImageWidth;
static GLdouble zoomFactory = 250 / mandelImageHeight;
static GLint height, wwidth = 250, wheight = 250;
static GLdouble mandelSize = 2;
static double starti = -1, startr = -1.5;

void makeMandelImage()
{
double ci, cr, xi, xr, inc, crtemp;
int x, y, attract;
inc = mandelSize / mandelImageWidth;
for (y = 0; y < mandelImageHeight; ++y) for (x = 0; x < mandelImageWidth; ++x) {
mandelImage[y][x][0] = 0; mandelImage[y][x][1] = 0; mandelImage[y][x][2] = 0;
}
ci = cr = 0;
for (y = 0, xi = starti; y < mandelImageHeight; ++y, xi += inc) for (x = 0, xr = startr; x < mandelImageWidth; ++x, xr += inc) {
//printf("xi: %f\nxr: %f\n", xi, xr);
ci = cr = 0;
for (attract = 0; attract <= 1024; ++attract) {
crtemp = cr * cr - ci * ci + xi;
ci = 2 * cr * ci + xr;
cr = crtemp;
if (cr * cr + ci * ci > 4) {
//printf("attract: %i\n", attract);
if (attract <= 255) { mandelImage[y][x][0] = (GLubyte) attract; break; }
mandelImage[y][x][0] = 255;
if (attract <= 510) { mandelImage[y][x][1] = (GLubyte) attract - 255; break; }
mandelImage[y][x][1] = 255;
mandelImage[y][x][2] = attract - 510;
break;
}
}
}
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glRasterPos2i(0, 0);
glDrawPixels(mandelImageWidth, mandelImageHeight, GL_RGB,
GL_UNSIGNED_BYTE, mandelImage);
}


Meine Mandelbrotmenge war glaube um 90Grad gedreht und statt einer Textur benutze ich glDrawPixels - mit einer Textur gehts wahrscheinlich flotter, was eigentlich unlogisch ist, aber die Treiber und alles sind eben auf Texturen ausgelegt.
Aber hier ist das schon OK, auch so ist das Programm sicher schon prozessorlimitiert.
Wenn Du doch lieber eine Textur benutzen willst -> http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=06
Geht an sich genau so und dann malt man halt einen Quad bzw. zwei Dreiecke texturierterweise über den ganzen Bildschirm.

Lord Nikon
2003-11-23, 15:09:28
thx für die Mühe , die du dir gemacht hast.

Lord Nikon
2003-11-23, 16:29:11
@Gast
Wie groß hast du den Sichbereich gemacht , mit glOrtho ?

Gast
2003-11-23, 17:25:00
War keine Mühe, lag ja noch auf meiner Platte.
Wie Du den Sichtbereich setzt, ist egal, wenn Du glDrawPixels nutzt.
Wenn Du es in eine Textur zeichnest, mußt Du nur glOrtho und das Polygon gleichgroß machen.

Lord Nikon
2003-11-23, 18:00:06
Wenn ich glClearColor(1.0f,1.0f,1.0f,1.0f); setzte sehe in linke ein schwarzes Quadrat und am oberen Rand des Quadrat eine kleine Linie mit verschiedenen Farben und der Rest ist weiss
Ist das normal ?

Gast
2003-11-24, 00:22:17
Nö, glViewport richtig gesetzt?
glClear(GL_COLOR_BUFFER_BIT); auch aufgerufen?
ZBuffer aus?

Gast
2007-02-01, 22:03:35
Hi,
ich muss fürs Studium die Mandelbrotmenge auf der GPU implementieren. gibt es für die oben genannten Codes vielleicht ne visual Studio project datei?

krieg die so irgendwie nicht zum laufen...
kenn mich allerdings auuch nicht so mit opengl aus.

wäre für jede hilfe sehr dankbar.

thx

Gast
2007-02-01, 22:06:04
nachtrag: falls jemande ne andere idee hat: es sollte wirklich ein kleiner simpler code sein, der leicht zu überblicken ist...ohne zoom usw...

Coda
2007-02-02, 02:20:49
Man sollte einzelne Pixel nicht mit Points zeichnen X-D

Schau mal hier (http://www.rush3d.com/reference/opengl-bluebook-1.0/ch05.html#id5465193)

Ohje, der Thread ist ja uralt. Vergesst es...

Gast
2007-02-02, 07:38:15
Warum, was ist an Points schlecht?