Camera.h

Go to the documentation of this file.

#pragma once
 
 
#include "gui/objects/Point.h"
#include "math/AffineMatrix.h"
#include "objects/wrappers/ClonePtr.h"
#include "objects/wrappers/Optional.h"
 
NAMESPACE_SPH_BEGIN
 
class Storage;
 
class ITracker : public Polymorphic {
public:
    // position and velocity
    virtual Pair<Vector> getTrackedPoint(const Storage& storage) const = 0;
};
 
class ParticleTracker : public ITracker {
private:
    Size index;
 
public:
    explicit ParticleTracker(const Size index)
        : index(index) {}
 
    virtual Pair<Vector> getTrackedPoint(const Storage& storage) const override;
};
 
class MedianTracker : public ITracker {
private:
    Vector offset;
 
public:
    explicit MedianTracker(const Vector& offset)
        : offset(offset) {}
 
    virtual Pair<Vector> getTrackedPoint(const Storage& storage) const override;
};
 
struct ProjectedPoint {
 
    Coords coords;
 
    float radius;
};
 
struct CameraRay {
    Vector origin;
    Vector target;
};
 
class ICamera : public Polymorphic {
public:
    virtual void autoSetup(const Storage& storage) = 0;
 
    virtual Optional<ProjectedPoint> project(const Vector& r) const = 0;
 
    virtual Optional<CameraRay> unproject(const Coords& coords) const = 0;
 
    virtual Pixel getSize() const = 0;
 
    virtual AffineMatrix getFrame() const = 0;
 
    virtual Vector getTarget() const = 0;
 
    virtual Vector getUpVector() const = 0;
 
    virtual Optional<float> getCutoff() const = 0;
 
    virtual Optional<float> getWorldToPixel() const = 0;
 
    virtual void setCutoff(const Optional<float> newCutoff) = 0;
 
    virtual void zoom(const Pixel fixedPoint, const float magnitude) = 0;
 
    virtual void setPosition(const Vector& newPosition) = 0;
 
    virtual void setTarget(const Vector& newTarget) = 0;
 
    virtual void transform(const AffineMatrix& matrix) = 0;
 
    virtual void pan(const Pixel offset) = 0;
 
    virtual void resize(const Pixel newSize) = 0;
 
    virtual AutoPtr<ICamera> clone() const = 0;
};
 
struct CameraParams {
    Pixel imageSize = Pixel(1024, 768);
 
    Vector position = Vector(0._f, 0._f, -1._f);
 
    Vector target = Vector(0._f);
 
    Vector up = Vector(0._f, 1._f, 0._f);
 
    Interval clipping = Interval(EPS, INFTY);
 
    struct {
        Float fov = PI / 3._f;
    } perspective;
 
    struct {
 
        float fov = 1.e5_f;
 
        Optional<float> cutoff = NOTHING;
 
    } ortho;
};
 
 
class OrthoCamera : public ICamera {
private:
    CameraParams data;
 
    struct {
        Vector u, v, w;
    } cached;
 
public:
    explicit OrthoCamera(const CameraParams& data);
 
    virtual void autoSetup(const Storage& storage) override;
 
    virtual Optional<ProjectedPoint> project(const Vector& r) const override;
 
    virtual Optional<CameraRay> unproject(const Coords& coords) const override;
 
    virtual Pixel getSize() const override;
 
    virtual AffineMatrix getFrame() const override;
 
    virtual Vector getTarget() const override;
 
    virtual Vector getUpVector() const override;
 
    virtual Optional<float> getCutoff() const override;
 
    virtual Optional<float> getWorldToPixel() const override;
 
    virtual void setCutoff(const Optional<float> newCutoff) override;
 
    virtual void zoom(const Pixel fixedPoint, const float magnitude) override;
 
    virtual void setPosition(const Vector& newPosition) override;
 
    virtual void setTarget(const Vector& newTarget) override;
 
