wze::camera Class Reference

Static Public Member Functions
static float	x ()
static void	set_x (float x)
static float	y ()
static void	set_y (float y)
static float	z ()
static void	set_z (float z)
static float	angle ()
static void	set_angle (float angle)
static std::array< float, 4 > const &	transformation_matrix ()
static float	focus ()
static void	set_focus (float focus)
static std::pair< float, float >	project (float x, float y, float z)
static std::pair< float, float >	unproject (float x, float y, float z)

Detailed Description

Definition at line 34 of file camera.hpp.

Member Function Documentation

x()

float wze::camera::x ( )

staticnodiscard

Definition at line 36 of file camera.cpp.

                   {
    return _x;
}

set_x()

void wze::camera::set_x ( float x )

static

Definition at line 40 of file camera.cpp.

                             {
    _x = x;
}

y()

float wze::camera::y ( )

staticnodiscard

Definition at line 44 of file camera.cpp.

                   {
    return _y;
}

set_y()

void wze::camera::set_y ( float y )

static

Definition at line 48 of file camera.cpp.

                             {
    _y = y;
}

z()

float wze::camera::z ( )

staticnodiscard

Definition at line 52 of file camera.cpp.

                   {
    return _z;
}

set_z()

void wze::camera::set_z ( float z )

static

Definition at line 56 of file camera.cpp.

                             {
    _z = z;
}

angle()

float wze::camera::angle ( )

staticnodiscard

Definition at line 60 of file camera.cpp.

                       {
    return _angle;
}

set_angle()

void wze::camera::set_angle ( float angle )

static

Definition at line 64 of file camera.cpp.

                                     {
    _angle = angle;
    _transformation_matrix = math::transformation_matrix(-camera::angle(), 1);
}

transformation_matrix()

std::array< float, 4 > const & wze::camera::transformation_matrix ( )

staticnodiscard

Definition at line 69 of file camera.cpp.

                                                           {
    return _transformation_matrix;
}

focus()

float wze::camera::focus ( )

staticnodiscard

Definition at line 73 of file camera.cpp.

                       {
    return _focus;
}

set_focus()

void wze::camera::set_focus ( float focus )

static

Definition at line 77 of file camera.cpp.

                                     {
    _focus = focus;
}

project()

std::pair< float, float > wze::camera::project ( float x, float y, float z )

staticnodiscard

Definition at line 92 of file camera.cpp.

                                            {
    float x;
    float y;
    float z;
 
    if (!instance.spatial()) {
        instance.set_screen_area(
            {instance.x(), instance.y(), instance.width(), instance.height()});
        instance.set_screen_angle(instance.angle());
        return;
    }
 
    instance.set_screen_angle(instance.angle() - angle());
 
    if (instance.z() == camera::z()) {
        instance.set_screen_area({0, 0, 0, 0});
        return;
    }
 
    x = instance.x() - camera::x();
    y = instance.y() - camera::y();
    z = instance.z() - camera::z();
 
    if (z == focus()) {
        instance.set_screen_area(
            {math::transform_x(x, y, transformation_matrix()),
             math::transform_y(x, y, transformation_matrix()), instance.width(),
             instance.height()});
        return;
    }
 
    z = focus() / z;
    x *= z;
    y *= z;
    instance.set_screen_area({math::transform_x(x, y, transformation_matrix()),
                              math::transform_y(x, y, transformation_matrix()),
                              instance.width() * z, instance.height() * z});
}

unproject()

std::pair< float, float > wze::camera::unproject ( float x, float y, float z )

staticnodiscard

Definition at line 150 of file camera.cpp.

                                                                    {
    float determinant;
 
    if (!(bool)focus()) {
        return {0, 0};
    }
 
    z -= camera::z();
    determinant =
        transformation_matrix().at(0) * transformation_matrix().at(3) -
        transformation_matrix().at(1) * transformation_matrix().at(2);
 
    if (z == focus()) {
        return {camera::x() + (x * transformation_matrix().at(3) -
                               y * transformation_matrix().at(1)) /
                                  determinant,
                camera::y() + (y * transformation_matrix().at(0) -
                               x * transformation_matrix().at(2)) /
                                  determinant};
    }
 
    z /= focus();
    return {camera::x() + (x * transformation_matrix().at(3) -
                           y * transformation_matrix().at(1)) /
                              determinant * z,
            camera::y() + (y * transformation_matrix().at(0) -
                           x * transformation_matrix().at(2)) /
                              determinant * z};
}

---

The documentation for this class was generated from the following files:

• include/wizard_engine/camera.hpp
• src/camera.cpp