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

Shader: total overhaul of permutations and shader flags

Browse Source
This commit is contained in:
korenkonder
2024-06-25 22:47:08 +03:00
parent 737fdd935f
commit 0cd4b4e0c4
18 changed files with 798 additions and 1535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/CRE/Glitter/render_scene.cpp
+20 -12
View File
@@ -1002,13 +1002,13 @@ namespace Glitter {
case PARTICLE_QUAD:
switch (rend_group->fog_type) {
default:
uniform_value[U_FOG_HEIGHT] = 0;
uniform_value[U_FOG_STAGE] = 0;
break;
case Glitter::FOG_DEPTH:
uniform_value[U_FOG_HEIGHT] = 1;
uniform_value[U_FOG_STAGE] = 1;
break;
case Glitter::FOG_HEIGHT:
uniform_value[U_FOG_HEIGHT] = 2;
uniform_value[U_FOG_STAGE] = 2;
break;
}
@@ -1031,7 +1031,7 @@ namespace Glitter {
gl_state_disable_cull_face();
break;
case PARTICLE_LINE:
uniform_value[U_FOG_HEIGHT] = 0;
uniform_value[U_FOG_STAGE] = 0;
uniform_value[U_ALPHA_BLEND] = 2;
gl_state_enable_depth_test();
@@ -1040,7 +1040,7 @@ namespace Glitter {
gl_state_set_cull_face_mode(GL_BACK);
break;
case PARTICLE_LOCUS:
uniform_value[U_FOG_HEIGHT] = 0;
uniform_value[U_FOG_STAGE] = 0;
uniform_value[U_ALPHA_BLEND] = 2;
gl_state_enable_depth_test();
@@ -1049,9 +1049,13 @@ namespace Glitter {
break;
}
rctx_ptr->obj_shader.set_shader_flags(uniform_value);
rctx_ptr->obj_shader_ubo.WriteMemory(rctx_ptr->obj_shader);
shaders_ft.set(SHADER_FT_GLITTER_PT);
rctx_ptr->obj_scene_ubo.Bind(0);
rctx_ptr->glitter_batch_ubo.Bind(2);
rctx_ptr->obj_shader_ubo.Bind(0);
rctx_ptr->obj_scene_ubo.Bind(1);
rctx_ptr->glitter_batch_ubo.Bind(3);
switch (rend_group->type) {
case PARTICLE_QUAD:
gl_state_bind_vertex_array(rend_group->vao);
@@ -2108,13 +2112,13 @@ namespace Glitter {
switch (rend_group->fog_type) {
default:
uniform_value[U_FOG_HEIGHT] = 0;
uniform_value[U_FOG_STAGE] = 0;
break;
case Glitter::FOG_DEPTH:
uniform_value[U_FOG_HEIGHT] = 1;
uniform_value[U_FOG_STAGE] = 1;
break;
case Glitter::FOG_HEIGHT:
uniform_value[U_FOG_HEIGHT] = 2;
uniform_value[U_FOG_STAGE] = 2;
break;
}
@@ -2140,9 +2144,13 @@ namespace Glitter {
else
gl_state_disable_cull_face();
rctx_ptr->obj_shader.set_shader_flags(uniform_value);
rctx_ptr->obj_shader_ubo.WriteMemory(rctx_ptr->obj_shader);
shaders_ft.set(SHADER_FT_GLITTER_PT);
rctx_ptr->obj_scene_ubo.Bind(0);
rctx_ptr->glitter_batch_ubo.Bind(2);
rctx_ptr->obj_shader_ubo.Bind(0);
rctx_ptr->obj_scene_ubo.Bind(1);
rctx_ptr->glitter_batch_ubo.Bind(3);
switch (rend_group->type) {
case PARTICLE_QUAD:
gl_state_bind_vertex_array(rend_group->vao);
src/CRE/effect.cpp
+1 -1
View File
@@ -4087,7 +4087,7 @@ void water_particle::draw(mat4* mat) {
shaders_ft.set(SHADER_FT_W_PTCL);
gl_state_bind_vertex_array(rctx_ptr->common_vao);
water_particle_scene_ubo.Bind(4);
water_particle_scene_ubo.Bind(5);
ssbo.Bind(0);
texture* tex = texture_manager_get_texture(splash_tex_id);
if (tex)
src/CRE/mdl/disp_manager.cpp
+8 -6
View File
@@ -2016,9 +2016,10 @@ namespace mdl {
uniform_value_reset();
gl_state_get();
rctx->obj_scene_ubo.Bind(0);
rctx->obj_batch_ubo.Bind(1);
rctx->obj_skinning_ubo.Bind(3);
rctx->obj_shader_ubo.Bind(0);
rctx->obj_scene_ubo.Bind(1);
rctx->obj_batch_ubo.Bind(2);
rctx->obj_skinning_ubo.Bind(4);
switch (type) {
case OBJ_TYPE_TRANSLUCENT:
@@ -2177,9 +2178,10 @@ namespace mdl {
uniform_value_reset();
gl_state_get();
rctx->obj_scene_ubo.Bind(0);
rctx->obj_batch_ubo.Bind(1);
rctx->obj_skinning_ubo.Bind(3);
rctx->obj_shader_ubo.Bind(0);
rctx->obj_scene_ubo.Bind(1);
rctx->obj_batch_ubo.Bind(2);
rctx->obj_skinning_ubo.Bind(4);
switch (type) {
case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1:
src/CRE/mdl/draw_object.cpp
+14 -20
View File
@@ -50,7 +50,10 @@ namespace mdl {
GL_UNSIGNED_INT,
};
rctx->obj_shader.set_shader_flags(uniform_value);
rctx->obj_shader_ubo.WriteMemory(rctx->obj_shader);
rctx->obj_batch_ubo.WriteMemory(rctx->obj_batch);
if (primitive_type == OBJ_PRIMITIVE_TRIANGLE_STRIP && index_format == OBJ_INDEX_U16)
shaders_ft.draw_range_elements(GL_TRIANGLE_STRIP,
start, end, count, GL_UNSIGNED_SHORT, (void*)indices);
@@ -325,7 +328,6 @@ namespace mdl {
if (!rctx->render_manager->npr_param)
chara = true;
break;
//case SHADER_FT_EYEBALL:
case SHADER_FT_GLASEYE:
uniform_value[U_NPR_NORMAL] = 0;
chara = true;
@@ -417,7 +419,6 @@ namespace mdl {
draw_object_material_set_uniform(material, false);
if (material->material.attrib.m.alpha_texture)
uniform_value[U_TEXTURE_COUNT] = 0;
rctx->obj_batch.g_texture_blend = { (float_t)uniform_value[U_TEXTURE_BLEND], 0.0f, 0.0f, 0.0f };
shaders_ft.set(rctx->draw_state->shader_index);
}
@@ -589,7 +590,7 @@ static bool draw_object_blend_set(render_context* rctx,
}
}
if (draw_object_blend_set_check_use_default_blend(shader_index)){
if (draw_object_blend_set_check_use_default_blend(shader_index)) {
src_blend_factor = GL_SRC_ALPHA;
dst_blend_factor = GL_ONE_MINUS_SRC_ALPHA;
}
@@ -602,11 +603,10 @@ static bool draw_object_blend_set(render_context* rctx,
static bool draw_object_blend_set_check_use_default_blend(int32_t index) {
bool use_default_blend[] = {
false, false, true, false, true, false, false, true, true, true, false, false,
false, true, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false, false, false, false, false,
false, false, false
false, false, false,
};
if (index >= 0 && index < SHADER_FT_MAX)
@@ -627,11 +627,8 @@ static void draw_object_chara_color_fog_set(render_context* rctx, const mdl::Obj
obj_material_attrib_member attrib = args->material->material.attrib.m;
if (!attrib.no_fog && !disable_fog) {
if (attrib.has_fog_height)
uniform_value[U_FOG_HEIGHT] = 2 + attrib.fog_height;
else
uniform_value[U_FOG_HEIGHT] = 1;
uniform_value[U_FOG] = rctx->draw_state->fog_height ? 2 : 1;
uniform_value[U_FOG_STAGE] = attrib.has_fog_height ? (attrib.fog_height ? 3 : 2) : 1;
uniform_value[U_FOG_CHARA] = rctx->draw_state->fog_height ? 2 : 1;
}
}
@@ -658,17 +655,16 @@ static void draw_object_material_set_default(render_context* rctx, const mdl::Ob
material->material.shader_info.get_lighting_type();
bool disable_fog = draw_object_blend_set(rctx, args, lighting_type);
draw_object_material_set_uniform(material, false);
if (!rctx->draw_state->light)
uniform_value[U_LIGHT_0] = 0;
if (!rctx->draw_state->shadow)
uniform_value[U_STAGE_SHADOW] = 0;
else if (args->self_shadow)
uniform_value[U_LIGHT_0] = 1;
uniform_value[U_STAGE_SHADOW] = 1;
else
uniform_value[U_LIGHT_0] = args->sub_mesh->attrib.m.recieve_shadow ? 1 : 0;
uniform_value[U_SHADOW] = 0;
uniform_value[U_SELF_SHADOW] = rctx->draw_state->self_shadow ? 1 : 0;
uniform_value[U_STAGE_SHADOW] = args->sub_mesh->attrib.m.recieve_shadow ? 1 : 0;
uniform_value[U_CHARA_SHADOW2] = args->shadow > SHADOW_CHARA ? 1 : 0;
uniform_value[U_CHARA_SHADOW] = rctx->draw_state->self_shadow ? 1 : 0;
const obj_material_texture_data* texdata = material->material.texdata;
uniform_value[U_SHADOW] = args->shadow > SHADOW_CHARA;
for (int32_t i = 0, j = 0; i < 8; i++, texdata++) {
if (texdata->tex_index == -1)
continue;
@@ -813,10 +809,9 @@ static void draw_object_material_set_default(render_context* rctx, const mdl::Ob
else
shaders_ft.set(SHADER_FT_CONSTANT);
rctx->obj_batch.g_texture_blend = { (float_t)uniform_value[U_TEXTURE_BLEND], 0.0f, 0.0f, 0.0f };
if (lighting_type != OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT) {
float_t material_shininess;
if (material->material.shader.index == SHADER_FT_GLASEYE/*SHADER_FT_EYEBALL*/)
if (material->material.shader.index == SHADER_FT_GLASEYE)
material_shininess = 10.0f;
else {
material_shininess = (material->material.color.shininess - 16.0f) * (float_t)(1.0 / 112.0);
@@ -963,7 +958,6 @@ static void draw_object_material_set_reflect(render_context* rctx, const mdl::Ob
}
draw_object_material_set_uniform(material, true);
rctx->obj_batch.g_texture_blend = { (float_t)uniform_value[U_TEXTURE_BLEND], 0.0f, 0.0f, 0.0f };
shaders_ft.set(rctx->draw_state->shader_index);
rctx->obj_batch.g_material_state_ambient = ambient;
rctx->obj_batch.g_material_state_diffuse = diffuse;
src/CRE/render.cpp
+43 -41
View File
@@ -1578,35 +1578,8 @@ namespace rndr {
uniform_value[U_TONE_MAP] = (int32_t)tone_map;
uniform_value[U_FLARE] = 0;
uniform_value[U_SCENE_FADE] = scene_fade_alpha[scene_fade_index] > 0.01f ? 1 : 0;
uniform_value[U_AET_BACK] = 0;
uniform_value[U_LIGHT_PROJ] = 0;
//uniform_value[U25] = 0;
gl_state_active_bind_texture_2d(0, rend_texture[0].GetColorTex());
gl_state_active_bind_texture_2d(1, reduce_tex_draw);
gl_state_active_bind_texture_2d(2, tonemap_lut_texture);
gl_state_active_bind_texture_2d(3, exposure_tex);
gl_state_active_bind_texture_2d(4, rctx->empty_texture_2d);
gl_state_active_bind_texture_2d(5, rctx->empty_texture_2d);
gl_state_active_bind_texture_2d(6, rctx->empty_texture_2d);
gl_state_bind_sampler(0, rctx->render_samplers[1]);
gl_state_bind_sampler(1, rctx->render_samplers[2]);
gl_state_bind_sampler(2, rctx->render_samplers[0]);
gl_state_bind_sampler(3, rctx->render_samplers[3]);
gl_state_bind_sampler(4, rctx->render_samplers[2]);
gl_state_bind_sampler(5, rctx->render_samplers[2]);
gl_state_bind_sampler(6, rctx->render_samplers[2]);
if (aet_back) {
gl_state_active_bind_texture_2d(6, aet_back_tex->glid);
uniform_value[U_AET_BACK] = 1;
}
if (light_proj_tex) {
gl_state_active_bind_texture_2d(6, light_proj_tex->glid);
uniform_value[U_LIGHT_PROJ] = 1;
}
int32_t scene_fade_blend_func = this->scene_fade_blend_func[scene_fade_index];
@@ -1633,14 +1606,26 @@ namespace rndr {
shader_data.g_texcoord_transforms[2] = { 1.0f, 0.0f, 0.0f, 0.0f };
shader_data.g_texcoord_transforms[3] = { 0.0f, 1.0f, 0.0f, 0.0f };
if (lens_flare_texture) {
static const vec4 border_color = 0.0f;
gl_state_active_bind_texture_2d(0, rend_texture[0].GetColorTex());
gl_state_bind_sampler(0, rctx->render_samplers[1]);
gl_state_active_bind_texture_2d(1, reduce_tex_draw);
gl_state_bind_sampler(1, rctx->render_samplers[2]);
if (tone_map == TONE_MAP_YCC_EXPONENT) {
gl_state_active_bind_texture_2d(2, tonemap_lut_texture);
gl_state_bind_sampler(2, rctx->render_samplers[0]);
}
gl_state_active_bind_texture_2d(3, exposure_tex);
gl_state_bind_sampler(3, rctx->render_samplers[3]);
if (lens_flare_texture) {
const float_t aspect = (float_t)height / (float_t)width;
uniform_value[U_FLARE] = 1;
gl_state_active_bind_texture_2d(4, lens_flare_texture);
gl_state_bind_sampler(4, rctx->render_samplers[2]);
mat4 mat;
mat4_translate(0.5f, 0.5f, 0.0f, &mat);
mat4_scale_rot(&mat, 0.75f, 0.75f, 1.0f, &mat);
@@ -1657,6 +1642,7 @@ namespace rndr {
uniform_value[U_FLARE] = 2;
gl_state_active_bind_texture_2d(5, lens_shaft_texture);
gl_state_bind_sampler(5, rctx->render_samplers[2]);
mat4_translate(0.5f, 0.5f, 0.0f, &mat);
mat4_scale_rot(&mat, lens_shaft_scale, lens_shaft_scale, 1.0f, &mat);
mat4_mul_rotate_z(&mat, (lens_flare_pos.x / (float_t)width)
@@ -1669,31 +1655,47 @@ namespace rndr {
shader_data.g_texcoord_transforms[7] = mat.row1;
}
else {
gl_state_active_bind_texture_2d(5, rctx->empty_texture_2d);
gl_state_bind_sampler(5, rctx->render_samplers[2]);
shader_data.g_texcoord_transforms[6] = { 1.0f, 0.0f, 0.0f, 0.0f };
shader_data.g_texcoord_transforms[7] = { 0.0f, 1.0f, 0.0f, 0.0f };
}
}
else {
gl_state_active_bind_texture_2d(4, rctx->empty_texture_2d);
gl_state_bind_sampler(4, rctx->render_samplers[2]);
gl_state_active_bind_texture_2d(5, rctx->empty_texture_2d);
gl_state_bind_sampler(5, rctx->render_samplers[2]);
shader_data.g_texcoord_transforms[4] = { 1.0f, 0.0f, 0.0f, 0.0f };
shader_data.g_texcoord_transforms[5] = { 0.0f, 1.0f, 0.0f, 0.0f };
shader_data.g_texcoord_transforms[6] = { 1.0f, 0.0f, 0.0f, 0.0f };
shader_data.g_texcoord_transforms[7] = { 0.0f, 1.0f, 0.0f, 0.0f };
}
if (npr_param == 1) {
gl_state_active_bind_texture_2d(14, rend_texture[0].GetDepthTex());
/*gl_state_active_bind_texture_2d(16, sss_contour_texture->GetColorTex());
gl_state_active_bind_texture_2d(17, sss_contour_texture->GetDepthTex());*/
}
else {
gl_state_active_bind_texture_2d(14, rctx_ptr->empty_texture_2d);
/*gl_state_active_bind_texture_2d(16, rctx_ptr->empty_texture_2d);
gl_state_active_bind_texture_2d(17, srctx_ptr->empty_texture_2d);*/
if (aet_back) {
gl_state_active_bind_texture_2d(6, aet_back_tex->glid);
gl_state_bind_sampler(6, rctx->render_samplers[2]);
uniform_value[U_AET_BACK] = 1;
}
gl_state_bind_sampler(14, rctx->render_samplers[1]);
/*gl_state_bind_sampler(16, rctx->render_samplers[1]);
gl_state_bind_sampler(17, rctx->render_samplers[1]);*/
if (light_proj_tex) {
uniform_value[U_LIGHT_PROJ] = 1;
gl_state_active_bind_texture_2d(7, light_proj_tex->glid);
gl_state_bind_sampler(7, rctx->render_samplers[2]);
shader_data.g_flare_coef.z = 1.0f;
}
else {
gl_state_active_bind_texture_2d(7, rctx->empty_texture_2d);
gl_state_bind_sampler(7, rctx->render_samplers[2]);
}
if (aet_back && npr_param == 1) {
gl_state_active_bind_texture_2d(14, rend_texture[0].GetDepthTex());
gl_state_bind_sampler(14, rctx->render_samplers[1]);
}
rctx->tone_map_ubo.WriteMemory(shader_data);
src/CRE/render_context.cpp
+79 -1
View File
@@ -50,7 +50,7 @@ void draw_state_stats::reset() {
field_1C = 0;
}
draw_state::draw_state() : wireframe(), wireframe_overlay(), light(), self_shadow(),
draw_state::draw_state() : wireframe(), wireframe_overlay(), shadow(), self_shadow(),
shader_debug_flag(), use_global_material(), fog_height(), ex_data_mat(), field_68() {
shader = true;
shader_index = -1;
@@ -195,6 +195,81 @@ bool light_proj::set_mat(bool set_mat) {
return true;
}
void obj_shader_shader_data::set_shader_flags(int32_t* shader_flags) {
g_shader_flags.x.m.alpha_mask = shader_flags[U_ALPHA_MASK];
g_shader_flags.x.m.alpha_test = shader_flags[U_ALPHA_TEST];
g_shader_flags.x.m.aniso = shader_flags[U_ANISO];
g_shader_flags.x.m.aet_back = shader_flags[U_AET_BACK];
g_shader_flags.x.m.texture_blend = shader_flags[U_TEXTURE_BLEND];
g_shader_flags.x.m.unk = 0; //shader_flags[U_UNK_NEW_IN_MM_IDK_WHAT_TO_DO_WITH_IT];
g_shader_flags.x.m.chara_color = shader_flags[U_CHARA_COLOR];
g_shader_flags.x.m.clip_plane = shader_flags[U_CLIP_PLANE];
g_shader_flags.x.m.u08 = shader_flags[U08];
g_shader_flags.x.m.depth_peel = shader_flags[U_DEPTH_PEEL];
g_shader_flags.x.m.depth = shader_flags[U_DEPTH];
g_shader_flags.x.m.u0b = shader_flags[U0B];
g_shader_flags.x.m.alpha_blend = shader_flags[U_ALPHA_BLEND];
g_shader_flags.x.m.ripple_emit = shader_flags[U_RIPPLE_EMIT];
g_shader_flags.x.m.esm_filter = shader_flags[U_ESM_FILTER];
g_shader_flags.x.m.exposure = shader_flags[U_EXPOSURE];
g_shader_flags.x.m.scene_fade = shader_flags[U_SCENE_FADE];
g_shader_flags.x.m.fade = shader_flags[U_FADE];
g_shader_flags.x.m.stage_ambient = shader_flags[U_STAGE_AMBIENT];
g_shader_flags.x.m.flare = shader_flags[U_FLARE];
g_shader_flags.y.m.fog_stage = shader_flags[U_FOG_STAGE];
g_shader_flags.y.m.fog_chara = shader_flags[U_FOG_CHARA];
g_shader_flags.y.m.u16 = shader_flags[U16];
g_shader_flags.y.m.gauss = shader_flags[U_GAUSS];
g_shader_flags.y.m.eyeball = shader_flags[U_EYEBALL];
g_shader_flags.y.m.image_filter = shader_flags[U_IMAGE_FILTER];
g_shader_flags.y.m.instance = shader_flags[U_INSTANCE];
g_shader_flags.y.m.tone_curve = shader_flags[U_TONE_CURVE];
g_shader_flags.y.m.light_proj = shader_flags[U_LIGHT_PROJ];
g_shader_flags.y.m.magnify = shader_flags[U_MAGNIFY];
g_shader_flags.y.m.membrane = shader_flags[U_MEMBRANE];
g_shader_flags.y.m.mlaa = shader_flags[U_MLAA];
g_shader_flags.y.m.mlaa_search = shader_flags[U_MLAA_SEARCH];
g_shader_flags.y.m.morph_color = shader_flags[U_MORPH_COLOR];
g_shader_flags.y.m.morph = shader_flags[U_MORPH];
g_shader_flags.y.m.movie = shader_flags[U_MOVIE];
g_shader_flags.y.m.u24 = shader_flags[U24];
g_shader_flags.y.m.u25 = shader_flags[U25];
g_shader_flags.y.m.npr_normal = shader_flags[U_NPR_NORMAL];
g_shader_flags.z.m.npr = shader_flags[U_NPR];
g_shader_flags.z.m.stage_shadow2 = shader_flags[U_STAGE_SHADOW2];
g_shader_flags.z.m.reflect = shader_flags[U_REFLECT];
g_shader_flags.z.m.reduce = shader_flags[U_REDUCE];
g_shader_flags.z.m.chara_shadow = shader_flags[U_CHARA_SHADOW];
g_shader_flags.z.m.chara_shadow2 = shader_flags[U_CHARA_SHADOW2];
g_shader_flags.z.m.u2d = shader_flags[U2D];
g_shader_flags.z.m.u2e = shader_flags[U2E];
g_shader_flags.z.m.show_vector = shader_flags[U_SHOW_VECTOR];
g_shader_flags.z.m.skinning = shader_flags[U_SKINNING];
g_shader_flags.z.m.snow_particle = shader_flags[U_SNOW_PARTICLE];
g_shader_flags.z.m.specular_ibl = shader_flags[U_SPECULAR_IBL];
g_shader_flags.z.m.combiner = shader_flags[U_COMBINER];
g_shader_flags.z.m.tex_0_type = shader_flags[U_TEX_0_TYPE];
g_shader_flags.z.m.tex_1_type = shader_flags[U_TEX_1_TYPE];
g_shader_flags.z.m.sss_filter = shader_flags[U_SSS_FILTER];
g_shader_flags.w.m.sss_chara = shader_flags[U_SSS_CHARA];
g_shader_flags.w.m.star = shader_flags[U_STAR];
g_shader_flags.w.m.texture_count = shader_flags[U_TEXTURE_COUNT];
g_shader_flags.w.m.env_map = shader_flags[U_ENV_MAP];
g_shader_flags.w.m.ripple = shader_flags[U_RIPPLE];
g_shader_flags.w.m.translucency = shader_flags[U_TRANSLUCENCY];
g_shader_flags.w.m.normal = shader_flags[U_NORMAL];
g_shader_flags.w.m.transparency = shader_flags[U_TRANSPARENCY];
g_shader_flags.w.m.water_reflect = shader_flags[U_WATER_REFLECT];
g_shader_flags.w.m.u40 = shader_flags[U40];
g_shader_flags.w.m.u41 = shader_flags[U41];
g_shader_flags.w.m.stage_shadow = shader_flags[U_STAGE_SHADOW];
g_shader_flags.w.m.specular = shader_flags[U_SPECULAR];
g_shader_flags.w.m.tone_map = shader_flags[U_TONE_MAP];
g_shader_flags.w.m.u45 = shader_flags[U45];
g_shader_flags.w.m.dof = shader_flags[U_DOF]; // Added
g_shader_flags.w.m.dof_stage = shader_flags[U_DOF_STAGE]; // Added
}
void obj_scene_shader_data::set_g_irradiance_r_transforms(const mat4& mat) {
mat4 temp;
mat4_transpose(&mat, &temp);
@@ -418,9 +493,11 @@ sprite_width(), sprite_height(), screen_x_offset(), screen_y_offset(), screen_wi
tone_map_ubo.Create(sizeof(tone_map_shader_data));
transparency_batch_ubo.Create(sizeof(transparency_batch_shader_data));
obj_shader = {};
obj_scene = {};
obj_batch = {};
obj_skinning = {};
obj_shader_ubo.Create(sizeof(obj_shader_shader_data));
obj_scene_ubo.Create(sizeof(obj_scene_shader_data));
obj_batch_ubo.Create(sizeof(obj_batch_shader_data));
obj_skinning_ubo.Create(sizeof(obj_skinning_shader_data));
@@ -554,6 +631,7 @@ render_context::~render_context() {
obj_skinning_ubo.Destroy();
obj_batch_ubo.Destroy();
obj_scene_ubo.Destroy();
obj_shader_ubo.Destroy();
tone_map_ubo.Destroy();
transparency_batch_ubo.Destroy();
src/CRE/render_context.hpp
+103 -3
View File
@@ -43,7 +43,7 @@ struct draw_state {
draw_state_stats stats_prev;
bool wireframe;
bool wireframe_overlay;
bool light;
bool shadow;
bool self_shadow;
bool shader_debug_flag;
bool use_global_material;
@@ -156,6 +156,105 @@ struct glitter_batch_shader_data {
vec4 g_state_material_emission;
};
struct obj_shader_shader_data {
struct {
union {
struct {
uint32_t alpha_mask : 1; // bit 0
uint32_t alpha_test : 1; // bit 1
uint32_t aniso : 2; // bit 2:3
uint32_t aet_back : 1; // bit 4
uint32_t texture_blend : 3; // bit 5:7
uint32_t unk : 2; // bit 8:9
uint32_t chara_color : 1; // bit 10
uint32_t clip_plane : 1; // bit 11
uint32_t u08 : 1; // bit 12
uint32_t depth_peel : 1; // bit 13
uint32_t depth : 1; // bit 14
uint32_t u0b : 1; // bit 15
uint32_t alpha_blend : 3; // bit 16:18
uint32_t ripple_emit : 1; // bit 19
uint32_t esm_filter : 2; // bit 20:21
uint32_t exposure : 2; // bit 22:23
uint32_t scene_fade : 1; // bit 24
uint32_t fade : 3; // bit 25:27
uint32_t stage_ambient : 1; // bit 28
uint32_t flare : 2; // bit 29:30
} m;
uint32_t w;
} x;
union {
struct {
uint32_t fog_stage : 2; // bit 32+0:1
uint32_t fog_chara : 2; // bit 32+2:3
uint32_t u16 : 1; // bit 32+4
uint32_t gauss : 2; // bit 32+5:6
uint32_t eyeball : 1; // bit 32+7
uint32_t image_filter : 3; // bit 32+8:10
uint32_t instance : 1; // bit 32+11
uint32_t tone_curve : 1; // bit 32+12
uint32_t light_proj : 1; // bit 32+13
uint32_t magnify : 4; // bit 32+14:17
uint32_t membrane : 2; // bit 32+18:19
uint32_t mlaa : 2; // bit 32+20:21
uint32_t mlaa_search : 2; // bit 32+22:23
uint32_t morph_color : 1; // bit 32+24
uint32_t morph : 1; // bit 32+25
uint32_t movie : 2; // bit 32+26:27
uint32_t u24 : 2; // bit 32+28:29
uint32_t u25 : 1; // bit 32+30
uint32_t npr_normal : 1; // bit 32+31
} m;
uint32_t w;
} y;
union {
struct {
uint32_t npr : 1; // bit 64+0
uint32_t stage_shadow2 : 2; // bit 64+1:2
uint32_t reflect : 2; // bit 64+3:4
uint32_t reduce : 4; // bit 64+5:8
uint32_t chara_shadow : 1; // bit 64+9
uint32_t chara_shadow2 : 2; // bit 64+10:11
uint32_t u2d : 3; // bit 64+12:14
uint32_t u2e : 2; // bit 64+15:16
uint32_t show_vector : 2; // bit 64+17:18
uint32_t skinning : 1; // bit 64+19
uint32_t snow_particle : 2; // bit 64+20:21
uint32_t specular_ibl : 2; // bit 64+22:23
uint32_t combiner : 1; // bit 64+24
uint32_t tex_0_type : 2; // bit 64+25:26
uint32_t tex_1_type : 2; // bit 64+27:28
uint32_t sss_filter : 2; // bit 64+29:30
} m;
uint32_t w;
} z;
union {
struct {
uint32_t sss_chara : 1; // bit 96+0
uint32_t star : 1; // bit 96+1
uint32_t texture_count : 2; // bit 96+2:3
uint32_t env_map : 1; // bit 96+4
uint32_t ripple : 2; // bit 96+5:6
uint32_t translucency : 1; // bit 96+7
uint32_t normal : 1; // bit 96+8
uint32_t transparency : 1; // bit 96+9
uint32_t water_reflect : 1; // bit 96+10
uint32_t u40 : 1; // bit 96+11
uint32_t u41 : 1; // bit 96+12
uint32_t stage_shadow : 1; // bit 96+13
uint32_t specular : 1; // bit 96+14
uint32_t tone_map : 2; // bit 96+15
uint32_t u45 : 1; // bit 96+16
uint32_t dof : 1; // bit 96+17 // Added
uint32_t dof_stage : 3; // bit 96+18 // Added
} m;
uint32_t w;
} w;
} g_shader_flags;
void set_shader_flags(int32_t* shader_flags);
};
struct obj_scene_shader_data {
vec4 g_irradiance_r_transforms[4];
vec4 g_irradiance_g_transforms[4];
@@ -243,7 +342,6 @@ struct obj_batch_shader_data {
vec4 g_bump_depth;
vec4 g_intensity;
vec4 g_reflect_uv_scale;
vec4 g_texture_blend;
void set_g_joint(const mat4& mat);
void set_g_texcoord_transforms(int32_t index, const mat4& mat);
@@ -279,7 +377,7 @@ struct sun_quad_shader_data {
struct tone_map_shader_data {
vec4 g_exposure;
vec4 g_flare_coef;
vec4 g_flare_coef; //xy=flare_coef, z=light_proj
vec4 g_fade_color;
vec4 g_tone_scale; //xyz=tone_scale, w=fade_func
vec4 g_tone_offset; //xyz=tone_offset, w=inv_tone
@@ -343,9 +441,11 @@ struct render_context {
GL::UniformBuffer transparency_batch_ubo;
GL::UniformBuffer tone_map_ubo;
obj_shader_shader_data obj_shader;
obj_scene_shader_data obj_scene;
obj_batch_shader_data obj_batch;
obj_skinning_shader_data obj_skinning;
GL::UniformBuffer obj_shader_ubo;
GL::UniformBuffer obj_scene_ubo;
GL::UniformBuffer obj_batch_ubo;
GL::UniformBuffer obj_skinning_ubo;
src/CRE/render_manager.cpp
+8 -8
View File
@@ -1243,7 +1243,7 @@ static void draw_pass_shadow_end_make_shadowmap(Shadow* shad, int32_t index, int
gl_state_disable_scissor_test();
rctx->draw_state->shader_index = -1;
if (a3 == shad->num_light - 1) {
if (a3 == shad->num_shadow - 1) {
draw_pass_shadow_filter(&shad->render_textures[3],
&shad->render_textures[4], shad->curr_render_textures[0],
shad->field_2DC, shad->field_2E0 / (shad->field_208 * 2.0f), false);
@@ -1606,11 +1606,11 @@ static void draw_pass_3d_shadow_reset(render_context* rctx) {
rctx->obj_scene.set_g_self_shadow_receivers(0, mat4_identity);
rctx->obj_scene.set_g_self_shadow_receivers(1, mat4_identity);
rctx->draw_state->self_shadow = false;
rctx->draw_state->light = false;
rctx->draw_state->shadow = false;
}
static void draw_pass_3d_shadow_set(Shadow* shad, render_context* rctx) {
if (shad->self_shadow && shad->num_light > 0) {
if (shad->self_shadow && shad->num_shadow > 0) {
gl_state_active_bind_texture_2d(19, shad->render_textures[3].GetColorTex());
gl_state_active_bind_texture_2d(20, shad->render_textures[5].GetColorTex());
gl_state_active_texture(0);
@@ -1628,9 +1628,9 @@ static void draw_pass_3d_shadow_set(Shadow* shad, render_context* rctx) {
gl_state_bind_sampler(19, rctx->render_samplers[0]);
gl_state_bind_sampler(20, rctx->render_samplers[0]);
if (shad->num_light > 0) {
rctx->draw_state->light = true;
uniform_value[U_LIGHT_1] = shad->num_light > 1 ? 1 : 0;
if (shad->num_shadow > 0) {
rctx->draw_state->shadow = true;
uniform_value[U_STAGE_SHADOW2] = shad->num_shadow > 1 ? 1 : 0;
float_t shadow_range = shad->get_shadow_range();
for (int32_t i = 0; i < 2; i++) {
@@ -1667,7 +1667,7 @@ static void draw_pass_3d_shadow_set(Shadow* shad, render_context* rctx) {
int32_t j = 0;
for (int32_t i = 0; i < 2; i++)
if (shad->light_enable[i]) {
if (shad->shadow_enable[i]) {
gl_state_active_bind_texture_2d(6 + j, shad->curr_render_textures[1 + i]->GetColorTex());
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f);
j++;
@@ -1690,7 +1690,7 @@ static void draw_pass_3d_shadow_set(Shadow* shad, render_context* rctx) {
rctx->obj_scene.g_shadow_ambient1 = { 1.0f - ambient.x, 1.0f - ambient.y, 1.0f - ambient.z, 0.0f };
}
else {
rctx->draw_state->light = false;
rctx->draw_state->shadow = false;
for (int32_t i = 0; i < 2; i++)
gl_state_active_bind_texture_2d(6 + i, shad->curr_render_textures[1 + i]->GetColorTex());
src/CRE/shader.cpp
+37 -68
View File
@@ -26,7 +26,7 @@ static bool shader_load_binary_shader(program_binary* bin, GLuint* program, cons
static void shader_update_data(shader_set_data* set);
int32_t shader::bind(shader_set_data* set, uint32_t sub_index) {
set->curr_shader = 0;
set->curr_program = 0;
if (num_sub < 1)
return -1;
@@ -40,33 +40,23 @@ int32_t shader::bind(shader_set_data* set, uint32_t sub_index) {
int32_t unival_shad_curr = 1;
int32_t unival_shad = 0;
int32_t uniform_val[SHADER_MAX_UNIFORM_VALUES] = {};
if (num_uniform > 0) {
const int32_t* vp_unival_max = sub_shader->vp_unival_max;
const int32_t* fp_unival_max = sub_shader->fp_unival_max;
int32_t i = 0;
for (i = 0; i < num_uniform && i < sizeof(uniform_val) / sizeof(int32_t); i++) {
const int32_t unival = uniform_value[use_uniform[i].first];
const int32_t unival_max = use_uniform[i].second
? max_def(vp_unival_max[i], fp_unival_max[i]) : 0;
for (i = 0; i < num_uniform; i++) {
const int32_t unival = uniform_value[use_uniform[i]];
const int32_t unival_max = max_def(vp_unival_max[i], fp_unival_max[i]);
unival_shad += unival_shad_curr * min_def(unival, unival_max);
unival_shad_curr *= unival_max + 1;
int32_t unival_max_glsl = max_def(vp_unival_max[i], fp_unival_max[i]);
uniform_val[i] = min_def(unival, unival_max_glsl);
}
}
shader_sub_shader* shader = &sub_shader->shaders[unival_shad];
set->curr_shader = shader;
GLuint program = sub_shader->programs[unival_shad];
set->curr_program = program;
gl_state_use_program(shader->program);
if (shader->has_uniform_val
&& memcmp(shader->uniform_val, uniform_val, sizeof(uniform_val))) {
memcpy(shader->uniform_val, uniform_val, sizeof(uniform_val));
shader->uniform_val_update = true;
}
gl_state_use_program(program);
return 0;
}
@@ -286,7 +276,7 @@ void shader::unbind() {
gl_state_use_program(0);
}
shader_set_data::shader_set_data() : size(), shaders(), curr_shader(), primitive_restart(),
shader_set_data::shader_set_data() : size(), shaders(), curr_program(), primitive_restart(),
primitive_restart_index(), get_index_by_name_func(), get_name_by_index_func() {
}
@@ -496,13 +486,12 @@ void shader_set_data::load(farc* f, bool ignore_cache,
uint32_t uniform_vert_flags = 0;
uint32_t uniform_frag_flags = 0;
for (int32_t k = 0; k < shader->num_uniform; k++)
if (shader->use_uniform[k].second) {
if (sub_table->vp_unival_max[k] > 0)
uniform_vert_flags |= 1 << k;
if (sub_table->fp_unival_max[k] > 0)
uniform_frag_flags |= 1 << k;
}
for (int32_t k = 0; k < shader->num_uniform; k++) {
if (sub_table->vp_unival_max[k] > 0)
uniform_vert_flags |= 1 << k;
if (sub_table->fp_unival_max[k] > 0)
uniform_frag_flags |= 1 << k;
}
char uniform_vert_flags_buf[9];
char uniform_frag_flags_buf[9];
@@ -567,17 +556,16 @@ void shader_set_data::load(farc* f, bool ignore_cache,
const int32_t* vp_unival_max = sub_table->vp_unival_max;
const int32_t* fp_unival_max = sub_table->fp_unival_max;
for (int32_t k = 0; k < num_uniform; k++) {
const int32_t unival_max = shader->use_uniform[k].second
? max_def(vp_unival_max[k], fp_unival_max[k]) : 0;
const int32_t unival_max = max_def(vp_unival_max[k], fp_unival_max[k]);
unival_shad_count += unival_shad_curr * unival_max;
unival_shad_curr *= unival_max + 1;
}
if (!ignore_cache)
program_data_binary.reserve(unival_shad_count);
shader_sub_shader* shaders = force_malloc<shader_sub_shader>(unival_shad_count);
sub->shaders = shaders;
if (shaders) {
GLuint* programs = force_malloc<GLuint>(unival_shad_count);
sub->programs = programs;
if (programs) {
strcpy_s(vert_buf, sizeof(vert_buf), sub_table->vp);
size_t vert_buf_pos = utf8_length(vert_buf);
vert_buf[vert_buf_pos++] = '.';
@@ -596,38 +584,36 @@ void shader_set_data::load(farc* f, bool ignore_cache,
for (int32_t k = 0; k < unival_shad_count; k++) {
for (int32_t l = 0, m = k; l < num_uniform; l++) {
int32_t unival_max = (shader->use_uniform[l].second
? max_def(vp_unival_max[l], fp_unival_max[l]) : 0) + 1;
int32_t unival_max = max_def(vp_unival_max[l], fp_unival_max[l]) + 1;
vec_vert_data[l] = min_def(m % unival_max, vp_unival_max[l]);
m /= unival_max;
vert_buf[vert_buf_pos + l] = (char)('0' + vec_vert_data[l]);
}
for (int32_t l = 0, m = k; l < num_uniform; l++) {
int32_t unival_max = (shader->use_uniform[l].second
? max_def(vp_unival_max[l], fp_unival_max[l]) : 0) + 1;
int32_t unival_max = max_def(vp_unival_max[l], fp_unival_max[l]) + 1;
vec_frag_data[l] = min_def(m % unival_max, fp_unival_max[l]);
m /= unival_max;
frag_buf[frag_buf_pos + l] = (char)('0' + vec_frag_data[l]);
}
if (!bin || !bin->binary_format || !bin->length
|| !shader_load_binary_shader(bin, &shaders[k].program, vert_buf, frag_buf)) {
|| !shader_load_binary_shader(bin, &programs[k], vert_buf, frag_buf)) {
bool vert_succ = shader::parse_define(vert_data, num_uniform,
vec_vert_data, &temp_vert, &temp_vert_size);
bool frag_succ = shader::parse_define(frag_data, num_uniform,
vec_frag_data, &temp_frag, &temp_frag_size);
if (ignore_cache)
shaders[k].program = shader_compile(vert_succ ? temp_vert : 0,
programs[k] = shader_compile(vert_succ ? temp_vert : 0,
frag_succ ? temp_frag : 0, vert_buf, frag_buf);
else {
program_data_binary.push_back({});
shaders[k].program = shader_compile_binary(vert_succ ? temp_vert : 0,
programs[k] = shader_compile_binary(vert_succ ? temp_vert : 0,
frag_succ ? temp_frag : 0, vert_buf, frag_buf,
&program_data_binary.back(), &buffer_size, &binary);
}
shader_cache_changed |= shaders[k].program ? true : false;
shader_cache_changed |= programs[k] ? true : false;
}
else {
program_data_binary.push_back({});
@@ -638,10 +624,6 @@ void shader_set_data::load(farc* f, bool ignore_cache,
memcpy((void*)b->binary, (void*)((size_t)bin + bin->binary), bin->length);
}
shaders[k].has_uniform_val = false;
if (shaders[k].program)
shaders[k].has_uniform_val = glGetUniformLocation(shaders[k].program, "uniform_val") >= 0;
if (!ignore_cache && bin)
bin++;
}
@@ -649,29 +631,29 @@ void shader_set_data::load(farc* f, bool ignore_cache,
}
else {
program_data_binary.reserve(1);
shader_sub_shader* shaders = force_malloc<shader_sub_shader>();
sub->shaders = shaders;
if (shaders) {
GLuint* programs = force_malloc<GLuint>();
sub->programs = programs;
if (programs) {
strcpy_s(vert_buf, sizeof(vert_buf), sub_table->vp);
strcpy_s(frag_buf, sizeof(vert_buf), sub_table->fp);
strcat_s(vert_buf, sizeof(vert_buf), "..vert");
strcat_s(frag_buf, sizeof(vert_buf), "..frag");
if (!bin || !bin->binary_format || !bin->length
|| !shader_load_binary_shader(bin, &shaders[0].program, vert_buf, frag_buf)) {
|| !shader_load_binary_shader(bin, &programs[0], vert_buf, frag_buf)) {
bool vert_succ = shader::parse_define(vert_data, &temp_vert, &temp_vert_size);
bool frag_succ = shader::parse_define(frag_data, &temp_frag, &temp_frag_size);
if (ignore_cache)
shaders[0].program = shader_compile(vert_succ ? temp_vert : 0,
programs[0] = shader_compile(vert_succ ? temp_vert : 0,
frag_succ ? temp_frag : 0, vert_buf, frag_buf);
else {
program_data_binary.push_back({});
shaders[0].program = shader_compile_binary(vert_succ ? temp_vert : 0,
programs[0] = shader_compile_binary(vert_succ ? temp_vert : 0,
frag_succ ? temp_frag : 0, vert_buf, frag_buf,
&program_data_binary.back(), &buffer_size, &binary);
}
shader_cache_changed |= shaders[0].program ? true : false;
shader_cache_changed |= programs[0] ? true : false;
}
else {
program_data_binary.push_back({});
@@ -682,10 +664,6 @@ void shader_set_data::load(farc* f, bool ignore_cache,
memcpy((void*)b->binary, (void*)((size_t)bin + bin->binary), bin->length);
}
shaders[0].has_uniform_val = false;
if (shaders[0].program)
shaders[0].has_uniform_val = glGetUniformLocation(shaders[0].program, "uniform_val") >= 0;
if (!ignore_cache && bin)
bin++;
}
@@ -782,19 +760,18 @@ void shader_set_data::unload() {
const int32_t* vp_unival_max = sub->vp_unival_max;
const int32_t* fp_unival_max = sub->fp_unival_max;
for (int32_t k = 0; k < num_uniform; k++) {
const int32_t unival_max = shader->use_uniform[k].second
? max_def(vp_unival_max[k], fp_unival_max[k]) : 0;
const int32_t unival_max = max_def(vp_unival_max[k], fp_unival_max[k]);
unival_shad_count += unival_shad_curr * unival_max;
unival_shad_curr *= unival_max + 1;
}
}
if (sub->shaders) {
shader_sub_shader* shaders = sub->shaders;
if (sub->programs) {
GLuint* programs = sub->programs;
for (int32_t k = 0; k < unival_shad_count; k++)
glDeleteProgram(shaders[k].program);
free(shaders);
sub->shaders = 0;
glDeleteProgram(programs[k]);
free(programs);
sub->programs = 0;
}
}
free(shader->sub);
@@ -1049,14 +1026,6 @@ static void shader_update_data(shader_set_data* set) {
if (!set)
return;
if (set->curr_shader) {
shader_sub_shader* shader = set->curr_shader;
if (shader->has_uniform_val && shader->uniform_val_update) {
glUniform1iv(0, SHADER_MAX_UNIFORM_VALUES, (GLint*)shader->uniform_val);
shader->uniform_val_update = false;
}
}
if (set->primitive_restart) {
gl_state_enable_primitive_restart();
gl_state_set_primitive_restart_index(set->primitive_restart_index);
src/CRE/shader.hpp
+4 -11
View File
@@ -29,7 +29,7 @@ struct shader_table {
int32_t num_sub;
const shader_sub_table* sub;
int32_t num_uniform;
const std::pair<uniform_name, bool>* use_uniform;
const uniform_name* use_uniform;
};
struct shader;
@@ -45,18 +45,11 @@ struct shader_bind_func {
PFNSHADERBINDFUNCPROC bind_func;
};
struct shader_sub_shader {
GLuint program;
bool has_uniform_val;
int32_t uniform_val[SHADER_MAX_UNIFORM_VALUES];
bool uniform_val_update;
};
struct shader_sub {
uint32_t sub_index;
const int32_t* vp_unival_max;
const int32_t* fp_unival_max;
shader_sub_shader* shaders;
GLuint* programs;
};
struct shader {
@@ -65,7 +58,7 @@ struct shader {
int32_t num_sub;
shader_sub* sub;
int32_t num_uniform;
const std::pair<uniform_name, bool>* use_uniform;
const uniform_name* use_uniform;
PFNSHADERBINDFUNCPROC bind_func;
int32_t bind(shader_set_data* set, uint32_t sub_index);
@@ -80,7 +73,7 @@ struct shader {
struct shader_set_data {
size_t size;
shader* shaders;
shader_sub_shader* curr_shader;
GLuint curr_program;
GLboolean primitive_restart;
GLuint primitive_restart_index;
src/CRE/shader_dev.cpp
+3 -4
View File
@@ -12,7 +12,6 @@
enum shader_dev_sub_enum {
SHADER_DEV_SUB_SHADER_FFP = 0,
SHADER_DEV_SUB_GLITTER_PT_WIREFRAME,
SHADER_DEV_SUB_GRID,
SHADER_DEV_SUB_SHADER_END,
};
@@ -24,8 +23,8 @@ static const int32_t glitter_particle_wireframe_fpt_unival_max[] = {
-1,
};
static const std::pair<uniform_name, bool> GLITTER_PT_WIREFRAME_uniform[] = {
{ U_INVALID , false,}
static const uniform_name GLITTER_PT_WIREFRAME_uniform[] = {
U_INVALID,
};
static const shader_sub_table GLITTER_PT_WIREFRAME_table[] = {
@@ -44,7 +43,7 @@ static const shader_sub_table GLITTER_PT_WIREFRAME_table[] = {
SHADER_DEV_##n, \
sizeof(n##_table) / sizeof(shader_sub_table), \
n##_table, \
sizeof(n##_uniform) / sizeof(std::pair<uniform_name, bool>), \
n##_uniform[0] > 0 ? sizeof(n##_uniform) / sizeof(uniform_name) : 0, \
n##_uniform, \
}
src/CRE/shader_ft.cpp
+425 -1290
View File
File diff suppressed because it is too large Load Diff
src/CRE/shader_ft.hpp
+2 -18
View File
@@ -20,12 +20,7 @@ enum shader_ft_enum {
SHADER_FT_CLOTH,
SHADER_FT_TIGHTS,
SHADER_FT_SKY,
//SHADER_FT_EYEBALL,
//SHADER_FT_EYELENS,
SHADER_FT_GLASEYE,
//SHADER_FT_MEMBRAN,
//SHADER_FT_SHDMAP,
//SHADER_FT_ESM,
SHADER_FT_ESMGAUSS,
SHADER_FT_ESMFILT,
SHADER_FT_LITPROJ,
@@ -33,7 +28,6 @@ enum shader_ft_enum {
SHADER_FT_SIL,
SHADER_FT_LAMBERT,
SHADER_FT_CONSTANT,
//SHADER_FT_PEEL,
SHADER_FT_TONEMAP,
SHADER_FT_REDUCE,
SHADER_FT_MAGNIFY,
@@ -44,37 +38,27 @@ enum shader_ft_enum {
SHADER_FT_GAUSS,
SHADER_FT_SUN,
SHADER_FT_SUN_NO_TEXTURED,
//SHADER_FT_FADE,
SHADER_FT_WATER01,
//SHADER_FT_WATER02,
//SHADER_FT_WATRING,
SHADER_FT_W_PTCL,
SHADER_FT_SNOW_PT,
SHADER_FT_LEAF_PT,
SHADER_FT_STAR,
//SHADER_FT_SNORING,
//SHADER_FT_SN_FOOT,
//SHADER_FT_SN_TSL,
//SHADER_FT_SN_NRM,
SHADER_FT_FLOOR,
SHADER_FT_PUDDLE,
SHADER_FT_S_REFL,
SHADER_FT_S_REFR,
SHADER_FT_RIPEMIT,
SHADER_FT_RAIN,
//SHADER_FT_VOLLIT,
//SHADER_FT_FENCE,
SHADER_FT_RIPPLE,
SHADER_FT_FOGPTCL,
SHADER_FT_PARTICL,
SHADER_FT_GLITTER_PT,
//SHADER_FT_SHOW_VEC,
SHADER_FT_FONT,
SHADER_FT_MOVIE,
SHADER_FT_IMGFILT,
SHADER_FT_SPRITE,
SHADER_FT_DOF, // Added
SHADER_FT_TRANSPARENCY, // Added
SHADER_FT_DOF,
SHADER_FT_TRANSPARENCY,
SHADER_FT_END,
SHADER_FT_MAX,
};
src/CRE/shadow.cpp
+19 -19
View File
@@ -13,7 +13,7 @@ extern render_context* rctx_ptr;
Shadow::Shadow() : curr_render_textures(), shadow_range(), shadow_range_factor(), field_1C0(), field_1C8(),
field_200(), field_208(), near_blur(), blur_filter(), far_blur(), field_2BC(), distance(), field_2C4(),
z_near(), z_far(), field_2D0(), field_2D4(), field_2D8(), field_2DC(), field_2E0(), shadow_ambient(),
show_texture(), num_light(), light_enable(), self_shadow(), blur_filter_enable(), separate() {
show_texture(), num_shadow(), shadow_enable(), self_shadow(), blur_filter_enable(), separate() {
reset();
}
@@ -23,7 +23,7 @@ Shadow::~Shadow() {
void Shadow::ctrl() {
for (int32_t i = 0; i < 2; i++)
light_enable[i] = false;
shadow_enable[i] = false;
if (rctx_ptr->render_manager->shadow) {
view_mat[0] = rctx_ptr->camera->view;
@@ -41,24 +41,24 @@ void Shadow::ctrl() {
for (int32_t i = 0; i < 2; i++)
if (rctx_ptr->disp_manager->get_obj_count((mdl::ObjType)((int32_t)mdl::OBJ_TYPE_SHADOW_CHARA + i)))
light_enable[i] = true;
shadow_enable[i] = true;
}
int32_t count = 0;
num_light = 0;
num_shadow = 0;
for (int32_t i = 0; i < 2; i++)
if (light_enable[i] && field_1D0[i].size() > 0) {
num_light++;
if (shadow_enable[i] && field_1D0[i].size() > 0) {
num_shadow++;
count += (int32_t)field_1D0[i].size();
}
else
light_enable[i] = false;
shadow_enable[i] = false;
if (count < 3) {
for (int32_t i = 0; i < 2; i++) {
field_1A8[i] = 0.0f;
field_1C8[i] = 0.0f;
if (!light_enable[i] || field_1D0[i].size() < 1)
if (!shadow_enable[i] || field_1D0[i].size() < 1)
continue;
vec3 v7 = 0.0f;
@@ -85,11 +85,11 @@ void Shadow::ctrl() {
field_1C8[i] = v15;
}
if (num_light > 0) {
if (num_shadow > 0) {
vec3 view_point = 0.0f;
vec3 interest = 0.0f;
for (int32_t i = 0; i < 2; i++) {
if (!light_enable[i])
if (!shadow_enable[i])
continue;
vec3 v11 = field_1A8[i] - direction * field_208;
@@ -104,8 +104,8 @@ void Shadow::ctrl() {
interest += this->interest[i];
}
view_point_shared = view_point * (1.0f / (float_t)num_light);
interest_shared = interest * (1.0f / (float_t)num_light);
view_point_shared = view_point * (1.0f / (float_t)num_shadow);
interest_shared = interest * (1.0f / (float_t)num_shadow);
}
float_t v2 = max_def(field_1C8[0], field_1C8[1]);
@@ -113,7 +113,7 @@ void Shadow::ctrl() {
shadow_range = v2 + 1.2f;
field_200[0] = 0;
field_200[1] = 1;
if (num_light >= 2) {
if (num_shadow >= 2) {
vec3 v12 = field_1A8[0] - interest_shared;
vec3 v14 = field_1A8[1] - interest_shared;
@@ -152,7 +152,7 @@ void Shadow::ctrl() {
for (int32_t i = 0; i < 2; i++) {
field_1A8[i] = 0.0f;
field_1C8[i] = 0.0;
if (!light_enable[i] || field_1D0[i].size() < 1)
if (!shadow_enable[i] || field_1D0[i].size() < 1)
continue;
vec3 v22 = 0.0f;
@@ -179,9 +179,9 @@ void Shadow::ctrl() {
field_1C8[i] = v30;
}
if (num_light > 0) {
if (num_shadow > 0) {
for (int32_t i = 0; i < 2; i++) {
if (!light_enable[i])
if (!shadow_enable[i])
continue;
vec3 v53 = field_1A8[i] - direction * field_208;
@@ -213,12 +213,12 @@ void Shadow::ctrl() {
shadow_range = v67 + 1.2f;
field_200[0] = 0;
field_200[1] = 1;
if (num_light >= 2) {
if (num_shadow >= 2) {
float_t v68 = 0.0f;
float_t v69 = 0.0f;
float_t v70 = 0.0f;
for (int32_t i = 0; i < 2; i++) {
if (!light_enable[i])
if (!shadow_enable[i])
continue;
for (vec3& j : field_1D0[i]) {
@@ -341,7 +341,7 @@ void Shadow::reset() {
field_2DC = 2.0f;
field_2E0 = 0.05f;
shadow_ambient = 0.4f;
num_light = 0;
num_shadow = 0;
direction = vec3(0.0f, -1.0f, -1.0f) * (1.0f / sqrtf(2.0f));
show_texture = false;
self_shadow = true;
src/CRE/shadow.hpp
+2 -2
View File
@@ -50,8 +50,8 @@ struct Shadow {
float_t field_2E0;
float_t shadow_ambient;
bool show_texture;
int32_t num_light;
bool light_enable[2];
int32_t num_shadow;
bool shadow_enable[2];
bool self_shadow;
bool blur_filter_enable[2];
bool separate;
src/CRE/static_var.cpp
+3 -3
View File
@@ -79,8 +79,8 @@ void uniform_value_reset() {
uniform_value[U_ANISO] = 0;
uniform_value[U0B] = 0;
uniform_value[U_TEXTURE_BLEND] = 0;
uniform_value[U_FOG_HEIGHT] = 0;
uniform_value[U_FOG] = 0;
uniform_value[U_FOG_STAGE] = 0;
uniform_value[U_FOG_CHARA] = 0;
uniform_value[U_SPECULAR_IBL] = 0;
uniform_value[U_TEX_0_TYPE] = 0;
uniform_value[U_TEX_1_TYPE] = 0;
@@ -89,7 +89,7 @@ void uniform_value_reset() {
uniform_value[U_TRANSLUCENCY] = 0;
uniform_value[U_NORMAL] = 0;
uniform_value[U_TRANSPARENCY] = 0;
uniform_value[U_LIGHT_0] = 0;
uniform_value[U_STAGE_SHADOW] = 0;
uniform_value[U_SPECULAR] = 0;
uniform_value[U45] = 0;
}
src/CRE/static_var.hpp
+6 -6
View File
@@ -48,8 +48,8 @@ enum uniform_name {
U_FADE,
U_STAGE_AMBIENT,
U_FLARE,
U_FOG_HEIGHT,
U_FOG,
U_FOG_STAGE,
U_FOG_CHARA,
U16,
U_GAUSS,
U_EYEBALL,
@@ -68,11 +68,11 @@ enum uniform_name {
U25,
U_NPR_NORMAL,
U_NPR,
U_LIGHT_1,
U_STAGE_SHADOW2,
U_REFLECT,
U_REDUCE,
U_SELF_SHADOW,
U_SHADOW,
U_CHARA_SHADOW,
U_CHARA_SHADOW2,
U2D,
U2E,
U_SHOW_VECTOR,
@@ -94,7 +94,7 @@ enum uniform_name {
U_WATER_REFLECT,
U40,
U41,
U_LIGHT_0,
U_STAGE_SHADOW,
U_SPECULAR,
U_TONE_MAP,
U45,
src/ReDIVA/main.cpp
+21 -22
View File
@@ -331,7 +331,7 @@ void compile_shaders(farc* f, farc* of, const shader_table* shaders_table, const
vec_frag.resize(shader_table->num_uniform);
int32_t* vec_vert_data = vec_vert.data();
int32_t* vec_frag_data = vec_frag.data();
for (size_t j = 0; j < num_sub; j++, sub_table++) {
for (int32_t j = 0; j < num_sub; j++, sub_table++) {
strcpy_s(vert_file_buf, sizeof(vert_file_buf), sub_table->vp);
strcat_s(vert_file_buf, sizeof(vert_file_buf), ".vert");
farc_file* vert_ff = f->read_file(vert_file_buf);
@@ -366,13 +366,12 @@ void compile_shaders(farc* f, farc* of, const shader_table* shaders_table, const
uint32_t uniform_vert_flags = 0;
uint32_t uniform_frag_flags = 0;
for (int32_t k = 0; k < shader_table->num_uniform; k++)
if (shader_table->use_uniform[k].second) {
if (sub_table->vp_unival_max[k] > 0)
uniform_vert_flags |= 1 << k;
if (sub_table->fp_unival_max[k] > 0)
uniform_frag_flags |= 1 << k;
}
for (int32_t k = 0; k < shader_table->num_uniform; k++) {
if (sub_table->vp_unival_max[k] > 0)
uniform_vert_flags |= 1 << k;
if (sub_table->fp_unival_max[k] > 0)
uniform_frag_flags |= 1 << k;
}
char uniform_vert_flags_buf[9];
char uniform_frag_flags_buf[9];
@@ -417,15 +416,15 @@ void compile_shaders(farc* f, farc* of, const shader_table* shaders_table, const
if ((!has_vert_bin || !has_frag_bin) && shader_table->num_uniform > 0
&& (sub_table->vp_unival_max[0] != -1 || sub_table->fp_unival_max[0] != -1)) {
int32_t num_uniform = shader_table->num_uniform;
size_t unival_vp_curr = 1;
size_t unival_vp_count = 1;
size_t unival_fp_curr = 1;
size_t unival_fp_count = 1;
int32_t unival_vp_curr = 1;
int32_t unival_vp_count = 1;
int32_t unival_fp_curr = 1;
int32_t unival_fp_count = 1;
const int32_t* vp_unival_max = sub_table->vp_unival_max;
const int32_t* fp_unival_max = sub_table->fp_unival_max;
for (size_t k = 0; k < num_uniform; k++) {
const size_t unival_vp_max = shader_table->use_uniform[k].second ? vp_unival_max[k] : 0;
const size_t unival_fp_max = shader_table->use_uniform[k].second ? fp_unival_max[k] : 0;
for (int32_t k = 0; k < num_uniform; k++) {
const int32_t unival_vp_max = vp_unival_max[k];
const int32_t unival_fp_max = fp_unival_max[k];
unival_vp_count += unival_vp_curr * unival_vp_max;
unival_fp_count += unival_fp_curr * unival_fp_max;
unival_vp_curr *= unival_vp_max + 1;
@@ -444,10 +443,10 @@ void compile_shaders(farc* f, farc* of, const shader_table* shaders_table, const
strcat_s(vert_buf, sizeof(vert_buf), ".vert.spv");
int32_t vert_buf_len = (int32_t)utf8_length(vert_buf);
for (size_t k = 0; k < unival_vp_count; k++) {
for (size_t l = 0, m = k; l < num_uniform; l++) {
size_t unival_max = (size_t)(shader_table->use_uniform[l].second ? vp_unival_max[l] : 0) + 1;
vec_vert_data[l] = (uint32_t)(min_def(m % unival_max, vp_unival_max[l]));
for (int32_t k = 0; k < unival_vp_count; k++) {
for (int32_t l = 0, m = k; l < num_uniform; l++) {
int32_t unival_max = vp_unival_max[l] + 1;
vec_vert_data[l] = min_def(m % unival_max, vp_unival_max[l]);
m /= unival_max;
vert_buf[vert_buf_pos + l] = (char)('0' + vec_vert_data[l]);
}
@@ -514,9 +513,9 @@ void compile_shaders(farc* f, farc* of, const shader_table* shaders_table, const
strcat_s(frag_buf, sizeof(frag_buf), ".frag.spv");
int32_t frag_buf_len = (int32_t)utf8_length(frag_buf);
for (size_t k = 0; k < unival_fp_count; k++) {
for (size_t l = 0, m = k; l < num_uniform; l++) {
size_t unival_max = (size_t)(shader_table->use_uniform[l].second ? fp_unival_max[l] : 0) + 1;
for (int32_t k = 0; k < unival_fp_count; k++) {
for (int32_t l = 0, m = k; l < num_uniform; l++) {
int32_t unival_max = fp_unival_max[l] + 1;
vec_frag_data[l] = (uint32_t)(min_def(m % unival_max, fp_unival_max[l]));
m /= unival_max;
frag_buf[frag_buf_pos + l] = (char)('0' + vec_frag_data[l]);