Jump to content

  • Log In with Google      Sign In   
  • Create Account


texture mapping really slow


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
6 replies to this topic

#1 bradbobak   Members   -  Reputation: 906

Like
0Likes
Like

Posted 28 May 2012 - 02:33 AM

Hi, I'm working on an opengl engine and for some reason, on my system, it seems that texture mapping is horribly slow.

I'm using ubuntu 64-bit, with ati's own drivers across two monitors.

I've modified a nehe example tutorial to make it as basic as I could to illustrate my problem.

(when I disable double buffering in my main app, I can see the texture rendering line-by-line (it draws maybe 5 lines per second)).

The modified tutorial prints out
Got Doublebuffer Visual!
glX-Version 1.4
Depth 24
Congrats, you have Direct Rendering!

Possibly the problem is that I'm driving 2 different monitors with one video card, causing texture mapping to happen on the cpu side of things?

Anyhow, here is the modified tutorial (stripped down as much as I could). It takes about 30 seconds to texture map a 512x512 texture to a simple QUAD.


/*
* This code was created by Jeff Molofee '99
* (ported to Linux/GLX by Mihael Vrbanec '00)
* [edited for brevity]
* (modified by me to illustrate a test case)
*/

#include <memory.h>

#include <stdio.h>
#include <GL/glx.h>
#include <GL/gl.h>

/* stuff about our window grouped together */
typedef struct {
	Display *dpy;
	int screen;
	Window win;
	GLXContext ctx;
	XSetWindowAttributes attr;
	int x, y;
	unsigned int width, height;
	unsigned int depth;	
} GLWindow;

static int attrListDbl[] = { GLX_RGBA, GLX_DOUBLEBUFFER,
	GLX_RED_SIZE, 8,
	GLX_GREEN_SIZE, 8,
	GLX_BLUE_SIZE, 8,
	GLX_DEPTH_SIZE, 24,
	None };

GLWindow GLWin;

/* function called when our window is resized (should only happen in window mode) */
void resizeGLScene(unsigned int width, unsigned int height)
{
	glViewport(0, 0, width, height);
}

// <added by me, this is the generated texture I am rendering>
int tex;

/* general OpenGL initialization function */
int initGL(GLvoid)
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	/* we use resizeGLScene once to set up our initial perspective */
	resizeGLScene(GLWin.width, GLWin.height);
	glFlush();

// <my additions for texture mapping setup>

// initial buffer to copy to texture
int size = 512;
unsigned zeros[size * size];
memset(zeros, 0, size * size * 4);

// make a red square
int xct, yct;
for (yct = 50; yct < 100; ++yct)
  for (xct = 50; xct < 100; ++xct)
	zeros[yct * size + xct] = 0x000000ff;

glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size, size, 1,
GL_RGBA, GL_UNSIGNED_BYTE, zeros);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	return True;
}

/* Here goes our drawing code */
int drawGLScene(GLvoid)
{
printf("Drawing\n");

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
glFrustum(-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 5.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

glEnable(GL_TEXTURE_2D);

glBindTexture(GL_TEXTURE_2D, tex);
	glColor3f(0.5f, 0.5f, 1.0f);
	glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-1.0f, 1.0f, -2.0f);
glTexCoord2f(1.0f, 0.0f);
		glVertex3f(1.0f, 1.0f, -2.0f);
glTexCoord2f(1.0f, 1.0f);
		glVertex3f(1.0f, -1.0f, -2.0f);
glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -2.0f);
	glEnd();
glDisable(GL_TEXTURE_2D);
	glXSwapBuffers(GLWin.dpy, GLWin.win);
	return True;	
}

