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

Overhaul of rndr::Render class

Browse Source 
Should be called PostProcess later
This commit is contained in:
korenkonder
2026-06-02 08:45:40 +03:00
parent 1d09052a16
commit f584e1d6e6
46 changed files with 3311 additions and 3118 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/CRE/Glitter/effect_inst.cpp
+1 -1
View File
@@ -1091,7 +1091,7 @@ namespace Glitter {
ext_anim_scale.z = 0.0f;
enum_or(flags, EFFECT_INST_EXT_SCALE);
if (rob_chr->check_disp() || !(data.ext_anim_x->flags & EFFECT_EXT_ANIM_NO_DRAW_IF_NO_DATA))
if (rob_chr->get_disp() || !(data.ext_anim_x->flags & EFFECT_EXT_ANIM_NO_DRAW_IF_NO_DATA))
set_flags = true;
else
set_flags = false;
src/CRE/auth_3d.cpp
+38 -35
View File
@@ -22,6 +22,7 @@
#include "effect.hpp"
#include "object.hpp"
#include "pv_db.hpp"
#include "render.hpp"
#include "shadow.hpp"
#include "sound.hpp"
#include "stage.hpp"
@@ -1053,25 +1054,25 @@ namespace auth_3d_detail {
// 0x1401CE3E0
void CameraAuxiliary::ctrl(Scene& in_scene, render_context* rctx) {
if (has_exposure())
rctx->render.set_exposure(exposure);
rctx->render->set_exposure(exposure);
if (has_gamma())
rctx->render.set_gamma(gamma);
rctx->render->set_gamma(gamma);
if (has_saturate())
rctx->render.set_saturate_coeff(saturate, 0, false);
rctx->render->set_saturate_coef(saturate, 0, false);
if (has_auto_exposure())
rctx->render.set_auto_exposure(auto_exposure > 0.0f);
rctx->render->set_auto_exposure(auto_exposure > 0.0f);
}
// 0x1401CFDE0
void CameraAuxiliary::dest(render_context* rctx) {
if (has_exposure())
rctx->render.set_exposure(2.0f);
rctx->render->set_exposure(2.0f);
if (has_gamma())
rctx->render.set_gamma(1.0f);
rctx->render->set_gamma(1.0f);
if (has_saturate())
rctx->render.set_saturate_coeff(1.0f, 0, false);
rctx->render->set_saturate_coef(1.0f, 0, false);
if (has_auto_exposure())
rctx->render.set_auto_exposure(true);
rctx->render->set_auto_exposure(true);
init();
}
@@ -1623,15 +1624,15 @@ namespace auth_3d_detail {
float_t focus = vec3::distance(model_transform.translation, view_point);
rctx->render.set_dof_enable(fabsf(model_transform.rotation.z) > 0.000001f);
rctx->render.set_dof_data(focus, model_transform.scale.x,
rctx->render->enable_dof_set(fabsf(model_transform.rotation.z) > 0.000001f);
rctx->render->set_dof_data(focus, model_transform.scale.x,
model_transform.rotation.x, model_transform.rotation.y);
}
// 0x1401CFE70
void Dof::dest(render_context* rctx) {
if (has_dof)
rctx->render.set_dof_enable(false);
rctx->render->enable_dof_set(false);
has_dof = false;
init();
}
@@ -1871,7 +1872,7 @@ namespace auth_3d_detail {
return;
}
rctx->render.reset_scene_fade(0);
rctx->render->set_fade_color_default();
}
// 0x1401D1780
@@ -1893,7 +1894,7 @@ namespace auth_3d_detail {
else
value.w = 1.0f - t;
rctx->render.set_scene_fade(value, 0);
rctx->render->set_fade_color(&value);
}
// 0x1401B3AD0
@@ -4196,80 +4197,82 @@ namespace auth_3d_detail {
// 0x1401CEF00
void PostProcess::ctrl(Scene& in_scene, render_context* rctx) {
if (has_lens()) {
vec3 lens = rctx->render.get_lens();
float_t flare_coef[3];
rctx->render->get_flare_coef(flare_coef);
if (has_lens_flare()) {
if (!(backup_flag & FLAG_LENS_FLARE)) {
backup_lens_flare = lens.x;
backup_lens_flare = flare_coef[0];
backup_flag |= FLAG_LENS_FLARE;
}
lens.x = lens_flare;
flare_coef[0] = lens_flare;
}
if (has_lens_shaft()) {
if (!(backup_flag & FLAG_LENS_SHAFT)) {
backup_lens_shaft = lens.y;
backup_lens_shaft = flare_coef[1];
backup_flag |= FLAG_LENS_SHAFT;
}
lens.y = lens_shaft;
flare_coef[1] = lens_shaft;
}
if (has_lens_ghost()) {
if (!(backup_flag & FLAG_LENS_GHOST)) {
backup_lens_ghost = lens.z;
backup_lens_ghost = flare_coef[2];
backup_flag |= FLAG_LENS_GHOST;
}
lens.z = lens_ghost;
flare_coef[2] = lens_ghost;
}
rctx->render.set_lens(lens);
rctx->render->set_fade_color(flare_coef);
}
if (has_radius()) {
if (!(backup_flag & FLAG_RADIUS)) {
*(vec3*)&backup_radius = rctx->render.get_radius();
rctx->render->get_sigma((float_t*)&backup_radius);
backup_flag |= FLAG_RADIUS;
}
rctx->render.set_radius(*(vec3*)&radius.color);
rctx->render->set_sigma((float_t*)&radius.color);
}
if (has_intensity()) {
if (!(backup_flag & FLAG_INTENSITY)) {
*(vec3*)&backup_intensity = rctx->render.get_intensity();
rctx->render->get_intensity((float_t*)&backup_intensity);
backup_flag |= FLAG_INTENSITY;
}
rctx->render.set_intensity(*(vec3*)&intensity.color);
rctx->render->set_intensity((float_t*)&intensity.color);
}
if (has_scene_fade()) {
if (!(backup_flag & FLAG_SCENE_FADE)) {
backup_scene_fade = rctx->render.get_scene_fade();
rctx->render->get_fade_color(&backup_scene_fade);
backup_flag |= FLAG_SCENE_FADE;
}
rctx->render.set_scene_fade(scene_fade.color, 0);
rctx->render->set_fade_color(&scene_fade.color);
}
}
// 0x1401D0050
void PostProcess::dest(render_context* rctx) {
if (backup_flag & (FLAG_LENS_FLARE | FLAG_LENS_SHAFT | FLAG_LENS_GHOST)) {
vec3 value = rctx->render.get_lens();
float_t flare_coef[3];
rctx->render->get_flare_coef(flare_coef);
if (backup_flag & FLAG_LENS_FLARE)
value.x = backup_lens_flare;
flare_coef[0] = backup_lens_flare;
if (backup_flag & FLAG_LENS_SHAFT)
value.y = backup_lens_shaft;
flare_coef[1] = backup_lens_shaft;
if (backup_flag & FLAG_LENS_GHOST)
value.z = backup_lens_ghost;
rctx->render.set_lens(value);
flare_coef[2] = backup_lens_ghost;
rctx->render->set_fade_color(flare_coef);
}
if (backup_flag & FLAG_RADIUS)
rctx->render.set_radius(*(vec3*)&backup_radius);
rctx->render->set_sigma((float_t*)&backup_radius);
if (backup_flag & FLAG_INTENSITY)
rctx->render.set_intensity(*(vec3*)&backup_intensity);
rctx->render->set_intensity((float_t*)&backup_intensity);
if (backup_flag & FLAG_SCENE_FADE)
rctx->render.set_scene_fade(backup_scene_fade, 0);
rctx->render->set_fade_color(&backup_scene_fade);
}
// 0x1401DF050
src/CRE/camera.cpp
+45 -1
View File
@@ -4,6 +4,7 @@
*/
#include "camera.hpp"
#include "render.hpp"
#include "render_context.hpp"
#include "screen_param.hpp"
@@ -321,7 +322,8 @@ static void camera_calculate_projection(camera* c) {
extern render_context* rctx_ptr;
vec2 persp_scale = 1.0f;
vec2 persp_offset = rctx_ptr->render.get_taa_offset();
vec2 persp_offset;
rctx_ptr->render->perspective(persp_offset);
mat4_persp_offset(c->fov * DEG_TO_RAD_FLOAT, (float_t)c->aspect,
c->min_distance, c->max_distance, &persp_scale, &persp_offset, &c->projection);
mat4_invert(&c->projection, &c->inv_projection);
@@ -514,3 +516,45 @@ void cam_data::set_up(const vec3& value) {
void cam_data::set_view_point(const vec3& value) {
view_point = value;
}
// 0x1401F9340
void project_screen(const mat4* vpmat, float_t fv,
vec2* pos2d, const vec3* pos3d, bool with_render_offset) {
project_screen(vpmat, fv, pos2d, pos3d, 0.0f, with_render_offset);
}
// 0x1401F92E0
void project_screen(const mat4* vpmat, float_t fv,
vec2* pos2d, const vec3* pos3d, float_t r, bool with_render_offset) {
vec3 src = *pos3d;
vec3 dst;
calc_screen_pos_r(vpmat, fv, &src, &dst, r, with_render_offset);
*pos2d = vec2(dst.x, dst.y);
}
// 0x1401F7EE0
float_t calc_screen_pos_r(const mat4* vpmat, float_t fv,
vec3* dst, const vec3* src, float_t r, bool with_render_offset) {
vec4 v18 = vec4(src->x, src->y, src->z, 1.0f);
mat4_transform_vector(vpmat, &v18, &v18);
if (fabs(v18.w) >= 1.0e-10f) {
float_t v10 = 1.0f / v18.w;
float_t v11 = v18.y * v10;
float_t v12 = v18.x * v10 + 1.0f;
ScreenParam& render_screen_param = get_render_screen_param();
float_t v14 = (v12 * 0.5f) * (float_t)render_screen_param.width;
float_t v15 = ((1.0f - v11) * 0.5f) * (float_t)render_screen_param.height;
if (with_render_offset) {
ScreenParam& screen_param = get_screen_param();
v14 += (float_t)render_screen_param.xoffset;
v15 += (float_t)(screen_param.height - render_screen_param.yoffset - render_screen_param.height);
}
dst->x = v14;
dst->y = v15;
dst->z = -v18.w;
return fabsf(v10) * (fv * r);
}
*dst = 0.0f;
return 0.0f;
}
src/CRE/camera.hpp
+7
View File
@@ -160,3 +160,10 @@ struct cam_data {
void set_up(const vec3& value);
void set_view_point(const vec3& value);
};
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/effect.cpp
+6 -5
View File
@@ -19,9 +19,10 @@
#include "gl_rend_state.hpp"
#include "gl_state.hpp"
#include "random.hpp"
#include "render_texture.hpp"
#include "render.hpp"
#include "render_context.hpp"
#include "render_manager.hpp"
#include "render_texture.hpp"
#include "shader_ft.hpp"
#include "stage.hpp"
#include "stage_param.hpp"
@@ -1509,8 +1510,8 @@ void snow_particle_draw(render_data_context& rend_data_ctx, const cam_data& cam)
mat4_transpose(&cam.view_mat, &temp);
snow_scene.g_view_world_row2 = temp.row2;
snow_scene.g_size_in_projection.x = 1.0f / (float_t)rctx_ptr->render.render_width[0];
snow_scene.g_size_in_projection.y = 1.0f / (float_t)rctx_ptr->render.render_height[0];
snow_scene.g_size_in_projection.x = 1.0f / (float_t)rctx_ptr->render->fb_width[0];
snow_scene.g_size_in_projection.y = 1.0f / (float_t)rctx_ptr->render->fb_height[0];
snow_scene.g_size_in_projection.z = snow_particle_size_min;
snow_scene.g_size_in_projection.w = snow_particle_size_max;
snow_scene.g_state_point_attenuation = { 0.0f, 0.0f, point_attenuation, 0.0f };
@@ -1528,7 +1529,7 @@ void snow_particle_draw(render_data_context& rend_data_ctx, const cam_data& cam)
rend_data_ctx.state.write_uniform_buffer(snow_particle_batch_ubo, snow_batch);
rend_data_ctx.state.active_bind_texture_2d(0, tex->glid);
rend_data_ctx.state.active_bind_texture_2d(1, rctx_ptr->render.rend_texture[0].get_depth_texture_glid());
rend_data_ctx.state.active_bind_texture_2d(1, rctx_ptr->render->fb_fbo[0].get_depth_texture_glid());
rend_data_ctx.state.bind_vertex_array(rctx_ptr->common_vao);
rend_data_ctx.shader_flags.arr[U_SNOW_TYPE] = 0;
@@ -6451,7 +6452,7 @@ static void snow_particle_init(bool change_stage) {
snow_particle_fallen_count = 0;
snow_particle_fallen_index = 0;
int32_t render_height = rctx_ptr->render.render_height[0];
int32_t render_height = rctx_ptr->render->fb_height[0];
float_t snow_particle_size = (float_t)render_height * (float_t)(1.0 / 720.0);
snow_particle_size_min = snow_particle_size;
snow_particle_size_mid = snow_particle_size * 31.0f;
src/CRE/gl_rend_state.cpp
+2
View File
@@ -1174,6 +1174,8 @@ inline void gl_rend_state::generate_texture_mipmap(GLuint texture) {
}
void gl_rend_state::get() {
gl_get_error_all_print();
glGetIntegerv(GL_CURRENT_PROGRAM, (GLint*)&program);
GLenum active_texture = GL_TEXTURE0;
src/CRE/light_param.cpp
+14 -14
View File
@@ -8,6 +8,7 @@
#include "../KKdLib/hash.hpp"
#include "../KKdLib/str_utils.hpp"
#include "gl_state.hpp"
#include "render.hpp"
#include "render_context.hpp"
#include "stage_param.hpp"
@@ -472,13 +473,13 @@ void light_param_data::set_fog(const light_param_fog* f) {
}
void light_param_data::set_glow(const light_param_glow* glow) {
rndr::Render* rend = &rctx_ptr->render;
rndr::Render* rend = rctx_ptr->render;
rend->set_auto_exposure(true);
rend->set_tone_map(TONE_MAP_YCC_EXPONENT);
rend->reset_saturate_coeff(0, false);
rend->reset_scene_fade(0);
rend->reset_tone_trans(0);
rend->set_auto_exposure(1);
rend->set_tone_map_method(0);
rend->set_saturate_coef_default();
rend->set_fade_color_default();
rend->set_tone_trans_default();
if (glow->has_exposure)
rend->set_exposure(glow->exposure);
@@ -490,13 +491,13 @@ void light_param_data::set_glow(const light_param_glow* glow) {
rend->set_saturate_power(glow->saturate_power);
if (glow->has_saturate_coef)
rend->set_saturate_coeff(glow->saturate_coef, 0, false);
rend->set_saturate_coef(glow->saturate_coef);
if (glow->has_flare)
rend->set_lens(glow->flare);
rend->set_flare_coef(glow->flare);
if (glow->has_sigma)
rend->set_radius(glow->sigma);
rend->set_sigma(glow->sigma);
if (glow->has_intensity)
rend->set_intensity(glow->intensity);
@@ -505,16 +506,15 @@ void light_param_data::set_glow(const light_param_glow* glow) {
rend->set_auto_exposure(glow->auto_exposure);
if (glow->has_tone_map_method)
rend->set_tone_map(glow->tone_map_method);
rend->set_tone_map_method(glow->tone_map_method);
if (glow->has_fade_color) {
vec4 fade_color = glow->fade_color;
rend->set_scene_fade(fade_color, 0);
rend->set_scene_fade_blend_func(glow->fade_color_blend_func, 0);
rend->set_fade_color(&glow->fade_color);
rend->set_fade_blend_func(glow->fade_color_blend_func);
}
if (glow->has_tone_transform)
rend->set_tone_trans(glow->tone_transform_start, glow->tone_transform_end, 0);
rend->set_tone_trans(glow->tone_transform_start, glow->tone_transform_end);
}
void light_param_data::set_ibl(const light_param_ibl* ibl, const light_param_data_storage* storage) {
src/CRE/mdl/disp_manager.cpp
+1
View File
@@ -11,6 +11,7 @@
#include "../gl_state.hpp"
#include "../ogl_buffer_object.hpp"
#include "../render_context.hpp"
#include "../render_manager.hpp"
#include "../shader_ft.hpp"
#include "draw_object.hpp"
src/CRE/mdl/draw_object.cpp
+1
View File
@@ -5,6 +5,7 @@
#include "draw_object.hpp"
#include "../light_param/light.hpp"
#include "../render_manager.hpp"
#include "../shader_ft.hpp"
#include "../static_var.hpp"
#include "../texture.hpp"
src/CRE/object.cpp
+3 -3
View File
@@ -1677,16 +1677,16 @@ inline uint32_t get_objnum_idx2uid(uint32_t objset_index, int32_t obj_index, con
inline GLuint get_objset_gen_textures_id(uint32_t objset_index, uint32_t uid) {
std::vector<GLuint>* gentex_vec = get_objset_gen_textures_vec(objset_index);
if (!gentex_vec)
return 0;
return -1;
ObjsetInfo* info = get_objset_info(objset_index);
if (!info)
return 0;
return -1;
auto elem = info->texidx_map.find(uid);
if (elem != info->texidx_map.end())
return (*gentex_vec)[elem->second];
return 0;
return -1;
}
// 0x14045A9E0
src/CRE/pv_param.cpp
+13 -13
View File
@@ -900,7 +900,7 @@ namespace pv_param_task {
else
value = vec3::lerp(data.data_prev.color, data.data.color, frame / duration);
rctx_ptr->render.set_intensity(value);
rctx_ptr->render->set_intensity((float_t*)&value);
frame += get_delta_frame();
if (frame > duration) {
@@ -954,16 +954,16 @@ namespace pv_param_task {
contrast = lerp_def(data.data_prev.contrast, data.data.contrast, t);
}
rctx_ptr->render.set_saturate_coeff(saturation, 1, false);
rctx_ptr->render.set_exposure(exposure * 2.0f);
rctx_ptr->render->set_saturate_coef(saturation, 1, false);
rctx_ptr->render->set_exposure(exposure * 2.0f);
vec3 tone_trans_start;
vec3 tone_trans_end;
CalcToneTrans(contrast + gamma.x, tone_trans_start.x, tone_trans_end.x);
CalcToneTrans(contrast + gamma.y, tone_trans_start.y, tone_trans_end.y);
CalcToneTrans(contrast + gamma.z, tone_trans_start.z, tone_trans_end.z);
float_t tone_trans_start[3];
float_t tone_trans_end[3];
CalcToneTrans(contrast + gamma.x, tone_trans_start[0], tone_trans_end[0]);
CalcToneTrans(contrast + gamma.y, tone_trans_start[1], tone_trans_end[1]);
CalcToneTrans(contrast + gamma.z, tone_trans_start[2], tone_trans_end[2]);
rctx_ptr->render.set_tone_trans(tone_trans_start, tone_trans_end, 1);
rctx_ptr->render->set_tone_trans(tone_trans_start, tone_trans_end, 1);
frame += get_delta_frame();
if (frame > duration) {
@@ -1147,7 +1147,7 @@ namespace pv_param_task {
void PostProcessCtrlDof::Set() {
bool autofocus = data.data.rob_id != ROB_ID_NULL;
if (autofocus) {
if (!rctx_ptr->render.get_dof_update())
if (!rctx_ptr->render->get_dof_update())
return;
vec3 trans = 0.0f;
@@ -1167,7 +1167,7 @@ namespace pv_param_task {
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);
rctx_ptr->render.set_dof_enable(enable);
rctx_ptr->render->enable_dof_set(enable);
}
else if (frame < 0.0f)
return;
@@ -1196,7 +1196,7 @@ namespace pv_param_task {
ratio = lerp_def(data.data_prev.ratio, data.data.ratio, t);
}
rctx_ptr->render.set_dof_data(focus, focus_range, fuzzing_range, ratio);
rctx_ptr->render->set_dof_data(focus, focus_range, fuzzing_range, ratio);
frame += get_delta_frame();
if (frame > duration) {
@@ -1212,7 +1212,7 @@ namespace pv_param_task {
data.data = *dof;
if (fabsf(duration) > 0.000001f)
rctx_ptr->render.get_dof_data(data.data_prev.focus,
rctx_ptr->render->get_dof_data(data.data_prev.focus,
data.data_prev.focus_range, data.data_prev.fuzzing_range, data.data_prev.ratio);
else
data.data_prev = data.data;
src/CRE/render.cpp
+2298 -2160
View File
File diff suppressed because it is too large Load Diff
src/CRE/render.hpp
+270 -226
View File
@@ -12,6 +12,25 @@
#include "camera.hpp"
#include "render_texture.hpp"
#define TONE_MAP_SAT_GAMMA_SAMPLES 32
enum MagFilterType {
MAG_FILTER_NEAREST = 0,
MAG_FILTER_BILINEAR,
MAG_FILTER_SHARPEN_5_TAP,
MAG_FILTER_SHARPEN_4_TAP,
MAG_FILTER_CONE_4_TAP,
MAG_FILTER_CONE_2_TAP,
MAG_FILTER_MAX,
};
enum ToneMapMethod {
TONE_MAP_YCC_EXPONENT = 0,
TONE_MAP_RGB_LINEAR,
TONE_MAP_RGB_LINEAR2,
TONE_MAP_MAX,
};
struct cam_data;
struct p_gl_rend_state;
struct render_data_context;
@@ -22,29 +41,44 @@ namespace renderer {
};
namespace rndr {
struct Render {
enum MagFilterType {
MAG_FILTER_NEAREST = 0,
MAG_FILTER_BILINEAR,
MAG_FILTER_SHARPEN_5_TAP,
MAG_FILTER_SHARPEN_4_TAP,
MAG_FILTER_CONE_4_TAP,
MAG_FILTER_CONE_2_TAP,
MAG_FILTER_MAX,
class Render {
public:
enum CaptureSlot {
CAPTURE_SLOT_CONT = 0,
CAPTURE_SLOT_A,
CAPTURE_SLOT_B,
CAPTURE_SLOT_C,
CAPTURE_SLOT_D,
CAPTURE_SLOT_E,
CAPTURE_SLOT_MAX,
};
enum FrameTextureType {
FRAME_TEXTURE_PRE_PP = 0,
FRAME_TEXTURE_POST_PP,
FRAME_TEXTURE_FB,
FRAME_TEXTURE_MAX,
enum CaptureType {
CAPTURE_PRE_PP = 0,
CAPTURE_POST_PP,
CAPTURE_FB,
CAPTURE_MAX,
};
static const int32_t fb_level_max = 5;
static const int32_t num_scr_tex = 3;
static const int32_t num_blur_tex = 5;
static const int32_t num_fb_copy = 16;
static const int32_t num_fb_movie = 1;
static const int32_t exposure_tex_width = 32;
static const int32_t tone_map_tex_width = 16 * TONE_MAP_SAT_GAMMA_SAMPLES;
static const int32_t mag_filter_tex_width = 256;
static const int32_t refract_tex_width = 512;
static const int32_t refract_tex_height = 256;
static const int32_t fade_tex_width = 512;
static const int32_t fade_tex_height = 256;
static const int32_t num_queries = 3;
struct ExposureCharaData {
vec4 spot_coefficients[8];
float_t spot_weight;
GLuint query[3];
GLuint query_data[3];
GLuint query[num_queries];
GLuint query_data[num_queries];
ExposureCharaData();
~ExposureCharaData();
@@ -52,121 +86,119 @@ namespace rndr {
void reset();
};
struct FrameTextureData {
texture* texture;
RenderTexture render_texture;
FrameTextureType type;
struct CaptureData {
texture* txhd;
RenderTexture fbo;
CaptureType type;
FrameTextureData();
~FrameTextureData();
CaptureData();
~CaptureData();
};
struct FrameTexture {
FrameTextureData data[4];
struct Capture {
CaptureData data[4];
bool capture;
FrameTexture();
~FrameTexture();
Capture();
~Capture();
};
int32_t downsample_count;
int32_t downsample_max_count;
int32_t ssaa;
int32_t taa;
int32_t mlaa;
int32_t fb_level;
int32_t blur_level;
int32_t anti_alias;
int32_t temporal_anti_alias;
int32_t morphological_anti_alias;
int32_t cam_blur;
int32_t hd_res;
int32_t base_downsample;
int32_t min_render;
int32_t min_res;
int32_t ss_alpha_mask;
RenderTexture rend_texture[5];
RenderTexture taa_buffer[3];
texture* taa_tex[3];
RenderTexture composite_back_texture;
texture* composite_back_tex;
RenderTexture downsample_texture;
RenderTexture reduce_texture[5];
texture* reduce_tex[5];
RenderTexture field_340;
GLuint reduce_tex_draw;
RenderTexture exposure_texture;
GLuint exposure_tex;
texture* exposure_history;
RenderTexture field_3B8;
RenderTexture field_3E8;
GLuint tonemap_lut_texture;
RenderTexture mlaa_buffer;
RenderTexture temp_buffer;
GLuint mlaa_area_texture;
RenderTexture* sss_contour_texture;
int32_t texture_counter;
GLuint lens_shaft_query[3];
GLuint lens_flare_query[3];
GLuint lens_shaft_query_data[3];
GLuint lens_flare_query_data[3];
int32_t lens_flare_query_index;
GLuint lens_flare_texture;
GLuint lens_shaft_texture;
GLuint lens_ghost_texture;
int32_t lens_ghost_count;
int32_t width;
int32_t height;
int32_t inner_width;
int32_t inner_height;
int32_t render_width[5];
int32_t render_height[5];
int32_t render_post_width[5];
int32_t render_post_height[5];
float_t render_post_width_scale;
float_t render_post_height_scale;
int32_t reduce_width[5];
int32_t reduce_height[5];
int32_t taa_texture_selector;
int32_t taa_texture;
float_t taa_blend;
vec3 view_point;
vec3 interest;
vec3 view_point_prev;
vec3 interest_prev;
mat4 cam_view_projection;
mat4 cam_view_projection_prev;
int32_t stage_index;
int32_t stage_index_prev;
RenderTexture fb_fbo[fb_level_max];
RenderTexture scr_fbo[num_scr_tex];
texture* scr_txhd[num_scr_tex];
RenderTexture composite_back_fbo;
texture* composite_back_txhd;
RenderTexture work_fbo;
RenderTexture blur_fbo[5];
texture* blur_txhd[5];
RenderTexture bloom_fbo;
GLuint bloom_tex;
RenderTexture exposure_avg_fbo;
GLuint exposure_avg_tex;
texture* exposure_txhd;
RenderTexture refract_fbo;
RenderTexture fade_fbo;
GLuint tone_map_tex;
RenderTexture mlaa_fbo;
RenderTexture user_fbo;
GLuint mlaa_area_tex;
RenderTexture* contour_fbo;
int32_t tex_count;
GLuint sun_queries_center[num_queries];
GLuint sun_queries_sphere[num_queries];
GLuint sun_pixels_center[num_queries];
GLuint sun_pixels_sphere[num_queries];
int32_t query_read_index;
GLuint flare_textures[3];
int32_t num_ghosts;
int32_t scr_width;
int32_t scr_height;
int32_t fb_width_org;
int32_t fb_height_org;
int32_t fb_width[5];
int32_t fb_height[5];
int32_t fb_tex_width[5];
int32_t fb_tex_height[5];
float_t fb_tex_width_scale;
float_t fb_tex_height_scale;
int32_t fb_work_width[5];
int32_t fb_work_height[5];
int32_t scr_index;
int32_t scr_disp_index;
float_t scr_tex_rate;
vec3 cam_pos;
vec3 cam_intr;
vec3 prev_cam_pos;
vec3 prev_cam_intr;
mat4 cam_view_proj;
mat4 prev_cam_view_proj;
int32_t stage_num;
int32_t prev_stage_num;
bool reset_exposure;
int32_t screen_x_offset;
int32_t screen_y_offset;
int32_t screen_width;
int32_t screen_height;
int32_t update_lut;
int32_t view_x;
int32_t view_y;
int32_t view_w;
int32_t view_h;
int32_t recalc_tone_map;
int32_t saturate_lock;
ExposureCharaData exposure_chara_data[6];
int32_t exposure_history_counter;
int32_t exposure_query_index;
vec3 lens_flare_pos;
float_t lens_shaft_scale;
float_t lens_shaft_inv_scale;
float_t lens_flare_power;
float_t field_A10;
float_t lens_flare_appear_power;
texture* render_textures_data[16];
RenderTexture render_textures[16];
texture* movie_textures_data[1];
RenderTexture movie_textures[1];
int32_t exposure_write_index;
int32_t exposure_chara_write_index;
vec3 flare_pos;
float_t flare_scale;
float_t flare_scale_default;
float_t flare_alpha;
float_t flare_alpha_enable;
float_t flare_alpha_offset;
const texture* fb_copy_txhd[num_fb_copy];
RenderTexture fb_copy_fbo[num_fb_copy];
const texture* fb_movie_txhd[num_fb_movie];
RenderTexture fb_movie_fbo[num_fb_movie];
int32_t composite_back;
renderer::DOF3* dof;
texture* transparency_tex[1];
renderer::Transparency* transparency;
int32_t saturate_index;
int32_t scene_fade_index;
int32_t fade_index;
int32_t tone_trans_index;
float_t saturate_coeff[2];
vec3 scene_fade_color[2];
float_t scene_fade_alpha[2];
int32_t scene_fade_blend_func[2];
vec3 tone_trans_scale[2];
vec3 tone_trans_offset[2];
vec3 tone_trans_start[2];
vec3 tone_trans_end[2];
tone_map_method tone_map;
float_t saturate_coef[2];
float_t fade_color[2][3];
float_t fade_rate[2];
int32_t fade_blend_func[2];
float_t tone_trans_scale[2][3];
float_t tone_trans_offset[2][3];
float_t tone_trans_start[2][3];
float_t tone_trans_end[2][3];
ToneMapMethod tone_map_method;
float_t exposure;
float_t exposure_rate;
int32_t auto_exposure;
@@ -174,128 +206,140 @@ namespace rndr {
float_t gamma_rate;
int32_t saturate_power;
MagFilterType mag_filter;
float_t fade_alpha;
int32_t fade;
float_t lens_flare;
float_t lens_shaft;
float_t lens_ghost;
vec3 radius;
vec3 intensity;
float_t fade_tex_rate;
int32_t fade_tex_type;
float_t flare_coef[3];
float_t sigma[3];
float_t filter_inten[3];
int32_t update;
FrameTexture frame_texture[6];
Render();
~Render();
void apply_post_process(render_data_context& rend_data_ctx,
const cam_data& cam, texture* light_proj_tex, int32_t npr_param);
void begin_render(p_gl_rend_state& p_gl_rend_st, bool composite_back = false);
void calc_exposure_chara_data(render_data_context& rend_data_ctx, const cam_data& cam);
void draw_lens_flare(render_data_context& rend_data_ctx, const cam_data& cam);
void draw_quad(render_data_context& rend_data_ctx,
int32_t width, int32_t height, float_t s0, float_t t0, float_t s1, float_t t1,
float_t scale, float_t param_x, float_t param_y, float_t param_z, float_t param_w);
void draw_sss_contour(render_data_context& rend_data_ctx, const cam_data& cam);
void end_render(p_gl_rend_state& p_gl_rend_st);
bool frame_texture_cont_capture_set(bool value);
void frame_texture_free();
int32_t frame_texture_load(int32_t slot, FrameTextureType type, texture* tex);
void frame_texture_reset();
bool frame_texture_slot_capture_set(int32_t index);
bool frame_texture_unload(int32_t slot, texture* tex);
void free();
bool get_auto_exposure();
int32_t get_cam_blur();
void get_dof_data(float_t& focus, float_t& focus_range, float_t& fuzzing_range, float_t& ratio);
bool get_dof_enable();
bool get_dof_update();
float_t get_exposure();
float_t get_exposure_rate();
float_t get_gamma();
float_t get_gamma_rate();
vec3 get_intensity();
vec3 get_lens();
float_t get_lens_flare_appear_power();
float_t get_lens_flare_power();
MagFilterType get_mag_filter();
int32_t get_mlaa();
vec3 get_radius();
void get_render_resolution(float_t* render_width, float_t* render_height,
float_t* render_post_width, float_t* render_post_height);
float_t get_saturate_coeff();
int32_t get_saturate_power();
vec4 get_scene_fade();
float_t get_scene_fade_alpha();
int32_t get_scene_fade_blend_func();
vec3 get_scene_fade_color();
int32_t get_taa();
vec2 get_taa_offset();
tone_map_method get_tone_map();
void get_tone_trans(vec3& start, vec3& end);
void init_render_buffers(int32_t width, int32_t height,
int32_t ssaa, int32_t hd_res, int32_t ss_alpha_mask);
void init_post_process_buffers();
int32_t movie_texture_set(texture* movie_texture);
void movie_texture_free(texture* movie_texture);
void post_proc();
void pre_proc(render_data_context& rend_data_ctx);
int32_t render_texture_set(texture* render_texture, bool task_photo);
void render_texture_free(texture* render_texture, bool task_photo);
void reset_saturate_coeff(int32_t index, bool lock);
void reset_scene_fade(int32_t index);
void reset_tone_trans(int32_t index);
void resize(int32_t width, int32_t height);
void set_auto_exposure(bool value);
void set_cam_blur(int32_t value);
void set_dof_data(float_t focus, float_t focus_range, float_t fuzzing_range, float_t ratio);
void set_dof_enable(bool value);
void set_dof_update(bool value);
void set_exposure(float_t value);
void set_exposure_rate(float_t value);
void set_gamma(float_t value);
void set_gamma_rate(float_t value);
void set_intensity(const vec3& value);
void set_lens(vec3 value);
void set_mag_filter(MagFilterType value);
void set_mlaa(int32_t value);
void set_radius(const vec3& value);
void set_saturate_coeff(float_t value, int32_t index, bool lock);
void set_saturate_power(int32_t value);
void set_scene_fade(const vec4& value, int32_t index);
void set_scene_fade_alpha(float_t value, int32_t index);
void set_scene_fade_blend_func(int32_t value, int32_t index);
void set_scene_fade_color(const vec3& value, int32_t index);
void set_screen_res(int32_t x_offset, int32_t y_offset, int32_t width, int32_t height);
void set_taa(int32_t value);
void set_tone_map(tone_map_method value);
void set_tone_trans(const vec3& start, const vec3& end, int32_t index);
void begin_render_transparency(render_data_context& rend_data_ctx, RenderTexture* rt);
void end_render_transparency(render_data_context& rend_data_ctx, RenderTexture* rt, float_t alpha);
void update_res(bool set, int32_t base_downsample);
Capture capture[6];
private:
void apply_mlaa(render_data_context& rend_data_ctx,
int32_t destination, int32_t source, int32_t ss_alpha_mask);
void apply_tone_map(render_data_context& rend_data_ctx, texture* light_proj_tex, int32_t npr_param);
void apply_tone_map(render_data_context& rend_data_ctx, int64_t a3, int64_t a4,
void draw_quad_simple(render_data_context& rend_data_ctx, float_t trnsl);
void draw_quad_sun(render_data_context& rend_data_ctx, const mat4& transform, const vec4& emission);
void draw_quad_ghost(int32_t index, float_t opacity, mat4* mat, float_t*& data);
void measure_exposure(render_data_context& rend_data_ctx, const cam_data& cam);
void reduce_texture(render_data_context& rend_data_ctx);
void handle_blur_texture(render_data_context& rend_data_ctx);
void tone_map(render_data_context& rend_data_ctx, texture* light_proj_tex, int32_t npr_param);
void tone_map(render_data_context& rend_data_ctx, int64_t a3, int64_t a4,
int32_t render_width, int32_t render_height, GLuint color_tex, GLuint bloom_tex,
GLuint composite_back_tex, GLuint litproj_tex, float_t litproj_quality, int32_t width, int32_t height,
float_t s0, float_t t0, const vec4& exposure, const vec3& tone_scale, const vec3& tone_offset,
int32_t fade_func, const vec4& fade_color, int32_t tone_map, float_t gamma,
const vec2& lens_flare_pos, float_t lens_shaft_scale, float_t lens_flare_coef, float_t lens_shaft_coef,
int32_t fade_blend_func, const vec4& fade_color, int32_t tone_map, float_t gamma,
const vec2& flare_pos, float_t flare_scale, float_t flare_coef, float_t shaft_coef,
GLuint contour_color_tex, GLuint contour_depth_tex, GLuint scene_depth_tex,
bool npr1, bool a31, bool npr_mask);
void calc_exposure(render_data_context& rend_data_ctx, const cam_data& cam);
void calc_gaussian_blur(render_data_context& rend_data_ctx, float_t start, float_t step,
bool npr1, bool a31, bool npr_mask); // Added
void mlaa_calc_area_value(float_t& val_left, float_t& val_right,
int32_t cross1, int32_t cross2, int32_t dleft, int32_t dright);
void mlaa_calc_area_texture(uint8_t* data, int32_t cross1, int32_t cross2);
void mlaa_gen_area_texture();
void mlaa(render_data_context& rend_data_ctx,
int32_t destination, int32_t source, int32_t ss_alpha_mask);
void set_gauss_coef(render_data_context& rend_data_ctx, float_t start, float_t step,
int32_t kernel_size, float_t radius_scale, float_t intensity_scale);
void calc_taa_blend();
void copy_to_frame_texture(render_data_context& rend_data_ctx,
void set_tone_map_texture(p_gl_rend_state& p_gl_rend_st);
void calc_scr_tex_rate();
public:
Render();
~Render();
void create_render_buffer(int32_t width, int32_t height,
int32_t aa, int32_t minify, int32_t ss_alpha_mask);
void create_other();
void destroy();
void calc_draw_size(bool first_time, int32_t min_res);
void begin_render(p_gl_rend_state& p_gl_rend_st, bool composite_back = false);
void end_render(p_gl_rend_state& p_gl_rend_st);
void begin_render_transparency(render_data_context& rend_data_ctx, RenderTexture* rt);
void end_render_transparency(render_data_context& rend_data_ctx, RenderTexture* rt, float_t alpha);
void pre_proc(render_data_context& rend_data_ctx);
void post_proc();
void draw_quad(render_data_context& rend_data_ctx,
int32_t texel_w, int32_t texel_h, float_t s0, float_t t0, float_t s1, float_t t1,
float_t scale, float_t param_x, float_t param_y, float_t param_z, float_t param_w);
void query_chara_exposure(render_data_context& rend_data_ctx, const cam_data& cam);
void draw_sun_request(const GLuint* flares, float_t scale, int32_t ghosts);
void draw_sun(render_data_context& rend_data_ctx, const cam_data& cam);
void draw_ghost(render_data_context& rend_data_ctx);
void draw_flare(render_data_context& rend_data_ctx,
const cam_data& cam, texture* light_proj_tex, int32_t npr_param);
void draw_contour(render_data_context& rend_data_ctx, const cam_data& cam);
int32_t register_fb_copy(const texture* txhd, bool task_photo = false);
void remove_fb_copy(const texture* txhd, bool task_photo = false);
int32_t register_fb_movie(const texture* txhd);
void remove_fb_movie(const texture* txhd);
GLuint get_scr_tex();
void perspective(vec2& offset, float_t scale = 1.0f) const;
void init_capture();
void free_capture();
int32_t register_fb_man_cap(CaptureSlot slot, CaptureType type, texture* txhd);
bool unregister_fb_man_cap(CaptureSlot slot, texture* txhd);
bool is_fb_man_cap();
bool set_frame_texture_aoto_cap(bool value);
bool capture_slot_enable(CaptureSlot slot);
void process_capture(render_data_context& rend_data_ctx,
GLuint pre_pp_tex, int32_t wight, int32_t height, GLuint post_pp_tex);
void draw_lens_ghost(render_data_context& rend_data_ctx);
void downsample(render_data_context& rend_data_ctx);
void generate_mlaa_area_texture();
void get_blur(render_data_context& rend_data_ctx);
void update_tone_map_lut(p_gl_rend_state& p_gl_rend_st);
void set_tone_map_method(int32_t value);
void set_exposure(float_t value);
void set_exposure_rate(float_t value);
void set_auto_exposure(int32_t value);
void set_gamma(float_t value);
void set_gamma_rate(float_t value);
void set_saturate_power(int32_t value);
void set_saturate_coef(float_t value, int32_t index = 0, bool lock = false);
void set_saturate_coef_default(int32_t index = 0, bool lock = false);
void set_mag_filter(int32_t value);
void set_temporal_aa(int32_t value);
void set_morphological_aa(int32_t value);
void set_cam_blur(int32_t value);
void set_fade_color(const vec4* in_value, int32_t index = 0);
void set_fade_color(const float_t* value, int32_t index = 0);
void set_fade_rate(float_t value, int32_t index = 0);
void set_fade_color_default(int32_t index = 0);
void set_fade_blend_func(int32_t value, int32_t index = 0);
void set_tone_trans(const float_t* start, const float_t* end, int32_t index = 0);
void set_tone_trans_default(int32_t index = 0);
void set_fade_tex_rate(float_t value);
void set_fade_tex_type(int32_t value);
void set_flare_coef(const float_t* value);
void set_sigma(const float_t* value);
void set_intensity(const float_t* value);
void set_viewport(int32_t x, int32_t y, int32_t w, int32_t h);
void get_tone_map_method(int32_t* value) const;
void get_exposure(float_t* value) const;
void get_exposure_rate(float_t* value) const;
void get_auto_exposure(int32_t* value) const;
void get_gamma(float_t* value) const;
void get_gamma_rate(float_t* value) const;
void get_saturate_power(int32_t* value) const;
void get_saturate_coef(float_t* value) const;
void get_mag_filter(int32_t* value) const;
void get_temporal_aa(int32_t* value) const;
void get_morphological_aa(int32_t* value) const;
void get_cam_blur(int32_t* value) const;
void get_fade_color(vec4* value) const;
void get_fade_color(float_t* value) const;
void get_fade_rate(float_t* value) const;
void get_fade_blend_func(int32_t* value) const;
void get_tone_trans(float_t* start_arg, float_t* end_arg) const;
void get_flare_coef(float_t* value) const;
void get_sigma(float_t* value) const;
void get_intensity(float_t* value) const;
void get_render_param(float_t* fb_width_arg, float_t* fb_height_arg,
float_t* fb_tex_width_arg, float_t* fb_tex_height_arg) const;
void enable_dof_set(bool value);
void update_dof_set(bool value); // Added
bool get_dof_enable();
bool get_dof_update(); // Added
void get_dof_data(float_t& focus, float_t& focus_range, float_t& fuzzing_range, float_t& ratio);
void set_dof_data(float_t focus, float_t focus_range, float_t fuzzing_range, float_t ratio);
void resize(int32_t width, int32_t height); // Added
};
}
src/CRE/render_context.cpp
+22 -16
View File
@@ -7,6 +7,8 @@
#include "app_system_detail.hpp"
#include "gl_rend_state.hpp"
#include "gl_state.hpp"
#include "render.hpp"
#include "render_manager.hpp"
#include "shader_ft.hpp"
#include "shadow.hpp"
#include "sound.hpp"
@@ -1050,11 +1052,12 @@ 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(),
sprite_width(), sprite_height(), screen_x_offset(), screen_y_offset(), screen_width(), screen_height() {
view_w(), view_h(), view_x(), view_y(), screen_width(), screen_height() {
camera = new ::camera;
draw_state = new ::draw_state;
disp_manager = new mdl::DispManager;
etc_obj_manager = new mdl::EtcObjManager;
render = new rndr::Render;
render_manager = new rndr::RenderManager;
sss_data = new ::sss_data;
@@ -1347,6 +1350,11 @@ render_context::~render_context() {
render_manager = 0;
}
if (render) {
delete render;
render = 0;
}
if (etc_obj_manager) {
delete etc_obj_manager;
etc_obj_manager = 0;
@@ -1445,46 +1453,44 @@ void render_context::init() {
src.get_depth_texture() ? src.get_depth_texture()->internal_format : GL_ZERO);
};
RenderTexture& render_buffer = render.rend_texture[0];
RenderTexture& render_buffer = render->fb_fbo[0];
RenderTexture& reflect_buffer = render_manager->get_render_texture(0);
RenderTexture& shadow_buffer = get_shadow()->get_rtex(1);
init_copy_buffer(reflect_buffer, this->reflect_buffer);
init_copy_buffer(render_buffer, this->render_buffer);
init_copy_buffer(shadow_buffer, this->shadow_buffer);
screen_buffer.create_texture(sprite_width, sprite_height, 0, GL_RGBA8, 0);
screen_overlay_buffer.create_texture(sprite_width, sprite_height, 0, GL_RGBA8, 0);
screen_buffer.create_texture(view_w, view_h, 0, GL_RGBA8, 0);
screen_overlay_buffer.create_texture(view_w, view_h, 0, GL_RGBA8, 0);
}
void render_context::resize(int32_t render_width, int32_t render_height,
int32_t sprite_width, int32_t sprite_height,
int32_t screen_width, int32_t screen_height) {
bool render_res_change = render.inner_width != render_width || render.inner_height != render_height;
bool sprite_res_change = this->sprite_width != sprite_width || this->sprite_height != sprite_height;
int32_t view_w, int32_t view_h, int32_t screen_width, int32_t screen_height) {
bool render_res_change = render->fb_width_org != render_width || render->fb_height_org != render_height;
bool sprite_res_change = this->view_w != view_w || this->view_h != view_h;
bool screen_res_change = this->screen_width != screen_width || this->screen_height != screen_height;
if (!render_res_change && !sprite_res_change && !screen_res_change)
return;
this->sprite_width = sprite_width;
this->sprite_height = sprite_height;
this->view_w = view_w;
this->view_h = view_h;
screen_x_offset = (screen_width - sprite_width) / 2 + (screen_width - sprite_width) % 2;
screen_y_offset = (screen_height - sprite_height) / 2 + (screen_height - sprite_height) % 2;
view_x = (screen_width - view_w) / 2 + (screen_width - view_w) % 2;
view_y = (screen_height - view_h) / 2 + (screen_height - view_h) % 2;
this->screen_width = screen_width;
this->screen_height = screen_height;
if (render_res_change)
render.resize(render_width, render_height);
render->resize(render_width, render_height);
if (sprite_res_change)
render_manager->resize(sprite_width, sprite_height);
render_manager->resize(view_w, view_h);
if (render_res_change)
litproj->resize(render_width, render_height);
sprite_manager_set_res((double_t)sprite_width / (double_t)sprite_height,
sprite_width, sprite_height);
sprite_manager_set_res((double_t)view_w / (double_t)view_h, view_w, view_h);
if (render_res_change) {
free();
src/CRE/render_context.hpp
+11 -8
View File
@@ -18,8 +18,6 @@
#include "mdl/disp_manager.hpp"
#include "camera.hpp"
#include "gl_rend_state.hpp"
#include "render.hpp"
#include "render_manager.hpp"
#include "render_texture.hpp"
#include "sss.hpp"
#include <unordered_map>
@@ -429,6 +427,11 @@ struct render_data {
void set_shader(uint32_t index);
};
namespace rndr {
class Render;
class RenderManager;
}
struct render_data_context {
struct fog_params {
vec4 depth_color;
@@ -552,6 +555,7 @@ struct render_context {
draw_state* draw_state;
mdl::DispManager* disp_manager;
mdl::EtcObjManager* etc_obj_manager;
rndr::Render* render;
rndr::RenderManager* render_manager;
sss_data* sss_data;
@@ -560,7 +564,6 @@ struct render_context {
light_proj* litproj;
light_set light_set[LIGHT_SET_MAX];
rndr::Render render;
bool chara_reflect;
bool chara_refract;
@@ -607,10 +610,10 @@ struct render_context {
GLuint render_samplers[4];
GLuint sprite_samplers[3];
int32_t sprite_width;
int32_t sprite_height;
int32_t screen_x_offset;
int32_t screen_y_offset;
int32_t view_w;
int32_t view_h;
int32_t view_x;
int32_t view_y;
int32_t screen_width;
int32_t screen_height;
@@ -632,7 +635,7 @@ struct render_context {
void free();
void init();
void resize(int32_t render_width, int32_t render_height,
int32_t sprite_width, int32_t sprite_height,
int32_t view_w, int32_t view_h,
int32_t screen_width, int32_t screen_height);
void add_shared_storage_uniform_buffer_data(size_t index,
src/CRE/render_manager.cpp
+71 -62
View File
@@ -57,8 +57,8 @@ static void draw_pass_reflect_full(render_data_context& rend_data_ctx, rndr::Ren
void apply_blur_filter_sub(render_data_context& rend_data_ctx, RenderTexture* dst, RenderTexture* src,
ImgfBoxSampl filter, const vec2 res_scale, const vec4 scale, const vec4 offset);
static void render_manager_free_render_textures();
static void render_manager_init_render_textures(int32_t multisample);
static void rndpass_create_render_texture(int32_t multisample);
static void rndpass_free_render_texture();
static void set_reflect_mat(render_data_context& rend_data_ctx, cam_data& cam);
@@ -102,7 +102,7 @@ namespace rndr {
silhouette_high(), show_ref_map(), reflect_type(), clear(), tex_index(), width(), height(),
multisample_framebuffer(), multisample_renderbuffer(), multisample(), check_state(), show_vector_flags(),
show_vector_length(), show_vector_z_offset(), show_stage_shadow(), effect_texture(), npr_param(),
npr_mask(), reflect_texture_mask(), reflect_tone_curve(), field_31F(), light_stage_ambient(), npr() {
npr_mask(), reflect_texture_mask(), reflect_tone_curve(), field_31F(), light_stage_ambient(), ss4x() {
for (bool& i : pass_sw)
i = true;
@@ -232,7 +232,7 @@ namespace rndr {
multisample_renderbuffer = 0;
multisample = false;//true;
npr = false;
ss4x = false;
}
void RenderManager::resize(int32_t width, int32_t height) {
@@ -582,21 +582,22 @@ namespace rndr {
if (npr_param == 1) {
if (sss->enable && sss->downsample) {
rend_data_ctx.shader_flags.arr[U_NPR] = 1;
rend->draw_sss_contour(rend_data_ctx, reflect_cam);
rend->draw_contour(rend_data_ctx, reflect_cam);
}
else if (npr) {
else if (ss4x) {
refl_tex.begin_render(rend_data_ctx.state);
refl_tex.set_viewport(rend_data_ctx.state);
rend_data_ctx.state.clear(GL_DEPTH_BUFFER_BIT);
rctx->draw_state->rend_data[rend_data_ctx.index].shader_index = SHADER_FT_SSS_SKIN;
rend_data_ctx.state.enable_depth_test();
rend_data_ctx.state.set_depth_func(GL_LEQUAL);
rend_data_ctx.state.set_depth_mask(GL_TRUE);
rctx->disp_manager->draw(rend_data_ctx, mdl::OBJ_TYPE_SSS, reflect_cam);
rend_data_ctx.state.disable_depth_test();
rctx->draw_state->rend_data[rend_data_ctx.index].shader_index = -1;
refl_tex.end_render(rend_data_ctx.state);
rend_data_ctx.shader_flags.arr[U_NPR] = 1;
rend->draw_sss_contour(rend_data_ctx, reflect_cam);
rend->draw_contour(rend_data_ctx, reflect_cam);
}
}
@@ -633,21 +634,22 @@ namespace rndr {
if (npr_param == 1) {
if (sss->enable && sss->downsample) {
rend_data_ctx.shader_flags.arr[U_NPR] = 1;
rend->draw_sss_contour(rend_data_ctx, cam);
rend->draw_contour(rend_data_ctx, cam);
}
else if (npr) {
rend->rend_texture[0].begin_render(rend_data_ctx.state);
rend->rend_texture[0].set_viewport(rend_data_ctx.state);
else if (ss4x) {
rend->fb_fbo[0].begin_render(rend_data_ctx.state);
rend->fb_fbo[0].set_viewport(rend_data_ctx.state);
rend_data_ctx.state.clear(GL_DEPTH_BUFFER_BIT);
rctx->draw_state->rend_data[rend_data_ctx.index].shader_index = SHADER_FT_SSS_SKIN;
rend_data_ctx.state.enable_depth_test();
rend_data_ctx.state.set_depth_func(GL_LEQUAL);
rend_data_ctx.state.set_depth_mask(GL_TRUE);
rctx->disp_manager->draw(rend_data_ctx, mdl::OBJ_TYPE_SSS, cam);
rend_data_ctx.state.disable_depth_test();
rctx->draw_state->rend_data[rend_data_ctx.index].shader_index = -1;
rend->rend_texture[0].end_render(rend_data_ctx.state);
rend->fb_fbo[0].end_render(rend_data_ctx.state);
rend_data_ctx.shader_flags.arr[U_NPR] = 1;
rend->draw_sss_contour(rend_data_ctx, cam);
rend->draw_contour(rend_data_ctx, cam);
}
}
@@ -916,7 +918,7 @@ namespace rndr {
rend_data_ctx.state.enable_blend();
rend_data_ctx.state.disable_cull_face();
spr::flush(rend_data_ctx, spr::SPR_TARGET_BACK, true,
rend->temp_buffer.get_texture(),
rend->user_fbo.get_texture(),
rctx->camera->view_projection_aet_3d);
rend_data_ctx.state.enable_cull_face();
rend_data_ctx.state.disable_blend();
@@ -1014,12 +1016,12 @@ namespace rndr {
if (silhouette_high)
rctx->disp_manager->draw(rend_data_ctx, mdl::OBJ_TYPE_SILHOUETTE_HIGH, cam);
render->calc_exposure_chara_data(rend_data_ctx, cam);
render->query_chara_exposure(rend_data_ctx, cam);
if (npr_param == 1)
pass_3d_contour(rend_data_ctx);
render->draw_lens_flare(rend_data_ctx, cam);
render->draw_sun(rend_data_ctx, cam);
star_catalog_draw(rend_data_ctx, cam);
draw_pass_3d_translucent(rend_data_ctx, rctx,
@@ -1082,7 +1084,10 @@ namespace rndr {
cam_data screen_cam = cam;
screen_cam.set_fov(32.2673416137695f * DEG_TO_RAD_FLOAT);
screen_cam.calc_persp_proj_mat_offset(1.0f, rctx->render.get_taa_offset());
vec2 persp_scale = 1.0f;
vec2 persp_offset;
rctx->render->perspective(persp_offset);
screen_cam.calc_persp_proj_mat_offset(persp_scale, persp_offset);
screen_cam.calc_view_proj_mat();
rend_data_ctx.set_batch_scene_camera(screen_cam);
@@ -1153,7 +1158,7 @@ namespace rndr {
light_proj_tex = litproj->draw_texture.get_texture();
}
render->apply_post_process(rend_data_ctx, cam, light_proj_tex, npr_param);
render->draw_flare(rend_data_ctx, cam, light_proj_tex, npr_param);
rend_data_ctx.state.end_event();
}
@@ -1207,14 +1212,14 @@ namespace rndr {
void RenderManager::pass_3d_contour(render_data_context& rend_data_ctx) {
render_context* rctx = rctx_ptr;
RenderTexture* rt;
RenderTexture* contour_rt;
RenderTexture* contour_fbo;
if (reflect_draw) {
rt = &get_render_texture(0);
contour_rt = &rctx->reflect_buffer;
contour_fbo = &rctx->reflect_buffer;
}
else {
rt = &render->rend_texture[0];
contour_rt = render->sss_contour_texture;
rt = &render->fb_fbo[0];
contour_fbo = render->contour_fbo;
}
rend_data_ctx.state.begin_event("`anonymous-namespace'::draw_npr_frame");
@@ -1240,8 +1245,8 @@ namespace rndr {
shaders_ft.set(rend_data_ctx.state, rend_data_ctx.shader_flags, SHADER_FT_CONTOUR_NPR);
rend_data_ctx.state.active_bind_texture_2d(14, rt->get_depth_texture_glid());
rend_data_ctx.state.active_bind_texture_2d(16, contour_rt->get_texture_glid());
rend_data_ctx.state.active_bind_texture_2d(17, contour_rt->get_depth_texture_glid());
rend_data_ctx.state.active_bind_texture_2d(16, contour_fbo->get_texture_glid());
rend_data_ctx.state.active_bind_texture_2d(17, contour_fbo->get_depth_texture_glid());
rend_data_ctx.state.bind_sampler(14, rctx->render_samplers[1]);
rend_data_ctx.state.bind_sampler(16, rctx->render_samplers[1]);
rend_data_ctx.state.bind_sampler(17, rctx->render_samplers[1]);
@@ -1273,7 +1278,7 @@ namespace rndr {
rend_data_ctx.state.enable_blend();
rend_data_ctx.state.disable_cull_face();
spr::flush(rend_data_ctx, spr::SPR_TARGET_FRONT_3D_SURF, true,
rend->temp_buffer.get_texture(),
rend->user_fbo.get_texture(),
rctx->camera->view_projection_aet_2d);
}
}
@@ -1312,24 +1317,25 @@ void image_filter_scale(render_data_context& rend_data_ctx,
rend_data_ctx.state.end_event();
}
void render_manager_init_data(int32_t ssaa, int32_t hd_res, int32_t ss_alpha_mask, bool npr) {
// 0x140502A10
void rndpass_init(int32_t anti_alias, int32_t min_render, int32_t ss_alpha_mask, bool ss4x) {
rndr::RenderManager& render_manager = *rctx_ptr->render_manager;
render_manager.reset();
render_manager.npr = npr;
render_manager.ss4x = ss4x;
RenderTexture::init();
ScreenParam& screen_param = get_screen_param();
ScreenParam& render_screen_param = get_render_screen_param();
render_manager.render = &rctx_ptr->render;
render_manager.render->init_render_buffers(render_screen_param.width,
render_screen_param.height, ssaa, hd_res, ss_alpha_mask);
render_manager.render->set_screen_res(render_screen_param.xoffset,
render_manager.render = rctx_ptr->render;
render_manager.render->create_render_buffer(render_screen_param.width,
render_screen_param.height, anti_alias, min_render, ss_alpha_mask);
render_manager.render->set_viewport(render_screen_param.xoffset,
render_screen_param.yoffset, render_screen_param.width, render_screen_param.height);
render_manager.width = screen_param.width;
render_manager.height = screen_param.height;
render_manager_init_render_textures(1);
render_manager.render->init_post_process_buffers();
rndpass_create_render_texture(1);
render_manager.render->create_other();
init_shadow();
render_manager.shadow_ptr = get_shadow();
@@ -1339,11 +1345,12 @@ void render_manager_init_data(int32_t ssaa, int32_t hd_res, int32_t ss_alpha_mas
gl_get_error_print();
}
void render_manager_free_data() {
// 0x140502770
void rndpass_finish() {
rndr::RenderManager& render_manager = *rctx_ptr->render_manager;
render_manager_free_render_textures();
render_manager.render->free();
rndpass_free_render_texture();
render_manager.render->destroy();
finish_shadow();
rctx_ptr->sss_data->free();
}
@@ -1513,10 +1520,10 @@ static void draw_pass_3d_translucent(render_data_context& rend_data_ctx,
&& rctx->disp_manager->get_obj_count(translucent) < 1)
return;
rndr::Render* rend = &rctx->render;
rndr::Render* rend = rctx->render;
RenderTexture& rt = reflect_draw
? rctx->render_manager->get_render_texture(0) : rend->rend_texture[0];
? rctx->render_manager->get_render_texture(0) : rend->fb_fbo[0];
int32_t alpha_array[256];
int32_t count = draw_pass_3d_translucent_count_layers(rctx,
@@ -1548,10 +1555,10 @@ static void draw_pass_3d_translucent(render_data_context& rend_data_ctx,
&& rctx->disp_manager->get_obj_count(translucent) < 1)
return;
rndr::Render* rend = &rctx->render;
rndr::Render* rend = rctx->render;
RenderTexture& rt = reflect_draw
? rctx->render_manager->get_render_texture(0) : rend->rend_texture[0];
? rctx->render_manager->get_render_texture(0) : rend->fb_fbo[0];
int32_t alpha_array[256];
int32_t count = draw_pass_3d_translucent_count_layers(rctx,
@@ -1854,28 +1861,8 @@ void apply_blur_filter_sub(render_data_context& rend_data_ctx, RenderTexture* ds
rend_data_ctx.state.end_event();
}
static void render_manager_free_render_textures() {
rndr::RenderManager& render_manager = *rctx_ptr->render_manager;
#ifdef USE_OPENGL
if (!Vulkan::use) {
if (render_manager.multisample_renderbuffer) {
glDeleteRenderbuffers(1, &render_manager.multisample_renderbuffer);
render_manager.multisample_renderbuffer = 0;
}
if (render_manager.multisample_framebuffer) {
glDeleteFramebuffers(1, &render_manager.multisample_framebuffer);
render_manager.multisample_framebuffer = 0;
}
}
#endif
for (RenderTexture& i : render_manager.render_textures)
i.destroy();
}
static void render_manager_init_render_textures(int32_t multisample) {
// 0x140502560
static void rndpass_create_render_texture(int32_t multisample) {
rndr::RenderManager& render_manager = *rctx_ptr->render_manager;
#ifdef USE_OPENGL
@@ -1918,6 +1905,28 @@ static void render_manager_init_render_textures(int32_t multisample) {
gl_state.bind_framebuffer(0);
}
// 0x1405027A0
static void rndpass_free_render_texture() {
rndr::RenderManager& render_manager = *rctx_ptr->render_manager;
#ifdef USE_OPENGL
if (!Vulkan::use) {
if (render_manager.multisample_renderbuffer) {
glDeleteRenderbuffers(1, &render_manager.multisample_renderbuffer);
render_manager.multisample_renderbuffer = 0;
}
if (render_manager.multisample_framebuffer) {
glDeleteFramebuffers(1, &render_manager.multisample_framebuffer);
render_manager.multisample_framebuffer = 0;
}
}
#endif
for (RenderTexture& i : render_manager.render_textures)
i.destroy();
}
static void set_reflect_mat(render_data_context& rend_data_ctx, cam_data& cam) {
const vec3 clip_plane = *(vec3*)&rend_data_ctx.data.buffer_scene_data.g_clip_plane;
const vec4 temp = 2.0f * rend_data_ctx.data.buffer_scene_data.g_clip_plane;
src/CRE/render_manager.hpp
+11 -5
View File
@@ -6,10 +6,13 @@
#pragma once
#include "../KKdLib/default.hpp"
#include "../KKdLib/image.hpp"
#include "../KKdLib/time.hpp"
#include "../KKdLib/vec.hpp"
#include "camera.hpp"
#include "gl.hpp"
#include "render.hpp"
#include "render_texture.hpp"
#include "static_var.hpp"
#include <list>
enum reflect_refract_resolution_mode {
@@ -49,7 +52,10 @@ namespace rndr {
RND_PASSID_NUM,
};
struct RenderManager {
class Render;
class RenderManager {
public:
bool pass_sw[RND_PASSID_NUM];
Shadow* shadow_ptr;
bool reflect;
@@ -91,7 +97,7 @@ namespace rndr {
bool reflect_tone_curve;
bool field_31F;
bool light_stage_ambient;
bool npr;
bool ss4x;
cam_data cam;
RenderManager();
@@ -148,5 +154,5 @@ namespace rndr {
extern void image_filter_scale(render_data_context& rend_data_ctx,
RenderTexture* dst, texture* src, const vec4& scale = 1.0f);
extern void render_manager_init_data(int32_t ssaa, int32_t hd_res, int32_t ss_alpha_mask, bool npr);
extern void render_manager_free_data();
extern void rndpass_init(int32_t anti_alias, int32_t min_render, int32_t ss_alpha_mask, bool ss4x);
extern void rndpass_finish();
src/CRE/renderer/dof.cpp
+1 -1
View File
@@ -86,7 +86,7 @@ namespace renderer {
size_t rob_num = rob_man->get_rob_num();
for (int32_t i = 0; i < rob_num; i++) {
rob_chara* rob_chr = rob_man->get_rob((ROB_ID)i);
if (!rob_chr || !rob_chr->check_disp())
if (!rob_chr || !rob_chr->get_disp())
continue;
mat4 mat = mat4_identity;
src/CRE/renderer/dof.hpp
+1 -1
View File
@@ -34,7 +34,7 @@ struct dof_debug {
struct dof_pv {
bool enable;
bool update;
bool update; // Added
dof_f2 f2;
};
src/CRE/renderer/transparency.cpp
+2 -1
View File
@@ -6,6 +6,7 @@
#include "transparency.hpp"
#include "../../KKdLib/str_utils.hpp"
#include "../gl_rend_state.hpp"
#include "../render.hpp"
#include "../render_context.hpp"
#include "../shader_ft.hpp"
@@ -56,7 +57,7 @@ namespace renderer {
shaders_ft.set(rend_data_ctx.state, rend_data_ctx.shader_flags, SHADER_FT_REDUCE);
rend_data_ctx.state.active_bind_texture_2d(0, texture);
rend_data_ctx.state.bind_sampler(0, rctx_ptr->render_samplers[1]);
rctx_ptr->render.draw_quad(rend_data_ctx, m_fbo.get_width(), m_fbo.get_height(),
rctx_ptr->render->draw_quad(rend_data_ctx, m_fbo.get_width(), m_fbo.get_height(),
1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
rend_data_ctx.state.enable_depth_test();
}
src/CRE/rob/rob.cpp
+5 -38
View File
@@ -23,6 +23,7 @@
#include "../pv_db.hpp"
#include "../pv_expression.hpp"
#include "../random.hpp"
#include "../render_manager.hpp"
#include "../screen_param.hpp"
#include "../shadow.hpp"
#include "../stage.hpp"
@@ -5182,7 +5183,7 @@ void rob_chara::set_rob_motion(uint32_t motnum, bool mirror, float_t frame,
// 0x140516890
void rob_chara::set_rob_motion_external(uint32_t motnum) {
if (check_disp())
if (get_disp())
set_rob_sys_command(ROB_ACT_MOTION, motnum, 0, false);
}
@@ -5826,7 +5827,7 @@ bool RobManagement::get_colli_check_on() const {
// 0x140531F50
bool RobManagement::get_disp_on(ROB_ID id) const {
if (is_init(id))
return rob_impl[id].check_disp();
return rob_impl[id].get_disp();
return false;
}
@@ -15561,40 +15562,6 @@ prj::BallCollision::BallCollision() : sink(), colli_ball_mask(), org_rad() {
}
pos_scale::pos_scale() : scale() {
}
float_t pos_scale::get_screen_pos_scale(const mat4& mat,
const vec3& pos, float_t scale, bool apply_offset) {
vec4 v19;
*(vec3*)&v19 = pos;
v19.w = 1.0f;
mat4_transform_vector(&mat, &v19, &v19);
if (fabsf(v19.w) >= 1.0e-10f) {
float_t v11 = v19.y * (1.0f / v19.w);
float_t v12 = v19.x * (1.0f / v19.w) + 1.0f;
ScreenParam& render_screen_param = get_render_screen_param();
float_t v14 = (float_t)(v12 * 0.5f) * (float_t)render_screen_param.width;
float_t v15 = (float_t)((1.0f - v11) * 0.5f) * (float_t)render_screen_param.height;
if (apply_offset) {
ScreenParam& screen_param = get_screen_param();
v14 += (float_t)render_screen_param.xoffset;
v15 += (float_t)(screen_param.height - render_screen_param.yoffset - render_screen_param.height);
}
this->pos.x = v14;
this->pos.y = v15;
this->scale = -v19.w;
return fabsf(1.0f / v19.w) * (rctx_ptr->camera->depth * scale);
}
else {
this->pos = 0.0f;
this->scale = 0.0f;
return 0.0f;
}
}
RobColliWall::RobColliWall() : wdist(), wheight() {
}
@@ -15670,7 +15637,7 @@ void RobCollision::init() {
for (prj::BallCollision& i : cb_stg)
i = {};
for (pos_scale& i : field_1AA0)
for (vec3& i : field_1AA0)
i = {};
for (float_t& i : field_1BE4)
@@ -19630,7 +19597,7 @@ void TaskRobDisp::disp() {
if (!i || pv_osage_manager_array_get_disp((ROB_ID)i->idnm))
continue;
if (i->check_disp() && !i->check_zero_disp())
if (i->get_disp() && !i->check_zero_disp())
i->disp_rob_disp_main();
}
}
src/CRE/rob/rob.hpp
+2 -12
View File
@@ -4800,16 +4800,6 @@ namespace prj {
};
}
struct pos_scale {
vec2 pos;
float_t scale;
pos_scale();
float_t get_screen_pos_scale(const mat4& mat,
const vec3& pos, float_t scale = 0.0f, bool apply_offset = false);
};
struct RobColliWall {
float_t wdist;
RobAngle wang;
@@ -4856,7 +4846,7 @@ struct RobCollision {
prj::BallCollision cb_hit[CB_NUM];
prj::BallCollision cb_rob[CB_NUM];
prj::BallCollision cb_stg[CB_NUM];
pos_scale field_1AA0[CB_NUM];
vec3 field_1AA0[CB_NUM];
float_t field_1BE4[CB_NUM];
prj::vector_pair<int64_t, float_t> field_1C50;
int64_t field_1C68;
@@ -5158,7 +5148,7 @@ public:
void ControlMotionFrameStep();
void UpdateMotionFrame();
inline bool check_disp() {
inline bool get_disp() {
return rob_base.flag.bit.disp;
}
src/CRE/shadow.cpp
+1
View File
@@ -6,6 +6,7 @@
#include "shadow.hpp"
#include "gl_state.hpp"
#include "render_context.hpp"
#include "render_manager.hpp"
#include "shader_ft.hpp"
#define MIN_SHADOW_RANGE (1.2f)
src/CRE/sss.cpp
+18 -16
View File
@@ -7,7 +7,9 @@
#include "rob/rob.hpp"
#include "camera.hpp"
#include "reflect_full.hpp"
#include "render.hpp"
#include "render_context.hpp"
#include "render_manager.hpp"
#include "shader_ft.hpp"
extern render_context* rctx_ptr;
@@ -46,22 +48,22 @@ void sss_data::apply_filter(struct render_data_context& rend_data_ctx) {
rend_data_ctx.state.active_texture(0);
if (downsample) {
textures[0].begin_render(rend_data_ctx.state);
rndr::Render* rend = &rctx->render;
float_t render_width;
float_t render_height;
float_t render_post_width;
float_t render_post_height;
rend->get_render_resolution(&render_width, &render_height, &render_post_width, &render_post_height);
rndr::Render* rend = rctx->render;
float_t fb_width;
float_t fb_height;
float_t fb_tex_width;
float_t fb_tex_height;
rend->get_render_param(&fb_width, &fb_height, &fb_tex_width, &fb_tex_height);
rend_data_ctx.state.set_viewport(0, 0, 640, 360);
rend_data_ctx.shader_flags.arr[U_REDUCE_TEX] = 0;
shaders_ft.set(rend_data_ctx.state, rend_data_ctx.shader_flags, SHADER_FT_REDUCE);
RenderTexture& rt = reflect_draw
? rctx->render_manager->get_render_texture(0)
: rend->rend_texture[0];
: rend->fb_fbo[0];
rend_data_ctx.state.bind_texture_2d(rt.get_texture_glid());
rend_data_ctx.state.bind_sampler(0, rctx->render_samplers[0]);
sss_draw_quad(rend_data_ctx, rt.get_width(), rt.get_height(),
render_width / render_post_width, render_height / render_post_height, 1.0f, 1.0f, 1.0f, 1.0f);
fb_width / fb_tex_width, fb_height / fb_tex_height, 1.0f, 1.0f, 1.0f, 1.0f);
}
textures[2].begin_render(rend_data_ctx.state);
@@ -186,18 +188,18 @@ bool sss_data::set(struct render_data_context& rend_data_ctx) {
return false;
}
rndr::Render* rend = &rctx_ptr->render;
float_t render_width;
float_t render_height;
rend->get_render_resolution(&render_width, &render_height, 0, 0);
rndr::Render* rend = rctx_ptr->render;
float_t fb_width;
float_t fb_height;
rend->get_render_param(&fb_width, &fb_height, 0, 0);
if (render_width > 1280.0f)
if (fb_width > 1280.0f)
downsample = false;
downsample = true; // Added
if (downsample) {
rend->rend_texture[0].begin_render(rend_data_ctx.state);
rend_data_ctx.state.set_viewport(0, 0, (int32_t)render_width, (int32_t)render_height);
rend->fb_fbo[0].begin_render(rend_data_ctx.state);
rend_data_ctx.state.set_viewport(0, 0, (int32_t)fb_width, (int32_t)fb_height);
}
else {
textures[0].begin_render(rend_data_ctx.state);
@@ -286,6 +288,6 @@ static void sss_calc_coef(const double_t step, const int32_t size,
static void sss_draw_quad(render_data_context& rend_data_ctx,
int32_t width, int32_t height, float_t s, float_t t,
float_t param_x, float_t param_y, float_t param_z, float_t param_w) {
rctx_ptr->render.draw_quad(rend_data_ctx, width, height,
rctx_ptr->render->draw_quad(rend_data_ctx, width, height,
s, t, 0.0f, 0.0f, 1.0f, param_x, param_y, param_z, param_w);
}
src/CRE/stage.cpp
+14 -18
View File
@@ -11,7 +11,9 @@
#include "effect.hpp"
#include "light_param.hpp"
#include "stage_param.hpp"
#include "render.hpp"
#include "render_context.hpp"
#include "render_manager.hpp"
#include "shadow.hpp"
namespace stage_detail {
@@ -550,19 +552,13 @@ static void stage_disp(stage* s) {
disp_manager.entry_obj_by_object_info(t, s->stage_data->object_sky);
}
if (s->stage_data->lens_flare_texture != -1 && s->lens_flare) {
if (s->stage_data->tex_flare != -1 && s->lens_flare) {
int32_t object_set_id = s->stage_data->object_set_id;
rndr::Render* rend = &rctx_ptr->render;
rend->lens_flare_texture = get_objset_gen_textures_id(
object_set_id, s->stage_data->lens_flare_texture);
if (rend->lens_flare_texture) {
rend->lens_shaft_texture = get_objset_gen_textures_id(
object_set_id, s->stage_data->lens_shaft_texture);
rend->lens_ghost_texture = get_objset_gen_textures_id(
object_set_id, s->stage_data->lens_ghost_texture);
rend->lens_ghost_count = 16;
rend->lens_shaft_inv_scale = s->stage_data->lens_shaft_inv_scale;
}
GLuint flares[3];
flares[0] = get_objset_gen_textures_id(object_set_id, s->stage_data->tex_flare);
flares[1] = get_objset_gen_textures_id(object_set_id, s->stage_data->tex_shaft);
flares[2] = get_objset_gen_textures_id(object_set_id, s->stage_data->tex_ghost);
rctx_ptr->render->draw_sun_request(flares, s->stage_data->shaft_scale, s->stage_data->num_ghosts);
}
}
@@ -603,15 +599,15 @@ static void stage_free(stage* s) {
rndr::RenderManager* render_manager = rctx_ptr->render_manager;
if (s->stage_data->render_texture != -1)
rctx_ptr->render.render_texture_free(
rctx_ptr->render->remove_fb_copy(
texture_manager_get_texture(s->stage_data->render_texture), 0);
if (s->stage_data->movie_texture != -1)
rctx_ptr->render.movie_texture_free(
rctx_ptr->render->remove_fb_movie(
texture_manager_get_texture(s->stage_data->movie_texture));
render_manager->set_shadow_true();
rctx_ptr->render.set_cam_blur(0);
rctx_ptr->render->set_cam_blur(0);
npr_cloth_spec_color.w = 1.0f;
render_manager->reflect_texture_mask = false;
render_manager->reflect_tone_curve = false;
@@ -663,11 +659,11 @@ static void stage_load(stage* s) {
return;
if (s->stage_data->render_texture != -1)
rctx_ptr->render.render_texture_set(
rctx_ptr->render->register_fb_copy(
texture_manager_get_texture(s->stage_data->render_texture), 0);
if (s->stage_data->movie_texture != -1)
rctx_ptr->render.movie_texture_set(
rctx_ptr->render->register_fb_movie(
texture_manager_get_texture(s->stage_data->movie_texture));
s->state = 6;
}
@@ -706,7 +702,7 @@ static void stage_set(stage* s, stage* other) {
render_manager->field_31F = false;
render_manager->light_stage_ambient = false;
render_manager->set_shadow_true();
rctx_ptr->render.set_cam_blur(0);
rctx_ptr->render->set_cam_blur(0);
npr_cloth_spec_color.w = 1.0f;
render_manager->set_npr_param(0);
light_chara_ambient = false;
src/CRE/stage_modern.cpp
+8 -6
View File
@@ -10,7 +10,9 @@
#include "rob/rob.hpp"
#include "effect.hpp"
#include "light_param.hpp"
#include "render.hpp"
#include "render_context.hpp"
#include "render_manager.hpp"
#include "shadow.hpp"
namespace stage_detail {
@@ -521,15 +523,15 @@ static void stage_modern_free(stage_modern* s) {
rndr::RenderManager* render_manager = rctx_ptr->render_manager;
if (s->stage_data->render_texture != -1 && s->stage_data->render_texture != hash_murmurhash_empty)
rctx_ptr->render.render_texture_free(
rctx_ptr->render->remove_fb_copy(
texture_manager_get_texture(s->stage_data->render_texture), 0);
if (s->stage_data->movie_texture != -1 && s->stage_data->movie_texture != hash_murmurhash_empty)
rctx_ptr->render.movie_texture_free(
rctx_ptr->render->remove_fb_movie(
texture_manager_get_texture(s->stage_data->movie_texture));
render_manager->set_shadow_true();
rctx_ptr->render.set_cam_blur(0);
rctx_ptr->render->set_cam_blur(0);
npr_cloth_spec_color.w = 1.0f;
render_manager->reflect_texture_mask = false;
render_manager->reflect_tone_curve = false;
@@ -576,11 +578,11 @@ static void stage_modern_load(stage_modern* s, void* data, object_database* obj_
return;
if (s->stage_data->render_texture != -1 && s->stage_data->render_texture != hash_murmurhash_empty)
rctx_ptr->render.render_texture_set(
rctx_ptr->render->register_fb_copy(
texture_manager_get_texture(s->stage_data->render_texture), 0);
if (s->stage_data->movie_texture != -1 && s->stage_data->movie_texture != hash_murmurhash_empty)
rctx_ptr->render.movie_texture_set(
rctx_ptr->render->register_fb_movie(
texture_manager_get_texture(s->stage_data->movie_texture));
s->state = 6;
}
@@ -617,7 +619,7 @@ static void stage_modern_set(stage_modern* s, stage_modern* other) {
render_manager->field_31F = false;
render_manager->light_stage_ambient = false;
render_manager->set_shadow_true();
rctx_ptr->render.set_cam_blur(0);
rctx_ptr->render->set_cam_blur(0);
npr_cloth_spec_color.w = 1.0f;
render_manager->set_npr_param(0);
light_chara_ambient = false;
src/KKdLib/database/stage.cpp
+33 -33
View File
@@ -32,50 +32,50 @@ stage_effects_modern::stage_effects_modern() {
field_20[0] = -1;
}
stage_data_file::stage_data_file() : id(), object_set_id(), lens_flare_texture(), lens_shaft_texture(),
lens_ghost_texture(), unknown(), render_texture(), movie_texture(), reflect_type(), refract_enable(),
stage_data_file::stage_data_file() : id(), object_set_id(), tex_flare(), tex_shaft(), tex_ghost(),
num_ghosts(), render_texture(), movie_texture(), reflect_type(), refract_enable(),
reflect(), reflect_data(), refract(), refract_data(), flags(), rect_x(), rect_y(),
rect_width(), rect_height(), ring_height(), out_height(), effects_init() {
lens_shaft_inv_scale = 1.0f;
shaft_scale = 1.0f;
}
stage_data_file::~stage_data_file() {
}
stage_data_modern_file::stage_data_modern_file() : unknown(), render_texture(),
render_texture_flag(), movie_texture(), movie_texture_flag(), field_04(), field_04_flag(), field_05(),
field_05_flag(), field_06(), field_06_flag(), field_07(), field_07_flag(), field_08(), field_09(),
stage_data_modern_file::stage_data_modern_file() : num_ghosts(), render_texture(), render_texture_flag(),
movie_texture(), movie_texture_flag(), field_04(), field_04_flag(), field_05(), field_05_flag(),
field_06(), field_06_flag(), field_07(), field_07_flag(), field_08(), field_09(),
field_10(), field_11(), field_12(), rect_x(), rect_y(), rect_width(),
rect_height(), ring_height(), out_height(), field_13(), effects_init() {
hash = hash_murmurhash_empty;
lens_shaft_inv_scale = 1.0f;
shaft_scale = 1.0f;
}
stage_data_modern_file::~stage_data_modern_file() {
}
stage_data::stage_data() : id(), object_set_id(), lens_flare_texture(), lens_shaft_texture(),
lens_ghost_texture(), unknown(), render_texture(), movie_texture(), reflect_type(), refract_enable(),
stage_data::stage_data() : id(), object_set_id(), tex_flare(), tex_shaft(), tex_ghost(),
num_ghosts(), render_texture(), movie_texture(), reflect_type(), refract_enable(),
reflect(), reflect_data(), refract(), refract_data(), flags(), rect_x(), rect_y(),
rect_width(), rect_height(), ring_height(), out_height(), effects_init() {
name_hash = hash_murmurhash_empty;
lens_shaft_inv_scale = 1.0f;
shaft_scale = 1.0f;
}
stage_data::~stage_data() {
}
stage_data_modern::stage_data_modern() : unknown(), render_texture(),
render_texture_flag(), movie_texture(), movie_texture_flag(), field_04(), field_04_flag(), field_05(),
field_05_flag(), field_06(), field_06_flag(), field_07(), field_07_flag(), field_08(), field_09(),
stage_data_modern::stage_data_modern() : num_ghosts(), render_texture(), render_texture_flag(),
movie_texture(), movie_texture_flag(), field_04(), field_04_flag(), field_05(), field_05_flag(),
field_06(), field_06_flag(), field_07(), field_07_flag(), field_08(), field_09(),
field_10(), field_11(), field_12(), rect_x(), rect_y(), rect_width(),
rect_height(), ring_height(), out_height(), field_13(), effects_init() {
hash = hash_murmurhash_empty;
auth_3d_name_hash = hash_murmurhash_empty;
lens_shaft_inv_scale = 1.0f;
shaft_scale = 1.0f;
}
stage_data_modern::~stage_data_modern() {
@@ -322,11 +322,11 @@ void stage_database::add(stage_database_file* stage_data_file) {
data->object_shadow = i.object_shadow;
data->object_reflect = i.object_reflect;
data->object_refract = i.object_refract;
data->lens_flare_texture = i.lens_flare_texture;
data->lens_shaft_texture = i.lens_shaft_texture;
data->lens_ghost_texture = i.lens_ghost_texture;
data->lens_shaft_inv_scale = i.lens_shaft_inv_scale;
data->unknown = i.unknown;
data->tex_flare = i.tex_flare;
data->tex_shaft = i.tex_shaft;
data->tex_ghost = i.tex_ghost;
data->shaft_scale = i.shaft_scale;
data->num_ghosts = i.num_ghosts;
data->render_texture = i.render_texture;
data->movie_texture = i.movie_texture;
data->collision_file_path = i.collision_file_path;
@@ -372,8 +372,8 @@ void stage_database::add(stage_database_file* stage_data_file) {
data->object_shadow = i.object_shadow;
data->object_reflect = i.object_reflect;
data->object_refract = i.object_refract;
data->lens_shaft_inv_scale = i.lens_shaft_inv_scale;
data->unknown = i.unknown;
data->shaft_scale = i.shaft_scale;
data->num_ghosts = i.num_ghosts;
data->render_texture = i.render_texture;
data->render_texture_flag = i.render_texture_flag;
data->movie_texture = i.movie_texture;
@@ -511,11 +511,11 @@ static void stage_database_file_classic_read_inner(stage_database_file* stage_da
stage->object_reflect.set_id = s.read_uint16_t();
stage->object_refract.id = s.read_uint16_t();
stage->object_refract.set_id = s.read_uint16_t();
stage->lens_flare_texture = s.read_uint32_t();
stage->lens_shaft_texture = s.read_uint32_t();
stage->lens_ghost_texture = s.read_uint32_t();
stage->lens_shaft_inv_scale = s.read_float_t();
stage->unknown = s.read_uint32_t();
stage->tex_flare = s.read_uint32_t();
stage->tex_shaft = s.read_uint32_t();
stage->tex_ghost = s.read_uint32_t();
stage->shaft_scale = s.read_float_t();
stage->num_ghosts = s.read_uint32_t();
stage->render_texture = s.read_uint32_t();
if (stage_data->format > STAGE_DATA_AC)
@@ -776,11 +776,11 @@ static void stage_database_file_classic_write_inner(stage_database_file* stage_d
s.write_uint16_t((uint16_t)stage->object_reflect.set_id);
s.write_uint16_t((uint16_t)stage->object_refract.id);
s.write_uint16_t((uint16_t)stage->object_refract.set_id);
s.write_uint32_t(stage->lens_flare_texture);
s.write_uint32_t(stage->lens_shaft_texture);
s.write_uint32_t(stage->lens_ghost_texture);
s.write_float_t(stage->lens_shaft_inv_scale);
s.write_uint32_t(stage->unknown);
s.write_uint32_t(stage->tex_flare);
s.write_uint32_t(stage->tex_shaft);
s.write_uint32_t(stage->tex_ghost);
s.write_float_t(stage->shaft_scale);
s.write_uint32_t(stage->num_ghosts);
s.write_uint32_t(stage->render_texture);
if (stage_data->format > STAGE_DATA_AC)
@@ -877,8 +877,8 @@ static void stage_database_file_modern_read_inner(stage_database_file* stage_dat
stage->object_reflect.set_id = s.read_uint32_t_reverse_endianness();
stage->object_refract.id = s.read_uint32_t_reverse_endianness();
stage->object_refract.set_id = s.read_uint32_t_reverse_endianness();
stage->lens_shaft_inv_scale = s.read_float_t_reverse_endianness();
stage->unknown = s.read_uint32_t_reverse_endianness();
stage->shaft_scale = s.read_float_t_reverse_endianness();
stage->num_ghosts = s.read_uint32_t_reverse_endianness();
stage->render_texture = s.read_uint32_t_reverse_endianness();
stage->render_texture_flag = s.read_uint32_t_reverse_endianness();
stage->movie_texture = s.read_uint32_t_reverse_endianness();
src/KKdLib/database/stage.hpp
+14 -14
View File
@@ -79,11 +79,11 @@ struct stage_data_file {
object_info object_shadow;
object_info object_reflect;
object_info object_refract;
uint32_t lens_flare_texture;
uint32_t lens_shaft_texture;
uint32_t lens_ghost_texture;
float_t lens_shaft_inv_scale;
uint32_t unknown;
uint32_t tex_flare;
uint32_t tex_shaft;
uint32_t tex_ghost;
float_t shaft_scale;
int32_t num_ghosts;
uint32_t render_texture;
uint32_t movie_texture;
std::string collision_file_path;
@@ -117,8 +117,8 @@ struct stage_data_modern_file {
object_info object_shadow;
object_info object_reflect;
object_info object_refract;
float_t lens_shaft_inv_scale;
uint32_t unknown;
float_t shaft_scale;
int32_t num_ghosts;
uint32_t render_texture;
uint32_t render_texture_flag;
uint32_t movie_texture;
@@ -163,11 +163,11 @@ struct stage_data {
object_info object_shadow;
object_info object_reflect;
object_info object_refract;
uint32_t lens_flare_texture;
uint32_t lens_shaft_texture;
uint32_t lens_ghost_texture;
float_t lens_shaft_inv_scale;
uint32_t unknown;
uint32_t tex_flare;
uint32_t tex_shaft;
uint32_t tex_ghost;
float_t shaft_scale;
int32_t num_ghosts;
uint32_t render_texture;
uint32_t movie_texture;
std::string collision_file_path;
@@ -202,8 +202,8 @@ struct stage_data_modern {
object_info object_shadow;
object_info object_reflect;
object_info object_refract;
float_t lens_shaft_inv_scale;
uint32_t unknown;
float_t shaft_scale;
int32_t num_ghosts;
uint32_t render_texture;
uint32_t render_texture_flag;
uint32_t movie_texture;
src/KKdLib/light_param/glow.cpp
+24 -31
View File
@@ -149,25 +149,22 @@ static void light_param_glow_read_inner(light_param_glow* glow, stream& s) {
glow->has_saturate_coef = true;
}
else if (!str_utils_compare_length(buf, sizeof(buf), "flare", 5)) {
vec3& flare = glow->flare;
if (buf[5] != ' ' || sscanf_s(buf + 6, "%f %f %f",
&flare.x, &flare.y, &flare.z) != 3)
&glow->flare[0], &glow->flare[1], &glow->flare[2]) != 3)
goto End;
glow->has_flare = true;
}
else if (!str_utils_compare_length(buf, sizeof(buf), "sigma", 5)) {
vec3& sigma = glow->sigma;
if (buf[5] != ' ' || sscanf_s(buf + 6, "%f %f %f",
&sigma.x, &sigma.y, &sigma.z) != 3)
&glow->sigma[0], &glow->sigma[1], &glow->sigma[2]) != 3)
goto End;
glow->has_sigma = true;
}
else if (!str_utils_compare_length(buf, sizeof(buf), "intensity", 9)) {
vec3& intensity = glow->intensity;
if (buf[9] != ' ' || sscanf_s(buf + 10, "%f %f %f",
&intensity.x, &intensity.y, &intensity.z) != 3)
&glow->intensity[0], &glow->intensity[1], &glow->intensity[2]) != 3)
goto End;
glow->has_intensity = true;
@@ -181,7 +178,7 @@ static void light_param_glow_read_inner(light_param_glow* glow, stream& s) {
glow->has_auto_exposure = true;
}
else if (!str_utils_compare_length(buf, sizeof(buf), "tone_map_method", 15)) {
if (buf[15] != ' ' || sscanf_s(buf + 16, "%d", (int32_t*)&glow->tone_map_method) != 1)
if (buf[15] != ' ' || sscanf_s(buf + 16, "%d", &glow->tone_map_method) != 1)
goto End;
glow->has_tone_map_method = true;
@@ -196,10 +193,11 @@ static void light_param_glow_read_inner(light_param_glow* glow, stream& s) {
glow->has_fade_color = true;
}
else if (!str_utils_compare_length(buf, sizeof(buf), "tone_transform", 14)) {
vec3& start = glow->tone_transform_start;
vec3& end = glow->tone_transform_end;
float_t* tone_transform_start = glow->tone_transform_start;
float_t* tone_transform_end = glow->tone_transform_end;
if (buf[14] != ' ' || sscanf_s(buf + 15, "%f %f %f %f %f %f",
&start.x, &start.y, &start.z, &end.x, &end.y, &end.z) != 6)
&tone_transform_start[0], &tone_transform_start[1], &tone_transform_start[2],
&tone_transform_end[0], &tone_transform_end[1], &tone_transform_end[2]) != 6)
goto End;
glow->has_tone_transform = true;
@@ -242,29 +240,26 @@ static void light_param_glow_write_inner(light_param_glow* glow, stream& s) {
}
if (glow->has_flare) {
vec3& flare = glow->flare;
s.write("flare", 5);
light_param_write_float_t(s, buf, sizeof(buf), flare.x);
light_param_write_float_t(s, buf, sizeof(buf), flare.y);
light_param_write_float_t(s, buf, sizeof(buf), flare.z);
light_param_write_float_t(s, buf, sizeof(buf), glow->flare[0]);
light_param_write_float_t(s, buf, sizeof(buf), glow->flare[1]);
light_param_write_float_t(s, buf, sizeof(buf), glow->flare[2]);
s.write_char('\n');
}
if (glow->has_sigma) {
vec3& sigma = glow->sigma;
s.write("sigma", 5);
light_param_write_float_t(s, buf, sizeof(buf), sigma.x);
light_param_write_float_t(s, buf, sizeof(buf), sigma.y);
light_param_write_float_t(s, buf, sizeof(buf), sigma.z);
light_param_write_float_t(s, buf, sizeof(buf), glow->sigma[0]);
light_param_write_float_t(s, buf, sizeof(buf), glow->sigma[1]);
light_param_write_float_t(s, buf, sizeof(buf), glow->sigma[2]);
s.write_char('\n');
}
if (glow->has_intensity) {
vec3& intensity = glow->intensity;
s.write("intensity", 9);
light_param_write_float_t(s, buf, sizeof(buf), intensity.x);
light_param_write_float_t(s, buf, sizeof(buf), intensity.y);
light_param_write_float_t(s, buf, sizeof(buf), intensity.z);
light_param_write_float_t(s, buf, sizeof(buf), glow->intensity[0]);
light_param_write_float_t(s, buf, sizeof(buf), glow->intensity[1]);
light_param_write_float_t(s, buf, sizeof(buf), glow->intensity[2]);
s.write_char('\n');
}
@@ -276,7 +271,7 @@ static void light_param_glow_write_inner(light_param_glow* glow, stream& s) {
if (glow->has_tone_map_method) {
s.write("tone_map_method", 15);
light_param_write_int32_t(s, buf, sizeof(buf), (int32_t)glow->tone_map_method);
light_param_write_int32_t(s, buf, sizeof(buf), glow->tone_map_method);
s.write_char('\n');
}
@@ -293,15 +288,13 @@ static void light_param_glow_write_inner(light_param_glow* glow, stream& s) {
}
if (glow->has_tone_transform) {
vec3& start = glow->tone_transform_start;
vec3& end = glow->tone_transform_end;
s.write("tone_transform", 14);
light_param_write_float_t(s, buf, sizeof(buf), start.x);
light_param_write_float_t(s, buf, sizeof(buf), start.y);
light_param_write_float_t(s, buf, sizeof(buf), start.z);
light_param_write_float_t(s, buf, sizeof(buf), end.x);
light_param_write_float_t(s, buf, sizeof(buf), end.y);
light_param_write_float_t(s, buf, sizeof(buf), end.z);
light_param_write_float_t(s, buf, sizeof(buf), glow->tone_transform_start[0]);
light_param_write_float_t(s, buf, sizeof(buf), glow->tone_transform_start[1]);
light_param_write_float_t(s, buf, sizeof(buf), glow->tone_transform_start[2]);
light_param_write_float_t(s, buf, sizeof(buf), glow->tone_transform_end[0]);
light_param_write_float_t(s, buf, sizeof(buf), glow->tone_transform_end[1]);
light_param_write_float_t(s, buf, sizeof(buf), glow->tone_transform_end[2]);
s.write_char('\n');
}
src/KKdLib/light_param/glow.hpp
+6 -13
View File
@@ -8,13 +8,6 @@
#include "../default.hpp"
#include "../vec.hpp"
enum tone_map_method {
TONE_MAP_YCC_EXPONENT = 0,
TONE_MAP_RGB_LINEAR = 1,
TONE_MAP_RGB_LINEAR2 = 2,
TONE_MAP_MAX = 3,
};
struct light_param_glow {
bool ready;
@@ -27,21 +20,21 @@ struct light_param_glow {
bool has_saturate_coef;
float_t saturate_coef;
bool has_flare;
vec3 flare;
float_t flare[3];
bool has_sigma;
vec3 sigma;
float_t sigma[3];
bool has_intensity;
vec3 intensity;
float_t intensity[3];
bool has_auto_exposure;
bool auto_exposure;
bool has_tone_map_method;
tone_map_method tone_map_method;
int32_t tone_map_method;
bool has_fade_color;
vec4 fade_color;
int32_t fade_color_blend_func;
bool has_tone_transform;
vec3 tone_transform_start;
vec3 tone_transform_end;
float_t tone_transform_start[3];
float_t tone_transform_end[3];
light_param_glow();
~light_param_glow();
src/ReDIVA/app.cpp
+14 -14
View File
@@ -810,12 +810,12 @@ static render_context* render_context_load(const wchar_t* config_path) {
init_mode(MODE_STARTUP, MODE_SUB_MAX);
render_manager_init_data(0, 0, 0, false);
/*render_manager_init_data(
stru_140EDA5B0.ssaa,
stru_140EDA5B0.hd_res,
stru_140EDA5B0.ss_alpha_mask,
stru_140EDA5B0.screen_shot_4x == 1);*/
rndpass_init(0, 0, 0, false);
/*rndpass_init(
s_main_info.anti_alias,
s_main_info.min_render,
s_main_info.ss_alpha_mask,
s_main_info.ss_mode == SS_MODE_SIZE_4X);*/
objset_info_storage_init(aft_obj_db);
stage_param_data_init();
@@ -1267,8 +1267,8 @@ static void render_context_disp(render_context* rctx) {
#if BAKE_PNG || BAKE_VIDEO
post_rend_data_ctx.state.set_viewport(0, 0, rctx->screen_width, rctx->screen_height);
#else
post_rend_data_ctx.state.set_viewport(rctx->screen_x_offset, rctx->screen_y_offset,
rctx->sprite_width, rctx->sprite_height);
post_rend_data_ctx.state.set_viewport(rctx->view_x, rctx->view_y,
rctx->view_w, rctx->view_h);
#endif
post_rend_data_ctx.state.bind_framebuffer(0);
@@ -1276,20 +1276,20 @@ static void render_context_disp(render_context* rctx) {
post_rend_data_ctx.shader_flags.arr[U_ALPHA_MASK] = 0;
post_rend_data_ctx.shader_flags.arr[U_REDUCE_TEX] = 0;
shaders_ft.set(post_rend_data_ctx.state, post_rend_data_ctx.shader_flags, SHADER_FT_REDUCE);
rctx->render.draw_quad(post_rend_data_ctx, rctx->sprite_width, rctx->sprite_height,
rctx->render->draw_quad(post_rend_data_ctx, rctx->view_w, rctx->view_h,
1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
}
#ifdef USE_OPENGL
else {
#if BAKE_PNG || BAKE_VIDEO
fbo_blit(post_rend_data_ctx.state, rctx->screen_buffer.get_fb(), 0,
0, 0, rctx->sprite_width, rctx->sprite_height,
0, 0, rctx->view_w, rctx->view_h,
0, 0, rctx->screen_width, rctx->screen_height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
#else
fbo_blit(post_rend_data_ctx.state, rctx->screen_buffer.get_fb(), 0,
0, 0, rctx->sprite_width, rctx->sprite_height,
rctx->screen_x_offset, rctx->screen_y_offset,
rctx->sprite_width, rctx->sprite_height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
0, 0, rctx->view_w, rctx->view_h,
rctx->view_x, rctx->view_y,
rctx->view_w, rctx->view_h, GL_COLOR_BUFFER_BIT, GL_LINEAR);
#endif
}
#endif
@@ -1437,7 +1437,7 @@ static void render_context_dispose(render_context* rctx) {
data_test_sel_free();
data_edit_sel_free();
render_manager_free_data();
rndpass_finish();
dw_free();
src/ReDIVA/data_test/rob_osage_test.cpp
+1 -1
View File
@@ -888,7 +888,7 @@ void RobOsageTest::disp() {
rob_chara* rob_chr = get_rob_management()->get_rob(rob_id);
if (rob_chr && !pv_osage_manager_array_get_disp(rob_id)
&& rob_chr->check_disp() && !rob_chr->check_zero_disp()) {
&& rob_chr->get_disp() && !rob_chr->check_zero_disp()) {
disp_coli();
disp_line();
}
src/ReDIVA/graphics/post_process.cpp
+174 -210
View File
@@ -6,6 +6,7 @@
#include "post_process.hpp"
#include "../../CRE/renderer/dof.hpp"
#include "../../CRE/light_param.hpp"
#include "../../CRE/render.hpp"
#include "../../CRE/render_context.hpp"
#include "../../CRE/stage.hpp"
#include "../dw.hpp"
@@ -18,7 +19,7 @@ public:
dw::Slider* exposure_slider;
dw::Slider* gamma_slider;
dw::Slider* saturate_power_slider;
dw::Slider* saturate_coeff_slider;
dw::Slider* saturate_coef_slider;
dw::ListBox* mag_filter_list;
dw::Button* taa_button;
dw::Button* mlaa_button;
@@ -42,19 +43,19 @@ public:
dw::Button* dof_enable_physical_dof;
dw::Button* dof_auto_focus;
dw::Button* show_face_query_button;
tone_map_method tone_map;
int32_t tone_map_method;
float_t exposure;
int32_t auto_exposure;
float_t gamma;
int32_t saturate_power;
float_t saturate_coeff;
int32_t taa;
int32_t mlaa;
rndr::Render::MagFilterType mag_filter;
float_t saturate_coef;
int32_t temporal_anti_alias;
int32_t morphological_anti_alias;
int32_t mag_filter;
bool set_for_each_cut;
vec3 lens;
vec3 radius;
vec3 intensity;
float_t flare_coef[3];
float_t sigma[3];
float_t intensity[3];
rndr::Render* rend;
dwPostProcess();
@@ -69,14 +70,14 @@ public:
static void AutoExposureCallback(dw::Widget* data);
static void DofCallback(dw::Widget* data);
static void ExposureCallback(dw::Widget* data);
static void FlareCallback(dw::Widget* data);
static void GammaCallback(dw::Widget* data);
static void IntensityCallback(dw::Widget* data);
static void LensCallback(dw::Widget* data);
static void LoadCallback(dw::Widget* data);
static void MagFilterCallback(dw::Widget* data);
static void MorphologicalAACallback(dw::Widget* data);
static void RadiusCallback(dw::Widget* data);
static void SaturateCoeffCallback(dw::Widget* data);
static void SaturateCoefCallback(dw::Widget* data);
static void SaturatePowerCallback(dw::Widget* data);
static void SaveCallback(dw::Widget* data);
static void SetForEachCutCallback(dw::Widget* data);
@@ -89,7 +90,7 @@ public:
dw::Slider* color_slider[3];
dw::Slider* alpha_slider;
dw::ListBox* blend_func_list;
vec3 color;
float_t color[3];
float_t alpha;
int32_t blend_func;
rndr::Render* rend;
@@ -112,8 +113,8 @@ class dwToneTrans : public dw::Shell {
public:
dw::Slider* start_slider[3];
dw::Slider* end_slider[3];
vec3 start;
vec3 end;
float_t start[3];
float_t end[3];
rndr::Render* rend;
dwToneTrans();
@@ -148,20 +149,20 @@ void dw_post_process_init() {
dwPostProcess::dwPostProcess() {
data = 0;
rend = &rctx_ptr->render;
rend = rctx_ptr->render;
tone_map = rend->get_tone_map();
exposure = rend->get_exposure();
auto_exposure = rend->get_auto_exposure();
gamma = rend->get_gamma();
saturate_power = rend->get_saturate_power();
saturate_coeff = rend->get_saturate_coeff();
taa = rend->get_taa();
mlaa = rend->get_mlaa();
mag_filter = rend->get_mag_filter();
lens = rend->get_lens();
radius = rend->get_radius();
intensity = rend->get_intensity();
rend->get_tone_map_method(&tone_map_method);
rend->get_exposure(&exposure);
rend->get_auto_exposure(&auto_exposure);
rend->get_gamma(&gamma);
rend->get_saturate_power(&saturate_power);
rend->get_saturate_coef(&saturate_coef);
rend->get_temporal_aa(&temporal_anti_alias);
rend->get_morphological_aa(&morphological_anti_alias);
rend->get_mag_filter(&mag_filter);
rend->get_flare_coef(flare_coef);
rend->get_sigma(sigma);
rend->get_intensity(intensity);
set_for_each_cut = false;
SetText("POST PROCESS");
@@ -186,12 +187,12 @@ dwPostProcess::dwPostProcess() {
taa_button = new dw::Button(this, dw::CHECKBOX);
taa_button->SetText("Temporal AA");
taa_button->SetValue(!!taa);
taa_button->SetValue(!!temporal_anti_alias);
taa_button->callback = dwPostProcess::TemporalAACallback;
mlaa_button = new dw::Button(this, dw::CHECKBOX);
mlaa_button->SetText("Morphological AA");
mlaa_button->SetValue(!!mlaa);
mlaa_button->SetValue(!!morphological_anti_alias);
mlaa_button->callback = dwPostProcess::MorphologicalAACallback;
const char* set_for_each_cut_text;
@@ -225,7 +226,7 @@ dwPostProcess::dwPostProcess() {
tone_map_list->AddItem("YCC EXPONENT");
tone_map_list->AddItem("RGB LINEAR");
tone_map_list->AddItem("RGB LINEAR2");
tone_map_list->SetItemIndex(tone_map);
tone_map_list->SetItemIndex(tone_map_method);
tone_map_list->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::ToneMapCallback));
exposure_slider = dw::Slider::Create(glow_param_group,
@@ -260,78 +261,60 @@ dwPostProcess::dwPostProcess() {
saturate_power_slider->format = "%3.1f";
saturate_power_slider->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::SaturatePowerCallback));
saturate_coeff_slider = dw::Slider::Create(glow_param_group,
saturate_coef_slider = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Saturate2");
saturate_coeff_slider->SetParams(saturate_coeff, 0.0f, 1.0f, 0.2f, 0.01f, 0.1f);
saturate_coeff_slider->format = "%4.2f";
saturate_coeff_slider->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::SaturateCoeffCallback));
saturate_coef_slider->SetParams(saturate_coef, 0.0f, 1.0f, 0.2f, 0.01f, 0.1f);
saturate_coef_slider->format = "%4.2f";
saturate_coef_slider->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::SaturateCoefCallback));
(new dw::Label(glow_param_group))->SetText("FLARE");
lens_sliders[0] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Flare A");
lens_sliders[0]->SetParams(lens.x, 0.0f, 1.0f, 0.2f, 0.01f, 0.1f);
lens_sliders[0]->format = "%4.2f";
lens_sliders[0]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::LensCallback));
lens_sliders[0]->callback_data.i64 = 0;
for (int32_t i = 0; i < 3; i++) {
static const char* flare_name[] = {
"Flare A",
"Shaft A",
"Ghost A",
};
lens_sliders[1] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Shaft A");
lens_sliders[1]->SetParams(lens.y, 0.0f, 1.0f, 0.2f, 0.01f, 0.1f);
lens_sliders[1]->format = "%4.2f";
lens_sliders[1]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::LensCallback));
lens_sliders[1]->callback_data.i64 = 1;
lens_sliders[2] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Ghost A");
lens_sliders[2]->SetParams(lens.z, 0.0f, 1.0f, 0.2f, 0.01f, 0.1f);
lens_sliders[2]->format = "%4.2f";
lens_sliders[2]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::LensCallback));
lens_sliders[2]->callback_data.i64 = 2;
lens_sliders[i] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, flare_name[i]);
lens_sliders[i]->SetParams(flare_coef[i], 0.0f, 1.0f, 0.2f, 0.01f, 0.1f);
lens_sliders[i]->format = "%4.2f";
lens_sliders[i]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::FlareCallback));
lens_sliders[i]->callback_data.i64 = i;
}
(new dw::Label(glow_param_group))->SetText("GLARE");
radius_sliders[0] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Radius R");
radius_sliders[0]->SetParams(radius.x, 1.0f, 3.0f, 0.5f, 0.1f, 0.1f);
radius_sliders[0]->format = "%4.2f";
radius_sliders[0]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::RadiusCallback));
radius_sliders[0]->callback_data.i64 = 0;
for (int32_t i = 0; i < 3; i++) {
static const char* radius_name[] = {
"Radius R",
"Radius G",
"Radius B",
};
radius_sliders[1] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Radius G");
radius_sliders[1]->SetParams(radius.y, 1.0f, 3.0f, 0.5f, 0.1f, 0.1f);
radius_sliders[1]->format = "%4.2f";
radius_sliders[1]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::RadiusCallback));
radius_sliders[1]->callback_data.i64 = 1;
radius_sliders[i] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, radius_name[i]);
radius_sliders[i]->SetParams(sigma[i], 1.0f, 3.0f, 0.5f, 0.1f, 0.1f);
radius_sliders[i]->format = "%4.2f";
radius_sliders[i]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::RadiusCallback));
radius_sliders[i]->callback_data.i64 = i;
}
radius_sliders[2] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Radius B");
radius_sliders[2]->SetParams(radius.z, 1.0f, 3.0f, 0.5f, 0.1f, 0.1f);
radius_sliders[2]->format = "%4.2f";
radius_sliders[2]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::RadiusCallback));
radius_sliders[2]->callback_data.i64 = 2;
for (int32_t i = 0; i < 3; i++) {
static const char* intensity_name[] = {
"Inten R",
"Inten G",
"Inten B",
};
intensity_sliders[0] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Inten R");
intensity_sliders[0]->SetParams(intensity.x, 0.0f, 2.0f, 0.5f, 0.05f, 0.1f);
intensity_sliders[0]->format = "%4.2f";
intensity_sliders[0]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::IntensityCallback));
intensity_sliders[0]->callback_data.i64 = 0;
intensity_sliders[1] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Inten G");
intensity_sliders[1]->SetParams(intensity.y, 0.0f, 2.0f, 0.5f, 0.05f, 0.1f);
intensity_sliders[1]->format = "%4.2f";
intensity_sliders[1]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::IntensityCallback));
intensity_sliders[1]->callback_data.i64 = 1;
intensity_sliders[2] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, "Inten B");
intensity_sliders[2]->SetParams(intensity.z, 0.0f, 2.0f, 0.5f, 0.05f, 0.1f);
intensity_sliders[2]->format = "%4.2f";
intensity_sliders[2]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::IntensityCallback));
intensity_sliders[2]->callback_data.i64 = 2;
intensity_sliders[i] = dw::Slider::Create(glow_param_group,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 192.0f, glyph_size.y, intensity_name[i]);
intensity_sliders[i]->SetParams(intensity[i], 0.0f, 2.0f, 0.5f, 0.05f, 0.1f);
intensity_sliders[i]->format = "%4.2f";
intensity_sliders[i]->AddSelectionListener(new dw::SelectionListenerOnHook(dwPostProcess::IntensityCallback));
intensity_sliders[i]->callback_data.i64 = i;
}
(new dw::Label(glow_param_group))->SetText("DOF");
@@ -456,31 +439,31 @@ void dwPostProcess::Hide() {
}
void dwPostProcess::ResetData() {
rend = &rctx_ptr->render;
rend = rctx_ptr->render;
exposure = rend->get_exposure();
auto_exposure = rend->get_auto_exposure();
gamma = rend->get_gamma();
saturate_power = rend->get_saturate_power();
saturate_coeff = rend->get_saturate_coeff();
lens = rend->get_lens();
radius = rend->get_radius();
intensity = rend->get_intensity();
rend->get_exposure(&exposure);
rend->get_auto_exposure(&auto_exposure);
rend->get_gamma(&gamma);
rend->get_saturate_power(&saturate_power);
rend->get_saturate_coef(&saturate_coef);
rend->get_flare_coef(flare_coef);
rend->get_sigma(sigma);
rend->get_intensity(intensity);
exposure_slider->SetValue(exposure);
auto_exposure_button->SetValue(auto_exposure != 0);
gamma_slider->SetValue(gamma);
saturate_power_slider->SetValue((float_t)saturate_power);
saturate_coeff_slider->SetValue(saturate_coeff);
saturate_coef_slider->SetValue(saturate_coef);
for (int32_t i = 0; i < 3; i++)
lens_sliders[i]->SetValue(((float_t*)&lens)[i]);
lens_sliders[i]->SetValue(flare_coef[i]);
for (int32_t i = 0; i < 3; i++)
radius_sliders[i]->SetValue(((float_t*)&radius)[i]);
radius_sliders[i]->SetValue(sigma[i]);
for (int32_t i = 0; i < 3; i++)
intensity_sliders[i]->SetValue(((float_t*)&intensity)[i]);
intensity_sliders[i]->SetValue(intensity[i]);
DofReset();
}
@@ -534,18 +517,18 @@ void dwPostProcess::DofCallback(dw::Widget* data) {
dof_debug_set(&debug);
const bool enable_dof = dw_post_process->dof_use_ui_params->value;
const bool dof_enable_physical_dof = dw_post_process->dof_enable_physical_dof->value;
const bool enable_physical_dof = dw_post_process->dof_enable_physical_dof->value;
dw_post_process->dof_enable_dof->SetEnabled(enable_dof);
dw_post_process->dof_enable_physical_dof->SetEnabled(enable_dof);
dw_post_process->dof_auto_focus->SetEnabled(enable_dof && dof_enable_physical_dof);
dw_post_process->dof_distance_to_focus->SetEnabled(enable_dof && dof_enable_physical_dof);
dw_post_process->dof_focal_length->SetEnabled(enable_dof && dof_enable_physical_dof);
dw_post_process->dof_f_number->SetEnabled(enable_dof && dof_enable_physical_dof);
dw_post_process->dof_f2_distance_to_focus->SetEnabled(enable_dof && !dof_enable_physical_dof);
dw_post_process->dof_f2_focus_range->SetEnabled(enable_dof && !dof_enable_physical_dof);
dw_post_process->dof_f2_fuzzing_range->SetEnabled(enable_dof && !dof_enable_physical_dof);
dw_post_process->dof_f2_ratio->SetEnabled(enable_dof && !dof_enable_physical_dof);
dw_post_process->dof_auto_focus->SetEnabled(enable_dof && enable_physical_dof);
dw_post_process->dof_distance_to_focus->SetEnabled(enable_dof && enable_physical_dof);
dw_post_process->dof_focal_length->SetEnabled(enable_dof && enable_physical_dof);
dw_post_process->dof_f_number->SetEnabled(enable_dof && enable_physical_dof);
dw_post_process->dof_f2_distance_to_focus->SetEnabled(enable_dof && !enable_physical_dof);
dw_post_process->dof_f2_focus_range->SetEnabled(enable_dof && !enable_physical_dof);
dw_post_process->dof_f2_fuzzing_range->SetEnabled(enable_dof && !enable_physical_dof);
dw_post_process->dof_f2_ratio->SetEnabled(enable_dof && !enable_physical_dof);
show_face_query_set(dw_post_process->show_face_query_button->value);
}
@@ -557,6 +540,14 @@ void dwPostProcess::ExposureCallback(dw::Widget* data) {
}
}
void dwPostProcess::FlareCallback(dw::Widget* data) {
dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
if (slider) {
dw_post_process->flare_coef[slider->callback_data.i32] = slider->GetValue();
dw_post_process->rend->set_flare_coef(dw_post_process->flare_coef);
}
}
void dwPostProcess::GammaCallback(dw::Widget* data) {
dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
if (slider) {
@@ -568,19 +559,11 @@ void dwPostProcess::GammaCallback(dw::Widget* data) {
void dwPostProcess::IntensityCallback(dw::Widget* data) {
dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
if (slider) {
((float_t*)&dw_post_process->intensity)[slider->callback_data.i32] = slider->GetValue();
dw_post_process->intensity[slider->callback_data.i32] = slider->GetValue();
dw_post_process->rend->set_intensity(dw_post_process->intensity);
}
}
void dwPostProcess::LensCallback(dw::Widget* data) {
dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
if (slider) {
((float_t*)&dw_post_process->lens)[slider->callback_data.i32] = slider->GetValue();
dw_post_process->rend->set_lens(dw_post_process->lens);
}
}
void dwPostProcess::LoadCallback(dw::Widget* data) {
}
@@ -588,7 +571,7 @@ void dwPostProcess::LoadCallback(dw::Widget* data) {
void dwPostProcess::MagFilterCallback(dw::Widget* data) {
dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
if (list_box) {
dw_post_process->mag_filter = (rndr::Render::MagFilterType)(int32_t)list_box->list->selected_item;
dw_post_process->mag_filter = (int32_t)list_box->list->selected_item;
dw_post_process->rend->set_mag_filter(dw_post_process->mag_filter);
}
}
@@ -596,24 +579,24 @@ void dwPostProcess::MagFilterCallback(dw::Widget* data) {
void dwPostProcess::MorphologicalAACallback(dw::Widget* data) {
dw::Button* button = dynamic_cast<dw::Button*>(data);
if (button) {
dw_post_process->mlaa = button->value ? 1 : 0;
dw_post_process->rend->set_mlaa(dw_post_process->mlaa);
dw_post_process->morphological_anti_alias = button->value ? 1 : 0;
dw_post_process->rend->set_morphological_aa(dw_post_process->morphological_anti_alias);
}
}
void dwPostProcess::RadiusCallback(dw::Widget* data) {
dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
if (slider) {
((float_t*)&dw_post_process->radius)[slider->callback_data.i32] = slider->GetValue();
dw_post_process->rend->set_radius(dw_post_process->radius);
dw_post_process->sigma[slider->callback_data.i32] = slider->GetValue();
dw_post_process->rend->set_sigma(dw_post_process->sigma);
}
}
void dwPostProcess::SaturateCoeffCallback(dw::Widget* data) {
void dwPostProcess::SaturateCoefCallback(dw::Widget* data) {
dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
if (slider) {
dw_post_process->saturate_coeff = slider->GetValue();
dw_post_process->rend->set_saturate_coeff(dw_post_process->saturate_coeff, 0, false);
dw_post_process->saturate_coef = slider->GetValue();
dw_post_process->rend->set_saturate_coef(dw_post_process->saturate_coef, 0, false);
}
}
@@ -638,21 +621,21 @@ void dwPostProcess::SetForEachCutCallback(dw::Widget* data) {
void dwPostProcess::TemporalAACallback(dw::Widget* data) {
dw::Button* button = dynamic_cast<dw::Button*>(data);
if (button) {
dw_post_process->taa = button->value ? 1 : 0;
dw_post_process->rend->set_taa(dw_post_process->taa);
dw_post_process->temporal_anti_alias = button->value ? 1 : 0;
dw_post_process->rend->set_temporal_aa(dw_post_process->temporal_anti_alias);
}
}
void dwPostProcess::ToneMapCallback(dw::Widget* data) {
dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
if (list_box) {
dw_post_process->tone_map = (tone_map_method)(int32_t)list_box->list->selected_item;
dw_post_process->rend->set_tone_map(dw_post_process->tone_map);
dw_post_process->tone_map_method = (int32_t)list_box->list->selected_item;
dw_post_process->rend->set_tone_map_method(dw_post_process->tone_map_method);
}
}
dwSceneFade::dwSceneFade() {
rend = &rctx_ptr->render;
rend = rctx_ptr->render;
SetText("SCENE FADE");
@@ -672,26 +655,20 @@ dwSceneFade::dwSceneFade() {
(new dw::Label(color_comp))->SetText("COLOR ");
color_slider[0] = dw::Slider::Create(color_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " R ");
color_slider[0]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
color_slider[0]->format = "%4.2f";
color_slider[0]->AddSelectionListener(new dw::SelectionListenerOnHook(dwSceneFade::ColorCallback));
color_slider[0]->callback_data.i64 = 0;
for (int32_t i = 0; i < 3; i++) {
static const char* color_name[] = {
" R ",
" G ",
" B ",
};
color_slider[1] = dw::Slider::Create(color_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " G ");
color_slider[1]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
color_slider[1]->format = "%4.2f";
color_slider[1]->AddSelectionListener(new dw::SelectionListenerOnHook(dwSceneFade::ColorCallback));
color_slider[1]->callback_data.i64 = 1;
color_slider[2] = dw::Slider::Create(color_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " B ");
color_slider[2]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
color_slider[2]->format = "%4.2f";
color_slider[2]->AddSelectionListener(new dw::SelectionListenerOnHook(dwSceneFade::ColorCallback));
color_slider[2]->callback_data.i64 = 2;
color_slider[i] = dw::Slider::Create(color_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, color_name[i]);
color_slider[i]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
color_slider[i]->format = "%4.2f";
color_slider[i]->AddSelectionListener(new dw::SelectionListenerOnHook(dwSceneFade::ColorCallback));
color_slider[i]->callback_data.i64 = i;
}
dw::Composite* blend_func_comp = new dw::Composite(this);
blend_func_comp->SetLayout(new dw::RowLayout(dw::HORIZONTAL));
@@ -725,21 +702,20 @@ void dwSceneFade::Hide() {
}
void dwSceneFade::ResetData() {
color = rend->get_scene_fade_color();
alpha = rend->get_scene_fade_alpha();
blend_func = rend->get_scene_fade_blend_func();
rend->get_fade_color(color);
rend->get_fade_rate(&alpha);
rend->get_fade_blend_func(&blend_func);
for (int32_t i = 0; i < 3; i++)
color_slider[i]->SetValue(((float_t*)&color)[i]);
color_slider[i]->SetValue(color[i]);
alpha_slider->SetValue(alpha);
blend_func_list->SetItemIndex(blend_func);
}
void dwSceneFade::SetData() {
rend->set_scene_fade_alpha(alpha, 0);
rend->set_scene_fade_color(color, 0);
rend->set_scene_fade_blend_func(blend_func, 0);
rend->set_fade_rate(alpha);
rend->set_fade_color(color);
rend->set_fade_blend_func(blend_func);
}
void dwSceneFade::AlphaCallback(dw::Widget* data) {
@@ -759,17 +735,17 @@ void dwSceneFade::BlendFuncCallback(dw::Widget* data) {
void dwSceneFade::ColorCallback(dw::Widget* data) {
dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
if (slider)
((float_t*)&dw_scene_fade->color)[slider->callback_data.i32] = slider->GetValue();
dw_scene_fade->color[slider->callback_data.i32] = slider->GetValue();
dw_scene_fade->SetData();
}
void dwSceneFade::ResetCallback(dw::Widget* data) {
rctx_ptr->render.reset_scene_fade(0);
rctx_ptr->render->set_fade_color_default();
dw_scene_fade->ResetData();
}
dwToneTrans::dwToneTrans() {
rend = &rctx_ptr->render;
rend = rctx_ptr->render;
SetText("TONE TRANS");
@@ -780,52 +756,40 @@ dwToneTrans::dwToneTrans() {
(new dw::Label(start_comp))->SetText("START ");
start_slider[0] = dw::Slider::Create(start_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " R ");
start_slider[0]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
start_slider[0]->format = "%4.2f";
start_slider[0]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::StartCallback));
start_slider[0]->callback_data.i64 = 0;
for (int32_t i = 0; i < 3; i++) {
static const char* start_name[] = {
" R ",
" G ",
" B ",
};
start_slider[1] = dw::Slider::Create(start_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " G ");
start_slider[1]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
start_slider[1]->format = "%4.2f";
start_slider[1]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::StartCallback));
start_slider[1]->callback_data.i64 = 1;
start_slider[2] = dw::Slider::Create(start_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " B ");
start_slider[2]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
start_slider[2]->format = "%4.2f";
start_slider[2]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::StartCallback));
start_slider[2]->callback_data.i64 = 2;
start_slider[i] = dw::Slider::Create(start_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, start_name[i]);
start_slider[i]->SetParams(0.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
start_slider[i]->format = "%4.2f";
start_slider[i]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::StartCallback));
start_slider[i]->callback_data.i64 = i;
}
dw::Composite* end_comp = new dw::Composite(this);
end_comp->SetLayout(new dw::RowLayout(dw::HORIZONTAL));
(new dw::Label(end_comp))->SetText("END ");
end_slider[0] = dw::Slider::Create(end_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " R ");
end_slider[0]->SetParams(1.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
end_slider[0]->format = "%4.2f";
end_slider[0]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::EndCallback));
end_slider[0]->callback_data.i64 = 0;
for (int32_t i = 0; i < 3; i++) {
static const char* end_name[] = {
" R ",
" G ",
" B ",
};
end_slider[1] = dw::Slider::Create(end_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " G ");
end_slider[1]->SetParams(1.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
end_slider[1]->format = "%4.2f";
end_slider[1]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::EndCallback));
end_slider[1]->callback_data.i64 = 1;
end_slider[2] = dw::Slider::Create(end_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, " B ");
end_slider[2]->SetParams(1.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
end_slider[2]->format = "%4.2f";
end_slider[2]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::EndCallback));
end_slider[2]->callback_data.i64 = 2;
end_slider[i] = dw::Slider::Create(end_comp,
dw::Flags(dw::FLAG_800 | dw::HORIZONTAL), 0.0f, 0.0f, 100.0f, glyph_size.y, end_name[i]);
end_slider[i]->SetParams(1.0f, 0.0f, 1.0f, 0.1f, 0.01f, 0.1f);
end_slider[i]->format = "%4.2f";
end_slider[i]->AddSelectionListener(new dw::SelectionListenerOnHook(dwToneTrans::EndCallback));
end_slider[i]->callback_data.i64 = i;
}
dw::Composite* reset_comp = new dw::Composite(this);
reset_comp->SetLayout(new dw::RowLayout(dw::HORIZONTAL));
@@ -850,8 +814,8 @@ void dwToneTrans::ResetData() {
rend->get_tone_trans(start, end);
for (int32_t i = 0; i < 3; i++) {
start_slider[i]->SetValue(((float_t*)&start)[i]);
end_slider[i]->SetValue(((float_t*)&end)[i]);
start_slider[i]->SetValue(start[i]);
end_slider[i]->SetValue(end[i]);
}
}
@@ -864,14 +828,14 @@ void dwToneTrans::EndCallback(dw::Widget* data) {
if (slider) {
float_t value = slider->GetValue();
int32_t index = slider->callback_data.i32;
if (((float_t*)&dw_tone_trans->start)[index] != value)
((float_t*)&dw_tone_trans->end)[index] = value;
if (dw_tone_trans->start[index] != value)
dw_tone_trans->end[index] = value;
}
dw_tone_trans->SetData();
}
void dwToneTrans::ResetCallback(dw::Widget* data) {
rctx_ptr->render.reset_tone_trans(0);
rctx_ptr->render->set_tone_trans_default();
dw_tone_trans->ResetData();
}
@@ -880,8 +844,8 @@ void dwToneTrans::StartCallback(dw::Widget* data) {
if (slider) {
float_t value = slider->GetValue();
int32_t index = slider->callback_data.i32;
if (((float_t*)&dw_tone_trans->end)[index] != value)
((float_t*)&dw_tone_trans->start)[index] = value;
if (dw_tone_trans->end[index] != value)
dw_tone_trans->start[index] = value;
}
dw_tone_trans->SetData();
}
src/ReDIVA/graphics/reflect_refract.cpp
+1
View File
@@ -7,6 +7,7 @@
#include "../../CRE/light_param/face.hpp"
#include "../../CRE/light_param.hpp"
#include "../../CRE/render_context.hpp"
#include "../../CRE/render_manager.hpp"
#include "../dw.hpp"
extern render_context* rctx_ptr;
src/ReDIVA/graphics/shadow.cpp
+1
View File
@@ -5,6 +5,7 @@
#include "shadow.hpp"
#include "../../CRE/render_context.hpp"
#include "../../CRE/render_manager.hpp"
#include "../../CRE/shadow.hpp"
#include "../dw.hpp"
src/ReDIVA/input_state.cpp
+8 -8
View File
@@ -1033,19 +1033,19 @@ void glut_motion_cb(int32_t x, int32_t y) {
ScreenParam screen_param = get_screen_param();
#if BAKE_PNG || BAKE_VIDEO
int32_t x_offset = 0;
int32_t y_offset = 0;
int32_t view_x = 0;
int32_t view_y = 0;
float_t x_scale = 1280.0f / (float_t)BAKE_BASE_WIDTH;
float_t y_scale = 720.0f / (float_t)BAKE_BASE_HEIGHT;
#else
int32_t x_offset = rctx_ptr->screen_x_offset;
int32_t y_offset = rctx_ptr->screen_y_offset;
float_t x_scale = 1280.0f / (float_t)rctx_ptr->sprite_width;
float_t y_scale = 720.0f / (float_t)rctx_ptr->sprite_height;
int32_t view_x = rctx_ptr->view_x;
int32_t view_y = rctx_ptr->view_y;
float_t x_scale = 1280.0f / (float_t)rctx_ptr->view_w;
float_t y_scale = 720.0f / (float_t)rctx_ptr->view_h;
#endif
x = (int32_t)(((float_t)x - x_offset) * x_scale);
y = (int32_t)(((float_t)y - y_offset) * y_scale);
x = (int32_t)(((float_t)x - view_x) * x_scale);
y = (int32_t)(((float_t)y - view_y) * y_scale);
glut_input.motion_x = x;
glut_input.motion_y = y;
src/ReDIVA/main.cpp
+67 -66
View File
@@ -16,7 +16,7 @@ bool cpu_caps_avx;
bool cpu_caps_f16c;
bool cpu_caps_avx2;
/*void scan_arguments(int32_t argc, wchar_t** argv) {
/*void read_arg(int32_t argc, wchar_t** argv) {
std::vector<std::wstring> arguments;
arguments.assign(argv + 1, argv + argc);
@@ -30,106 +30,106 @@ bool cpu_caps_avx2;
if (!i->compare(L"--help"))
show_help = true;
else if (!i->compare(L"-debug"))
stru_140EDA5B0.debug = 1;
s_main_info.debug_mode = 1;
else if (!i->compare(L"-t"))
sys_am_set_test_mode_starting(true);
else if (!i->compare(L"-m")) {
if (++i == i_end)
break;
stru_140EDA5B0.mode = _wtoi(i->c_str());
s_main_info.start_mode = _wtoi(i->c_str());
}
else if (!i->compare(L"-s")) {
if (++i == i_end)
break;
stru_140EDA5B0.sub_mode = _wtoi(i->c_str());
s_main_info.start_mode_sub = _wtoi(i->c_str());
}
else if (!i->compare(L"-sm") || !i->compare(L"--start-up-mode")) {
if (++i == i_end)
break;
if (i->compare(L"server"))
stru_140EDA5B0.start_up_mode = 0;
s_main_info.start_up_mode = START_UP_MODE_SERVER;
else
stru_140EDA5B0.start_up_mode = 1;
s_main_info.start_up_mode = START_UP_MODE_SATELLITE;
}
else if (!i->compare(L"-ve"))
stru_140EDA5B0.vsync_emulation = 1;
s_main_info.vsync_emu = 1;
else if (!i->compare(L"-fs") || !i->compare(L"-f"))
stru_140EDA5B0.full_screen = 1;
s_main_info.full_screen = 1;
else if (!i->compare(L"-w"))
stru_140EDA5B0.full_screen = 0;
s_main_info.full_screen = 0;
else if (!i->compare(L"-aa"))
stru_140EDA5B0.ssaa = 1;
s_main_info.anti_alias = 1;
else if (!i->compare(L"-qvga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_QVGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_QVGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-vga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_VGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_VGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-wvga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_WVGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_WVGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-svga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_SVGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_SVGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-xga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_XGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_XGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-wxga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_WXGA;
stru_140EDA5B0.hd_res = 1;
s_main_info.screen_mode = SCREEN_MODE_WXGA;
s_main_info.min_render = 1;
}
else if (!i->compare(L"-wxga_dbd")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_WXGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_WXGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-uxga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_UXGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_UXGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-wuxga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_WUXGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_WUXGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-wqxga")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_WQXGA;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_WQXGA;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-hdtv720")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_HD;
stru_140EDA5B0.hd_res = 1;
s_main_info.screen_mode = SCREEN_MODE_HD;
s_main_info.min_render = 1;
}
else if (!i->compare(L"-hdtv720_dbd")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_HD;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_HD;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-hdtv1080")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_FHD;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_FHD;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-wqhd")) {
stru_140EDA5B0.res_launch = SCREEN_MODE_QHD;
stru_140EDA5B0.hd_res = 0;
s_main_info.screen_mode = SCREEN_MODE_QHD;
s_main_info.min_render = 0;
}
else if (!i->compare(L"-ss")) {
if (++i == i_end)
break;
stru_140EDA5B0.screen_shot = 1;
stru_140EDA5B0.field_80 = 0;
stru_140EDA5B0.field_40.assign(*i);
stru_140EDA5B0.field_60.assign(stru_140EDA5B0.field_40);
stru_140EDA5B0.ssaa = 1;
s_main_info.ss_flag = 1;
s_main_info.field_80 = 0;
s_main_info.field_40.assign(*i);
s_main_info.field_60.assign(s_main_info.field_40);
s_main_info.anti_alias = 1;
}
else if (!i->compare(L"-no_aa")) {
stru_140EDA5B0.ssaa = 0;
s_main_info.anti_alias = 0;
continue;
}
else if (!i->compare(L"-ssformat")) {
@@ -137,47 +137,48 @@ bool cpu_caps_avx2;
break;
if (!i->compare(L"ppm"))
stru_140EDA5B0.ss_format = 0;
s_main_info.ss_suffix = SS_SUFFIX_PPM;
else if (!i->compare(L"bmp"))
stru_140EDA5B0.ss_format = 1;
s_main_info.ss_suffix = SS_SUFFIX_BMP;
else if (!i->compare(L"tga"))
stru_140EDA5B0.ss_format = 2;
s_main_info.ss_suffix = SS_SUFFIX_TGA;
else if (!i->compare(L"yuy2"))
stru_140EDA5B0.ss_format = 3;
s_main_info.ss_suffix = SS_SUFFIX_YUY2;
else if (!i->compare(L"jpg"))
stru_140EDA5B0.ss_format = 4;
s_main_info.ss_suffix = SS_SUFFIX_JPEG;
}
else if (!i->compare(L"-ss4x")) {
if (++i == i_end)
break;
stru_140EDA5B0.screen_shot = 1;
stru_140EDA5B0.field_80 = 0;
stru_140EDA5B0.field_40.assign(*i);
stru_140EDA5B0.field_60.assign(stru_140EDA5B0.field_40);
stru_140EDA5B0.screen_shot_4x = 1;
stru_140EDA5B0.ssaa = 1;
s_main_info.ss_flag = 1;
s_main_info.field_80 = 0;
s_main_info.field_40.assign(*i);
s_main_info.field_60.assign(s_main_info.field_40);
s_main_info.ss_mode = SS_MODE_SIZE_4X;
s_main_info.anti_alias = 1;
}
else if (!i->compare(L"-ss36x"));
else if (i->compare(L"-ssalphamask"))
stru_140EDA5B0.ss_alpha_mask = 1;
s_main_info.ss_alpha_mask = 1;
else if (!i->compare(L"-fix_pv_timer"))
stru_140EDA5B0.fix_pv_timer = 1;
s_main_info.fix_pv_timer = 1;
else if (!i->compare(L"-ps3"))
stru_140EDA5B0.ps3 = 1;
s_main_info.ps3 = 1;
else if (!i->compare(L"-dev_rom"))
stru_140EDA5B0.dev_rom = 1;
s_main_info.dev_rom = 1;
else if (!i->compare(L"-pv_full_open"))
stru_140EDA5B0.pv_full_open = 1;
s_main_info.pv_full_open = 1;
else if (!i->compare(L"-no_local_rom"))
stru_140EDA5B0.local_rom = 0;
s_main_info.local_rom = 0;
else if (!i->compare(L"-pcv"))
stru_140EDA5B0.pcv = 1;
s_main_info.pcv = 1;
}
sub_140558EB0(screen_shot_impl_ptr, stru_140EDA5B0.ss_format);
if (stru_140EDA5B0.ssaa || stru_140EDA5B0.screen_shot)
stru_140EDA5B0.hd_res = 0;
screen_shot_impl_ptr->set_format(s_main_info.ss_suffix);
if (s_main_info.anti_alias || s_main_info.ss_flag)
s_main_info.min_render = 0;
if (show_help) {
printf("Usage: %ls [option]...\n", *argv);
@@ -212,7 +213,7 @@ int32_t wmain(int32_t argc, wchar_t** argv) {
return 0;
}
int32_t max_minor_ver = 2;
int32_t max_minor_ver = 6;
bool vulkan = false;
const wchar_t* config_path = 0;
if (argc >= 2)
src/ReDIVA/mode_advertise.cpp
+1
View File
@@ -8,6 +8,7 @@
#include "../CRE/data.hpp"
#include "../CRE/module_table.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/render_manager.hpp"
#include "../CRE/sound.hpp"
#include "pv_game/pv_game.hpp"
#include "am_data.hpp"
src/ReDIVA/mode_data_edit.cpp
+1
View File
@@ -5,6 +5,7 @@
#include "mode_data_edit.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/render_manager.hpp"
#include "data_edit/face_anim.hpp"
#include "data_edit/glitter_editor.hpp"
#include "data_edit/selector.hpp"
src/ReDIVA/mode_data_test.cpp
+1
View File
@@ -6,6 +6,7 @@
#include "mode_data_test.hpp"
#include "../CRE/clear_color.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/render_manager.hpp"
#include "../CRE/stage.hpp"
#include "data_edit/rob_chara_adjust.hpp"
#include "data_test/auth_2d_test.hpp"
src/ReDIVA/mode_game.cpp
+1
View File
@@ -5,6 +5,7 @@
#include "mode_game.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/render_manager.hpp"
#include "pv_game/player_data.hpp"
#include "pv_game/pv_game.hpp"
#include "mask_screen.hpp"
src/ReDIVA/pv_game/pv_game.cpp
+30 -26
View File
@@ -12,9 +12,12 @@
#include "../../CRE/customize_item_table.hpp"
#include "../../CRE/effect.hpp"
#include "../../CRE/hand_item.hpp"
#include "../../CRE/random.hpp"
#include "../../CRE/pv_expression.hpp"
#include "../../CRE/pv_param.hpp"
#include "../../CRE/random.hpp"
#include "../../CRE/render.hpp"
#include "../../CRE/render_context.hpp"
#include "../../CRE/render_manager.hpp"
#include "../../CRE/shadow.hpp"
#include "../../CRE/sound.hpp"
#include "../../CRE/stage_param.hpp"
@@ -1204,7 +1207,7 @@ void pv_game::change_field(size_t field, ssize_t dsc_time, ssize_t curr_time) {
light_param_data_storage_data_set_pv_cut((int32_t)field);
rctx_ptr->render_manager->set_npr_param(next_field_data.npr_type);
rctx_ptr->render.set_cam_blur(next_field_data.cam_blur);
rctx_ptr->render->set_cam_blur(next_field_data.cam_blur);
if (next_field_data.sdw_off)
rctx_ptr->render_manager->set_shadow_false();
@@ -1823,7 +1826,7 @@ int32_t pv_game::ctrl_end(float_t delta_time) {
task_mask_screen_fade_out(0.75f, 0);
}
rctx_ptr->render.set_exposure(0.0f);
rctx_ptr->render->set_exposure(0.0f);
if (data.play_data.get_aet_next_info_disp())
return 0;
@@ -2750,9 +2753,9 @@ bool pv_game::load() {
}
if (data.pv->get_performer_count() < 2)
rctx_ptr->render.update_res(false, 1);
rctx_ptr->render->calc_draw_size(false, 1);
else
rctx_ptr->render.update_res(false, 2);
rctx_ptr->render->calc_draw_size(false, 2);
rctx_ptr->render_manager->set_effect_texture(0);
} return false;
case 3: {
@@ -3247,7 +3250,7 @@ bool pv_game::load() {
for (const pv_db_pv_frame_texture& i : get_pv_db_pv()->frame_texture)
if (i.data.size()) {
data.has_frame_texture = true;
rctx_ptr->render.frame_texture_reset();
rctx_ptr->render->init_capture();
break;
}
}
@@ -3562,13 +3565,14 @@ bool pv_game::load() {
state = 12;
} break;
case 12: {
rndr::Render& rend = rctx_ptr->render;
int32_t frame_texture_slot = 0;
rndr::Render* rend = rctx_ptr->render;
int32_t slot = 0;
for (const pv_db_pv_frame_texture& i : data.pv->frame_texture) {
texture* tex = texture_manager_get_texture(aft_tex_db->get_texture_id(i.data.c_str()));
if (tex)
rend.frame_texture_load(frame_texture_slot, (rndr::Render::FrameTextureType)i.type, tex);
frame_texture_slot++;
texture* txhd = texture_manager_get_texture(aft_tex_db->get_texture_id(i.data.c_str()));
if (txhd)
rend->register_fb_man_cap((rndr::Render::CaptureSlot)slot,
(rndr::Render::CaptureType)i.type, txhd);
slot++;
}
/*if (sel_main_get()->check_alive())
@@ -4601,7 +4605,7 @@ bool pv_game::set_pv_param_post_process_color_correction_data(bool set, int32_t
}
bool pv_game::set_pv_param_post_process_dof_data(bool set, int32_t id, float_t duration) {
rctx_ptr->render.set_dof_enable(set);
rctx_ptr->render->enable_dof_set(set);
pv_param::dof& dof = pv_param::post_process_data_get_dof_data(id);
if (set)
@@ -4690,19 +4694,19 @@ bool pv_game::unload() {
data.field_2CF30 = 4;
rndr::Render& rend = rctx_ptr->render;
int32_t frame_texture_slot = 0;
rndr::Render* rend = rctx_ptr->render;
int32_t slot = 0;
for (const pv_db_pv_frame_texture& i : data.pv->frame_texture) {
if (i.data.size()) {
texture* tex = texture_manager_get_texture(aft_tex_db->get_texture_id(i.data.c_str()));
if (tex)
rend.frame_texture_unload(frame_texture_slot, tex);
texture* txhd = texture_manager_get_texture(aft_tex_db->get_texture_id(i.data.c_str()));
if (txhd)
rend->unregister_fb_man_cap((rndr::Render::CaptureSlot)slot, txhd);
}
frame_texture_slot++;
slot++;
}
if (data.has_frame_texture) {
rend.frame_texture_free();
rend->free_capture();
data.has_frame_texture = false;
}
@@ -4891,13 +4895,13 @@ bool pv_game::unload() {
light_param_data_storage_data_reset();
rndr::Render& rend = rctx_ptr->render;
rend.reset_saturate_coeff(0, true);
rend.set_dof_enable(false);
rend.reset_scene_fade(0);
rndr::Render* rend = rctx_ptr->render;
rend->set_saturate_coef_default(0, true);
rend->enable_dof_set(false);
rend->set_fade_color_default();
if (!false/*sub_140192E20()*/)
rend.set_taa(1);
rend.update_res(0, -1);
rend->set_temporal_aa(1);
rend->calc_draw_size(0, -1);
rctx_ptr->disp_manager->object_culling = true;
get_shadow()->set_shadow_range(1.0f);
src/ReDIVA/pv_game/pv_game_pv_data.cpp
+29 -24
View File
@@ -8,6 +8,9 @@
#include "../../CRE/app_system_detail.hpp"
#include "../../CRE/pv_expression.hpp"
#include "../../CRE/pv_param.hpp"
#include "../../CRE/render.hpp"
#include "../../CRE/render_context.hpp"
#include "../../CRE/render_manager.hpp"
#include "../../CRE/shadow.hpp"
#include "../information/dw_console.hpp"
#include "../mask_screen.hpp"
@@ -238,7 +241,7 @@ pv_data_camera::pv_data_camera() : enable(), time() {
index = -1;
}
pv_scene_fade::pv_scene_fade() : enable(), time(), duration(), start_alpha(), end_alpha() {
pv_scene_fade::pv_scene_fade() : enable(), time(), duration(), start_alpha(), end_alpha(), color() {
}
@@ -259,8 +262,8 @@ void pv_scene_fade::ctrl(float_t delta_time) {
end = false;
}
rctx_ptr->render.set_scene_fade_color(color, 1);
rctx_ptr->render.set_scene_fade_alpha(alpha, 1);
rctx_ptr->render->set_fade_color(color, 1);
rctx_ptr->render->set_fade_rate(alpha, 1);
if (end)
reset();
@@ -272,7 +275,9 @@ void pv_scene_fade::reset() {
duration = 0.0f;
start_alpha = 0.0f;
end_alpha = 0.0f;
color = 0.0f;
color[0] = 0.0f;
color[1] = 0.0f;
color[2] = 0.0f;
}
pv_dsc_target::pv_dsc_target() : amplitude(), frequency(), slide_chain_start(),
@@ -1538,36 +1543,36 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
scene_fade.duration = (float_t)data[0] * 0.001f;
scene_fade.start_alpha = (float_t)data[1] * 0.001f;
scene_fade.end_alpha = (float_t)data[2] * 0.001f;
scene_fade.color.x = (float_t)data[3] * 0.001f;
scene_fade.color.y = (float_t)data[4] * 0.001f;
scene_fade.color.z = (float_t)data[5] * 0.001f;
scene_fade.color[0] = (float_t)data[3] * 0.001f;
scene_fade.color[1] = (float_t)data[4] * 0.001f;
scene_fade.color[2] = (float_t)data[5] * 0.001f;
scene_fade.enable = true;
scene_fade.time = 0.0f;
scene_fade_ctrl(0.0f);
} break;
case DSC_FT_TONE_TRANS: {
vec3 start;
start.x = (float_t)data[0] * 0.001f;
start.y = (float_t)data[1] * 0.001f;
start.z = (float_t)data[2] * 0.001f;
float_t start[3];
start[0] = (float_t)data[0] * 0.001f;
start[1] = (float_t)data[1] * 0.001f;
start[2] = (float_t)data[2] * 0.001f;
vec3 end;
end.x = (float_t)data[3] * 0.001f;
end.y = (float_t)data[4] * 0.001f;
end.z = (float_t)data[5] * 0.001f;
float_t end[3];
end[0] = (float_t)data[3] * 0.001f;
end[1] = (float_t)data[4] * 0.001f;
end[2] = (float_t)data[5] * 0.001f;
rctx_ptr->render.set_tone_trans(start, end, 1);
rctx_ptr->render->set_tone_trans(start, end, 1);
} break;
case DSC_FT_SATURATE: {
float_t saturate_coeff = (float_t)data[0] * 0.001f;
float_t saturate_coef = (float_t)data[0] * 0.001f;
rctx_ptr->render.set_saturate_coeff(saturate_coeff, 1, false);
rctx_ptr->render->set_saturate_coef(saturate_coef, 1, false);
} break;
case DSC_FT_FADE_MODE: {
int32_t blend_func = data[0];
rctx_ptr->render.set_scene_fade_blend_func(blend_func, 1);
rctx_ptr->render->set_fade_blend_func(blend_func, 1);
} break;
case DSC_FT_AUTO_BLINK: {
rob_id = (ROB_ID)data[0];
@@ -1960,13 +1965,13 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
int32_t enable = data[0];
if (pv_game->data.pv)
rctx_ptr->render.frame_texture_cont_capture_set(enable == 1);
rctx_ptr->render->set_frame_texture_aoto_cap(enable == 1);
} break;
case DSC_FT_MAN_CAP: {
int32_t slot = data[0];
if (pv_game->data.pv && slot >= 0 && slot <= 4)
rctx_ptr->render.frame_texture_slot_capture_set(slot + 1);
rctx_ptr->render->capture_slot_enable((rndr::Render::CaptureSlot)(1 + slot));
} break;
case DSC_FT_TOON: {
int32_t npr_param = data[0];
@@ -2562,9 +2567,9 @@ void pv_game_pv_data::reset_camera_post_process() {
cam->set_ignore_fov(false);
cam->set_fov(32.2673416137695f);
rctx_ptr->render.reset_scene_fade(1);
rctx_ptr->render.reset_tone_trans(1);
rctx_ptr->render.reset_saturate_coeff(1, 1);
rctx_ptr->render->set_fade_color_default(1);
rctx_ptr->render->set_tone_trans_default(1);
rctx_ptr->render->set_saturate_coef_default(1, true);
Shadow* shad = get_shadow();
if (shad)
src/ReDIVA/pv_game/pv_game_pv_data.hpp
+1 -1
View File
@@ -199,7 +199,7 @@ struct pv_scene_fade {
float_t duration;
float_t start_alpha;
float_t end_alpha;
vec3 color;
float_t color[3];
pv_scene_fade();
src/ReDIVA/system_startup.cpp
+2
View File
@@ -7,6 +7,8 @@
#include "../CRE/app_system_detail.hpp"
#include "../CRE/auth_2d.hpp"
#include "../CRE/mdata_manager.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/render_manager.hpp"
#include "../CRE/sprite.hpp"
#include "../KKdLib/io/path.hpp"
#include "pv_game/pv_game.hpp"
src/ReDIVA/x_pv_game.cpp
+36 -35
View File
@@ -18,6 +18,8 @@
#include "../CRE/pv_expression.hpp"
#include "../CRE/pv_param.hpp"
#include "../CRE/random.hpp"
#include "../CRE/render.hpp"
#include "../CRE/render_manager.hpp"
#include "../CRE/shader_ft.hpp"
#include "../CRE/shadow.hpp"
#include "../CRE/sound.hpp"
@@ -3409,27 +3411,27 @@ bool x_pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
} break;
case DSC_X_TONE_TRANS: {
vec3 start;
start.x = (float_t)data[0] * 0.001f;
start.y = (float_t)data[1] * 0.001f;
start.z = (float_t)data[2] * 0.001f;
float_t start[3];
start[0] = (float_t)data[0] * 0.001f;
start[1] = (float_t)data[1] * 0.001f;
start[2] = (float_t)data[2] * 0.001f;
vec3 end;
end.x = (float_t)data[3] * 0.001f;
end.y = (float_t)data[4] * 0.001f;
end.z = (float_t)data[5] * 0.001f;
float_t end[3];
end[0] = (float_t)data[3] * 0.001f;
end[1] = (float_t)data[4] * 0.001f;
end[2] = (float_t)data[5] * 0.001f;
rctx_ptr->render.set_tone_trans(start, end, 1);
rctx_ptr->render->set_tone_trans(start, end, 1);
} break;
case DSC_X_SATURATE: {
float_t saturate_coeff = (float_t)data[0] * 0.001f;
float_t saturate_coef = (float_t)data[0] * 0.001f;
rctx_ptr->render.set_saturate_coeff(saturate_coeff, 1, false);
rctx_ptr->render->set_saturate_coef(saturate_coef, 1, false);
} break;
case DSC_X_FADE_MODE: {
int32_t blend_func = data[0];
rctx_ptr->render.set_scene_fade_blend_func(blend_func, 1);
rctx_ptr->render->set_fade_blend_func(blend_func, 1);
} break;
case DSC_X_AUTO_BLINK: {
@@ -4322,8 +4324,8 @@ bool x_pv_game_pv_data::set_pv_param_post_process_color_correction_data(bool set
}
bool x_pv_game_pv_data::set_pv_param_post_process_dof_data(bool set, int32_t id, float_t duration) {
rctx_ptr->render.set_dof_enable(set);
rctx_ptr->render.set_dof_update(set);
rctx_ptr->render->enable_dof_set(set);
rctx_ptr->render->update_dof_set(set);
pv_param::dof& dof = pv_param::post_process_data_get_dof_data(id);
if (set)
@@ -6491,9 +6493,9 @@ bool x_pv_game::ctrl() {
}
if (pv_data.play_param->chara.size() < 2)
rctx_ptr->render.update_res(false, 1);
rctx_ptr->render->calc_draw_size(false, 1);
else
rctx_ptr->render.update_res(false, 2);
rctx_ptr->render->calc_draw_size(false, 2);
#if BAKE_PV826
if (pv_data.pv_id == 826)
@@ -7995,14 +7997,14 @@ void x_pv_game::post() {
rend_data_ctx.state.set_viewport(0, 0, width, height);
if (nvenc_rgb) {
rend_data_ctx.shader_flags.arr[U_REDUCE] = 0;
rend_data_ctx.shader_flags.arr[U_REDUCE_TEX] = 0;
shaders_dev.set(rend_data_ctx.state,
rend_data_ctx.shader_flags, SHADER_FT_REDUCE);
}
else
shaders_dev.set(rend_data_ctx.state,
rend_data_ctx.shader_flags, SHADER_DEV_CONVERT_ALPHA);
rctx_ptr->render.draw_quad(rend_data_ctx, width, height,
rctx_ptr->render->draw_quad(rend_data_ctx, width, height,
1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
if (nvenc_rgb)
@@ -8021,14 +8023,14 @@ void x_pv_game::post() {
if (dof_cam_data.frame != frame) {
camera* cam = rctx_ptr->camera;
bool enable = rctx_ptr->render.get_dof_enable();
bool enable = rctx_ptr->render->get_dof_enable();
float_t focus;
float_t focus_range;
float_t fuzzing_range;
float_t ratio;
rctx_ptr->render.get_dof_data(focus, focus_range, fuzzing_range, ratio);
ratio *= rctx_ptr->render.get_dof_enable() ? 1.0f : 0.0f;
rctx_ptr->render->get_dof_data(focus, focus_range, fuzzing_range, ratio);
ratio *= rctx_ptr->render->get_dof_enable() ? 1.0f : 0.0f;
vec3 interest;
vec3 view_point;
@@ -8280,14 +8282,14 @@ bool x_pv_game::unload() {
light_param_data_storage_data_reset();
rndr::Render& rend = rctx_ptr->render;
rend.reset_saturate_coeff(0, true);
rend.set_dof_enable(false);
rend.set_dof_update(false);
rend.reset_scene_fade(0);
rndr::Render* rend = rctx_ptr->render;
rend->set_saturate_coef_default(0, true);
rend->enable_dof_set(false);
rend->update_dof_set(false);
rend->set_fade_color_default();
rend.set_taa(1);
rend.update_res(0, -1);
rend->set_temporal_aa(1);
rend->calc_draw_size(false, -1);
rctx_ptr->disp_manager->object_culling = true;
get_shadow()->set_shadow_range(1.0f);
@@ -9277,8 +9279,7 @@ void obj_set_reflect::pack_file(void** data, size_t* size, bool mmp,
for (uint32_t i = 0; i < 0x10; i += sizeof(uint32_t))
*(uint32_t*)(iv + i) = Random(RANDOM_TYPE_GLOBAL);
prj::Rijndael rijndael(prj::Rijndael_Nb, prj::Rijndael_Nk128, key);
prj::Rijndael rijndael(prj::Rijndael_Nb, prj::Rijndael_Nk256, key);
uint8_t _iv[prj::Rijndael_Nlen];
memcpy(_iv, iv, prj::Rijndael_Nlen);
@@ -13432,11 +13433,11 @@ static void x_pv_game_write_stage_data(int32_t stage_id, const auth_3d_database*
stage_data->object_shadow = replace_object_info(i.object_shadow, x_stage_obj_db, x_pack_obj_db);
stage_data->object_reflect = replace_object_info(i.object_reflect, x_stage_obj_db, x_pack_obj_db);
stage_data->object_refract = replace_object_info(i.object_refract, x_stage_obj_db, x_pack_obj_db);
stage_data->lens_flare_texture = -1;
stage_data->lens_shaft_texture = -1;
stage_data->lens_ghost_texture = -1;
stage_data->lens_shaft_inv_scale = 1.0f;
stage_data->unknown = 0;
stage_data->tex_flare = -1;
stage_data->tex_shaft = -1;
stage_data->tex_ghost = -1;
stage_data->shaft_scale = 1.0f;
stage_data->num_ghosts = 0;
stage_data->render_texture = replace_texture_id(i.render_texture, x_stage_tex_db, x_pack_tex_db);
if (stage_data->render_texture == -1) {