---

glcontext.cc

Go to the documentation of this file.

#include "glcontext.hh"
#include <GL/gl.h>
#include <GL/glu.h>
#include <iostream>

namespace anoid {
    namespace context {

        using namespace std;
        using namespace simple;

        void GLContext::quit(int code) {
            cout << (frames * 1000.0 / (SDL_GetTicks() - then)) << " fps" << endl;
            SDL_Quit();
            exit(code);
        }

        void GLContext::init(int width, int height, bool window) {
            const SDL_VideoInfo *info = NULL;
            int bpp = 0;
            int flags = 0;

            info = SDL_GetVideoInfo();

            if (!info) {
                cerr << "Video query failed: " << SDL_GetError() << endl;
                quit(1);
            }

            bpp = info->vfmt->BitsPerPixel;

            SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
            SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
            SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
            SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
            SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

            if (window)
                flags = SDL_SWSURFACE | SDL_OPENGL;
            else
                flags = SDL_SWSURFACE | SDL_OPENGL | SDL_FULLSCREEN;

            if (SDL_SetVideoMode(width, height, bpp, flags) == 0) {
                cerr << "Video mode set failed: " << SDL_GetError() << endl;
                quit(1);
            }

            SDL_ShowCursor(SDL_DISABLE);
            SDL_ShowCursor(SDL_ENABLE); // TODO remove this line

            // setup OpenGL
            float ratio = (float) width / (float) height;
            GLfloat LightAmbient[]= { 0.5f, 0.5f, 0.5f, 0.5f };
            GLfloat LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f };
            GLfloat LightSpecular[]= { 1.0f, 1.0f, 1.0f, 1.0f };
            GLfloat LightPosition[]= { 0.0f, -1.0f, 2.0f, 1.0f };

            glShadeModel(GL_SMOOTH);

            glCullFace(GL_BACK);
            glFrontFace(GL_CCW);
            glEnable(GL_CULL_FACE);

            glDepthFunc(GL_LEQUAL);
            glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
            glEnable(GL_DEPTH_TEST);

            glClearColor(0, 0, 0, 1.0);
            glClearDepth(1.0f);

            glViewport(0, 0, width, height);

            glMatrixMode(GL_PROJECTION);
            glLoadIdentity();

            gluPerspective(60.0, ratio, 1.0, 1024.0);
            glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5);
            glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);
            glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);
            glLightfv(GL_LIGHT1, GL_SPECULAR, LightSpecular);
            glLightfv(GL_LIGHT1, GL_POSITION, LightPosition);
            glEnable(GL_LIGHT1);
            glEnable(GL_LIGHTING);

            // Get current time
            then = SDL_GetTicks();
        }

        void GLContext::initWindow(int width, int height) {
            init(width, height, true);
        }

        void GLContext::initFullscreen(int width, int height) {
            init(width, height, false);
        }

        void GLContext::setView() { // TODO
        }

        void GLContext::loadIdentity() {
            glLoadIdentity();
        }

        void GLContext::pushMatrix() {
            glPushMatrix();
        }

        void GLContext::popMatrix() {
            glPopMatrix();
        }

        void GLContext::rotate(Matrix &rotation) {
        }

        void GLContext::scale(Vector &scale) {
            glScaled(scale.getX(), scale.getY(), scale.getZ());
        }

        void GLContext::translate(Vector &translation) {
            glTranslated(translation.getX(), translation.getY(), translation.getZ());
        }

        int GLContext::beginFigure() {
            GLint newobject = glGenLists(1);
            glNewList(newobject, GL_COMPILE);
            return newobject;
        }

        void GLContext::endFigure() {
            endDrawing();
            glEndList();
        }

        void GLContext::removeFigure(int id) { // TODO
        }

        void GLContext::endDrawing() {
            if (drawingTriangles || drawingQuads)
                glEnd();
            drawingTriangles = drawingQuads = false;
        }
        void GLContext::drawTriangle(Vector &A, Vector &B, Vector &C, Vector &normal, int a) {
            if (!drawingTriangles) {
                endDrawing();
                glBegin(GL_TRIANGLES);
                drawingTriangles = true;
            }

            glNormal3d(normal.getX(), normal.getY(), normal.getZ());
            glVertex3d(A.getX(), A.getY(), A.getZ());
            glVertex3d(B.getX(), B.getY(), B.getZ());
            glVertex3d(C.getX(), C.getY(), C.getZ());
        }

        void GLContext::drawQuad(Vector &A, Vector &B, Vector &C, Vector &D, Vector &normal, int a) {
            if (!drawingQuads) {
                endDrawing();
                glBegin(GL_QUADS);
                drawingQuads = true;
            }

            glNormal3d(normal.getX(), normal.getY(), normal.getZ());
            glVertex3d(A.getX(), A.getY(), A.getZ());
            glVertex3d(B.getX(), B.getY(), B.getZ());
            glVertex3d(C.getX(), C.getY(), C.getZ());
            glVertex3d(D.getX(), D.getY(), D.getZ());
        }

        void GLContext::drawFigure(int id) {
            glCallList(id);
        }

        Matrix GLContext::getMatrix() { // TODO
        }

        void GLContext::setMatrix(Matrix &m) { // TODO
        }

        void GLContext::swapBuffers() {
            frames++;
            SDL_GL_SwapBuffers();
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
            glTranslatef(0.0,0.0,-5.0);
            glScalef(0.001,0.001,0.001);
        }

        GLContext::~GLContext() {
            quit(0);
        }

    };
};

---

Anoid NG © Michael Westergaard, Martin Stig Stissing, Ronni Michael Laursen, and Kristian Bisgaard Lassen