Max/korenkonder_ReDIVA
1
0
Fork 0
mirror of https://github.com/korenkonder/ReDIVA.git synced 2026-10-12 09:08:11 +03:00
Code Issues Packages Projects Releases Wiki Activity

Overhaul of Camera

Browse Source
This commit is contained in:
korenkonder
2026-06-12 18:49:01 +03:00
parent 47ce6002ed
commit 8239ad3866
47 changed files with 1044 additions and 861 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/CRE/Glitter/emitter_inst.cpp
+8 -7
View File
@@ -4,6 +4,7 @@
*/
#include "glitter.hpp"
#include "../camera.hpp"
#include "../render_context.hpp"
extern render_context* rctx_ptr;
@@ -148,7 +149,7 @@ namespace Glitter {
mat4 dir_mat;
switch (data.direction) {
case DIRECTION_BILLBOARD:
mat4_from_mat3(&rctx_ptr->camera->inv_view_mat3, &dir_mat);
mat4_from_mat3(&rctx_ptr->camera->imat3, &dir_mat);
mat4_mul(&eff_inst->mat, &dir_mat, &dir_mat);
mat4_clear_trans(&dir_mat, &dir_mat);
break;
@@ -162,7 +163,7 @@ namespace Glitter {
mat4_rotate_z((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_BILLBOARD_Y_AXIS:
mat4_rotate_y(rctx_ptr->camera->rotation.y, &dir_mat);
mat4_rotate_y(rctx_ptr->camera->get_rot_y() * DEG_TO_RAD_FLOAT, &dir_mat);
break;
default:
mult = false;
@@ -567,7 +568,7 @@ namespace Glitter {
switch (data.direction) {
case DIRECTION_BILLBOARD: {
if (eff_inst->data.flags & EFFECT_SCREEN) {
dir_mat = rctx_ptr->camera->view;
dir_mat = rctx_ptr->camera->cmat;
mat4_clear_trans(&dir_mat, &dir_mat);
mat4_mul(&dir_mat, &mat, &dir_mat);
}
@@ -575,7 +576,7 @@ namespace Glitter {
dir_mat = mat;
mat4 inv_view_mat;
mat4_from_mat3(&rctx_ptr->camera->inv_view_mat3, &inv_view_mat);
mat4_from_mat3(&rctx_ptr->camera->imat3, &inv_view_mat);
mat4_mul(&dir_mat, &inv_view_mat, &dir_mat);
mat4_clear_trans(&dir_mat, &dir_mat);
} break;
@@ -586,7 +587,7 @@ namespace Glitter {
mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_BILLBOARD_Y_AXIS:
mat4_rotate_y(rctx_ptr->camera->rotation.y, &dir_mat);
mat4_rotate_y(rctx_ptr->camera->get_rot_y() * DEG_TO_RAD_FLOAT, &dir_mat);
break;
default:
mult = false;
@@ -681,7 +682,7 @@ namespace Glitter {
mat4 dir_mat;
switch (data.direction) {
case DIRECTION_BILLBOARD: {
mat4_from_mat3(&rctx_ptr->camera->inv_view_mat3, &dir_mat);
mat4_from_mat3(&rctx_ptr->camera->imat3, &dir_mat);
mat4_mul(&dir_mat, &mat, &dir_mat);
mat4_clear_trans(&dir_mat, &dir_mat);
} break;
@@ -692,7 +693,7 @@ namespace Glitter {
mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_BILLBOARD_Y_AXIS:
mat4_rotate_y(rctx_ptr->camera->rotation.y, &dir_mat);
mat4_rotate_y(rctx_ptr->camera->get_rot_y() * DEG_TO_RAD_FLOAT, &dir_mat);
break;
default:
mult = false;
src/CRE/Glitter/render_scene.cpp
+29 -26
View File
@@ -4,8 +4,11 @@
*/
#include "glitter.hpp"
#include "../mdl/disp_manager.hpp"
#include "../camera.hpp"
#include "../gl_rend_state.hpp"
#include "../gl_state.hpp"
#include "../object.hpp"
#include "../render_context.hpp"
#include "../shader.hpp"
#include "../shader_ft.hpp"
@@ -342,9 +345,9 @@ namespace Glitter {
vec3 x_vec = { 1.0f, 0.0f, 0.0f };
if (rend_group->flags & PARTICLE_SCREEN) {
mat4 mat;
mat4_mul(&rctx_ptr->camera->inv_view, &rend_group->mat, &mat);
mat4_mul(&rctx_ptr->camera->view, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->inv_view, &rend_group->mat_draw);
mat4_mul(&rctx_ptr->camera->imat, &rend_group->mat, &mat);
mat4_mul(&rctx_ptr->camera->cmat, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->imat, &rend_group->mat_draw);
}
else
rend_group->mat_draw = mat4_identity;
@@ -371,7 +374,7 @@ namespace Glitter {
else
model_mat = mat3_identity;
mat3_transform_vector(&rctx_ptr->camera->inv_view_mat3, &x_vec, &x_vec);
mat3_transform_vector(&rctx_ptr->camera->imat3, &x_vec, &x_vec);
Buffer* buf = rend_group->buffer;
if (!buf)
@@ -480,13 +483,13 @@ namespace Glitter {
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
model_mat = rend_group->mat;
mat4_normalize_rotation(&model_mat, &view_mat);
mat4_mul(&view_mat, &rctx_ptr->camera->view, &view_mat);
mat4_mul(&view_mat, &rctx_ptr->camera->cmat, &view_mat);
mat4_invert(&view_mat, &inv_view_mat);
}
else {
model_mat = mat4_identity;
view_mat = rctx_ptr->camera->view;
inv_view_mat = rctx_ptr->camera->inv_view;
view_mat = rctx_ptr->camera->cmat;
inv_view_mat = rctx_ptr->camera->imat;
}
if (rend_group->flags & PARTICLE_SCREEN) {
@@ -495,7 +498,7 @@ namespace Glitter {
mat4_invert(&view_mat, &inv_view_mat);
}
mat4_mul(&view_mat, &rctx_ptr->camera->inv_view, &rend_group->mat_draw);
mat4_mul(&view_mat, &rctx_ptr->camera->imat, &rend_group->mat_draw);
mat4 dir_mat;
switch (rend_group->draw_type) {
@@ -525,7 +528,7 @@ namespace Glitter {
mat4_rotate_z((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_BILLBOARD_Y_AXIS:
mat4_rotate_y(rctx_ptr->camera->rotation.y, &dir_mat);
mat4_rotate_y(rctx_ptr->camera->get_rot_y() * DEG_TO_RAD_FLOAT, &dir_mat);
break;
default:
dir_mat = mat4_identity;
@@ -674,7 +677,7 @@ namespace Glitter {
if (fabsf(rend_group->z_offset) > 0.000001f) {
use_z_offset = true;
mat4_get_translation(model_mat, &dist_to_cam);
dist_to_cam = rctx_ptr->camera->view_point - dist_to_cam;
dist_to_cam = rctx_ptr->camera->get_pos() - dist_to_cam;
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4_normalize_rotation(model_mat, &z_offset_inv_mat);
mat4_invert(&z_offset_inv_mat, &z_offset_inv_mat);
@@ -1341,9 +1344,9 @@ namespace Glitter {
vec3 x_vec = { 1.0f, 0.0f, 0.0f };
if (rend_group->flags & PARTICLE_SCREEN) {
mat4 mat;
mat4_mul(&rctx_ptr->camera->inv_view, &rend_group->mat, &mat);
mat4_mul(&rctx_ptr->camera->view, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->inv_view, &rend_group->mat_draw);
mat4_mul(&rctx_ptr->camera->imat, &rend_group->mat, &mat);
mat4_mul(&rctx_ptr->camera->cmat, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->imat, &rend_group->mat_draw);
}
else
rend_group->mat_draw = mat4_identity;
@@ -1369,7 +1372,7 @@ namespace Glitter {
else
model_mat = mat3_identity;
mat3_transform_vector(&rctx_ptr->camera->inv_view_mat3, &x_vec, &x_vec);
mat3_transform_vector(&rctx_ptr->camera->imat3, &x_vec, &x_vec);
Buffer* buf = rend_group->buffer;
if (!buf)
@@ -1482,13 +1485,13 @@ namespace Glitter {
mat4_clear_rot(&rend_group->mat, &model_mat);
else
mat4_normalize_rotation(&rend_group->mat, &model_mat);
mat4_mul(&model_mat, &rctx_ptr->camera->view, &view_mat);
mat4_mul(&model_mat, &rctx_ptr->camera->cmat, &view_mat);
mat4_invert(&view_mat, &inv_view_mat);
}
else {
model_mat = mat4_identity;
view_mat = rctx_ptr->camera->view;
inv_view_mat = rctx_ptr->camera->inv_view;
view_mat = rctx_ptr->camera->cmat;
inv_view_mat = rctx_ptr->camera->imat;
}
if (rend_group->flags & PARTICLE_SCREEN) {
@@ -1497,7 +1500,7 @@ namespace Glitter {
mat4_mul(&view_mat, &inv_view_mat, &view_mat);
mat4_invert(&view_mat, &inv_view_mat);
}
mat4_mul(&view_mat, &rctx_ptr->camera->inv_view, &rend_group->mat_draw);
mat4_mul(&view_mat, &rctx_ptr->camera->imat, &rend_group->mat_draw);
mat4 dir_mat;
switch (rend_group->draw_type) {
@@ -1518,7 +1521,7 @@ namespace Glitter {
mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_BILLBOARD_Y_AXIS:
mat4_rotate_y(rctx_ptr->camera->rotation.y, &dir_mat);
mat4_rotate_y(rctx_ptr->camera->get_rot_y() * DEG_TO_RAD_FLOAT, &dir_mat);
break;
default:
dir_mat = mat4_identity;
@@ -1664,7 +1667,7 @@ namespace Glitter {
if (fabsf(rend_group->z_offset) > 0.000001f) {
use_z_offset = true;
mat4_get_translation(model_mat, &dist_to_cam);
dist_to_cam = rctx_ptr->camera->view_point - dist_to_cam;
dist_to_cam = rctx_ptr->camera->get_pos() - dist_to_cam;
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
mat4_normalize_rotation(model_mat, &z_offset_inv_mat);
mat4_invert(&z_offset_inv_mat, &z_offset_inv_mat);
@@ -2169,7 +2172,7 @@ namespace Glitter {
if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
model_mat = rend_group->mat;
mat4_normalize_rotation(&model_mat, &view_mat);
mat4_mul(&view_mat, &rctx_ptr->camera->view, &view_mat);
mat4_mul(&view_mat, &rctx_ptr->camera->cmat, &view_mat);
mat4_invert(&view_mat, &inv_view_mat);
emitter_local = true;
@@ -2180,8 +2183,8 @@ namespace Glitter {
}
else {
model_mat = mat4_identity;
view_mat = rctx_ptr->camera->view;
inv_view_mat = rctx_ptr->camera->inv_view;
view_mat = rctx_ptr->camera->cmat;
inv_view_mat = rctx_ptr->camera->imat;
}
bool screen = false;
@@ -2191,7 +2194,7 @@ namespace Glitter {
mat4_invert(&view_mat, &inv_view_mat);
screen = true;
}
mat4_mul(&view_mat, &rctx_ptr->camera->inv_view, &rend_group->mat_draw);
mat4_mul(&view_mat, &rctx_ptr->camera->imat, &rend_group->mat_draw);
mat4 dir_mat = mat4_identity;
vec3 up_vec = { 0.0f, 0.0f, 1.0f };
@@ -2222,7 +2225,7 @@ namespace Glitter {
mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
break;
case DIRECTION_BILLBOARD_Y_AXIS:
mat4_rotate_y(rctx_ptr->camera->rotation.y, &dir_mat);
mat4_rotate_y(rctx_ptr->camera->get_rot_y() * DEG_TO_RAD_FLOAT, &dir_mat);
break;
case DIRECTION_EMITTER_ROTATION:
emitter_rotation = true;
@@ -2332,7 +2335,7 @@ namespace Glitter {
disp_manager.set_texture_transform(tex_trans_count, tex_trans);
if (screen)
mat4_mul(&mat, &rctx_ptr->camera->inv_view, &mat);
mat4_mul(&mat, &rctx_ptr->camera->imat, &mat);
elem->mat_draw = mat;
if (screen
src/CRE/auth_3d.cpp
+7 -12
View File
@@ -16,6 +16,7 @@
#include "rob/rob.hpp"
#include "rob/motion.hpp"
#include "app_system_detail.hpp"
#include "camera.hpp"
#include "clear_color.hpp"
#include "data.hpp"
#include "debug_print.hpp"
@@ -1338,7 +1339,7 @@ namespace auth_3d_detail {
|| intr_translation.y.check_threshold_discontinuity(frame)
|| intr_translation.z.check_threshold_discontinuity(frame)) {
frame = prj::floorf(frame);
rctx->camera->set_fast_change(true);
rctx->camera->set_discontinuity();
}
else {
float_t frame_prev = frame - get_delta_frame();
@@ -1350,7 +1351,7 @@ namespace auth_3d_detail {
|| intr_translation.x.check_threshold_discontinuity(frame_prev)
|| intr_translation.y.check_threshold_discontinuity(frame_prev)
|| intr_translation.z.check_threshold_discontinuity(frame_prev))
rctx->camera->set_fast_change_hist0(true);
rctx->camera->set_discontinuity2();
}
}
@@ -1619,10 +1620,7 @@ namespace auth_3d_detail {
if (!has_dof)
return;
vec3 view_point;
rctx->camera->get_view_point(view_point);
float_t focus = vec3::distance(model_transform.translation, view_point);
float_t focus = vec3::distance(model_transform.translation, rctx->camera->get_pos());
rctx->render->enable_dof_set(fabsf(model_transform.rotation.z) > 0.000001f);
rctx->render->set_dof_data(focus, model_transform.scale.x,
@@ -5504,16 +5502,13 @@ namespace auth_3d_detail {
for (CameraRoot& i : camera_root_list) {
CameraParam cam = i.get(frame, *this, rctx);
if (M_is_reverse_side) {
cam.interest.x = -cam.interest.x;
cam.view_point.x = -cam.view_point.x;
cam.roll = -cam.roll;
}
if (M_is_reverse_side)
cam.reverse_side();
mat4_transform_point(&base_matrix, &cam.interest, &cam.interest);
mat4_transform_point(&base_matrix, &cam.view_point, &cam.view_point);
cam.set(rctx->camera);
cam.set_to_camera(rctx->camera);
break;
}
src/CRE/camera.cpp
+468 -419
View File
File diff suppressed because it is too large Load Diff
src/CRE/camera.hpp
+92 -124
View File
@@ -9,96 +9,98 @@
#include "../KKdLib/mat.hpp"
#include "../KKdLib/vec.hpp"
struct camera {
vec3 view_point;
vec3 interest;
float_t roll;
float_t fov;
float_t aet_fov;
struct CameraData {
vec3 pos;
vec3 intr;
float_t rot_z;
float_t pers;
float_t pers_2d;
double_t aspect;
float_t min_distance;
float_t max_distance;
float_t proj_left_offset;
float_t proj_right_offset;
float_t proj_bottom_offset;
float_t proj_top_offset;
float_t clip_near;
float_t clip_far;
float_t frustum_left_offset;
float_t frustum_right_offset;
float_t frustum_bottom_offset;
float_t frustum_top_offset;
bool use_up;
vec3 up;
bool ignore_fov;
bool ignore_min_dist;
mat4 view;
mat4 inv_view;
mat4 projection;
mat4 inv_projection;
mat4 view_projection;
mat4 inv_view_projection;
mat4 view_projection_prev;
mat4 inv_view_projection_prev;
mat3 view_mat3;
mat3 inv_view_mat3;
mat4 view_rot;
mat4 inv_view_rot;
mat4 view_projection_aet_2d;
mat4 view_projection_aet_3d;
float_t depth;
float_t aet_depth;
vec3 field_1E4;
vec3 field_1F0;
vec3 field_1FC;
vec3 field_208;
vec3 rotation;
bool fast_change;
bool fast_change_hist0;
bool fast_change_hist1;
bool ignore_pers;
bool ignore_near_clip;
mat4 cmat;
mat4 imat;
mat4 pmat;
mat4 vpmat;
mat3 imat3; // Added
mat4 vpmat_2d;
mat4 vpmat_pre2d;
float_t fv;
float_t fv_2d;
vec3 fpn_left;
vec3 fpn_right;
vec3 fpn_bottom;
vec3 fpn_top;
float_t distance;
vec3 rot;
float_t pers_tan;
bool portrait;
bool discontinuity;
bool discontinuity2;
bool discontinuity3;
vec3 forward;
float_t yaw;
float_t pitch;
camera();
~camera();
CameraData();
void initialize(double_t aspect);
float_t get_min_distance();
void set_min_distance(float_t value);
float_t get_max_distance();
void set_max_distance(float_t value);
double_t get_aspect();
void set_aspect(double_t value);
float_t get_fov();
void set_fov(float_t value);
float_t get_pitch();
void set_pitch(float_t value);
float_t get_yaw();
void set_yaw(float_t value);
float_t get_roll();
void set_roll(float_t value);
void get_view_point(vec3& value);
void get_view_point(vec4& value);
void set_view_point(const vec3& value);
void set_view_point(const vec3&& value);
void get_interest(vec3& value);
void set_interest(const vec3& value);
void set_interest(const vec3&& value);
void get_up(bool& use_up, vec3& value);
void set_up(bool use_up, const vec3& value);
void set_up(bool use_up, const vec3&& value);
void set_fast_change(bool value);
void set_fast_change_hist0(bool value);
void set_fast_change_hist1(bool value);
void set_ignore_fov(bool value);
void set_ignore_min_dist(bool value);
void reset();
double_t get_aspect() const;
float_t get_far_clip() const;
float_t get_fv_2d() const;
bool get_ignore_near_clip() const;
bool get_ignore_pers() const;
vec3 get_intr() const;
void get_imatrix(mat4* imat) const;
void get_matrix(mat4* cmat, mat4* pmat, mat4* vpmat) const;
float_t get_near_clip() const;
float_t get_pers() const;
vec3 get_pos() const;
float_t get_rot_y() const;
float_t get_rot_z() const;
vec3 get_up() const;
void set_aspect(double_t in_aspect);
void set_discontinuity();
void set_discontinuity2();
void set_frustum_offset(
float_t left_offset, float_t right_offset, float_t bottom_offset, float_t top_offset);
void set_far_clip(float_t in_far_clip);
void set_ignore_near_clip(bool in_ignore_near_clip);
void set_ignore_pers(bool in_ignore_pers);
void set_intr(const vec3& in_intr);
void set_near_clip(float_t in_near_clip);
void set_pers(float_t in_pers);
void set_portrait(bool in_portrait);
void set_pos(const vec3& in_pos);
void set_rot_z(float_t in_rot_z);
void set_up(bool in_use_up, const vec3& in_up);
void init();
void ctrl();
const mat4& set_projection_matrix_2d(bool is_pre2d);
// Added
void move(float_t move_x, float_t move_y);
void rotate(float_t rotate_x, float_t rotate_y);
void set(const vec3& view_point, const vec3& interest,
const vec3& trans, const vec3& rot, const vec3& scale, float_t roll, float_t fov);
void set(const vec3&& view_point, const vec3&& interest,
const vec3&& trans, const vec3&& rot, const vec3&& scale, float_t roll, float_t fov);
void set_position(const vec3& pos);
void set_position(const vec3&& pos);
void update();
void update_data();
float_t get_pitch() const;
float_t get_yaw() const;
float_t get_roll() const;
void set_pos_forward(const vec3& pos);
void set_pitch(float_t value);
void set_yaw(float_t value);
void set_roll(float_t value);
};
struct CameraParam {
@@ -115,55 +117,21 @@ struct CameraParam {
init();
}
void get(camera* cam);
void init();
void set(camera* cam);
};
struct cam_data {
vec3 view_point;
vec3 interest;
vec3 up;
float_t fov;
float_t aspect;
float_t min_distance;
float_t max_distance;
mat4 view_mat;
mat4 proj_mat;
mat4 view_proj_mat;
vec2 persp_scale;
vec2 persp_offset;
cam_data();
void calc_ortho_proj_mat(float_t left, float_t right,
float_t bottom, float_t top, const vec2& scale, const vec2& offset);
void calc_persp_proj_mat();
void calc_persp_proj_mat_offset(const vec2& persp_scale, const vec2& persp_offset);
void calc_view_mat();
void calc_view_proj_mat();
void get(const camera* cam);
float_t get_aspect() const;
float_t get_fov() const;
const vec3& get_interest() const;
float_t get_min_distance() const;
float_t get_max_distance() const;
const mat4& get_proj_mat() const;
const mat4& get_view_mat() const;
const vec3& get_view_point() const;
const mat4& get_view_proj_mat() const;
void set_aspect(float_t value);
void set_fov(float_t value);
void set_interest(const vec3& value);
void set_min_distance(float_t value);
void set_max_distance(float_t value);
void set_up(const vec3& value);
void set_view_point(const vec3& value);
void get_from_camera(CameraData* data);
void set_to_camera(CameraData* data);
void reverse_side();
};
extern vec2 calc_screen_pos(const mat4* cmat, float_t fv,
const vec3* pos, bool with_render_offset);
extern vec3 calc_screen_pos(const mat4* vpmat, float_t fv,
const vec3* pos, float_t r, bool with_render_offset);
extern float_t calc_screen_pos_r(const mat4* vpmat, float_t fv,
vec3* sc_pos, const vec3* pos, float_t r, bool with_render_offset);
extern int32_t check_screen_aabb(const struct obj_axis_aligned_bounding_box* aabb,
CameraData* cam, const mat4& mat);
extern void project_screen(const mat4* vpmat, float_t fv,
vec2* pos2d, const vec3* pos3d, bool with_render_offset);
extern void project_screen(const mat4* vpmat, float_t fv,
vec2* pos2d, const vec3* pos3d, float_t r, bool with_render_offset);
extern float_t calc_screen_pos_r(const mat4* vpmat, float_t fv,
vec3* dst, const vec3* src, float_t r, bool with_render_offset);
src/CRE/camera_render.cpp
+115
View File
@@ -0,0 +1,115 @@
/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#include "camera_render.hpp"
#include "camera.hpp"
cam_data::cam_data() : view_point(0.0f, 0.0f, 1.0f), interest(), up(0.0f, 1.0f, 0.0f),
fov(30.0f * DEG_TO_RAD_FLOAT), aspect(4.0f / 3.0f), min_distance(1.0f), max_distance(200.0f),
view_mat(), proj_mat(), view_proj_mat(), persp_scale(), persp_offset() {
}
void cam_data::calc_ortho_proj_mat(float_t left, float_t right,
float_t bottom, float_t top, const vec2& scale, const vec2& offset) {
mat4_ortho_offset(left, right, bottom, top, min_distance, max_distance, &scale, &offset, &proj_mat);
}
void cam_data::calc_persp_proj_mat() {
mat4_persp(fov, aspect, min_distance, max_distance, &proj_mat);
persp_scale = 1.0f;
persp_offset = 0.0f;
}
void cam_data::calc_persp_proj_mat_offset(const vec2& persp_scale, const vec2& persp_offset) {
mat4_persp_offset(fov, aspect, min_distance, max_distance, &persp_scale, &persp_offset, &proj_mat);
this->persp_scale = persp_scale;
this->persp_offset = persp_offset;
}
void cam_data::calc_view_mat() {
mat4_look_at(&view_point, &interest, &up, &view_mat);
}
void cam_data::calc_view_proj_mat() {
mat4_mul(&view_mat, &proj_mat, &view_proj_mat);
}
void cam_data::get(const CameraData* cam) {
view_point = cam->get_pos();
interest = cam->get_intr();
up = cam->get_up();
fov = cam->get_pers() * DEG_TO_RAD_FLOAT;
aspect = (float_t)cam->get_aspect();
min_distance = cam->get_near_clip();
max_distance = cam->get_far_clip();
cam->get_matrix(&view_mat, &proj_mat, &view_proj_mat);
persp_scale = 1.0f;
persp_offset = 0.0f;
}
float_t cam_data::get_aspect() const {
return aspect;
}
float_t cam_data::get_fov() const {
return fov;
}
const vec3& cam_data::get_interest() const {
return interest;
}
float_t cam_data::get_min_distance() const {
return min_distance;
}
float_t cam_data::get_max_distance() const {
return max_distance;
}
const mat4& cam_data::get_proj_mat() const {
return proj_mat;
}
const mat4& cam_data::get_view_mat() const {
return view_mat;
}
const vec3& cam_data::get_view_point() const {
return view_point;
}
const mat4& cam_data::get_view_proj_mat() const {
return view_proj_mat;
}
void cam_data::set_aspect(float_t value) {
aspect = value;
}
void cam_data::set_fov(float_t value) {
fov = value;
}
void cam_data::set_interest(const vec3& value) {
interest = value;
}
void cam_data::set_min_distance(float_t value) {
min_distance = value;
}
void cam_data::set_max_distance(float_t value) {
max_distance = value;
}
void cam_data::set_up(const vec3& value) {
up = value;
}
void cam_data::set_view_point(const vec3& value) {
view_point = value;
}
src/CRE/camera_render.hpp
+51
View File
@@ -0,0 +1,51 @@
/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#pragma once
#include "../KKdLib/default.hpp"
#include "../KKdLib/mat.hpp"
#include "../KKdLib/vec.hpp"
struct cam_data {
vec3 view_point;
vec3 interest;
vec3 up;
float_t fov;
float_t aspect;
float_t min_distance;
float_t max_distance;
mat4 view_mat;
mat4 proj_mat;
mat4 view_proj_mat;
vec2 persp_scale;
vec2 persp_offset;
cam_data();
void calc_ortho_proj_mat(float_t left, float_t right,
float_t bottom, float_t top, const vec2& scale, const vec2& offset);
void calc_persp_proj_mat();
void calc_persp_proj_mat_offset(const vec2& persp_scale, const vec2& persp_offset);
void calc_view_mat();
void calc_view_proj_mat();
void get(const struct CameraData* cam);
float_t get_aspect() const;
float_t get_fov() const;
const vec3& get_interest() const;
float_t get_min_distance() const;
float_t get_max_distance() const;
const mat4& get_proj_mat() const;
const mat4& get_view_mat() const;
const vec3& get_view_point() const;
const mat4& get_view_proj_mat() const;
void set_aspect(float_t value);
void set_fov(float_t value);
void set_interest(const vec3& value);
void set_min_distance(float_t value);
void set_max_distance(float_t value);
void set_up(const vec3& value);
void set_view_point(const vec3& value);
};
src/CRE/debug_print.cpp
+7 -5
View File
@@ -4,6 +4,8 @@
*/
#include "debug_print.hpp"
#include "mdl/disp_manager.hpp"
#include "camera.hpp"
#include "render_context.hpp"
#include "screen_param.hpp"
#include "sprite.hpp"
@@ -76,8 +78,8 @@ void debug_put_line(const prj::Line3f& line) {
}
void debug_put_line(const vec3& p0, const vec3& p1) {
vec2 sc_p0 = project_screen(p0, true);
vec2 sc_p1 = project_screen(p1, true);
vec2 sc_p0 = calc_screen_pos(&rctx_ptr->camera->cmat, rctx_ptr->camera->fv, &p0, true);
vec2 sc_p1 = calc_screen_pos(&rctx_ptr->camera->cmat, rctx_ptr->camera->fv, &p1, true);
spr::putLine(sc_p0, sc_p1, SCREEN_MODE_MAX, spr::SPR_PRIO_DW, primitive_color);
}
@@ -177,13 +179,13 @@ void dx_draw_line(vec3 p1, vec3 p2, color4u8 color) {
}
vec2 project_screen(vec3 vec, bool offset) {
camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
mat4_transform_point(&cam->view, &vec, &vec);
mat4_transform_point(&cam->cmat, &vec, &vec);
if (fabsf(vec.z) < 1.0e-10f)
return 0.0f;
vec2 sc_vec = cam->depth * *(vec2*)&vec.x * (1.0f / vec.z);
vec2 sc_vec = cam->fv * *(vec2*)&vec.x * (1.0f / vec.z);
ScreenParam& render_screen_param = get_render_screen_param();
sc_vec.x = (float_t)render_screen_param.width * 0.5f - sc_vec.x;
src/CRE/debug_print.hpp
-2
View File
@@ -42,5 +42,3 @@ extern void debug_put_triangle(const prj::Triangle3f& triangle);
extern void debug_put_trnsl(float_t trnsl);
extern void dx_draw_line(vec3 p1, vec3 p2, color4u8 color);
extern vec2 project_screen(vec3 vec, bool with_render_offset);
src/CRE/effect.cpp
+3 -1
View File
@@ -15,6 +15,7 @@
#include "rob/rob.hpp"
#include "app_system_detail.hpp"
#include "auth_3d.hpp"
#include "camera.hpp"
#include "data.hpp"
#include "gl_rend_state.hpp"
#include "gl_state.hpp"
@@ -1470,7 +1471,8 @@ void particle_draw(render_data_context& rend_data_ctx, const cam_data& cam) {
shader_data.g_transform[1] = temp.row1;
shader_data.g_transform[2] = temp.row2;
shader_data.g_transform[3] = temp.row3;
rctx_ptr->camera->get_view_point(shader_data.g_view_pos);
*(vec3*)&shader_data.g_view_pos = rctx_ptr->camera->get_pos();
shader_data.g_view_pos.w = 0.0f;
light_chara.get_diffuse(shader_data.g_light_env_chara_diffuse);
light_chara.get_specular(shader_data.g_light_env_chara_specular);
rend_data_ctx.state.write_uniform_buffer(particle_scene_ubo, shader_data);
src/CRE/mdl/disp_manager.cpp
+18 -60
View File
@@ -7,6 +7,7 @@
#include "../../KKdLib/database/stage.hpp"
#include "../Glitter/glitter.hpp"
#include "../prj/memory_manager.hpp"
#include "../camera.hpp"
#include "../config.hpp"
#include "../gl_state.hpp"
#include "../ogl_buffer_object.hpp"
@@ -2151,96 +2152,53 @@ namespace mdl {
obj_reflect[type].push_back(data);
}
static int32_t obj_bounding_sphere_check_visibility_default(const vec3& center, camera* cam, float_t radius) {
static int32_t obj_bounding_sphere_check_visibility_default(const vec3& center, CameraData* cam, float_t radius) {
vec3 _center;
mat4_transform_point(&cam->view, &center, &_center);
mat4_transform_point(&cam->cmat, &center, &_center);
double_t min_depth = (double_t)_center.z - (double_t)radius;
double_t max_depth = (double_t)_center.z + (double_t)radius;
if (-cam->min_distance < min_depth || -cam->max_distance > max_depth)
if (-cam->clip_near < min_depth || -cam->clip_far > max_depth)
return 0;
float_t v5 = vec3::dot(cam->field_1E4, _center);
float_t v5 = vec3::dot(cam->fpn_left, _center);
if (v5 < -radius)
return 0;
float_t v6 = vec3::dot(cam->field_1F0, _center);
float_t v6 = vec3::dot(cam->fpn_right, _center);
if (v6 < -radius)
return 0;
float_t v7 = vec3::dot(cam->field_1FC, _center);
float_t v7 = vec3::dot(cam->fpn_bottom, _center);
if (v7 < -radius)
return 0;
float_t v8 = vec3::dot(cam->field_208, _center);
float_t v8 = vec3::dot(cam->fpn_top, _center);
if (v8 < -radius)
return 0;
if (-cam->min_distance >= max_depth && -cam->max_distance <= min_depth
if (-cam->clip_near >= max_depth && -cam->clip_far <= min_depth
&& v5 >= radius && v6 >= radius && v7 >= radius && v8 >= radius)
return 1;
return 2;
}
static int32_t obj_bounding_sphere_check_visibility(const obj_bounding_sphere& sphere,
CullingCheck* culling, camera* cam, const mat4& mat) {
CullingCheck* culling, CameraData* cam, const mat4& mat) {
if (culling->func)
return culling->func(&sphere, &cam->view);
return culling->func(&sphere, &cam->cmat);
vec3 center;
mat4_transform_point(&mat, &sphere.center, &center);
return obj_bounding_sphere_check_visibility_default(center, cam, mat4_get_max_scale(&mat) * sphere.radius);
}
static int32_t obj_axis_aligned_bounding_box_check_visibility_default(
const obj_axis_aligned_bounding_box* aabb, camera* cam, const mat4& mat) {
vec3 points[8];
points[0] = aabb->center + (aabb->size ^ vec3( 0.0f, 0.0f, 0.0f));
points[1] = aabb->center + (aabb->size ^ vec3(-0.0f, -0.0f, -0.0f));
points[2] = aabb->center + (aabb->size ^ vec3(-0.0f, 0.0f, 0.0f));
points[3] = aabb->center + (aabb->size ^ vec3( 0.0f, -0.0f, -0.0f));
points[4] = aabb->center + (aabb->size ^ vec3( 0.0f, -0.0f, 0.0f));
points[5] = aabb->center + (aabb->size ^ vec3(-0.0f, 0.0f, -0.0f));
points[6] = aabb->center + (aabb->size ^ vec3( 0.0f, 0.0f, -0.0f));
points[7] = aabb->center + (aabb->size ^ vec3(-0.0f, -0.0f, 0.0f));
mat4 view_mat;
mat4_mul(&mat, &cam->view, &view_mat);
for (int32_t i = 0; i < 8; i++)
mat4_transform_point(&view_mat, &points[i], &points[i]);
vec4 v2[6];
*(vec3*)&v2[0] = { 0.0f, 0.0f, -1.0f };
v2[0].w = -cam->min_distance;
*(vec3*)&v2[1] = cam->field_1E4;
v2[1].w = 0.0f;
*(vec3*)&v2[2] = cam->field_1F0;
v2[2].w = 0.0f;
*(vec3*)&v2[3] = cam->field_1FC;
v2[3].w = 0.0f;
*(vec3*)&v2[4] = cam->field_208;
v2[4].w = 0.0f;
*(vec3*)&v2[5] = { 0.0f, 0.0f, 1.0f };
v2[5].w = cam->max_distance;
for (int32_t i = 0; i < 6; i++)
for (int32_t j = 0; j < 8; j++) {
float_t vtx_data = vec3::dot(*(vec3*)&v2[i], points[j]) + v2[i].w;
if (vtx_data > 0.0f)
break;
if (j == 7)
return 0;
}
return 1;
}
static int32_t obj_axis_aligned_bounding_box_check_visibility(
const obj_axis_aligned_bounding_box* aabb,
CullingCheck* culling, camera* cam, const mat4& mat) {
// 0x140436F80
static int32_t check_culling_aabb(const obj_axis_aligned_bounding_box* aabb,
CullingCheck* culling, CameraData* cam, const mat4& mat) {
if (culling->func)
return 1;
return obj_axis_aligned_bounding_box_check_visibility_default(aabb, cam, mat);
return check_screen_aabb(aabb, cam, mat);
}
bool DispManager::entry_obj(const ::obj* obj, const mat4& mat, VertexBuffer* vbhn_array,
@@ -2254,7 +2212,7 @@ namespace mdl {
return false;
}
::camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
if (object_culling && !instances_count && !bone_mat && (!obj
|| !obj_bounding_sphere_check_visibility(
@@ -2299,7 +2257,7 @@ namespace mdl {
sub_mesh->bounding_sphere, &culling, cam, mat);
if (v32 != 2 || (!mesh->attrib.m.billboard_view && !mesh->attrib.m.billboard)) {
if (v32 == 2)
v32 = obj_axis_aligned_bounding_box_check_visibility(
v32 = check_culling_aabb(
&sub_mesh->axis_aligned_bounding_box, &culling, cam, mat);
if (!v32) {
@@ -2317,7 +2275,7 @@ namespace mdl {
int32_t v32 = obj_bounding_sphere_check_visibility(
sub_mesh_morph->bounding_sphere, &culling, cam, mat);
if (v32 == 2)
v32 = obj_axis_aligned_bounding_box_check_visibility(
v32 = check_culling_aabb(
&sub_mesh_morph->axis_aligned_bounding_box, &culling, cam, mat);
if (!v32) {
src/CRE/mdl/draw_object.cpp
+3 -1
View File
@@ -7,8 +7,10 @@
#include "../light_param/light.hpp"
#include "../render_manager.hpp"
#include "../shader_ft.hpp"
#include "../sss.hpp"
#include "../static_var.hpp"
#include "../texture.hpp"
#include "disp_manager.hpp"
enum MaterialLightingType {
MAT_SHADER_LIGHTING_LAMBERT = 0,
@@ -88,7 +90,7 @@ namespace mdl {
stats.draw_triangle_count += count - 2;
}
void draw_etc_obj(render_data_context& rend_data_ctx, const mdl::EtcObjData* etc, const mat4* mat) {
void draw_etc_obj(render_data_context& rend_data_ctx, const EtcObjData* etc, const mat4* mat) {
const vec4 normal_color = etc->color;
const vec4 const_color = 0.0f;
src/CRE/mdl/draw_object.hpp
+4 -1
View File
@@ -12,11 +12,14 @@
#include "../render_context.hpp"
namespace mdl {
struct EtcObjData;
struct ObjSubMeshArgs;
extern void draw(
render_data_context& rend_data_ctx, obj_primitive_type primitive_type, uint32_t count,
uint16_t start, uint16_t end, obj_index_format index_format, size_t indices);
extern void draw_etc_obj(
render_data_context& rend_data_ctx, const mdl::EtcObjData* etc, const mat4* mat);
render_data_context& rend_data_ctx, const EtcObjData* etc, const mat4* mat);
extern void draw_sub_mesh(render_data_context& rend_data_ctx, const ObjSubMeshArgs* args,
const mat4* mat, void(*func)(render_data_context& rend_data_ctx,
const ObjSubMeshArgs* args, const cam_data& cam, const mat4* mat), const cam_data& cam);
src/CRE/object.cpp
+1
View File
@@ -12,6 +12,7 @@
#include "../KKdLib/hash.hpp"
#include "../KKdLib/msgpack.hpp"
#include "../KKdLib/str_utils.hpp"
#include "mdl/disp_manager.hpp"
#include "prj/memory_manager.hpp"
#include "data.hpp"
#include "ogl_buffer_object.hpp"
src/CRE/ogl_buffer_object.cpp
+1
View File
@@ -5,6 +5,7 @@
#include "ogl_buffer_object.hpp"
#include "../KKdLib/obj.hpp"
#include "mdl/disp_manager.hpp"
#include "gl_state.hpp"
#include "render_context.hpp"
src/CRE/pv_param.cpp
+4 -6
View File
@@ -7,6 +7,7 @@
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/str_utils.hpp"
#include "app_system_detail.hpp"
#include "camera.hpp"
#include "render.hpp"
#include "render_context.hpp"
@@ -1159,14 +1160,11 @@ namespace pv_param_task {
mat4_get_translation(rob_chr->get_bone_data_mat(BLK_CL_KAO), &trans);
}
camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
bool enable = true;
vec3 view_point;
cam->get_view_point(view_point);
get_autofocus_data(vec3::distance(trans, view_point), cam->get_fov(),
enable, data.data.focus, data.data.focus_range,
data.data.fuzzing_range, data.data.ratio);
get_autofocus_data(vec3::distance(trans, cam->get_pos()), cam->get_pers(), enable,
data.data.focus, data.data.focus_range, data.data.fuzzing_range, data.data.ratio);
rctx_ptr->render->enable_dof_set(enable);
}
else if (frame < 0.0f)
src/CRE/render.cpp
+3 -2
View File
@@ -7,6 +7,7 @@
#include "renderer/dof.hpp"
#include "renderer/transparency.hpp"
#include "rob/rob.hpp"
#include "camera.hpp"
#include "gl_rend_state.hpp"
#include "gl_state.hpp"
#include "reflect_full.hpp"
@@ -1415,7 +1416,7 @@ namespace rndr {
prev_cam_view_proj = cam_view_proj;
cam_view_proj = cam.get_view_proj_mat();
reset_exposure = rctx_ptr->camera->fast_change_hist1 && !rctx_ptr->camera->fast_change_hist0;
reset_exposure = rctx_ptr->camera->discontinuity3 && !rctx_ptr->camera->discontinuity2;
if (reset_exposure) {
float_t pos_dist = vec3::distance(cam_pos, prev_cam_pos);
@@ -1611,7 +1612,7 @@ namespace rndr {
mat4_transform_vector(&inv_view_proj_mat, &v45, &v45);
calc_screen_pos_r(&cam.get_view_proj_mat(),
rctx_ptr->camera->depth, &flare_pos, &position, 0.0f, false);
rctx_ptr->camera->fv, &flare_pos, &position, 0.0f, false);
float_t v17 = flare_pos.x - (float_t)scr_width * 0.5f;
float_t v19 = v5 / ((float_t)scr_height * 0.5f);
src/CRE/render.hpp
-1
View File
@@ -9,7 +9,6 @@
#include "../KKdLib/light_param/glow.hpp"
#include "../KKdLib/vec.hpp"
#include "GL/uniform_buffer.hpp"
#include "camera.hpp"
#include "render_texture.hpp"
#define TONE_MAP_SAT_GAMMA_SAMPLES 32
src/CRE/render_context.cpp
+5 -2
View File
@@ -4,7 +4,9 @@
*/
#include "render_context.hpp"
#include "mdl/disp_manager.hpp"
#include "app_system_detail.hpp"
#include "camera.hpp"
#include "gl_rend_state.hpp"
#include "gl_state.hpp"
#include "render.hpp"
@@ -13,6 +15,7 @@
#include "shadow.hpp"
#include "sound.hpp"
#include "sprite.hpp"
#include "sss.hpp"
#include "task.hpp"
extern float_t rob_frame;
@@ -1053,7 +1056,7 @@ vec2i render_context::texture_skinning_buffer::fill_data(const void* data, int32
render_context::render_context() : litproj(), chara_reflect(), chara_refract(), box_vao(), lens_ghost_vao(),
common_vao(), empty_texture_2d(), empty_texture_cube_map(), samplers(), render_samplers(), sprite_samplers(),
view_w(), view_h(), view_x(), view_y(), screen_width(), screen_height() {
camera = new ::camera;
camera = new CameraData;
draw_state = new ::draw_state;
disp_manager = new mdl::DispManager;
etc_obj_manager = new mdl::EtcObjManager;
@@ -1394,7 +1397,7 @@ void render_context::disp() {
disp_manager->refresh();
draw_state->stats_update();
spr::refresh();
camera->update();
camera->ctrl();
render_manager->cam.get(camera);
app::disp_task();
render_manager->calc_shadow();
src/CRE/render_context.hpp
+8 -5
View File
@@ -15,11 +15,9 @@
#include "light_param/fog.hpp"
#include "light_param/light.hpp"
#include "light_param/wind.hpp"
#include "mdl/disp_manager.hpp"
#include "camera.hpp"
#include "camera_render.hpp"
#include "gl_rend_state.hpp"
#include "render_texture.hpp"
#include "sss.hpp"
#include <unordered_map>
#define MATRIX_BUFFER_COUNT 320
@@ -427,6 +425,11 @@ struct render_data {
void set_shader(uint32_t index);
};
namespace mdl {
struct DispManager;
struct EtcObjManager;
}
namespace rndr {
class Render;
class RenderManager;
@@ -551,13 +554,13 @@ struct render_context {
vec2i offset;
};
::camera* camera;
struct CameraData* camera;
draw_state* draw_state;
mdl::DispManager* disp_manager;
mdl::EtcObjManager* etc_obj_manager;
rndr::Render* render;
rndr::RenderManager* render_manager;
sss_data* sss_data;
struct sss_data* sss_data;
face face;
fog fog[FOG_MAX];
src/CRE/render_manager.cpp
+6 -4
View File
@@ -11,6 +11,7 @@
#include "mdl/draw_object.hpp"
#include "rob/rob.hpp"
#include "Vulkan/gl_wrap.hpp"
#include "camera.hpp"
#include "config.hpp"
#include "clear_color.hpp"
#include "effect.hpp"
@@ -23,6 +24,7 @@
#include "shader_ft.hpp"
#include "shadow.hpp"
#include "sprite.hpp"
#include "sss.hpp"
#include "static_var.hpp"
#include "texture.hpp"
@@ -133,7 +135,7 @@ namespace rndr {
shadow_ptr->reset_group();
if (shadow) {
shadow_ptr->set_view_mtx(&rctx_ptr->camera->view);
shadow_ptr->set_view_mtx(&rctx_ptr->camera->cmat);
light_data& light_chara = rctx_ptr->light_set[LIGHT_SET_MAIN].lights[LIGHT_CHARA];
@@ -917,7 +919,7 @@ namespace rndr {
rend_data_ctx.state.disable_cull_face();
spr::flush(rend_data_ctx, spr::SPR_TARGET_BACK, true,
rend->user_fbo.get_texture(),
rctx_ptr->camera->view_projection_aet_3d);
rctx_ptr->camera->set_projection_matrix_2d(true));
rend_data_ctx.state.enable_cull_face();
rend_data_ctx.state.disable_blend();
rend_data_ctx.state.enable_depth_test();
@@ -1184,7 +1186,7 @@ namespace rndr {
rend_data_ctx.state.disable_cull_face();
spr::flush(rend_data_ctx, spr::SPR_TARGET_FRONT, true,
rctx->screen_overlay_buffer.get_texture(),
rctx->camera->view_projection_aet_2d);
rctx->camera->set_projection_matrix_2d(false));
rend_data_ctx.state.enable_cull_face();
rend_data_ctx.state.disable_blend();
rend_data_ctx.state.enable_depth_test();
@@ -1280,7 +1282,7 @@ namespace rndr {
rend_data_ctx.state.disable_cull_face();
spr::flush(rend_data_ctx, spr::SPR_TARGET_FRONT_3D_SURF, true,
rend->user_fbo.get_texture(),
rctx->camera->view_projection_aet_2d);
rctx->camera->set_projection_matrix_2d(false));
}
}
src/CRE/render_manager.hpp
+1 -1
View File
@@ -9,7 +9,7 @@
#include "../KKdLib/image.hpp"
#include "../KKdLib/time.hpp"
#include "../KKdLib/vec.hpp"
#include "camera.hpp"
#include "camera_render.hpp"
#include "gl.hpp"
#include "render_texture.hpp"
#include "static_var.hpp"
src/CRE/renderer/dof.cpp
+17 -13
View File
@@ -79,10 +79,13 @@ namespace renderer {
// Inlined
void DOF3::apply(render_data_context& rend_data_ctx, RenderTexture* rt, RenderTexture* buf_rt) {
camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
bool use_dof_f2 = false;
if (dof_debug_data.flags & DOF_DEBUG_USE_UI_PARAMS) {
if (dof_debug_data.flags & DOF_DEBUG_ENABLE_DOF) {
const float_t min_distance = cam->get_near_clip();
const float_t max_distance = cam->get_far_clip();
const float_t fov = cam->get_pers() * DEG_TO_RAD_FLOAT;
if (dof_debug_data.flags & DOF_DEBUG_ENABLE_PHYS_DOF) {
float_t focus = dof_debug_data.focus;
if (dof_debug_data.flags & DOF_DEBUG_AUTO_FOCUS) {
@@ -99,34 +102,35 @@ namespace renderer {
vec3 chara_trans = 0.0f;
mat4_get_translation(&mat, &chara_trans);
mat4 view_transpose;
mat4_transpose(&cam->view, &view_transpose);
focus = -vec3::dot(*(vec3*)&view_transpose.row2, chara_trans)
- view_transpose.row2.w - 0.1f;
mat4 cmat;
cam->get_matrix(&cmat, 0, 0);
const vec3 z_axis = { cmat.row0.z, cmat.row1.z, cmat.row2.z };
focus = -vec3::dot(z_axis, chara_trans) - cmat.row3.z - 0.1f;
break;
}
}
focus = max_def(focus, (float_t)cam->min_distance);
focus = max_def(focus, (float_t)min_distance);
apply(rend_data_ctx, rt, buf_rt, rt->get_texture_glid(), rt->get_depth_texture_glid(),
cam->min_distance, cam->max_distance, focus,
dof_debug_data.focal_length, cam->fov * DEG_TO_RAD_FLOAT, dof_debug_data.f_number);
min_distance, max_distance, focus,
dof_debug_data.focal_length, fov, dof_debug_data.f_number);
}
else {
float_t fuzzing_range = max_def(dof_debug_data.f2.fuzzing_range, 0.01f);
apply_f2(rend_data_ctx, rt, buf_rt, rt->get_texture_glid(), rt->get_depth_texture_glid(),
cam->min_distance, cam->max_distance, cam->fov * DEG_TO_RAD_FLOAT,
dof_debug_data.f2.focus, dof_debug_data.f2.focus_range,
min_distance, max_distance, fov, dof_debug_data.f2.focus, dof_debug_data.f2.focus_range,
fuzzing_range, dof_debug_data.f2.ratio);
use_dof_f2 = true;
}
}
}
else if (dof_pv_data.enable && dof_pv_data.f2.ratio > 0.0f) {
float_t fuzzing_range = max_def(dof_pv_data.f2.fuzzing_range, 0.01f);
const float_t min_distance = cam->get_near_clip();
const float_t max_distance = cam->get_far_clip();
const float_t fuzzing_range = max_def(dof_pv_data.f2.fuzzing_range, 0.01f);
const float_t fov = cam->get_pers() * DEG_TO_RAD_FLOAT;
apply_f2(rend_data_ctx, rt, buf_rt, rt->get_texture_glid(), rt->get_depth_texture_glid(),
cam->min_distance, cam->max_distance, cam->fov * DEG_TO_RAD_FLOAT,
dof_pv_data.f2.focus, dof_pv_data.f2.focus_range,
min_distance, max_distance, fov, dof_pv_data.f2.focus, dof_pv_data.f2.focus_range,
fuzzing_range, dof_pv_data.f2.ratio);
enum_or(dof_debug_data.flags, DOF_DEBUG_ENABLE_DOF);
dof_debug_data.f2 = dof_pv_data.f2;
src/CRE/rob/rob.cpp
+17 -18
View File
@@ -13,13 +13,14 @@
#include "../../KKdLib/str_utils.hpp"
#include "../../KKdLib/waitable_timer.hpp"
#include "../app_farc.hpp"
#include "../camera.hpp"
#include "../customize_item_table.hpp"
#include "../module_table.hpp"
#include "../data.hpp"
#include "../effect.hpp"
#include "../gl_state.hpp"
#include "../hand_item.hpp"
#include "../mdata_manager.hpp"
#include "../module_table.hpp"
#include "../pv_db.hpp"
#include "../pv_expression.hpp"
#include "../random.hpp"
@@ -727,7 +728,7 @@ struct rob_chara_age_age_object {
void calc_vertex(rob_chara_age_age_object_vertex*& vtx_data,
obj_mesh* mesh, const mat4& mat, float_t alpha);
void disp(render_context* rctx, size_t id,
bool npr, bool reflect, const vec3& a5, bool chara_color);
bool npr, bool reflect, const vec3& z_axis, bool chara_color);
::obj* get_obj_set_obj();
std::vector<GLuint>& get_obj_set_texture();
void load(object_info obj_info, int32_t count);
@@ -760,7 +761,7 @@ struct rob_chara_age_age {
void ctrl_data(rob_chara_age_age_data* data, mat4& mat);
void ctrl_skip();
void disp(render_context* rctx, size_t id,
bool npr, bool reflect, const vec3& a5, bool chara_color);
bool npr, bool reflect, const vec3& z_axis, bool chara_color);
void load(object_info obj_info, rob_chara_age_age_data* data, int32_t count);
void reset();
void set_alpha(float_t value);
@@ -8957,7 +8958,7 @@ static void sub_140409170(rob_chara_look_anim* look_anim, const mat4& adjust_mat
float_t eyes_rot_step = look_anim->eyes_rot_step * step;
if (fabsf(look_anim->eyes_rot_step - 1.0f) <= 0.000001f
|| eyes_rot_step > 1.0f || look_anim->init_eyes_rotation && !eyes_rot_anim
|| rctx_ptr->camera->fast_change_hist0 && rctx_ptr->camera->fast_change_hist1)
|| rctx_ptr->camera->discontinuity2 && rctx_ptr->camera->discontinuity3)
eyes_rot_step = 1.0f;
look_anim->init_head_rotation = false;
@@ -9079,11 +9080,8 @@ static void rob_chara_head_adjust(rob_chara* rob_chr) {
vec3* target_view_point = 0;
if (rob_bone_data->get_look_anim_head_rotation()
|| rob_bone_data->get_look_anim_ext_head_rotation()) {
if (rob_bone_data->get_look_anim_update_view_point()) {
vec3 view_point;
rctx_ptr->camera->get_view_point(view_point);
rob_bone_data->set_look_anim_target_view_point(view_point);
}
if (rob_bone_data->get_look_anim_update_view_point())
rob_bone_data->set_look_anim_target_view_point(rctx_ptr->camera->get_pos());
if (rob_bone_data->check_look_anim_head_rotation()
|| rob_bone_data->check_look_anim_ext_head_rotation())
@@ -9971,11 +9969,12 @@ static void rob_chara_age_age_ctrl(rob_chara_age_age* arr,
static void rob_chara_age_age_disp(rob_chara_age_age* arr,
render_context* rctx, int32_t rob_id, bool reflect, bool chara_color) {
bool npr = !!rctx->render_manager->npr_param;
mat4& view = rctx->camera->view;
vec3 v11 = { view.row0.z, view.row1.z, view.row2.z };
arr[rob_id * 3 + 0].disp(rctx, rob_id, npr, reflect, v11, chara_color);
arr[rob_id * 3 + 1].disp(rctx, rob_id, npr, reflect, v11, chara_color);
arr[rob_id * 3 + 2].disp(rctx, rob_id, npr, reflect, v11, chara_color);
mat4 cmat;
rctx->camera->get_matrix(&cmat, 0, 0);
const vec3 z_axis(cmat.row0.z, cmat.row1.z, cmat.row2.z);
arr[rob_id * 3 + 0].disp(rctx, rob_id, npr, reflect, z_axis, chara_color);
arr[rob_id * 3 + 1].disp(rctx, rob_id, npr, reflect, z_axis, chara_color);
arr[rob_id * 3 + 2].disp(rctx, rob_id, npr, reflect, z_axis, chara_color);
}
static void rob_chara_age_age_load(rob_chara_age_age* arr,
@@ -18055,7 +18054,7 @@ void rob_chara_age_age_object::calc_vertex(rob_chara_age_age_object_vertex*& vtx
}
void rob_chara_age_age_object::disp(render_context* rctx, size_t id,
bool npr, bool reflect, const vec3& a5, bool chara_color) {
bool npr, bool reflect, const vec3& z_axis, bool chara_color) {
int32_t disp_count = this->disp_count;
if (!info_object.info || !disp_count)
return;
@@ -18064,7 +18063,7 @@ void rob_chara_age_age_object::disp(render_context* rctx, size_t id,
std::pair<float_t, int32_t> v44[10];
for (int32_t i = 0; i < disp_count; i++) {
v44[i].first = vec3::dot(pos[i], a5);
v44[i].first = vec3::dot(pos[i], z_axis);
v44[i].second = i;
}
@@ -18511,9 +18510,9 @@ void rob_chara_age_age::ctrl_skip() {
}
void rob_chara_age_age::disp(render_context* rctx, size_t id,
bool npr, bool reflect, const vec3& a5, bool chara_color) {
bool npr, bool reflect, const vec3& z_axis, bool chara_color) {
if (alpha >= 0.1f && visible)
object.disp(rctx, id, npr || this->npr, reflect, a5, chara_color);
object.disp(rctx, id, npr || this->npr, reflect, z_axis, chara_color);
}
void rob_chara_age_age::load(object_info obj_info, rob_chara_age_age_data* data, int32_t count) {
src/CRE/shadow.cpp
+2
View File
@@ -4,9 +4,11 @@
*/
#include "shadow.hpp"
#include "mdl/disp_manager.hpp"
#include "gl_state.hpp"
#include "render_context.hpp"
#include "render_manager.hpp"
#include "object.hpp"
#include "shader_ft.hpp"
#define MIN_SHADOW_RANGE (1.2f)
src/CRE/sprite.cpp
+17 -14
View File
@@ -10,6 +10,7 @@
#include "../KKdLib/txp.hpp"
#include "GL/array_buffer.hpp"
#include "GL/element_array_buffer.hpp"
#include "camera.hpp"
#include "data.hpp"
#include "file_handler.hpp"
#include "gl.hpp"
@@ -1892,27 +1893,29 @@ namespace spr {
int32_t x_max;
int32_t y_max;
if (in_target == SPR_TARGET_FRONT || in_target == SPR_TARGET_3) {
ScreenParam& screen_param = get_screen_param();
const ScreenParam& screen_param = get_screen_param();
float_t sprite_half_width = (float_t)screen_param.width * 0.5f;
float_t sprite_half_height = (float_t)screen_param.height * 0.5f;
const float_t half_width = (float_t)screen_param.width * 0.5f;
const float_t half_height = (float_t)screen_param.height * 0.5f;
float_t aet_depth = rctx_ptr->camera->aet_depth;
float_t aet_depth_1 = 1.0f / aet_depth;
const float_t fv_2d = rctx_ptr->camera->get_fv_2d();
float_t v15a = sprite_half_height * projection_list[i].aspect * 0.2f * aet_depth_1;
float_t v15b = sprite_half_height * 0.2f * aet_depth_1;
const float_t clip_near_2d = 0.2f;
const float_t clip_far_2d = 3000.0f;
mat4 proj;
mat4_frustrum(-v15a, v15a, v15b, -v15b, 0.2f, 3000.0f, &proj);
const float_t range_x_2d = clip_near_2d * (half_height * projection_list[i].aspect) * (1.0f / fv_2d);
const float_t range_y_2d = clip_near_2d * half_height * (1.0f / fv_2d);
vec3 eye = { sprite_half_width, sprite_half_height, aet_depth };
vec3 target = { sprite_half_width, sprite_half_height, 0.0f };
mat4 pmat_2d;
mat4_frustum(-range_x_2d, range_x_2d, range_y_2d, -range_y_2d, clip_near_2d, clip_far_2d, &pmat_2d);
vec3 pos = { half_width, half_height, fv_2d };
vec3 intr = { half_width, half_height, 0.0f };
vec3 up = { 0.0f, 1.0f, 0.0f };
mat4 vmat_2d;
mat4_look_at(&pos, &intr, &up, &vmat_2d);
mat4 view;
mat4_look_at(&eye, &target, &up, &view);
mat4_mul(&view, &proj, &view_projection);
mat4_mul(&vmat_2d, &pmat_2d, &view_projection);
vec2 min;
vec2 max;
src/CRE/sss.cpp
+3 -3
View File
@@ -126,8 +126,8 @@ void sss_data::pre_proc(const struct cam_data& cam) {
render_context* rctx = rctx_ptr;
vec3 interest = rctx->camera->interest;
vec3 view_point = rctx->camera->view_point;
vec3 interest = rctx->camera->intr;
vec3 view_point = rctx->camera->pos;
RobManagement* rob_man = get_rob_management();
vec3 chara_position[2];
@@ -157,7 +157,7 @@ void sss_data::pre_proc(const struct cam_data& cam) {
interest = chara_position[0];
float_t distance_to_interest = max_def(vec3::distance(view_point, interest), 0.25f);
float_t fov_scale = max_def(tanf(rctx->camera->fov * 0.5f * DEG_TO_RAD_FLOAT) * 5.0f, 0.25f);
float_t fov_scale = max_def(tanf(rctx->camera->pers * 0.5f * DEG_TO_RAD_FLOAT) * 5.0f, 0.25f);
float_t sss_strength = 0.6f;
float_t inverse_scale = (float_t)(1.0 / clamp_def(fov_scale * distance_to_interest, 0.25f, 100.0f));
if (inverse_scale < 0.145f)
src/KKdLib/mat.cpp
+1 -1
View File
@@ -2266,7 +2266,7 @@ void mat4_lerp_rotation(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float
*(vec3*)&out_m->row2 = m2;
}
inline void mat4_frustrum(float_t left, float_t right,
inline void mat4_frustum(float_t left, float_t right,
float_t bottom, float_t top, float_t z_near, float_t z_far, mat4* out_m) {
*out_m = mat4_null;
out_m->row0.x = (2.0f * z_near) / (right - left);
src/KKdLib/mat.hpp
+1 -1
View File
@@ -232,7 +232,7 @@ extern float_t mat4_get_max_scale(const mat4* in_m1);
extern void mat4_blend(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend);
extern void mat4_blend_rotation(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend);
extern void mat4_lerp_rotation(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend);
extern void mat4_frustrum(float_t left, float_t right,
extern void mat4_frustum(float_t left, float_t right,
float_t bottom, float_t top, float_t z_near, float_t z_far, mat4* out_m);
extern void mat4_ortho(float_t left, float_t right,
float_t bottom, float_t top, float_t z_near, float_t z_far, mat4* out_m);
src/ReDIVA/app.cpp
+25 -25
View File
@@ -173,8 +173,6 @@ static int32_t old_height;
int32_t width;
int32_t height;
static const double_t aspect = 16.0 / 9.0;
static const int32_t fast_loader_speed = 60;
bool light_chara_ambient;
@@ -862,7 +860,7 @@ static render_context* render_context_load(const wchar_t* config_path) {
rctx->resize(internal_3d_res.x, internal_3d_res.y,
internal_2d_res.x, internal_2d_res.y, width, height);
rctx->camera->initialize(aspect);
rctx->camera->init();
app_resize_fb(rctx, true);
@@ -919,17 +917,17 @@ static render_context* render_context_load(const wchar_t* config_path) {
command_buffer.Destroy();
}
camera* cam = rctx->camera;
CameraData* cam = rctx->camera;
//cam->set_position({ 1.35542f, 1.41634f, 1.27852f });
//cam->set_pos_forward({ 1.35542f, 1.41634f, 1.27852f });
//cam->rotate({ -45.0, -32.5 });
//cam->set_position({ -6.67555f, 4.68882f, -3.67537f });
//cam->set_pos_forward({ -6.67555f, 4.68882f, -3.67537f });
//cam->rotate({ 136.5, -20.5 });
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
//cam->set_fov(70.0);
cam->set_view_point({ 0.0f, 1.4f, 1.0f });
cam->set_interest({ 0.0f, 1.4f, 0.0f });
cam->set_pos({ 0.0f, 1.0f, 3.45f });
cam->set_intr({ 0.0f, 1.0f, 0.0f });
//cam->set_pers(70.0);
cam->set_pos({ 0.0f, 1.4f, 1.0f });
cam->set_intr({ 0.0f, 1.4f, 0.0f });
rend_data_ctx.shader_flags.arr[U16] = 1;
@@ -1043,7 +1041,7 @@ static void render_context_ctrl(render_context* rctx) {
Vulkan::manager_next_frame(vulkan_current_frame);
}
camera* cam = rctx->camera;
CameraData* cam = rctx->camera;
gl_state.get();
@@ -1060,17 +1058,17 @@ static void render_context_ctrl(render_context* rctx) {
if (window_handle == GetForegroundWindow()) {
if (input_reset) {
input_reset = false;
cam->reset();
//cam->set_position({ 1.35542f, 1.41634f, 1.27852f });
cam->init();
//cam->set_pos_forward({ 1.35542f, 1.41634f, 1.27852f });
//cam->rotate({ -45.0, -32.5 });
//cam->set_position({ -6.67555f, 4.68882f, -3.67537f });
//cam->set_pos_forward({ -6.67555f, 4.68882f, -3.67537f });
//cam->rotate({ 136.5, -20.5 });
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
//cam->set_fov(70.0);
cam->set_fast_change_hist0(true);
cam->set_view_point({ 0.0f, 1.4f, 1.0f });
cam->set_interest({ 0.0f, 1.4f, 0.0f });
cam->set_pos({ 0.0f, 1.0f, 3.45f });
cam->set_intr({ 0.0f, 1.0f, 0.0f });
//cam->set_pers(70.0);
cam->set_discontinuity2();
cam->set_pos({ 0.0f, 1.4f, 1.0f });
cam->set_intr({ 0.0f, 1.4f, 0.0f });
}
else {
cam->rotate((float_t)input_rotate_x, (float_t)input_rotate_y);
@@ -1553,15 +1551,17 @@ static void app_resize_fb_glfw(GLFWwindow* window, int32_t w, int32_t h) {
}
static void app_resize_fb(render_context* rctx, bool change_fb) {
const ScreenParam& render_screen_param = get_render_screen_param();
internal_3d_res = vec2i::max(internal_3d_res, 20);
double_t res_width = (double_t)width;
double_t res_height = (double_t)height;
double_t view_aspect = res_width / res_height;
if (view_aspect < aspect)
res_height = round(res_width / aspect);
else if (view_aspect > aspect)
res_width = round(res_height * aspect);
if (view_aspect < render_screen_param.aspect)
res_height = round(res_width / render_screen_param.aspect);
else if (view_aspect > render_screen_param.aspect)
res_width = round(res_height * render_screen_param.aspect);
#if BAKE_PNG || BAKE_VIDEO
vec2i internal_res = { (int32_t)res_width * BAKE_RES_SCALE, (int32_t)res_height * BAKE_RES_SCALE };
src/ReDIVA/data_edit/face_anim.cpp
+1 -1
View File
@@ -288,7 +288,7 @@ bool FaceAnim::init() {
camera* cam = rctx_ptr->camera;
cam->reset();
cam->set_fast_change_hist0(true);
cam->set_discontinuity2(true);
cam->set_view_point({ 0.0f, 1.4f, 1.0f });
cam->set_interest({ 0.0f, 1.4f, 0.0f });
src/ReDIVA/data_edit/glitter_editor.cpp
+13 -12
View File
@@ -14,6 +14,7 @@
#include "../../KKdLib/txp.hpp"
#include "../../KKdLib/vec.hpp"
#include "../../CRE/Glitter/glitter.hpp"
#include "../../CRE/mdl/disp_manager.hpp"
#include "../../CRE/app_system_detail.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/data.hpp"
@@ -1941,9 +1942,9 @@ static void glitter_editor_draw_emitter_type_emitter_inst_f2(
mat4 mat;
mat4_normalize_rotation(&emit_inst->mat, &mat);
if (screen) {
mat4_mul(&rctx_ptr->camera->inv_view, &emit_inst->mat, &mat);
mat4_mul(&rctx_ptr->camera->view, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->inv_view, &mat);
mat4_mul(&rctx_ptr->camera->imat, &emit_inst->mat, &mat);
mat4_mul(&rctx_ptr->camera->cmat, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->imat, &mat);
mat4_normalize_rotation(&mat, &mat);
}
else
@@ -2019,9 +2020,9 @@ static void glitter_editor_draw_emitter_type_emitter_inst_x(
mat4 mat;
mat4_normalize_rotation(&emit_inst->mat, &mat);
if (screen) {
mat4_mul(&rctx_ptr->camera->inv_view, &emit_inst->mat, &mat);
mat4_mul(&rctx_ptr->camera->view, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->inv_view, &mat);
mat4_mul(&rctx_ptr->camera->imat, &emit_inst->mat, &mat);
mat4_mul(&rctx_ptr->camera->cmat, &mat, &mat);
mat4_mul(&mat, &rctx_ptr->camera->imat, &mat);
mat4_normalize_rotation(&mat, &mat);
}
else
@@ -2187,13 +2188,13 @@ static void glitter_editor_test_window(GlitterEditor* glt_edt) {
ImGui::Separator();
camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
static const float_t fov_min = 0.0;
static const float_t fov_max = 180.0;
float_t fov = cam->get_fov();
float_t fov = cam->get_pers();
if (ImGui::SliderScalar("Camera FOV", ImGuiDataType_Float, &fov, &fov_min, &fov_max, "%g"))
cam->set_fov(fov);
cam->set_pers(fov);
input_locked |= ImGui::IsWindowFocused();
ImGui::End();
@@ -2868,13 +2869,13 @@ static void glitter_editor_play_manager(GlitterEditor* glt_edt) {
ImGui::Separator();
camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
static const float_t fov_min = 0.0f;
static const float_t fov_max = 180.0f;
float_t fov = cam->get_fov();
float_t fov = cam->get_pers();
if (ImGui::SliderScalar("Camera FOV", ImGuiDataType_Float, &fov, &fov_min, &fov_max, "%g"))
cam->set_fov(fov);
cam->set_pers(fov);
}
static void glitter_editor_property(GlitterEditor* glt_edt) {
src/ReDIVA/data_test/auth_3d_test.cpp
+2 -1
View File
@@ -7,6 +7,7 @@
#include "../../CRE/rob/rob.hpp"
#include "../../CRE/rob/motion.hpp"
#include "../../CRE/app_system_detail.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/clear_color.hpp"
#include "../../CRE/data.hpp"
#include "../../CRE/debug_print.hpp"
@@ -1440,7 +1441,7 @@ Auth3dTestWindow::SelectionButtonCamReset::~SelectionButtonCamReset() {
void Auth3dTestWindow::SelectionButtonCamReset::Callback(dw::SelectionListener::CallbackData* data) {
CameraParam cam;
cam.set(rctx_ptr->camera);
cam.set_to_camera(rctx_ptr->camera);
}
Auth3dTestWindow::SelectionButtonDebugCamera::SelectionButtonDebugCamera() {
src/ReDIVA/data_test/glitter_test.cpp
+5 -3
View File
@@ -4,6 +4,8 @@
*/
#include "glitter_test.hpp"
#include "../../CRE/mdl/disp_manager.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/clear_color.hpp"
#include "../../CRE/data.hpp"
#include "../../CRE/render_context.hpp"
@@ -69,9 +71,9 @@ bool TaskDataTestGlitterParticle::init() {
Glitter::glt_particle_manager->draw_all = false;
Glitter::glt_particle_manager->draw_all_mesh = false;
camera* cam = rctx_ptr->camera;
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
CameraData* cam = rctx_ptr->camera;
cam->set_pos({ 0.0f, 1.0f, 3.45f });
cam->set_intr({ 0.0f, 1.0f, 0.0f });
hash = hash_fnv1a64m_empty;
scene_counter = 0;
src/ReDIVA/data_test/motion_test.cpp
+7 -6
View File
@@ -9,6 +9,7 @@
#include "../../CRE/rob/motion.hpp"
#include "../../CRE/rob/skin_param.hpp"
#include "../../CRE/app_system_detail.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/clear_color.hpp"
#include "../../CRE/data.hpp"
#include "../../CRE/debug_print.hpp"
@@ -426,10 +427,10 @@ bool DataTestMot::init() {
clear_color = 0xFF606060;
set_clear_color = true;
camera* cam = rctx_ptr->camera;
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
cam->set_roll(0.0f);
CameraData* cam = rctx_ptr->camera;
cam->set_pos({ 0.0f, 1.0f, 3.45f });
cam->set_intr({ 0.0f, 1.0f, 0.0f });
cam->set_rot_z(0.0f);
data_test_mot_dw_array_init(ROB_ID_1P, &dtm_mot_array[ROB_ID_1P]);
data_test_mot_dw_array_init(ROB_ID_2P, &dtm_mot_array[ROB_ID_2P]);
@@ -625,13 +626,13 @@ bool DataTestMot::ctrl() {
cam.interest = { 0.0f, 1.0f, 0.0f };
cam.v_fov = 0.563171327114105f;
}
cam.set(rctx_ptr->camera);
cam.set_to_camera(rctx_ptr->camera);
}
if (data.field_A8) {
data.field_A8 = false;
//sub_1401F9510(data.field_A9 ? 32.2673416137695f : 32.8125f);
//set_debug_camera_pers(data.field_A9 ? 32.2673416137695f : 32.8125f);
}
if (data.running && dtm_mot_array[ROB_ID_1P].CheckFirstFrame() && !frame_comp
src/ReDIVA/data_test/object_test.cpp
+13 -11
View File
@@ -4,6 +4,8 @@
*/
#include "object_test.hpp"
#include "../../CRE/mdl/disp_manager.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/clear_color.hpp"
#include "../../CRE/data.hpp"
#include "../../CRE/render_context.hpp"
@@ -87,9 +89,9 @@ TaskDataTestObj::~TaskDataTestObj() {
bool TaskDataTestObj::init() {
clear_color = 0xFF606060;
camera* cam = rctx_ptr->camera;
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
CameraData* cam = rctx_ptr->camera;
cam->set_pos({ 0.0f, 1.0f, 3.45f });
cam->set_intr({ 0.0f, 1.0f, 0.0f });
data_test_obj_dw_init();
task_stage_set_stage_index(data.stage_index);
@@ -127,28 +129,28 @@ bool TaskDataTestObj::ctrl() {
if (data.cull_camera) {
const obj_bounding_sphere* sphere = data_test_object_manager->get_object_bounding_sphere(data.obj_index);
if (sphere) {
camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
float_t v13 = tanf(cam->get_fov() * DEG_TO_RAD_FLOAT * 0.5f);
float_t v13 = tanf(cam->get_pers() * DEG_TO_RAD_FLOAT * 0.5f);
vec3 view_point;
view_point.x = sphere->center.x;
view_point.y = sphere->center.y;
view_point.z = v13 * sphere->radius + sphere->center.z + 0.2f;
view_point.z = sphere->center.z + v13 * sphere->radius + 0.2f;
vec3 interest;
interest.x = sphere->center.x;
interest.y = sphere->center.y;
interest.z = 0.0f;
cam->set_view_point(view_point);
cam->set_interest(interest);
cam->set_pos(view_point);
cam->set_intr(interest);
}
}
else {
camera* cam = rctx_ptr->camera;
cam->set_view_point({ 0.0f, 1.0f, 3.45f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
CameraData* cam = rctx_ptr->camera;
cam->set_pos({ 0.0f, 1.0f, 3.45f });
cam->set_intr({ 0.0f, 1.0f, 0.0f });
}
}
src/ReDIVA/data_test/rob_osage_test.cpp
+9 -4
View File
@@ -6,6 +6,7 @@
#include "rob_osage_test.hpp"
#include "../../CRE/Glitter/glitter.hpp"
#include "../../CRE/rob/rob.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/data.hpp"
#include "../../CRE/debug_print.hpp"
#include "../../CRE/render_context.hpp"
@@ -1168,9 +1169,11 @@ void RobOsageTest::disp_line() {
for (const RobJointNode* j = j_begin; j != j_end; j++)
dx_draw_line(j[-1].pos, j[0].pos, line_color);
for (const RobJointNode* j = j_begin; j != j_end; j++)
spr::putRect({ project_screen(j->pos, true) - 2.0f, 4.0f },
SCREEN_MODE_MAX, spr::SPR_PRIO_DW, rect_color);
for (const RobJointNode* j = j_begin; j != j_end; j++) {
vec2 pos2d;
project_screen(&rctx_ptr->camera->vpmat, rctx_ptr->camera->fv, &pos2d, &j->pos, true);
spr::putRect({ pos2d - 2.0f, 4.0f }, SCREEN_MODE_MAX, spr::SPR_PRIO_DW, rect_color);
}
mat4_scale_rot(i->osage_work.effector.dst_node_mat, 0.05f, &mat);
debug_put_line_axis(mat, color_dark_red, color_dark_green, color_dark_blue);
@@ -1253,7 +1256,9 @@ void RobOsageTest::disp_line_cls_param(const mat4& motion_matrix, const vec3& po
mat4_get_translation(&motion_matrix, &p_node);
dx_draw_line(p, p_node, color_grey);
spr::putRect({ project_screen(p, true) - 1.0f, 2.0f },
vec2 pos2d;
project_screen(&rctx_ptr->camera->vpmat, rctx_ptr->camera->fv, &pos2d, &p, true);
spr::putRect({ pos2d - 1.0f, 2.0f },
SCREEN_MODE_MAX, spr::SPR_PRIO_DW, color_yellow);
}
src/ReDIVA/data_view/draw_task.cpp
+2 -1
View File
@@ -4,9 +4,10 @@
*/
#include "draw_task.hpp"
#include "../../CRE/render_context.hpp"
#include "../../KKdLib/hash.hpp"
#include "../../KKdLib/sort.hpp"
#include "../../CRE/mdl/disp_manager.hpp"
#include "../../CRE/render_context.hpp"
#include "../imgui_helper.hpp"
#include "../task_window.hpp"
src/ReDIVA/graphics/material.cpp
+2
View File
@@ -4,8 +4,10 @@
*/
#include "material.hpp"
#include "../../KKdLib/obj.hpp"
#include "../../CRE/light_param/face.hpp"
#include "../../CRE/light_param.hpp"
#include "../../CRE/object.hpp"
#include "../../CRE/render_context.hpp"
#include "../dw.hpp"
src/ReDIVA/mode_data_edit.cpp
+4 -3
View File
@@ -4,6 +4,7 @@
*/
#include "mode_data_edit.hpp"
#include "../CRE/camera.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/render_manager.hpp"
#include "data_edit/face_anim.hpp"
@@ -57,9 +58,9 @@ bool dest_data_edit_main_md() { // Added
}
bool init_data_edit_glitter_editor_md() { // Added
camera* cam = rctx_ptr->camera;
cam->set_view_point({ 0.0f, 1.4f, 1.0f });
cam->set_interest({ 0.0f, 1.4f, 0.0f });
CameraData* cam = rctx_ptr->camera;
cam->set_pos({ 0.0f, 1.4f, 1.0f });
cam->set_intr({ 0.0f, 1.4f, 0.0f });
glitter_editor.open("GLITTER EDITOR", app::TASK_PRIO_HIGH);
return true;
src/ReDIVA/mode_data_test.cpp
+4 -3
View File
@@ -4,6 +4,7 @@
*/
#include "mode_data_test.hpp"
#include "../CRE/camera.hpp"
#include "../CRE/clear_color.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/render_manager.hpp"
@@ -110,9 +111,9 @@ bool dest_data_test_obj_md() {
bool init_data_test_stg_md() {
clear_color = 0xFF606060;
camera* cam = rctx_ptr->camera;
cam->set_view_point({ 0.0f, 0.88f, 4.3f });
cam->set_interest({ 0.0f, 1.0f, 0.0f });
CameraData* cam = rctx_ptr->camera;
cam->set_pos({ 0.0f, 0.88f, 4.3f });
cam->set_intr({ 0.0f, 1.0f, 0.0f });
dtm_stg->open("DATA_TEST_STAGE");
dtw_stg_init();
src/ReDIVA/pv_game/pv_game.cpp
+12 -12
View File
@@ -9,6 +9,7 @@
#include "../../CRE/rob/motion.hpp"
#include "../../CRE/rob/skin_param.hpp"
#include "../../CRE/app_system_detail.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/customize_item_table.hpp"
#include "../../CRE/effect.hpp"
#include "../../CRE/hand_item.hpp"
@@ -426,8 +427,8 @@ void pv_game_data::reset() {
pv_game_camera_reset();
pv_data.fov = 32.2673416137695f;
pv_data.min_dist = 0.05f;
pv_data.pers = 32.2673416137695f;
pv_data.clip_near = 0.05f;
pv_data.scene_fade.reset();
pv_data.pv_game->data_itmpv_disable();
pv_data.reset_camera_post_process();
@@ -3728,7 +3729,7 @@ bool pv_game::load() {
sub_14013C8F0()->sub_14012AE60();*/
}
rctx_ptr->camera->reset();
rctx_ptr->camera->init();
data.score_final = 0;
data.challenge_time_total_bonus = 0;
@@ -3803,16 +3804,15 @@ bool pv_game::load() {
break;
}
float_t view_point_xz_pos_angle =
(float_t)(36 * get_main_timer() % 360) * DEG_TO_RAD_FLOAT;
vec3 view_point;
view_point.x = sinf(view_point_xz_pos_angle) * 40.0f;
view_point.y = 0.0f;
view_point.z = cosf(view_point_xz_pos_angle) * 40.0f;
float_t cam_pos_xz_angle = (float_t)(36 * get_main_timer() % 360) * DEG_TO_RAD_FLOAT;
vec3 cam_pos;
cam_pos.x = sinf(cam_pos_xz_angle) * 40.0f;
cam_pos.y = 0.0f;
cam_pos.z = cosf(cam_pos_xz_angle) * 40.0f;
camera* cam = rctx_ptr->camera;
cam->set_view_point(view_point);
cam->set_interest({ 0.0f, 0.0f, 0.0f });
CameraData* cam = rctx_ptr->camera;
cam->set_pos(cam_pos);
cam->set_intr({ 0.0f, 0.0f, 0.0f });
data.change_field_branch_success_counter--;
if (data.field_index < data.field_data.size())
src/ReDIVA/pv_game/pv_game_camera.cpp
+12 -11
View File
@@ -5,6 +5,7 @@
#include "pv_game_camera.hpp"
#include "../../CRE/rob/rob.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/render_context.hpp"
struct pv_game_camera {
@@ -23,8 +24,8 @@ struct pv_game_camera {
mat4 up_mat;
vec3 view_direction;
vec3 up_vec;
float_t fov;
float_t min_dist;
float_t pers;
float_t clip_near;
ROB_ID rob_id;
int32_t chara_follow_point;
float_t acceleration_1;
@@ -47,7 +48,7 @@ static bool pv_game_camera_get_edit_camera(CameraParam* cam, float_t delta_time)
static bool pv_game_camera_get_move_camera(CameraParam* cam, float_t delta_time);
pv_game_camera::pv_game_camera() : enable(), follow_chara(), edit_camera(), duration(), curr_time(),
start_distance(), end_distance(), fov(), min_dist(), rob_id(), chara_follow_point(),
start_distance(), end_distance(), pers(), clip_near(), rob_id(), chara_follow_point(),
acceleration_1(), acceleration_2(), field_F4(), acceleration(), acceleration_curr_time() {
}
@@ -66,8 +67,8 @@ void pv_game_camera::reset() {
up_mat = mat4_identity;
view_direction = { 0.0f, 0.0f, 1.0f };
up_vec = { 0.0f, 1.0f, 0.0f };
fov = 32.2673416137695f;
min_dist = 0.05f;
pers = 32.2673416137695f;
clip_near = 0.05f;
rob_id = ROB_ID_1P;
chara_follow_point = 0;
acceleration_1 = 0.0f;
@@ -92,9 +93,9 @@ void pv_game_camera_ctrl(float_t delta_time) {
else
in_transition = pv_game_camera_get_move_camera(&cam, delta_time);
cam.v_fov = pv_game_camera_data.fov * DEG_TO_RAD_FLOAT;
cam.clip_near = pv_game_camera_data.min_dist;
cam.set(rctx_ptr->camera);
cam.v_fov = pv_game_camera_data.pers * DEG_TO_RAD_FLOAT;
cam.clip_near = pv_game_camera_data.clip_near;
cam.set_to_camera(rctx_ptr->camera);
if (!in_transition)
pv_game_camera_data.reset();
@@ -164,9 +165,9 @@ void pv_game_camera_set_dsc_data(float_t duration, pv_game_camera_dsc_data& star
pv_game_camera_data.acceleration_2 = acceleration_2;
}
void pv_game_camera_set_fov_min_dist(float_t fov, float_t min_dist) {
pv_game_camera_data.fov = fov;
pv_game_camera_data.min_dist = min_dist;
void pv_game_camera_set_pers_clip_near(float_t pers, float_t clip_near) {
pv_game_camera_data.pers = pers;
pv_game_camera_data.clip_near = clip_near;
}
static float_t sub_14011B160(float_t acceleration_1, float_t acceleration_2, float_t t) {
src/ReDIVA/pv_game/pv_game_camera.hpp
+1 -1
View File
@@ -21,4 +21,4 @@ extern void pv_game_camera_reset();
extern void pv_game_camera_set_dsc_data(float_t duration, pv_game_camera_dsc_data& start,
pv_game_camera_dsc_data& end, float_t acceleration_1, float_t acceleration_2,
int32_t follow_chara, int32_t rob_id, int32_t chara_follow_point, bool edit_camera);
extern void pv_game_camera_set_fov_min_dist(float_t fov, float_t min_dist);
extern void pv_game_camera_set_pers_clip_near(float_t pers, float_t clip_near);
src/ReDIVA/pv_game/pv_game_pv_data.cpp
+35 -34
View File
@@ -6,6 +6,7 @@
#include "pv_game_pv_data.hpp"
#include "../../CRE/rob/motion.hpp"
#include "../../CRE/app_system_detail.hpp"
#include "../../CRE/camera.hpp"
#include "../../CRE/pv_expression.hpp"
#include "../../CRE/pv_param.hpp"
#include "../../CRE/render.hpp"
@@ -328,8 +329,8 @@ scene_rot_y(), field_2C550(), branch_mode(), last_challenge_note(), field_2C560(
field_2BFB8 = -1;
field_2BFBC = -1;
music_play = true;
fov = 32.2673416137695f;
min_dist = 0.05f;
pers = 32.2673416137695f;
clip_near = 0.05f;
target_flying_time = -1.0f;
measured_fps = 60.0f;
anim_frame_speed = 1.0f;
@@ -706,7 +707,7 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
frame = dsc_frame;
pv_game->set_data_campv(0, index, frame);
rctx_ptr->camera->set_fast_change_hist0(true);
rctx_ptr->camera->set_discontinuity2();
set_camera_frame_max(data_camera[0].time);
} break;
case 1: {
@@ -731,12 +732,12 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
field_2C560.field_2D0 = data_camera[1].time;
pv_game->set_data_campv(1, index, frame);
rctx_ptr->camera->set_fast_change_hist0(true);
rctx_ptr->camera->set_discontinuity2();
set_camera_frame_max(data_camera[1].time);
} break;
case 2: {
pv_game->set_data_campv(2, index, 0.0f);
rctx_ptr->camera->set_fast_change_hist0(true);
rctx_ptr->camera->set_discontinuity2();
} break;
}
} break;
@@ -1224,12 +1225,12 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
chara_follow_point = data[23];
}
pv_game_camera_set_fov_min_dist(fov, min_dist);
pv_game_camera_set_pers_clip_near(pers, clip_near);
pv_game_camera_set_dsc_data(duration, start, end, acceleration_1, acceleration_2,
follow_chara, rob_id, chara_follow_point, func == DSC_FT_EDIT_CAMERA);
pv_game_camera_ctrl(0.0f);
rctx_ptr->camera->set_fast_change_hist0(true);
rctx_ptr->camera->set_discontinuity2();
} break;
case DSC_FT_PV_END: {
dsc_data_ptr++;
@@ -1496,34 +1497,34 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
rob_chr->set_face_object_index(index >= 0 || index < 15 ? index : 0);
} break;
case DSC_FT_NEAR_CLIP: {
float_t _min_dist = (float_t)data[0] * 0.001f;
float_t _fov = (float_t)data[1] * 0.001f;
float_t clip_near = (float_t)data[0] * 0.001f;
float_t pers = (float_t)data[1] * 0.001f;
camera* cam = rctx_ptr->camera;
CameraData* cam = rctx_ptr->camera;
bool ignore_min_dist = true;
if (_min_dist <= 0.0f) {
_min_dist = 0.05f;
ignore_min_dist = false;
bool ignore_near_clip = true;
if (clip_near <= 0.0f) {
clip_near = 0.05f;
ignore_near_clip = false;
}
bool ignore_fov = true;
if (_fov <= 0.0f) {
_fov = 32.2673416137695f;
ignore_fov = false;
bool ignore_pers = true;
if (pers <= 0.0f) {
pers = 32.2673416137695f;
ignore_pers = false;
}
min_dist = _min_dist;
cam->set_ignore_min_dist(false);
cam->set_min_distance(_min_dist);
cam->set_ignore_min_dist(ignore_min_dist);
this->clip_near = clip_near;
cam->set_ignore_near_clip(false);
cam->set_near_clip(clip_near);
cam->set_ignore_near_clip(ignore_near_clip);
fov = _fov;
cam->set_ignore_fov(false);
cam->set_fov(_fov);
cam->set_ignore_fov(ignore_fov);
this->pers = pers;
cam->set_ignore_pers(false);
cam->set_pers(pers);
cam->set_ignore_pers(ignore_pers);
pv_game_camera_set_fov_min_dist(_fov, _min_dist);
pv_game_camera_set_pers_clip_near(pers, clip_near);
} break;
case DSC_FT_CLOTH_WET: {
rob_id = (ROB_ID)data[0];
@@ -2456,8 +2457,8 @@ void pv_game_pv_data::init(::pv_game* pv_game, bool music_play) {
pv_game_camera_reset();
fov = 32.2673416137695f;
min_dist = 0.05f;
pers = 32.2673416137695f;
clip_near = 0.05f;
scene_fade.reset();
@@ -2561,11 +2562,11 @@ void pv_game_pv_data::reset() {
}
void pv_game_pv_data::reset_camera_post_process() {
camera* cam = rctx_ptr->camera;
cam->set_ignore_min_dist(false);
cam->set_min_distance(0.05f);
cam->set_ignore_fov(false);
cam->set_fov(32.2673416137695f);
CameraData* cam = rctx_ptr->camera;
cam->set_ignore_near_clip(false);
cam->set_near_clip(0.05f);
cam->set_ignore_pers(false);
cam->set_pers(32.2673416137695f);
rctx_ptr->render->set_fade_color_default(1);
rctx_ptr->render->set_tone_trans_default(1);
src/ReDIVA/pv_game/pv_game_pv_data.hpp
+2 -2
View File
@@ -292,8 +292,8 @@ struct pv_game_pv_data {
bool music_playing;
int32_t field_2BFC4;
bool pv_end;
float_t fov;
float_t min_dist;
float_t pers;
float_t clip_near;
bool look_camera_enable;
bool field_2BFD5;
pv_play_data playdata[ROB_ID_MAX];
src/ReDIVA/x_pv_game.cpp
+3 -2
View File
@@ -10,6 +10,7 @@
#include "../CRE/rob/motion.hpp"
#include "../CRE/rob/skin_param.hpp"
#include "../CRE/app_system_detail.hpp"
#include "../CRE/camera.hpp"
#include "../CRE/data.hpp"
#include "../CRE/effect.hpp"
#include "../CRE/gl_state.hpp"
@@ -962,7 +963,7 @@ void x_pv_game_camera::ctrl(float_t curr_time) {
}
this->id = id;
rctx_ptr->camera->reset();
rctx_ptr->camera->init();
state = 11;
} break;
case 11: {
@@ -8347,7 +8348,7 @@ void x_pv_game::ctrl(float_t curr_time, float_t delta_time) {
x_pv_game_data* data = this->data;
for (int32_t i = 0; i < pv_count; i++, data++) {
if (!data->state) {
rctx_ptr->camera->reset();
rctx_ptr->camera->init();
data->field_1C &= ~0xD1;
data->state = 0;
data->stage_effect_index = 0;