Camera.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_CAMERA_HPP
#define DONUT_GRAPHICS_CAMERA_HPP
 
#include <donut/math.hpp>
 
namespace donut::graphics {
 
struct CameraOrthographicOptions {
    vec2 offset{0.0f, 0.0f};
 
    vec2 size{1.0f, 1.0f};
};
 
struct CameraPerspectiveOptions {
    float verticalFieldOfView = 1.28700221758656877361f;
 
    float aspectRatio = 1.0f;
 
    float nearZ = 0.01f;
 
    float farZ = 1000.0f;
};
 
class Camera {
public:
    [[nodiscard]] static Camera createOrthographic(const CameraOrthographicOptions& options, const mat4& viewMatrix) noexcept {
        return Camera{ortho(options.offset.x, options.offset.x + options.size.x, options.offset.y, options.offset.y + options.size.y), viewMatrix};
    }
 
    [[nodiscard]] static Camera createOrthographic(const CameraOrthographicOptions& options) noexcept {
        return createOrthographic(options, identity<mat4>());
    }
 
    [[nodiscard]] static Camera createOrthographic(const CameraOrthographicOptions& options, vec3 position, vec3 target, vec3 up) noexcept {
        return createOrthographic(options, lookAt(position, target, up));
    }
    [[nodiscard]] static Camera createPerspective(const CameraPerspectiveOptions& options, const mat4& viewMatrix) noexcept {
        return Camera{perspective(options.verticalFieldOfView, options.aspectRatio, options.nearZ, options.farZ), viewMatrix};
    }
 
    [[nodiscard]] static Camera createPerspective(const CameraPerspectiveOptions& options) noexcept {
        return createPerspective(options, identity<mat4>());
    }
 
    [[nodiscard]] static Camera createPerspective(const CameraPerspectiveOptions& options, vec3 position, vec3 target, vec3 up) noexcept {
        return createPerspective(options, lookAt(position, target, up));
    }
 
    constexpr Camera() noexcept
        : projectionMatrix(identity<mat4>())
        , viewMatrix(identity<mat4>()) {}
 
    constexpr Camera(const mat4& projectionMatrix, const mat4& viewMatrix) noexcept
        : projectionMatrix(projectionMatrix)
        , viewMatrix(viewMatrix) {}
 
    void setProjectionOrthographic(const CameraOrthographicOptions& options) noexcept {
        setProjectionMatrix(ortho(options.offset.x, options.offset.x + options.size.x, options.offset.y, options.offset.y + options.size.y));
    }
 
    void setProjectionPerspective(const CameraPerspectiveOptions& options) noexcept {
        setProjectionMatrix(perspective(options.verticalFieldOfView, options.aspectRatio, options.nearZ, options.farZ));
    }
 
    void setView(vec3 newPosition, vec3 newTarget, vec3 newUp) noexcept {
        setViewMatrix(lookAt(newPosition, newTarget, newUp));
    }
 
    void setProjectionMatrix(const mat4& newProjectionMatrix) noexcept {
        projectionMatrix = newProjectionMatrix;
    }
 
    void setViewMatrix(const mat4& newViewMatrix) noexcept {
        viewMatrix = newViewMatrix;
    }
 
    [[nodiscard]] const mat4& getProjectionMatrix() const noexcept {
        return projectionMatrix;
    }
 
    [[nodiscard]] const mat4& getViewMatrix() const noexcept {
        return viewMatrix;
    }
 
private:
    mat4 projectionMatrix;
    mat4 viewMatrix;
};
 
} // namespace donut::graphics
 
#endif