Make the shaders work on NVidia

[gltest.git] / gltest.cpp

diff --git a/gltest.cpp b/gltest.cpp
index feb794fcc08948f3d386f61e21200c073a6d2003..edc17f85851036a86730db2ee3752cb4301954ed 100644 (file)
--- a/gltest.cpp
+++ b/gltest.cpp
@@ -24,20 +24,21 @@
 #include <limits.h>
 #include <unistd.h>
 #include <assert.h>
 #include <limits.h>
 #include <unistd.h>
 #include <assert.h>

-#include <GL/gl.h>

 #include <boost/program_options.hpp>
 
 namespace po = boost::program_options;
 
 #include <boost/program_options.hpp>
 
 namespace po = boost::program_options;
 

-// include proper GL connector
+// my GL utility functions and the GL window class
+#include "glutil.h"

 #include "glwindow.h"
 #include "glwindow.h"

-#if defined(USE_GLX)
+// include proper GL backend (windowing system)
+#if defined(WIN_GLX)

 #include "glxbackend.h"
 static GLBackend *createGLBackend()
 {
        return new GLXBackend();
 }
 #include "glxbackend.h"
 static GLBackend *createGLBackend()
 {
        return new GLXBackend();
 }

-#elif defined(USE_EGL)
+#elif defined(WIN_EGL)

 #include "eglbackend.h"
 static GLBackend *createGLBackend()
 {
 #include "eglbackend.h"
 static GLBackend *createGLBackend()
 {


@@ -63,24 +64,29 @@ static double getTime()
        return tp.tv_sec + 1e-9 * tp.tv_nsec;
 }
 
        return tp.tv_sec + 1e-9 * tp.tv_nsec;
 }
 

-static void rectQuad(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
-{
-       glVertex2f(x1, y1);
-       glVertex2f(x2, y1);
-       glVertex2f(x2, y2);
-       glVertex2f(x1, y2);
-}
-

 // the window
 class TearTestWindow : public GLWindow {
 public:
 // the window
 class TearTestWindow : public GLWindow {
 public:

-       TearTestWindow(bool overdraw, bool copy, int sleep_time) : GLWindow(XOpenDisplay(0), createGLBackend()),
-               overdraw(overdraw), copy(copy), sleep_time(sleep_time), boxPos(0), boxDirection(1)
+       TearTestWindow() : GLWindow(XOpenDisplay(0), createGLBackend()),
+               overdraw(false), sleep_time(0), boxPos(0), boxDirection(1)

        {}
 
        {}
 

-       void setSwapInterval(int i) {
-               getBackend()->setSwapInterval(i);
-       }
+       void setOverdraw(bool overdraw) { this->overdraw = overdraw; }
+       void setSleepTime(int sleep_time) { this->sleep_time = sleep_time; }
+
+       void setSwapInterval(int i) { getBackend()->setSwapInterval(i); }
+
+private:
+       bool overdraw;
+       int sleep_time;
+       // animation control
+       double lastFrame;
+       GLfloat boxPos, boxDirection;
+       // FPS, profiler
+       double lastDisplay, lastProfile;                 
+       int framect;
+       ProfilerState curState;
+       double stateTime[NumProfilerStates];

 
 protected:
        virtual void initGL()
 
 protected:
        virtual void initGL()


@@ -99,17 +105,9 @@ protected:
        
        virtual void resizeGL(unsigned int width, unsigned int height)
        {
        
        virtual void resizeGL(unsigned int width, unsigned int height)
        {

-               // prevent divide-by-zero
-               if (height == 0)
-                       height = 1;

                glViewport(0, 0, width, height);
                glViewport(0, 0, width, height);

-               glMatrixMode(GL_PROJECTION);
-               glLoadIdentity();
-               glOrtho (0, 1, 1, 0, 0, 1);
-               glMatrixMode(GL_MODELVIEW);
+               initialise2dProjection();

                glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
                glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

-               glClear(GL_COLOR_BUFFER_BIT);
-               glFlush();

        }
        
        void profilerTick(ProfilerState nextState)
        }
        
        void profilerTick(ProfilerState nextState)


@@ -158,34 +156,21 @@ protected:
                profilerTick(StateClear);
                if (overdraw) {
                        // clear manually
                profilerTick(StateClear);
                if (overdraw) {
                        // clear manually

-                       glBegin(GL_QUADS);
-                       glColor3f(0.0f, 0.0f, 0.0f);
-                       rectQuad(0, 0, 1, 1);
-                       glEnd();
+                       drawQuad(/*color*/0.0f, 0.0f, 0.0f, /*coordinates*/0, 0, 1, 1);

                }
                else {
                        glClear(GL_COLOR_BUFFER_BIT);
                }
                //////////////////////////////////////////////
                profilerTick(StateDraw);
                }
                else {
                        glClear(GL_COLOR_BUFFER_BIT);
                }
                //////////////////////////////////////////////
                profilerTick(StateDraw);

-               glBegin(GL_QUADS);
-               glColor3f(0.8f, 1.0f, 0.75f);
-               rectQuad(boxPos, 0, boxPos+boxWidth, 1);
-               glEnd();
+               drawQuad(/*color*/0.8f, 1.0f, 0.75f, /*coordinates*/boxPos, 0, boxPos+boxWidth, 1);

                usleep(sleep_time*1000);
                //////////////////////////////////////////////
                profilerTick(StatePresent);
                usleep(sleep_time*1000);
                //////////////////////////////////////////////
                profilerTick(StatePresent);

-               if (copy) {
-                       glDrawBuffer(GL_FRONT);
-                       glCopyPixels(0, 0, getWidth(), getHeight(), GL_COLOR);
-                       glDrawBuffer(GL_BACK);
-               }
-               else {
-                       getBackend()->swapBuffers();
-               }
+               getBackend()->swapBuffers();

                //////////////////////////////////////////////
                profilerTick(StatePostRender);
                //////////////////////////////////////////////
                profilerTick(StatePostRender);

-               glFlush();
+               glFinish();

                ++framect;
                //////////////////////////////////////////////
                profilerTick(StateOutsideRender);
                ++framect;
                //////////////////////////////////////////////
                profilerTick(StateOutsideRender);


@@ -199,18 +184,6 @@ protected:
                        default: break;
                }
        }
                        default: break;
                }
        }

