camera.h

Go to the documentation of this file.

#ifndef CAMERA_H
#define CAMERA_H
 
#include <vector>
#include <cstdint>
 
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include <lua.h>
 
#include <atom.h>
#include <util.h>
#include <LuaNumber.h>
#include <LuaBool.h>
 
class Camera
{
public:
 
    Camera(const std::vector<Atom> & atoms, uint16_t resX, uint16_t resY)
    : resX(resX), resY(resY)
    {
        reset(atoms);
    }
 
    Camera(glm::vec3 positionSpherical, uint16_t resX, uint16_t resY)
    : resX(resX), resY(resY), positionSpherical(positionSpherical)
    {
        reset();
    }
 
    void reset()
    {
        focus = {0.0, 0.0, 0.0};
        up = 1.0;
 
        projection = glm::perspective
        (
            glm::radians(45.0f), float(resX)/float(resY),
            0.1f,
            1000.0f
        );
        invProjection = glm::inverse(projection);
 
        view = glm::lookAt
        (
            spherical2cartesian(positionSpherical),
            focus,
            glm::vec3(0.0, up, 0.0)
        );
        invView = glm::inverse(view);
 
        pv = projection*view;
        invPv = glm::inverse(pv);
    }
 
    void reset(const std::vector<Atom> & atoms)
    {
        glm::vec3 ext = extent(atoms);
        positionSpherical = glm::vec3
        (
            2.0f*std::max(std::max(ext.x, ext.y), ext.z),
            M_PI*0.5f,
            M_PI
        );
        reset();
    }
 
    void zoom(float increment) { positionSpherical.x += increment; setView(); }
 
    void incline(float increment)
    {
        positionSpherical.y += increment*up;
        if (positionSpherical.y > M_PI || positionSpherical.y < 0.0)
        {
            positionSpherical.y -= 2.0*increment*up;
            up = -1.0*up;
            positionSpherical.z += M_PI;
            if ( positionSpherical.z < 0) { positionSpherical.z += 2.0*M_PI; }
            else if ( positionSpherical.z > 2.0*M_PI) { positionSpherical.z = std::fmod(positionSpherical.z, 2.0*M_PI); }
        }
        setView();
    }
 
    void rotate(float increment)
    {
        positionSpherical.z -= increment;
        if ( positionSpherical.z < 0) { positionSpherical.z += 2.0*M_PI; }
        else if ( positionSpherical.z > 2.0*M_PI) { positionSpherical.z = std::fmod(positionSpherical.z, 2.0*M_PI); }
        setView();
    }
 
    void setPosition(glm::vec3 positionSpherical)
    {
        this->positionSpherical = positionSpherical;
        setView();
    }
 
    glm::vec3 position(bool spherical = false) const
    {
        return spherical ? positionSpherical : spherical2cartesian(positionSpherical);
    }
 
    void setUp(float up) { this->up = up < 0 ? -1.0 : 1.0; setView(); }
 
    float getUp() const { return up; }
 
    glm::mat4 getProjection() const { return projection; }
 
    glm::mat4 getInverseProjection() const { return invProjection; }
 
    glm::mat4 getView() const { return view; }
 
    glm::mat4 getInverseView() const { return invView; }
 
    glm::mat4 getPV() const { return pv; }
 
    glm::mat4 getInversePV() const { return invPv; }
 
 
    uint16_t getResX() const { return resX; }
    uint16_t getResY() const { return resY; }
 
    inline int lua_cameraPosition(lua_State * lua);
 
    inline int lua_setCameraPosition(lua_State * lua);
 
    inline int lua_rotateCamera(lua_State * lua);
 
    inline int lua_zoomCamera(lua_State * lua);
 
    inline int lua_inclineCamera(lua_State * lua);
 
private:
 
    uint16_t resX;
    uint16_t resY;
 
    glm::vec3 positionSpherical;
    glm::vec3 focus;
    float up;
 
    glm::mat4 projection;
    glm::mat4 invProjection;
    glm::mat4 view;
    glm::mat4 invView;
    glm::mat4 pv;
    glm::mat4 invPv;
 
    void setView()
    {
        view = glm::lookAt
        (
            spherical2cartesian(positionSpherical),
            focus,
            glm::vec3(0.0, up, 0.0)
        );
        invView = glm::inverse(view);
        pv = projection*view;
        invPv = glm::inverse(pv);
    }
 
};
 
#include <luaBindings/camera.h>
 
#endif /* CAMERA_H */