Re: Possible PyOpenGL Material/Shader/Display List Bug

Ian Mallett <[email protected]> Mon, 29 Aug 2011 21:32:56 -0600

Newsgroups	gmane.comp.python.opengl.user
Message-ID	<CAG4NV=tOOoK9MMTVd1+wuduuBfm=ZMxQNmSf2CrS21i5Bb5sjw@mail.gmail.com>

Well, I made my test, and it's not PyOpenGL :-)

Problem still occurs.  The code is mostly just a direct port of the Python
version, with a few simplifications and rearrangements as necessary.

Thanks,
Ian

------------------------------------------------------------------------------
Special Offer -- Download ArcSight Logger for FREE!
Finally, a world-class log management solution at an even better 
price-free! And you'll get a free "Love Thy Logs" t-shirt when you
download Logger. Secure your free ArcSight Logger TODAY!
http://p.sf.net/sfu/arcsisghtdev2dev

_______________________________________________
PyOpenGL Homepage
http://pyopengl.sourceforge.net
_______________________________________________
PyOpenGL-Users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/pyopengl-users

MaterialTest.cpp (text/x-c++src, 4.3 KB)

const double pi = 3.141592653589793238;
inline float radians(float angle) { return angle*((float)pi/180.0f); }
inline float degrees(float angle) { return angle*(180.0f/(float)pi); }
inline double radians(double angle) { return angle*(pi/180.0); }
inline double degrees(double angle) { return angle*(180.0/pi); }

#define GLEW_STATIC
#define NO_SDL_GLEXT
#include <GLEW/glew.h>
//#include <gl/GLUT.h>

#include <SDL.h>
#include <SDL_opengl.h>

#include <math.h>
#include <string>

int Screen[] = {800,600};

bool draw_base = false;
float camera_rotation[2] = {90,23};
float camera_radius = 8.0;

SDL_Surface* screen;
GLhandleARB program;
GLuint dl;

bool GetInput(void) {
	SDL_Event event;
	while (SDL_PollEvent(&event)) {
		switch (event.type) {
			case SDL_KEYDOWN:
				switch (event.key.keysym.sym) {
					case SDLK_ESCAPE:
						return false;
						break;
					case SDLK_d: {
						draw_base = !draw_base;
						break;
					}
				}
				break;
			case SDL_QUIT:
				return false;
				break;
			default:
				break;
		}
	}
	return true;
}
void Draw(void) {
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

	glViewport(0,0,Screen[0],Screen[1]);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45,float(Screen[0])/float(Screen[1]),0.1,20.0);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	float camerapos[3] = {
		camera_radius*cos(radians(camera_rotation[0]))*cos(radians(camera_rotation[1])),
		camera_radius*sin(radians(camera_rotation[1])),
		camera_radius*sin(radians(camera_rotation[0]))*cos(radians(camera_rotation[1]))};
	gluLookAt(camerapos[0],camerapos[1],camerapos[2], 0,0,0, 0,1,0);

	float params[4] = {0,5,0, 1};
	glLightfv(GL_LIGHT0,GL_POSITION,params);

	glUseProgramObjectARB(program);

	float params2[4] = {1,1,1, 1};
	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,  params2);
	if (draw_base) {
		glBegin(GL_QUADS);
		glNormal3f(0,1,0);
		glVertex3f(1,0,-1);
		glVertex3f(-1,0,-1);
		glVertex3f(-1,0,1);
		glVertex3f(1,0,1);
		glEnd();
	}

	glPushMatrix();
	glTranslatef(0,1,0);
	glCallList(dl);
	glPopMatrix();

	glUseProgramObjectARB(0);

	glFlush();
	SDL_GL_SwapBuffers();
}
int main(int argc, char **argv) {
	SDL_Init(SDL_INIT_EVERYTHING);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);

	screen = SDL_SetVideoMode(Screen[0],Screen[1],32,SDL_HWSURFACE|SDL_OPENGL);

	GLenum err = glewInit();
	if (err != GLEW_OK) {
		printf("GLEW extension loading failed: %s",std::string((char*)glewGetErrorString(err)).c_str());
		throw 1;
	}

	printf("Vendor: %s\n",glGetString(GL_VENDOR));
	printf("Renderer: %s\n",glGetString(GL_RENDERER));
	printf("OpenGL: %s\n",glGetString(GL_VERSION));

	glEnable(GL_LIGHTING);

	float params[4] = {0,5,0, 1};
	glLightfv(GL_LIGHT0,GL_POSITION,params);
	glEnable(GL_LIGHT0);

	dl = glGenLists(1);
	glNewList(dl,GL_COMPILE);
	float params2[4] = {1,0.1f,0.1f,1};
	glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,params2);
	glBegin(GL_QUADS);
	glNormal3f(0,1,0);
	glVertex3f(1,0,0);
	glVertex3f(2,0,0);
	glVertex3f(2,0,1);
	glVertex3f(1,0,1);
	glEnd();
	glEndList();

	program = glCreateProgramObjectARB();

	GLhandleARB vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	const char* v_source = "void main() { gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex; }";
	const GLint l_v = strlen(v_source);
	glShaderSourceARB( vert, 1, &v_source, &l_v );
	glCompileShaderARB(vert);
	glAttachObjectARB(program,vert);

	GLhandleARB frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	const char* f_source = "void main() { gl_FragData[0] = vec4(gl_FrontMaterial.diffuse.rgb,1.0); }";
	const GLint l_f = strlen(f_source);
	glShaderSourceARB( frag, 1, &f_source, &l_f );
	glCompileShaderARB(frag);
	glAttachObjectARB(program,frag);

	glValidateProgramARB(program);
	glLinkProgramARB(program);

	glDeleteObjectARB(vert);
	glDeleteObjectARB(frag);

	int errorLoglength, actualErrorLogLength; char* errorLogText;
	glGetObjectParameterivARB(program, GL_OBJECT_INFO_LOG_LENGTH_ARB, &errorLoglength);
	errorLogText = (char*)malloc(sizeof(char)*errorLoglength);
	glGetInfoLogARB(program, errorLoglength, &actualErrorLogLength, errorLogText);
	printf("%s\n",errorLogText);
	free(errorLogText);

	while (true) {
		if (GetInput()==false) break;
		Draw();
	}

	SDL_FreeSurface(screen);

	return 0;
}