mirror of
https://github.com/korenkonder/ReDIVA.git
synced 2026-10-04 12:47:56 +03:00
435 lines
12 KiB
C++
435 lines
12 KiB
C++
/*
|
|
by korenkonder
|
|
GitHub/GitLab: korenkonder
|
|
*/
|
|
|
|
#include "camera.hpp"
|
|
|
|
static void camera_calculate_projection(camera* c);
|
|
static void camera_calculate_projection_aet(camera* c);
|
|
static void camera_calculate_view(camera* c);
|
|
static void camera_calculate_forward(camera* c);
|
|
|
|
camera::camera() : forward(), rotation(), view_point(), interest(), fov_correct_height(),
|
|
aet_depth(), render_width(), render_height(), sprite_width(), sprite_height(),
|
|
field_1E4(), field_1F0(), field_1FC(), field_208(), yaw(), pitch(), roll(), aspect(),
|
|
fov(), fov_rad(), max_distance(), min_distance(), changed_view(), changed_proj(),
|
|
changed_proj_aet(), fast_change(), fast_change_hist0(), fast_change_hist1() {
|
|
|
|
}
|
|
|
|
camera::~camera() {
|
|
|
|
}
|
|
|
|
void camera::initialize(double_t aspect, int32_t render_width,
|
|
int32_t render_height, int32_t sprite_width, int32_t sprite_height) {
|
|
this->aspect = aspect;
|
|
fov = 0.0;
|
|
fov_correct_height = 0.0f;
|
|
aet_depth = 0.0f;
|
|
forward = { 0.0f, 0.0f, -1.0f };
|
|
rotation = { 0.0f, 0.0f, 0.0f };
|
|
view_point = { 0.0, 0.0f, 0.0f };
|
|
interest = { 0.0f, 0.0f, -1.0f };
|
|
this->render_width = render_width;
|
|
this->render_height = render_height;
|
|
this->sprite_width = sprite_width;
|
|
this->sprite_height = sprite_height;
|
|
view = mat4_identity;
|
|
inv_view = mat4_identity;
|
|
projection = mat4_identity;
|
|
inv_projection = mat4_identity;
|
|
view_projection = mat4_identity;
|
|
inv_view_projection = mat4_identity;
|
|
view_projection_prev = mat4_identity;
|
|
inv_view_projection_prev = mat4_identity;
|
|
min_distance = 0.05;
|
|
max_distance = 6000.0;
|
|
changed_proj = true;
|
|
changed_proj_aet = true;
|
|
changed_view = true;
|
|
fast_change = false;
|
|
fast_change_hist0 = false;
|
|
fast_change_hist1 = false;
|
|
set_pitch(0.0);
|
|
set_yaw(0.0);
|
|
set_roll(0.0);
|
|
set_fov(32.2673416137695);
|
|
camera_calculate_forward(this);
|
|
set_position(0.0f);
|
|
update();
|
|
}
|
|
|
|
double_t camera::get_min_distance() {
|
|
return min_distance;
|
|
}
|
|
|
|
void camera::set_min_distance(double_t value) {
|
|
if (value != min_distance) {
|
|
min_distance = value;
|
|
changed_proj = true;
|
|
changed_proj_aet = true;
|
|
}
|
|
}
|
|
|
|
double_t camera::get_max_distance() {
|
|
return max_distance;
|
|
}
|
|
|
|
void camera::set_max_distance(double_t value) {
|
|
if (value != max_distance) {
|
|
max_distance = value;
|
|
changed_proj = true;
|
|
}
|
|
}
|
|
|
|
double_t camera::get_aspect() {
|
|
return aspect;
|
|
}
|
|
|
|
void camera::set_aspect(double_t value) {
|
|
if (value != aspect) {
|
|
aspect = value;
|
|
changed_proj = true;
|
|
}
|
|
}
|
|
|
|
double_t camera::get_fov() {
|
|
return fov;
|
|
}
|
|
|
|
void camera::set_fov(double_t value) {
|
|
value = clamp_def(value, 1.0, 180.0);
|
|
if (value != fov) {
|
|
fov = value;
|
|
fov_rad = value * DEG_TO_RAD;
|
|
changed_proj = true;
|
|
}
|
|
}
|
|
|
|
double_t camera::get_pitch() {
|
|
return pitch;
|
|
}
|
|
|
|
void camera::set_pitch(double_t value) {
|
|
value = fmod(value, 360.0);
|
|
value = clamp_def(value, -89.5, 89.5);
|
|
if (pitch != value) {
|
|
pitch = value;
|
|
changed_view = true;
|
|
}
|
|
}
|
|
|
|
double_t camera::get_yaw() {
|
|
return yaw;
|
|
}
|
|
|
|
void camera::set_yaw(double_t value) {
|
|
value = fmod(value, 360.0);
|
|
if (yaw != value) {
|
|
yaw = value;
|
|
changed_view = true;
|
|
}
|
|
}
|
|
|
|
double_t camera::get_roll() {
|
|
return roll;
|
|
}
|
|
|
|
void camera::set_roll(double_t value) {
|
|
value = fmod(value, 360.0);
|
|
if (roll != value) {
|
|
roll = value;
|
|
changed_view = true;
|
|
}
|
|
}
|
|
|
|
void camera::get_view_point(vec3& value) {
|
|
value = view_point;
|
|
}
|
|
|
|
void camera::get_view_point(vec4& value) {
|
|
*(vec3*)&value = view_point;
|
|
value.w = 0.0f;
|
|
}
|
|
|
|
void camera::set_view_point(const vec3& value) {
|
|
if (value != view_point) {
|
|
view_point = value;
|
|
changed_view = true;
|
|
}
|
|
}
|
|
|
|
void camera::set_view_point(const vec3&& value) {
|
|
if (value != view_point) {
|
|
view_point = value;
|
|
changed_view = true;
|
|
}
|
|
}
|
|
|
|
void camera::get_interest(vec3& value) {
|
|
value = interest;
|
|
}
|
|
|
|
void camera::set_interest(const vec3& value) {
|
|
if (value != interest) {
|
|
interest = value;
|
|
changed_view = true;
|
|
}
|
|
}
|
|
|
|
void camera::set_interest(const vec3&& value) {
|
|
if (value != interest) {
|
|
interest = value;
|
|
changed_view = true;
|
|
}
|
|
}
|
|
|
|
void camera::get_res(int32_t& render_width, int32_t& render_height,
|
|
int32_t& sprite_width, int32_t& sprite_height) {
|
|
render_width = this->render_width;
|
|
render_height = this->render_height;
|
|
sprite_width = this->sprite_width;
|
|
sprite_height = this->sprite_height;
|
|
}
|
|
|
|
void camera::set_res(int32_t render_width, int32_t render_height,
|
|
int32_t sprite_width, int32_t sprite_height) {
|
|
if (this->render_width != render_width || this->render_height != render_height
|
|
|| this->sprite_width != sprite_width || this->sprite_height != sprite_height) {
|
|
this->render_width = render_width;
|
|
this->render_height = render_height;
|
|
this->sprite_width = sprite_width;
|
|
this->sprite_height = sprite_height;
|
|
changed_proj = true;
|
|
changed_proj_aet = true;
|
|
}
|
|
}
|
|
|
|
void camera::set_fast_change(bool value) {
|
|
fast_change = value;
|
|
}
|
|
|
|
void camera::set_fast_change_hist0(bool value) {
|
|
fast_change_hist0 = value;
|
|
}
|
|
|
|
void camera::set_fast_change_hist1(bool value) {
|
|
fast_change_hist1 = value;
|
|
}
|
|
|
|
void camera::reset() {
|
|
set_pitch(0.0);
|
|
set_yaw(0.0);
|
|
set_roll(0.0);
|
|
set_fov(32.2673416137695);
|
|
min_distance = 0.05;
|
|
max_distance = 6000.0;
|
|
fast_change = false;
|
|
fast_change_hist0 = false;
|
|
fast_change_hist1 = false;
|
|
camera_calculate_forward(this);
|
|
set_position(0.0f);
|
|
update_data();
|
|
}
|
|
|
|
void camera::move(double_t move_x, double_t move_y) {
|
|
if (move_x != 0.0 || move_y != 0.0) {
|
|
vec3 up = { 0.0f, 1.0f, 0.0f };
|
|
vec3 view_point = this->view_point;
|
|
view_point += vec3::normalize(vec3::cross(forward, up)) * (float_t)move_y;
|
|
view_point += forward * (float_t)move_x;
|
|
set_view_point(view_point);
|
|
set_interest(view_point + forward);
|
|
}
|
|
}
|
|
|
|
void camera::rotate(double_t rotate_x, double_t rotate_y) {
|
|
if (rotate_x != 0.0)
|
|
set_yaw(get_yaw() + rotate_x);
|
|
|
|
if (rotate_y != 0.0)
|
|
set_pitch(get_pitch() + rotate_y);
|
|
|
|
if (rotate_x != 0.0 || rotate_y != 0.0) {
|
|
camera_calculate_forward(this);
|
|
|
|
set_interest(view_point + forward);
|
|
}
|
|
}
|
|
|
|
void camera::set(const vec3& view_point, const vec3& interest,
|
|
const vec3& trans, const vec3& rot, const vec3& scale, double_t roll, double_t fov) {
|
|
vec3 _vp;
|
|
vec3 _int;
|
|
double_t _roll;
|
|
double_t _fov;
|
|
|
|
_vp = view_point;
|
|
_int = interest;
|
|
_roll = roll;
|
|
_fov = fov;
|
|
|
|
mat4 cam;
|
|
mat4_translate(&trans, &cam);
|
|
mat4_rotate_zyx_mult(&cam, &rot, &cam);
|
|
mat4_scale_rot(&cam, &scale, &cam);
|
|
mat4_mult_vec3_trans(&cam, &_vp, &_vp);
|
|
mat4_mult_vec3_trans(&cam, &_int, &_int);
|
|
|
|
set_view_point(_vp);
|
|
set_interest(_int);
|
|
set_roll(_roll);
|
|
set_fov(_fov);
|
|
}
|
|
|
|
void camera::set(const vec3&& view_point, const vec3&& interest,
|
|
const vec3&& trans, const vec3&& rot, const vec3&& scale, double_t roll, double_t fov) {
|
|
set(*(vec3*)&view_point, *(vec3*)&interest, *(vec3*)&trans, *(vec3*)&rot, *(vec3*)&scale, roll, fov);
|
|
}
|
|
|
|
void camera::set_position(const vec3& pos) {
|
|
set_view_point(pos);
|
|
set_interest(pos + forward);
|
|
}
|
|
|
|
void camera::set_position(const vec3&& pos) {
|
|
set_view_point(pos);
|
|
set_interest(pos + forward);
|
|
}
|
|
|
|
void camera::update() {
|
|
update_data();
|
|
|
|
fast_change_hist1 = fast_change_hist0;
|
|
fast_change_hist0 = fast_change;
|
|
fast_change = false;
|
|
}
|
|
|
|
void camera::update_data() {
|
|
if (changed_proj)
|
|
camera_calculate_projection(this);
|
|
|
|
if (changed_proj_aet)
|
|
camera_calculate_projection_aet(this);
|
|
|
|
if (changed_view)
|
|
camera_calculate_view(this);
|
|
|
|
if (changed_proj || changed_view) {
|
|
mat4_mult(&view, &projection, &view_projection);
|
|
mat4_inverse(&view_projection, &inv_view_projection);
|
|
}
|
|
|
|
changed_proj = false;
|
|
changed_proj_aet = false;
|
|
changed_view = false;
|
|
}
|
|
|
|
static void camera_calculate_forward(camera* c) {
|
|
c->forward.x = (float_t)(cos(c->pitch * DEG_TO_RAD) * sin(c->yaw * DEG_TO_RAD));
|
|
c->forward.y = (float_t)sin(c->pitch * DEG_TO_RAD);
|
|
c->forward.z = (float_t)(cos(c->pitch * DEG_TO_RAD) * -cos(c->yaw * DEG_TO_RAD));
|
|
}
|
|
|
|
static void camera_calculate_projection(camera* c) {
|
|
mat4_persp(c->fov_rad, c->aspect, c->min_distance, c->max_distance, &c->projection);
|
|
mat4_inverse(&c->projection, &c->inv_projection);
|
|
|
|
float_t fov_correct_height = (float_t)(((double_t)c->render_height * 0.5) / tan(c->fov_rad * 0.5));
|
|
|
|
float_t height = (float_t)c->render_height * 0.5f;
|
|
float_t width = (float_t)c->render_height * (float_t)c->aspect * 0.5f;
|
|
|
|
c->field_1E4.x = fov_correct_height;
|
|
c->field_1E4.y = 0.0f;
|
|
c->field_1E4.z = -width;
|
|
c->field_1E4 = vec3::normalize(c->field_1E4);
|
|
c->field_1F0.x = -fov_correct_height;
|
|
c->field_1F0.y = 0.0f;
|
|
c->field_1F0.z = -width;
|
|
c->field_1F0 = vec3::normalize(c->field_1F0);
|
|
c->field_1FC.x = 0.0f;
|
|
c->field_1FC.y = fov_correct_height;
|
|
c->field_1FC.z = -height;
|
|
c->field_1FC = vec3::normalize(c->field_1FC);
|
|
c->field_208.x = 0.0f;
|
|
c->field_208.y = -fov_correct_height;
|
|
c->field_208.z = -height;
|
|
c->field_208 = vec3::normalize(c->field_208);
|
|
}
|
|
|
|
static void camera_calculate_projection_aet(camera* c) {
|
|
float_t sprite_half_width = (float_t)c->sprite_width * 0.5f;
|
|
float_t sprite_half_height = (float_t)c->sprite_height * 0.5f;
|
|
float_t render_half_width = (float_t)c->render_width * 0.5f;
|
|
float_t render_half_height = (float_t)c->render_height * 0.5f;
|
|
|
|
float_t aet_depth = sprite_half_height / (tanf(0.34557518363f) * 0.75f);
|
|
c->aet_depth = aet_depth;
|
|
|
|
float_t fov_correct_height = (float_t)(sprite_half_height / tan(c->fov_rad * 0.5));
|
|
c->fov_correct_height = fov_correct_height;
|
|
|
|
float_t v8a = (float_t)c->min_distance / aet_depth * sprite_half_width;
|
|
float_t v8b = (float_t)c->min_distance / aet_depth * sprite_half_height;
|
|
|
|
mat4 spr_2d_proj;
|
|
mat4_frustrum(-v8a, v8a, v8b, -v8b, c->min_distance, 3000.0, &spr_2d_proj);
|
|
|
|
vec3 spr_2d_viewpoint = { sprite_half_width, sprite_half_height, aet_depth };
|
|
vec3 spr_2d_interest = { sprite_half_width, sprite_half_height, 0.0f };
|
|
vec3 spr_2d_up = { 0.0f, 1.0f, 0.0f };
|
|
mat4 spr_2d_view;
|
|
mat4_look_at(&spr_2d_viewpoint, &spr_2d_interest, &spr_2d_up, &spr_2d_view);
|
|
|
|
mat4_mult(&spr_2d_view, &spr_2d_proj, &c->view_projection_aet_2d);
|
|
|
|
float_t v13a = (float_t)c->min_distance / aet_depth * render_half_width;
|
|
float_t v13b = (float_t)c->min_distance / aet_depth * render_half_height;
|
|
|
|
mat4 spr_3d_proj;
|
|
mat4_frustrum(-v13a, v13a, v13b, -v13b, c->min_distance, 3000.0, &spr_3d_proj);
|
|
|
|
vec3 spr_3d_viewpoint = { render_half_width, render_half_height, render_half_height };
|
|
vec3 spr_3d_interest = { render_half_width, render_half_height, 0.0f };
|
|
vec3 spr_3d_up = { 0.0f, 1.0f, 0.0f };
|
|
mat4 spr_3d_view;
|
|
mat4_look_at(&spr_3d_viewpoint, &spr_3d_interest, &spr_3d_up, &spr_3d_view);
|
|
|
|
mat4_mult(&spr_3d_view, &spr_3d_proj, &c->view_projection_aet_3d);
|
|
}
|
|
|
|
static void camera_calculate_view(camera* c) {
|
|
vec3 direction = c->view_point - c->interest;
|
|
|
|
vec3 rotation;
|
|
rotation.x = atan2f(-direction.y, sqrtf(direction.x * direction.x + direction.z * direction.z));
|
|
rotation.y = atan2f(direction.x, direction.z);
|
|
rotation.z = (float_t)(c->roll * DEG_TO_RAD);
|
|
|
|
c->rotation = rotation;
|
|
rotation = -rotation;
|
|
|
|
vec3 view_point = -c->view_point;
|
|
|
|
mat4_rotate_z(rotation.z, &c->view);
|
|
mat4_rotate_x_mult(&c->view, rotation.x, &c->view);
|
|
mat4_rotate_y_mult(&c->view, rotation.y, &c->view);
|
|
mat4_translate_mult(&c->view, &view_point, &c->view);
|
|
|
|
mat4_inverse(&c->view, &c->inv_view);
|
|
mat3_from_mat4(&c->view, &c->view_mat3);
|
|
mat3_inverse(&c->view_mat3, &c->inv_view_mat3);
|
|
mat4_from_mat3(&c->view_mat3, &c->view_rot);
|
|
mat4_from_mat3(&c->inv_view_mat3, &c->inv_view_rot);
|
|
|
|
if (fabs(c->rotation.x * RAD_TO_DEG - c->pitch) > 0.01
|
|
|| fabs(-c->rotation.y * RAD_TO_DEG - c->yaw) > 0.01) {
|
|
c->pitch = c->rotation.x * RAD_TO_DEG;
|
|
c->yaw = -c->rotation.y * RAD_TO_DEG;
|
|
camera_calculate_forward(c);
|
|
}
|
|
}
|