bradbobak

 Hi. I'm having a problem getting glDrawElements working right with a vbo and index buffer.

 

 Heres the render code: (error checking omitted for brevity).

 

// ... load shaders and program
 
GLfloat verts[] = ( 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0 };
GLushort idx[] = ( 0, 1, 2 };
 
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
GLuint v1, v2;
glGenBuffers(1, &v1);
glBindBuffer(GL_ARRAY_BUFFER, v1);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 9, verts, GL_STATIC_DRAW);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 3, 0);
glEnableVertexAttribArray(1);
 
glGenBuffers(1, &v2);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, v2);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort) * 3, idx, GL_STATIC_DRAW);
 
glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, 0);
 
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
glDisableVertexAttribArray(1);
glDeleteBuffers(1, &v1);
glDeleteBuffers(1, &v2);

 

Vertex shader:

#version 330
 
layout (location = 1) in vec3 position;
 
uniform mat4 from_identity = mat4(1.0); // identity for now, this will change
 
void main()
{
  gl_Position = from_identity * vec4(position, 0);
}

 

Frag shader:

#version 330
 
void main()
{
  gl_FragColor = vec4(0.5, 1, 0, 0.5);
}

 

 This renders nothing.

 

 If I change the vertex shader to "gl_Position = gl_Vertex;" and draw the triangle with the old stuff (glBegin(GL_TRIANGLES); ...; glEnd();) it draws fine.

 

 Any suggestions?

 

 

 

 

 

 

I've used the code from nehe's lesson2 to build a simple app that demonstrates the problem I'm having.
The code is original, except I've removed the gluPerspective line, made it non-fullscreen and changed the drawGLScene() routine.

Here is the new drawGLScene() :

int drawGLScene(GLvoid)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	glTranslatef(0, 0.0f, -0.5f);
glColor3f(1, 1, 1);
	glBegin(GL_QUADS);
		glVertex3f(-0.5f, 0.5f, 0.2f);
		glVertex3f(0.5f, 0.5f, 0.2f);
		glVertex3f(0.5f, -0.5f, 0.2f);
		glVertex3f(-0.5f, -0.5f, 0.2f);
	glEnd();
glColor3f(1, 0, 0);
	glBegin(GL_QUADS);
		glVertex3f(-0.5f, 0.5f, -0.2f);
		glVertex3f(0.5f, 0.5f, -0.2f);
		glVertex3f(0.5f, -0.5f, -0.2f);
		glVertex3f(-0.5f, -0.5f, -0.2f);
	glEnd();
	if (GLWin.doubleBuffered)
	{
		glXSwapBuffers(GLWin.dpy, GLWin.win);
	}
	return True;  
}

As you can see, I'm drawing 2 rectangles at the same position, except along the z-axis.
The first is colored white, and has its vectices for z at 0.2f. The second is red, and z is at -0.2f.
For some reason, the red quad appears in front of the white one. Seeing how opengl treats the negative z axis as going into the screen, I'm trying to understand why the white quad (z at 0.2f) isn't drawn in front of the red one.

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.