    virtual void transform(const AffineMatrix& matrix) override;
 
    virtual void pan(const Pixel offset) override;
 
    virtual void resize(const Pixel newSize) override;
 
    virtual AutoPtr<ICamera> clone() const override {
        return makeAuto<OrthoCamera>(*this);
    }
 
private:
    void update();
 
    Optional<CameraRay> unprojectImpl(const Coords& coords, const bool adjustZ) const;
 
    float estimateFov(const Storage& storage) const;
};
 
class PerspectiveCamera : public ICamera {
private:
    CameraParams data;
 
    struct {
        Vector dir;
 
        Vector up;
 
        Vector left;
 
        Vector velocity;
 
    } cached;
 
public:
    PerspectiveCamera(const CameraParams& data);
 
    virtual void autoSetup(const Storage& storage) override;
 
    virtual Optional<ProjectedPoint> project(const Vector& r) const override;
 
    virtual Optional<CameraRay> unproject(const Coords& coords) const override;
 
    virtual Pixel getSize() const override;
 
    virtual AffineMatrix getFrame() const override;
 
    virtual Vector getTarget() const override;
 
    virtual Vector getUpVector() const override;
 
    virtual Optional<float> getCutoff() const override;
 
    virtual Optional<float> getWorldToPixel() const override;
 
    virtual void setCutoff(const Optional<float> newCutoff) override;
 
    virtual void zoom(const Pixel UNUSED(fixedPoint), const float magnitude) override;
 
    virtual void setPosition(const Vector& newPosition) override;
 
    virtual void setTarget(const Vector& newTarget) override;
 
    virtual void transform(const AffineMatrix& matrix) override;
 
    virtual void pan(const Pixel offset) override;
 
    virtual void resize(const Pixel newSize) override;
 
    virtual AutoPtr<ICamera> clone() const override {
        return makeAuto<PerspectiveCamera>(*this);
    }
 
private:
    void update();
};
 
class PanoCameraBase : public ICamera {
protected:
    CameraParams data;
    AffineMatrix matrix;
 
public:
    explicit PanoCameraBase(const CameraParams& data);
 
    virtual void autoSetup(const Storage& storage) override;
 
    virtual Optional<ProjectedPoint> project(const Vector& r) const override;
 
    virtual Pixel getSize() const override;
 
    virtual AffineMatrix getFrame() const override;
 
    virtual Vector getTarget() const override;
 
    virtual Vector getUpVector() const override;
 
    virtual Optional<float> getCutoff() const override;
 
    virtual Optional<float> getWorldToPixel() const override;
 
    virtual void setCutoff(const Optional<float> newCutoff) override;
 
    virtual void zoom(const Pixel UNUSED(fixedPoint), const float magnitude) override;
 
    virtual void setPosition(const Vector& newPosition) override;
 
    virtual void setTarget(const Vector& newTarget) override;
 
    virtual void transform(const AffineMatrix& matrix) override;
 
    virtual void pan(const Pixel offset) override;
 
    virtual void resize(const Pixel newSize) override;
 
protected:
    virtual void update();
};
 
class FisheyeCamera : public PanoCameraBase {
private:
    struct {
        Coords center;
 
        float radius;
    } cached;
 
public:
    explicit FisheyeCamera(const CameraParams& data);
 
    virtual Optional<CameraRay> unproject(const Coords& coords) const override;
 
    virtual AutoPtr<ICamera> clone() const override {
        return makeAuto<FisheyeCamera>(*this);
    }
 
private:
    virtual void update() override;
};
 
class SphericalCamera : public PanoCameraBase {
public:
    explicit SphericalCamera(const CameraParams& data);
 
    virtual Optional<CameraRay> unproject(const Coords& coords) const override;
 
    virtual AutoPtr<ICamera> clone() const override {
        return makeAuto<SphericalCamera>(*this);
    }
};
 
 
NAMESPACE_SPH_END