pgl.h

Go to the documentation of this file.

#ifndef PGL_PGL_H_
#define PGL_PGL_H_

#include "math.h"

#include <GL/gl.h>

#include <memory>
#include <vector>
#include <fstream>
#include <iostream>

// GLFW-compatible defines
#define PGL_RELEASE 0
#define PGL_PRESS   1
#define PGL_REPEAT  2

#define PGL_MOUSE_BUTTON_LEFT   0
#define PGL_MOUSE_BUTTON_RIGHT  1
#define PGL_MOUSE_BUTTON_MIDDLE 2

namespace pgl {

class Node
{
  public:
    std::vector<Node*> children; 
    
  public:
    virtual ~Node()
    {
      for (size_t ii=0; ii != children.size(); ++ii)
        delete children[ii];
      children.clear();
    }

    virtual void draw()
    {
      for (size_t ii=0; ii != children.size(); ++ii)
        children[ii]->draw();
    }
    
    template<class T>
    T* attach(T *child)
    {
      children.push_back(child);
      return child;
    }
};

class Object : public Node
{
  public:
    Transform transform; 
    
  public:
    Object() : transform({0, 0, 0}, {0, 0, 0}) { }

    virtual void draw()
    {
      glPushMatrix();
      glMultMatrixd(transform.data);
      Node::draw();
      glPopMatrix();
    }
};

class Scene : public Node
{
  public:
    Vector3 color; 

  public:
    Scene() : color(0, 0, 0) { }
  
    virtual void draw()
    {
      glClearColor(color.x, color.y, color.z, 1);
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      
      Node::draw();
    }
};

class Camera
{
  public:
    Transform transform; 
    Scene *scene;        
    double fovy;         
  
  public:
    Camera(Scene *_scene, double _fovy = 0.92) : scene(_scene), fovy(_fovy) { }
  
    void draw()
    {
      int dims[4];
      glGetIntegerv(GL_VIEWPORT, dims);
      double aspect = dims[2]/(double)dims[3];
      
      double f = 1/tan(fovy/2);
      double near = 1, far = 100;
      
      double matrix[] = {f/aspect, 0., 0., 0.,
                         0., f, 0., 0.,
                         0., 0., (far+near)/(near-far), -1.,
                         0., 0., 2*far*near/(near-far), 0.};
      
      glMatrixMode(GL_PROJECTION);
      glLoadMatrixd(matrix);
      
      GLfloat pos[] = {0, 0, 1, 0};
      glLightfv(GL_LIGHT0, GL_POSITION, pos);
      
      glMatrixMode(GL_MODELVIEW);
      glLoadMatrixd(transform.data);
      
      scene->draw();
    }
};

class Controller
{
  public:
    Camera *camera; 
    
  public:
    Controller(Camera *_camera) : camera(_camera) { }
    virtual ~Controller() { }
  
    virtual void click(int button, int action, int mods, double xpos, double ypos) = 0;
    
    virtual void scroll(double xoffset, double yoffset) = 0;
    
    virtual void motion(double xpos, double ypos) = 0;
};

class Texture
{
  protected:
    typedef std::shared_ptr<GLuint> GLuintPtr;

  public:
    int width = 0,          
        height = 0;         
    
  protected:
    GLuintPtr texture_ = 0; 
    
  public:
    Texture() { }
  
    Texture(int width, int height, unsigned char *data, bool interpolate=false)
    {
      make(width, height, data, interpolate);
    }
    
    Texture(const std::string &file, bool interpolate=true)
    {
      std::ifstream ifs(file);
      std::string magic;
      
      ifs >> magic;
      if (magic != "P6")
      {
        std::cerr << file << " is not a valid binary PPM" << std::endl;
        return;
      }
      
      int _width = readint(ifs);
      int _height = readint(ifs);
      int maxval  = readint(ifs);
      
      if (maxval != 255)
      {
        std::cerr << file << ": pixel format not supported" << std::endl;
        return;
      }
      
      unsigned char *data = new unsigned char[_width*_height*3];

      ifs.read((char*)data, _width*_height*3);
      if (!ifs.good())
      {
        std::cerr << file << " is truncated" << std::endl;
        return;
      }
      
      make(_width, _height, data, interpolate);
      
      delete[] data;
    }
    
    ~Texture()
    {
      // Delete OpenGL texture when last reference goes out of scope.
      if (texture_.use_count() == 1)
        glDeleteTextures(1, texture_.get());
    }
    
    operator bool() const
    {
      return texture_ != 0;
    }
    
    void bind() const
    {
      glBindTexture(GL_TEXTURE_2D, *texture_);
    }
    
  protected:
    void make(int _width, int _height, unsigned char *data, bool interpolate)
    {
      width = _width;
      height = _height;
      texture_ = GLuintPtr(new GLuint);
    
      glGenTextures(1, texture_.get());
      glBindTexture(GL_TEXTURE_2D, *texture_);
      glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
      glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, interpolate?GL_LINEAR:GL_NEAREST);
      glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, interpolate?GL_LINEAR:GL_NEAREST);
      glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
      glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, (void*)data);
    }
    
    void eatcomments(std::ifstream &ifs)
    {
      char c;
      do
      {
        c = ifs.get();
        if (c == '#')
        {
          char buffer[256];
          ifs.getline(buffer, 256);
        }
      } while (isspace(c) || c == '#');

      ifs.putback(c);
    }
    
    int readint(std::ifstream &ifs)
    {
      int val;
      
      eatcomments(ifs);
      ifs >> val;
      eatcomments(ifs);
      
      return val;
    }
};

class Checkerboard4x4 : public Texture
{
  public:
    Checkerboard4x4()
    {
      const unsigned char m = 255;
      unsigned char data[] = {0,0,0,m,m,m,0,0,0,m,m,m,
                              m,m,m,0,0,0,m,m,m,0,0,0,
                              0,0,0,m,m,m,0,0,0,m,m,m,
                              m,m,m,0,0,0,m,m,m,0,0,0};
                              
      make(4, 4, data, false);
    }
};

}

#include "primitive.h"
#include "controller.h"

#endif // PGL_PGL_H_