renamed libpg to libbear

[physics.git] / src / graphics / graphics.cpp

/*
 *  Copyright (C) 2008 Patrik Gornicz, Gornicz_P (at) hotmail (dot) com.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "graphics.h"

#include <bear/debug.h>
#include <bear/mathw.h>
using namespace bear;

#include <GL/gl.h>
#include <GL/glu.h>
#include <SDL/SDL.h>
#include <cmath>

#include <iostream>
using std::cerr;
using std::cout;
using std::endl;


/// ***** Private Method Headers *****

void glDrawCircle(int);
void glDrawPolygon( const std::vector<Vector2>& points );
void sdlInit();
void glInit();

/// ***** Initializers/Cleaners *****

void graphics::init()
{
    sdlInit();
    glInit();
}

void graphics::clean()
{

}

/// ***** Public Methods *****

void graphics::drawCircle(float radius, const Vector2& pos, const float* color)
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(pos.m_fX, pos.m_fY, -1);
    glScalef(radius, radius, radius);

    if(color != NULL)
        glColor3fv(color);

    glDrawCircle(32);
}

void graphics::drawPolygon
(
  const std::vector<Vector2>& points,
  const float* color
)
{
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    if(color != NULL)
        glColor3fv(color);

    glDrawPolygon(points);
}

/// ***** Private Methods *****

void glDrawCircle(int pieces)
{
    glBegin(GL_POLYGON);
        for(int n = 0; n < pieces; n++)
        {
            float angle = 2 * PI * n / pieces;
            float ix = cos(angle);
            float iy = sin(angle);

            glVertex3f(ix, iy, 0);
        }
    glEnd();
}

void glDrawPolygon( const std::vector<Vector2>& points )
{
    glBegin(GL_POLYGON);
        for(unsigned int n = 0; n < points.size(); n++)
        {
            const Vector2& vec = points.at(n);

            glVertex3f(vec.m_fX, vec.m_fY, 0);
        }
    glEnd();
}

void sdlInit()
{
    if(SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        cerr << "SDL_Init failed: " << SDL_GetError() << endl;
        exit(1);
    }

    // In order to use SDL_OPENGLBLIT we have to
    // set GL attributes first
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

    if(SDL_SetVideoMode(800, 600, 16, SDL_OPENGL) < 0)
    {
        cerr << "SDL_SetVideoMode failed: " << SDL_GetError() << endl;
        exit(1);
    }
}

void glInit()
{
    glClearColor(0.0, 0.0, 0.0, 0.0);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glOrtho(0, 800.0, 600.0, 0.0, -0.01, 1.01);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glEnable(GL_DEPTH_TEST);

    // anti aliasing?
    /*
    glEnable(GL_BLEND);
    glEnable(GL_POLYGON_SMOOTH_HINT);

    glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE);

    glHint(GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE);
    */
}