-
-private:
-       bool overdraw, copy;
-       int sleep_time;
-       // animation control
-       double lastFrame;
-       GLfloat boxPos, boxDirection;
-       // FPS, profiler
-       double lastDisplay, lastProfile;                 
-       int framect;
-       ProfilerState curState;
-       double stateTime[NumProfilerStates];

 };
 
 int main(int argc, char ** argv)
 };
 
 int main(int argc, char ** argv)


@@ -220,7 +193,6 @@ int main(int argc, char ** argv)
        desc.add_options()
                ("help,h", "produce help message")
                ("swap-interval,i", po::value<int>(), "set swap interval")
        desc.add_options()
                ("help,h", "produce help message")
                ("swap-interval,i", po::value<int>(), "set swap interval")

-               ("copy,c", "copy to front buffer (instead of performing a buffer swap)")

                ("overdraw,o", "overdraw previous image (instead of calling glClear)")
                ("sleep,s", po::value<int>()->default_value(0), "Number of milliseconds to sleap in each frame (in the drawing phase)")
        ;
                ("overdraw,o", "overdraw previous image (instead of calling glClear)")
                ("sleep,s", po::value<int>()->default_value(0), "Number of milliseconds to sleap in each frame (in the drawing phase)")
        ;


@@ -234,7 +206,9 @@ int main(int argc, char ** argv)
        }
 
        // actual program
        }
 
        // actual program

-       TearTestWindow w(vm.count("overdraw"), vm.count("copy"), vm["sleep"].as<int>());
+       TearTestWindow w;
+       w.setOverdraw(vm.count("overdraw"));
+       w.setSleepTime(vm["sleep"].as<int>());

        w.open(800, 600);
        if (vm.count("swap-interval"))
                w.setSwapInterval(vm["swap-interval"].as<int>());
        w.open(800, 600);
        if (vm.count("swap-interval"))
                w.setSwapInterval(vm["swap-interval"].as<int>());