/* this function creates our window and sets it up properly */
/* FIXME: bits is currently unused */
Bool createGLWindow(char* title, int width, int height, int bits)
{
	XVisualInfo *vi;
	Colormap cmap;
	int dpyWidth, dpyHeight;
	int i;
	int glxMajorVersion, glxMinorVersion;
	Window winDummy;
	unsigned int borderDummy;

	/* set best mode to current */
	/* get a connection */
	GLWin.dpy = XOpenDisplay(0);
	GLWin.screen = DefaultScreen(GLWin.dpy);

	vi = glXChooseVisual(GLWin.dpy, GLWin.screen, attrListDbl);
	if (vi == NULL)
return 0;
	else
	{
		printf("Got Doublebuffered Visual!\n");
	}
	glXQueryVersion(GLWin.dpy, &glxMajorVersion, &glxMinorVersion);
	printf("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion);
	/* create a GLX context */
	GLWin.ctx = glXCreateContext(GLWin.dpy, vi, 0, GL_TRUE);
	/* create a color map */
	cmap = XCreateColormap(GLWin.dpy, RootWindow(GLWin.dpy, vi->screen),
		vi->visual, AllocNone);
	GLWin.attr.colormap = cmap;
	GLWin.attr.border_pixel = 0;

	{
		/* create a window in window mode*/
		GLWin.attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
			StructureNotifyMask;
		GLWin.win = XCreateWindow(GLWin.dpy, RootWindow(GLWin.dpy, vi->screen),
			0, 0, width, height, 0, vi->depth, InputOutput, vi->visual,
			CWBorderPixel | CWColormap | CWEventMask, &GLWin.attr);
		XMapRaised(GLWin.dpy, GLWin.win);
	}	  
	/* connect the glx-context to the window */
	glXMakeCurrent(GLWin.dpy, GLWin.win, GLWin.ctx);
	XGetGeometry(GLWin.dpy, GLWin.win, &winDummy, &GLWin.x, &GLWin.y,
		&GLWin.width, &GLWin.height, &borderDummy, &GLWin.depth);
	printf("Depth %d\n", GLWin.depth);
	if (glXIsDirect(GLWin.dpy, GLWin.ctx))
		printf("Congrats, you have Direct Rendering!\n");
	else
		printf("Sorry, no Direct Rendering possible!\n");
	initGL();
	return True;	
}

int main(int argc, char **argv)
{
	XEvent event;

	createGLWindow("NeHe's Color Tutorial", 640, 480, 24);

for (;;)
		drawGLScene();

return 0;
}

Any help will be appreciated.

Sponsor:

#2 WiredCat   Members   -  Reputation: 94

Like
0Likes
Like

Posted 28 May 2012 - 03:15 AM

first of all disable in every rendering instead set it after resizing window (resize gl window procedure)



glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 5.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();


rest of code seems to be fine

#3 szecs   Members   -  Reputation: 1991

Like
0Likes
Like

Posted 28 May 2012 - 03:29 AM

first of all disable in every rendering instead set it after resizing window (resize gl window procedure)


Setting projection matrices in every frame is peanuts for the GPU.
I usually do so, because there can be a lot of post processes, HUDs etc.

Things that can hurt performance:
1. No graphics driver installed. Sounds trivial, but I run into the problem. I was disappointed how slow openGL is. Then i realized something is wrong with the driver, i updated it and bam! at least 200 times faster rendering (it was really about 200).

2. You use non power-of-too textures.

3. Other stuff... Maybe for some reason, your openGL switches to "software rendering" instead of hardware rendering. Try to google that, I don't know specifics about why this can happen.

Edited by szecs, 28 May 2012 - 03:32 AM.


#4 WiredCat   Members   -  Reputation: 94

Like
-2Likes
Like

Posted 28 May 2012 - 04:08 AM

aa and one other thing with doublebuffered make sure you ste opengl window to doublebuffered i don't know how you initialize opengl window so there could be the problem

i create ogl window by this:

void __fastcall TFCOpenGL::TWORZ_GL()
{
angle  = 0;
ppp  = 0;
PIXELFORMATDESCRIPTOR pfd;
int pf;


dc = GetDC( FCOpenGL->Handle );
ZeroMemory( &pfd, sizeof( pfd));
pfd.nSize = sizeof( pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 32;  pfd.cStencilBits	= 8;
pfd.iLayerType = PFD_MAIN_PLANE;

  pf = ChoosePixelFormat(dc, &pfd);   /
  SetPixelFormat(dc, pf, &pfd);
  rc = wglCreateContext(dc);  
  wglMakeCurrent(dc,rc);  

  glInit();

   OnResize(NULL);

}


and make sure that control on what you are displaying is doublebuffered too (*TWinControl)NAME->DoubleBuffered = true; ;]

Edited by ___, 28 May 2012 - 04:23 AM.


#5 bradbobak   Members   -  Reputation: 906

Like
0Likes
Like

Posted 28 May 2012 - 06:11 AM

I'm not using windows. I'm pretty sure the opengl initialization is fine, its just texture mapping is very slow.

#6 bradbobak   Members   -  Reputation: 906

Like
0Likes
Like

Posted 28 May 2012 - 07:21 AM

Well I've uninstalled the proprietary ati drivers and went to the open source ones and everything is working fine. Thanks for the replys.

#7 Spirrwell   Members   -  Reputation: 240

Like
0Likes
Like

Posted 28 May 2012 - 07:44 AM

Well I've uninstalled the proprietary ati drivers and went to the open source ones and everything is working fine. Thanks for the replys.


A word on that, ATI drivers generally suck especially on Linux based system, and especially for OpenGL. This high resolution pack for a game uses OpenGL, and half of what was rendered when using ATI drivers, was white rectangles. The way to get it to work was go back to an old driver, 10.5 I believe. That's just in my experience anyway. I was actually doing some texture mapping on a sphere in OpenGL and it worked fine on my computer with a NVIDIA GPU, but when I went to two other computers that used ATI, I noticed a slowdown, and this is on Windows. I've just had really bad experiences with ATI, there really should be another company out there that makes GPUs




Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS