# HG changeset patch
# User Sam Lantinga <slouken@libsdl.org>
# Date 1077041809 0
# Node ID 7b255f0290da3284a685fbbbedc7d93fe8a727f4
# Parent  f9a5fbcdf86817cd2c029494552116e140efb049
Added a test program for dynamically loading OpenGL

diff -r f9a5fbcdf868 -r 7b255f0290da test/Makefile.am
--- a/test/Makefile.am	Tue Feb 17 18:01:39 2004 +0000
+++ b/test/Makefile.am	Tue Feb 17 18:16:49 2004 +0000
@@ -4,7 +4,7 @@
 	testver testtypes testcpuinfo testhread testlock testerror testsem testtimer \
 	loopwave testcdrom testkeys testvidinfo checkkeys testwin graywin \
 	testsprite testbitmap testalpha testgamma testpalette testwm \
-	threadwin testoverlay testoverlay2 testgl testjoystick
+	threadwin testoverlay testoverlay2 testgl testdyngl testjoystick
 
 testalpha_SOURCES = testalpha.c
 testalpha_LDADD = @MATHLIB@
diff -r f9a5fbcdf868 -r 7b255f0290da test/testdyngl.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/testdyngl.c	Tue Feb 17 18:16:49 2004 +0000
@@ -0,0 +1,196 @@
+/*
+ * Small SDL example to demonstrate dynamically loading 
+ * OpenGL lib and functions
+ *
+ * (FYI it was supposed to look like snow in the wind or something...)
+ *
+ * Compile with :
+ * gcc testdyngl.c `sdl-config --libs --cflags` -o testdyngl
+ *
+ * You can specify a different OpenGL lib on the command line, i.e. :
+ * ./testdyngl  /usr/X11R6/lib/libGL.so.1.2
+ * or
+ * ./testdyngl  /usr/lib/libGL.so.1.0.4496
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "SDL.h"
+
+#ifdef HAVE_OPENGL
+
+#include "SDL_opengl.h"
+
+void* get_funcaddr(const char* p)
+{
+	void* f=SDL_GL_GetProcAddress(p);
+	if (f)
+	{
+		return f;
+	}
+	else
+	{
+		printf("Unable to get function pointer for %s\n",p);
+		exit(1);
+	}
+}
+
+typedef struct
+{
+	void(*glBegin)(GLenum);
+	void(*glEnd)();
+	void(*glVertex3f)(GLfloat, GLfloat, GLfloat);
+	void(*glClearColor)(GLfloat, GLfloat, GLfloat, GLfloat);
+	void(*glClear)(GLbitfield);
+	void(*glDisable)(GLenum);
+	void(*glEnable)(GLenum);
+	void(*glColor4ub)(GLubyte,GLubyte,GLubyte,GLubyte);
+	void(*glPointSize)(GLfloat);
+	void(*glHint)(GLenum,GLenum);
+	void(*glBlendFunc)(GLenum,GLenum);
+	void(*glMatrixMode)(GLenum);
+	void(*glLoadIdentity)();
+	void(*glOrtho)(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
+	void(*glRotatef)(GLfloat,GLfloat,GLfloat,GLfloat);
+	void(*glViewport)(GLint,GLint,GLsizei,GLsizei);
+	void(*glFogf)(GLenum,GLfloat);
+}
+glfuncs;
+
+void init_glfuncs(glfuncs* f)
+{
+	f->glBegin=get_funcaddr("glBegin");
+	f->glEnd=get_funcaddr("glEnd");
+	f->glVertex3f=get_funcaddr("glVertex3f");
+	f->glClearColor=get_funcaddr("glClearColor");
+	f->glClear=get_funcaddr("glClear");
+	f->glDisable=get_funcaddr("glDisable");
+	f->glEnable=get_funcaddr("glEnable");
+	f->glColor4ub=get_funcaddr("glColor4ub");
+	f->glPointSize=get_funcaddr("glPointSize");
+	f->glHint=get_funcaddr("glHint");
+	f->glBlendFunc=get_funcaddr("glBlendFunc");
+	f->glMatrixMode=get_funcaddr("glMatrixMode");
+	f->glLoadIdentity=get_funcaddr("glLoadIdentity");
+	f->glOrtho=get_funcaddr("glOrtho");
+	f->glRotatef=get_funcaddr("glRotatef");
+	f->glViewport=get_funcaddr("glViewport");
+	f->glFogf=get_funcaddr("glFogf");
+}
+
+#define NB_PIXELS 1000
+
+int main(int argc,char *argv[])
+{
+	glfuncs f;
+	int i;
+	SDL_Event event;
+	int done=0;
+	GLfloat pixels[NB_PIXELS*3];
+	char default_gl_lib[]="/usr/lib/libGL.so";
+	char* current_gl_lib=default_gl_lib;
+	
+	if (argc==2)
+	{
+		current_gl_lib=argv[1];
+	}
+	
+	if (SDL_Init(SDL_INIT_EVERYTHING)<0)
+	{
+		printf("Unable to init SDL : %s\n",SDL_GetError());
+		exit(1);
+	}
+	
+	if (SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1)<0)
+	{
+		printf("Unable to set GL attribute : %s\n",SDL_GetError());
+		exit(1);
+	}
+	
+	if (SDL_GL_LoadLibrary(current_gl_lib)<0)
+	{
+		printf("Unable to dynamically open GL lib : %s\n",SDL_GetError());
+		exit(1);
+	}
+
+	if (SDL_SetVideoMode(640,480,0,SDL_OPENGL)==NULL)
+	{
+		printf("Unable to open video mode : %s\n",SDL_GetError());
+		exit(1);
+	}
+
+	init_glfuncs(&f);
+
+	for(i=0;i<NB_PIXELS;i++)
+	{
+		pixels[3*i]=rand()%250-125;
+		pixels[3*i+1]=rand()%250-125;
+		pixels[3*i+2]=rand()%250-125;
+	}
+	
+	f.glViewport(0,0,640,480);
+	
+	f.glMatrixMode(GL_PROJECTION);
+	f.glLoadIdentity();
+	f.glOrtho(-100,100,-100,100,-500,500);
+	
+	f.glMatrixMode(GL_MODELVIEW);
+	f.glLoadIdentity();
+	
+	f.glEnable(GL_DEPTH_TEST);
+	f.glDisable(GL_TEXTURE_2D);
+	f.glEnable(GL_BLEND);
+	f.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	
+	f.glClearColor(0.0f,0.0f,0.0f,0.0f);
+	f.glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+	
+	f.glEnable(GL_POINT_SMOOTH);
+	f.glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
+	f.glPointSize(5.0f);
+	f.glEnable(GL_FOG);
+	f.glFogf(GL_FOG_START,-500);
+	f.glFogf(GL_FOG_END,500);
+	f.glFogf(GL_FOG_DENSITY,0.005);
+	
+	do
+	{
+		f.glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+		
+		f.glRotatef(2.0,1.0,1.0,1.0);
+		f.glRotatef(1.0,0.0,1.0,1.0);
+		
+		f.glColor4ub(255,255,255,255);
+		f.glBegin(GL_POINTS);
+		for(i=0;i<NB_PIXELS;i++)
+		{
+			f.glVertex3f(pixels[3*i],pixels[3*i+1],pixels[3*i+2]);
+		}
+		f.glEnd();
+		SDL_GL_SwapBuffers();
+
+		while(SDL_PollEvent(&event))
+		{
+			if(event.type & SDL_KEYDOWN)
+				done=1;
+		}
+
+		SDL_Delay(20);
+	}
+	while(!done);
+	
+	SDL_Quit();
+	return 0;
+}
+
+#else /* HAVE_OPENGL */
+
+int main(int argc, char *argv[])
+{
+	printf("No OpenGL support on this system\n");
+	return 1;
+}
+
+#endif /* HAVE_OPENGL */