diff --git a/src/CRE/Glitter/effect.cpp b/src/CRE/Glitter/effect.cpp index 3941ca20..696dbb4a 100644 --- a/src/CRE/Glitter/effect.cpp +++ b/src/CRE/Glitter/effect.cpp @@ -6,8 +6,8 @@ #include "glitter.hpp" namespace Glitter { - Effect::Data::Data(GLT) : appear_time(), life_time(), - start_time(), ext_anim(), flags(), emission(), seed(), unk() { + Effect::Data::Data(GLT) : appear_time(), life_time(), start_time(), ext_anim(), + flags(), emission(), seed(), ext_anim_scale_start_time() { color = 0xFFFFFFFF; name_hash = GLT_VAL != Glitter::FT ? hash_murmurhash_empty : hash_fnv1a64m_empty; diff --git a/src/CRE/Glitter/effect_inst.cpp b/src/CRE/Glitter/effect_inst.cpp index b5a16c65..8f412bb7 100644 --- a/src/CRE/Glitter/effect_inst.cpp +++ b/src/CRE/Glitter/effect_inst.cpp @@ -28,7 +28,7 @@ namespace Glitter { req_frame = 0.0f; ext_color = 0.0f; ext_anim_scale = 0.0f; - some_scale = -1.0f; + ext_scale = -1.0f; if (appear_now) data.appear_time = 0; @@ -40,18 +40,18 @@ namespace Glitter { } - bool EffectInst::GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale) { + bool EffectInst::GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale) { if (!(flags & EFFECT_INST_HAS_EXT_ANIM_SCALE)) return false; if (ext_anim_scale) *ext_anim_scale = this->ext_anim_scale; - if (some_scale) - *some_scale = this->some_scale; + if (ext_scale) + *ext_scale = this->ext_scale; return true; } - void EffectInst::SetExtColor(bool set, float_t r, float_t g, float_t b, float_t a) { + void EffectInst::SetExtColor(float_t r, float_t g, float_t b, float_t a, bool set) { ext_color.x = r; ext_color.y = g; ext_color.z = b; @@ -63,6 +63,11 @@ namespace Glitter { enum_or(flags, EFFECT_INST_EXT_COLOR); } + void EffectInst::SetExtScale(float_t scale) { + ext_scale = scale; + enum_or(flags, EFFECT_INST_HAS_EXT_SCALE); + } + int32_t EffectInst::GetExtAnimBoneIndex(GPM, EffectExtAnimCharaNode node) { if (node < EFFECT_EXT_ANIM_CHARA_HEAD || node > EFFECT_EXT_ANIM_CHARA_RIGHT_TOE) return -1; @@ -118,7 +123,9 @@ namespace Glitter { ext_anim = 0; if (!init && !(eff->data.flags & EFFECT_LOCAL) && data.ext_anim) { - F2EffectInst::ExtAnim* inst_ext_anim = new F2EffectInst::ExtAnim; + InitExtAnim(); + + F2EffectInst::ExtAnim* inst_ext_anim = this->ext_anim; if (inst_ext_anim) { Effect::ExtAnim* ext_anim = data.ext_anim; if (ext_anim->flags & EFFECT_EXT_ANIM_SET_ONCE) @@ -141,7 +148,7 @@ namespace Glitter { inst_ext_anim->mesh_name = 0; } } - ext_anim = inst_ext_anim; + enum_or(flags, EFFECT_INST_HAS_EXT_ANIM); enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_NON_INIT); enum_or(flags, EFFECT_INST_GET_EXT_ANIM_MAT); @@ -193,41 +200,6 @@ namespace Glitter { } } - void F2EffectInst::Ctrl(GPM, GLT, float_t delta_frame, float_t emission) { - GetExtAnim(); - GetValue(GLT_VAL); - - mat4 mat; - if (GetExtAnimMat(&mat)) - mat4_mul_translate(&mat, &translation, &mat); - else - mat4_translate(&translation, &mat); - - vec3 rot = rotation; - vec3 scale = this->scale * scale_all; - - mat4_mul_rotate_zyx(&mat, &rot, &mat); - mat4_scale_rot(&mat, &scale, &this->mat); - - for (F2EmitterInst*& i : emitters) - if (i) - i->Ctrl(GPM_VAL, GLT_VAL, this, delta_frame); - - if (frame0 >= 0.0f) - if (frame0 < (float_t)data.life_time) { - for (F2EmitterInst*& i : emitters) - if (i) - i->Emit(GPM_VAL, GLT_VAL, delta_frame, emission); - } - else if (data.flags & EFFECT_LOOP) - frame0 -= (float_t)data.life_time; - else - Free(GPM_VAL, GLT_VAL, emission, false); - - render_scene.Ctrl(GLT_VAL, delta_frame); - frame0 += delta_frame; - } - void F2EffectInst::Disp(GPM, DispType disp_type) { render_scene.Disp(GPM_VAL, disp_type); } @@ -292,8 +264,43 @@ namespace Glitter { return false; } + void F2EffectInst::SetExtAnimMat(const mat4* mat) { + + } + + void F2EffectInst::Ctrl(GPM, GLT, float_t delta_frame) { + GetExtAnim(); + GetValue(GLT_VAL); + + mat4 mat; + if (GetExtAnimMat(&mat)) + mat4_mul_translate(&mat, &translation, &mat); + else + mat4_translate(&translation, &mat); + + vec3 rot = rotation; + vec3 scale = this->scale * scale_all; + + mat4_mul_rotate_zyx(&mat, &rot, &mat); + mat4_scale_rot(&mat, &scale, &this->mat); + + for (F2EmitterInst*& i : emitters) + if (i) + i->Ctrl(GPM_VAL, GLT_VAL, this, delta_frame); + } + + void F2EffectInst::CtrlInit(GPM, GLT, float_t delta_frame) { + if (frame0 < 0.0f) + return; + + GetValue(GLT_VAL); + + for (F2EmitterInst*& i : emitters) + i->CtrlInit(GPM_VAL, GLT_VAL, this, delta_frame); + } + void F2EffectInst::CtrlMat(GPM, GLT) { - if (!(flags & EFFECT_INST_JUST_INIT)) + if (!(flags & EFFECT_INST_RESET_INIT)) return; vec3 trans = translation; @@ -310,7 +317,42 @@ namespace Glitter { if (i) i->CtrlMat(GPM_VAL, GLT_VAL, this); - enum_and(flags, ~EFFECT_INST_JUST_INIT); + enum_and(flags, ~EFFECT_INST_RESET_INIT); + } + + void F2EffectInst::Emit(GPM, GLT, float_t delta_frame, float_t emission) { + if (frame0 >= 0.0f) { + if (frame0 < (float_t)data.life_time) { + for (F2EmitterInst*& i : emitters) + if (i) + i->Emit(GPM_VAL, GLT_VAL, delta_frame, emission); + } + else if (data.flags & EFFECT_LOOP) + frame0 -= (float_t)data.life_time; + else + Free(GPM_VAL, GLT_VAL, emission, false); + } + + frame0 += delta_frame; + } + + void F2EffectInst::EmitInit(GPM, GLT, float_t delta_frame, float_t emission) { + if (frame0 >= 0.0f) { + if (frame0 < (float_t)data.life_time) { + for (F2EmitterInst*& i : emitters) + if (i) + i->EmitInit(GPM_VAL, GLT_VAL, this, delta_frame, emission); + } + else if (data.flags & EFFECT_LOOP) + frame0 -= (float_t)data.life_time; + else + Free(GPM_VAL, GLT_VAL, emission, false); + + for (F2EmitterInst*& i : emitters) + i->RenderGroupCtrl(GLT_VAL, delta_frame); + } + + frame0 += delta_frame; } DispType F2EffectInst::GetDispType() { @@ -551,6 +593,15 @@ namespace Glitter { } } + void F2EffectInst::InitExtAnim() { + if (!ext_anim) + ext_anim = new F2EffectInst::ExtAnim; + } + + void F2EffectInst::RenderSceneCtrl(GLT, float_t delta_frame) { + render_scene.Ctrl(GLT_VAL, delta_frame); + } + bool F2EffectInst::ResetInit(GPM, GLT, Glitter::Scene* sc, float_t* init_delta_frame) { if (data.start_time < 1) return false; @@ -576,42 +627,15 @@ namespace Glitter { const float_t emission = sc->emission; while (start_time > 0.0f) { - enum_or(flags, EFFECT_INST_JUST_INIT); + enum_or(flags, EFFECT_INST_RESET_INIT); if (delta_frame > start_time) delta_frame -= start_time; - if (frame0 >= 0.0f) { - GetValue(GLT_VAL); + CtrlInit(GPM_VAL, GLT_VAL, delta_frame); + EmitInit(GPM_VAL, GLT_VAL, delta_frame, emission); - vec3 trans = translation; - vec3 rot = rotation; - vec3 scale = this->scale * scale_all; - - mat4 mat; - mat4_translate(&trans, &mat); - mat4_mul_rotate_zyx(&mat, &rot, &mat); - mat4_scale_rot(&mat, &scale, &this->mat); - - for (F2EmitterInst*& i : emitters) - if (i) - i->CtrlInit(GPM_VAL, GLT_VAL, this, delta_frame); - - if (frame0 < (float_t)data.life_time) { - for (F2EmitterInst*& i : emitters) - if (i) - i->Emit(GPM_VAL, GLT_VAL, delta_frame, emission); - } - else if (data.flags & EFFECT_LOOP) - frame0 -= (float_t)data.life_time; - else - Free(GPM_VAL, GLT_VAL, emission, false); - - render_scene.Ctrl(GLT_VAL, delta_frame); - } - - frame0 += delta_frame; - frame1 += delta_frame; start_time -= delta_frame; + frame1 += delta_frame; } CtrlMat(GPM_VAL, GLT_VAL); @@ -641,6 +665,7 @@ namespace Glitter { mat_rot = mat4_identity; mat_rot_eff_rot = mat4_identity; random_shared.XReset(); + flags = EFFECT_INST_JUST_INIT; ext_anim = 0; render_scene = {}; @@ -656,7 +681,9 @@ namespace Glitter { random_shared.value = random; if (!init && !(eff->data.flags & EFFECT_LOCAL) && data.ext_anim_x) { - XEffectInst::ExtAnim* inst_ext_anim = new XEffectInst::ExtAnim; + InitExtAnim(); + + XEffectInst::ExtAnim* inst_ext_anim = this->ext_anim; if (inst_ext_anim) { Effect::ExtAnimX* ext_anim = data.ext_anim_x; if (ext_anim->flags & EFFECT_EXT_ANIM_SET_ONCE) @@ -688,7 +715,7 @@ namespace Glitter { else inst_ext_anim->mesh_name = 0; } - ext_anim = inst_ext_anim; + enum_or(flags, EFFECT_INST_HAS_EXT_ANIM); enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_NON_INIT); enum_or(flags, EFFECT_INST_GET_EXT_ANIM_MAT); @@ -740,57 +767,6 @@ namespace Glitter { } } - void XEffectInst::Ctrl(GPM, GLT, float_t delta_frame, float_t emission) { - GetExtAnim(); - if (flags & EFFECT_INST_GET_EXT_ANIM_THEN_UPDATE && !GPM_VAL->draw_all) - return; - - GetValue(); - - vec3& rot = rotation; - - mat4 mat; - if (GetExtAnimMat(&mat)) { - mat4_normalize_rotation(&mat, &mat_rot); - mat4_clear_trans(&mat_rot, &mat_rot); - - mat_rot_eff_rot = mat_rot; - mat4_mul_rotate_zyx(&mat_rot, &rot, &mat_rot); - - mat4_mul_translate(&mat, &translation, &mat); - } - else { - mat_rot = mat4_identity; - mat_rot_eff_rot = mat4_identity; - mat4_rotate_zyx(&rot, &mat_rot); - - mat4_translate(&translation, &mat); - } - - vec3 scale = this->scale * scale_all; - - mat4_mul_rotate_zyx(&mat, &rot, &mat); - mat4_scale_rot(&mat, &scale, &this->mat); - - for (XEmitterInst*& i : emitters) - if (i) - i->Ctrl(GPM_VAL, this, delta_frame); - - if (frame0 >= 0.0f) - if (frame0 < (float_t)data.life_time) { - for (XEmitterInst*& i : emitters) - if (i) - i->Emit(delta_frame, emission); - } - else if (data.flags & EFFECT_LOOP) - frame0 -= (float_t)data.life_time; - else - Free(GPM_VAL, Glitter::X, emission, false); - - render_scene.Ctrl(delta_frame, true); - frame0 += delta_frame; - } - void XEffectInst::Disp(GPM, DispType disp_type) { render_scene.Disp(GPM_VAL, disp_type); } @@ -863,8 +839,141 @@ namespace Glitter { return false; } + void XEffectInst::SetExtAnimMat(const mat4* mat) { + InitExtAnim(); + + if (!mat || !ext_anim) + return; + ext_anim->mat = *mat; + ext_anim->translation = 0.0f; + + if ((flags & EFFECT_INST_HAS_EXT_ANIM_NON_INIT)) + enum_and(flags, ~EFFECT_INST_HAS_EXT_ANIM_NON_INIT); + if (!(flags & EFFECT_INST_HAS_EXT_ANIM_TRANS)) + enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_TRANS); + + enum_and(flags, ~(EFFECT_INST_GET_EXT_ANIM_MAT | EFFECT_INST_CHARA_ANIM)); + enum_or(flags, EFFECT_INST_SET_EXT_ANIM_MAT); + } + + void XEffectInst::CheckDataDependency() { + bool depends_on_ext_data = false; + if (ext_anim) + if (!(flags & EFFECT_INST_SET_EXT_ANIM_MAT) && !(flags & EFFECT_INST_HAS_EXT_ANIM) + || (flags & EFFECT_INST_HAS_EXT_ANIM_SCALE) + || (flags & EFFECT_INST_SET_EXT_ANIM_ONCE) && (flags & EFFECT_INST_HAS_EXT_ANIM_TRANS)) + depends_on_ext_data = true; + + if (!depends_on_ext_data) + for (XEmitterInst*& i : emitters) + if (i->CheckUseCamera()) { + depends_on_ext_data = true; + break; + } + + if (depends_on_ext_data) + enum_or(flags, EFFECT_INST_DEPENDS_ON_EXT_DATA); + else + enum_and(flags, ~EFFECT_INST_DEPENDS_ON_EXT_DATA); + } + + void XEffectInst::CheckUpdate() { + CheckDataDependency(); + render_scene.CheckUseCamera(); + } + + void XEffectInst::Ctrl(GPM, float_t delta_frame) { + GetExtAnim(); + if (flags & EFFECT_INST_GET_EXT_ANIM_THEN_UPDATE && !GPM_VAL->draw_all) + return; + + GetValue(); + + vec3& rot = rotation; + + mat4 mat; + if (GetExtAnimMat(&mat)) { + mat4_normalize_rotation(&mat, &mat_rot); + mat4_clear_trans(&mat_rot, &mat_rot); + + mat_rot_eff_rot = mat_rot; + mat4_mul_rotate_zyx(&mat_rot, &rot, &mat_rot); + + mat4_mul_translate(&mat, &translation, &mat); + } + else { + mat_rot = mat4_identity; + mat_rot_eff_rot = mat4_identity; + mat4_rotate_zyx(&rot, &mat_rot); + + mat4_translate(&translation, &mat); + } + + vec3 scale = this->scale * scale_all; + + mat4_mul_rotate_zyx(&mat, &rot, &mat); + mat4_scale_rot(&mat, &scale, &this->mat); + + for (XEmitterInst*& i : emitters) + if (i) + i->Ctrl(GPM_VAL, this, delta_frame); + } + + void XEffectInst::CtrlFlags(float_t delta_frame) { + if (flags & EFFECT_INST_NOT_ENDED) + enum_and(flags, ~EFFECT_INST_NOT_ENDED); + + if (flags & EFFECT_INST_JUST_INIT) + enum_and(flags, ~EFFECT_INST_JUST_INIT); + + frame0 += delta_frame; + + if ((flags & EFFECT_INST_HAS_EXT_ANIM) && !(flags & EFFECT_INST_HAS_EXT_ANIM_SCALE)) { + if (data.ext_anim_scale_start_time >= 0.0f && (flags & EFFECT_INST_HAS_EXT_ANIM_TRANS) + && frame0 >= data.ext_anim_scale_start_time) + enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_SCALE); + } + + float_t life_time = (float_t)data.life_time; + if (frame0 >= life_time) { + enum_or(flags, EFFECT_INST_NOT_ENDED); + if (data.flags & EFFECT_LOOP) { + if (life_time <= 0.0f) + frame0 = 0.0f; + else + while (frame0 >= life_time) + frame0 -= life_time; + } + } + } + + void XEffectInst::CtrlInit(GPM, float_t delta_frame) { + if (frame0 < 0.0f) + return; + + GetValue(); + + for (XEmitterInst*& i : emitters) { + if (i->data.timer != EMITTER_TIMER_BY_DISTANCE) + continue; + + mat4 mat; + mat4_mul_translate(&this->mat, &translation, &mat); + + vec3 rot = rotation; + vec3 scale = this->scale * scale_all; + + mat4_mul_rotate_zyx(&mat, &rot, &mat); + mat4_scale_rot(&mat, &scale, &this->mat); + break; + } + + for (XEmitterInst*& i : emitters) + i->CtrlInit(this, delta_frame); + } + void XEffectInst::CtrlMat(GPM) { - if (!(flags & EFFECT_INST_JUST_INIT)) + if (!(flags & EFFECT_INST_RESET_INIT)) return; vec3 trans = translation; @@ -881,7 +990,42 @@ namespace Glitter { if (i) i->CtrlMat(GPM_VAL, this); - enum_and(flags, ~EFFECT_INST_JUST_INIT); + enum_and(flags, ~EFFECT_INST_RESET_INIT); + } + + void XEffectInst::Emit(GPM, float_t delta_frame, float_t emission) { + if (flags & EFFECT_INST_GET_EXT_ANIM_THEN_UPDATE) + return; + else if (flags & EFFECT_INST_NOT_ENDED) { + if (!(data.flags & EFFECT_LOOP)) { + Free(GPM_VAL, Glitter::X, emission, false); + return; + } + } + else if (frame0 < 0.0f) + return; + + for (XEmitterInst*& i : emitters) + i->Emit(delta_frame, emission); + } + + void XEffectInst::EmitInit(GPM, float_t delta_frame, float_t emission) { + if (frame0 >= 0.0f) { + if (frame0 < (float_t)data.life_time) { + for (XEmitterInst*& i : emitters) + if (i) + i->EmitInit(GPM_VAL, this, delta_frame, emission); + } + else if (data.flags & EFFECT_LOOP) + frame0 -= (float_t)data.life_time; + else + Free(GPM_VAL, Glitter::X, emission, false); + + for (XEmitterInst*& i : emitters) + i->RenderGroupCtrl(delta_frame); + } + + frame0 += delta_frame; } DispType XEffectInst::GetDispType() { @@ -898,8 +1042,9 @@ namespace Glitter { if (!ext_anim || !data.ext_anim_x) return; - if (!(flags & EFFECT_INST_HAS_EXT_ANIM) || (flags & EFFECT_INST_SET_EXT_ANIM_ONCE - && flags & EFFECT_INST_HAS_EXT_ANIM_TRANS)) + if (!(flags & EFFECT_INST_SET_EXT_ANIM_MAT) && !(flags & EFFECT_INST_HAS_EXT_ANIM) + || (flags & EFFECT_INST_HAS_EXT_ANIM_SCALE) + || (flags & EFFECT_INST_SET_EXT_ANIM_ONCE) && (flags & EFFECT_INST_HAS_EXT_ANIM_TRANS)) return; bool set_flags = false; @@ -1058,6 +1203,10 @@ namespace Glitter { return Glitter::FOG_NONE; } + bool XEffectInst::GetUseCamera() { + return !!(flags & EFFECT_INST_DEPENDS_ON_EXT_DATA); + } + void XEffectInst::GetValue() { Animation* anim = &effect->animation; size_t length = anim->curves.size(); @@ -1114,6 +1263,15 @@ namespace Glitter { } } + void XEffectInst::InitExtAnim() { + if (!ext_anim) + ext_anim = new XEffectInst::ExtAnim; + } + + void XEffectInst::RenderSceneCtrl(float_t delta_frame) { + render_scene.Ctrl(delta_frame, true); + } + bool XEffectInst::ResetInit(GPM, Scene* sc, float_t* init_delta_frame) { if (data.start_time < 1) return false; @@ -1139,40 +1297,13 @@ namespace Glitter { const float_t emission = sc->emission; while (start_time > 0.0f) { - enum_or(flags, EFFECT_INST_JUST_INIT); + enum_or(flags, EFFECT_INST_RESET_INIT); if (delta_frame > start_time) delta_frame -= start_time; - if (frame0 >= 0.0f) { - GetValue(); + CtrlInit(GPM_VAL, delta_frame); + EmitInit(GPM_VAL, delta_frame, emission); - vec3 trans = translation; - vec3 rot = rotation; - vec3 scale = this->scale * scale_all; - - mat4 mat; - mat4_translate(&trans, &mat); - mat4_mul_rotate_zyx(&mat, &rot, &mat); - mat4_scale_rot(&mat, &scale, &this->mat); - - for (XEmitterInst*& i : emitters) - if (i) - i->CtrlInit(this, delta_frame); - - if (frame0 < (float_t)data.life_time) { - for (XEmitterInst*& i : emitters) - if (i) - i->Emit(delta_frame, emission); - } - else if (data.flags & EFFECT_LOOP) - frame0 -= (float_t)data.life_time; - else - Free(GPM_VAL, Glitter::X, emission, false); - - render_scene.Ctrl(delta_frame, false); - } - - frame0 += delta_frame; frame1 += delta_frame; start_time -= delta_frame; } diff --git a/src/CRE/Glitter/emitter_inst.cpp b/src/CRE/Glitter/emitter_inst.cpp index 02cc4cb3..3bdf0170 100644 --- a/src/CRE/Glitter/emitter_inst.cpp +++ b/src/CRE/Glitter/emitter_inst.cpp @@ -92,16 +92,20 @@ namespace Glitter { return; if (loop) - if (data.loop_end_time < 0.0f || frame < data.loop_end_time) { - if (frame >= data.life_time) { - frame -= data.life_time; + if ((float_t)data.loop_end_time < 0.0f || frame < (float_t)data.loop_end_time) { + float_t life_time = (float_t)data.life_time; + if (frame >= life_time) { + frame -= life_time; if (emission == EMITTER_EMISSION_EMITTED && emission_interval > 0.0f) emission = EMITTER_EMISSION_ON_TIMER; } } - else - while (frame > data.loop_end_time) - frame -= data.loop_end_time - data.loop_start_time; + else { + float_t loop_time = (float_t)(data.loop_end_time - data.loop_start_time); + float_t loop_end_time = (float_t)data.loop_end_time; + while (frame > loop_end_time) + frame -= loop_time; + } GetValue(GLT_VAL); rotation += data.rotation_add * delta_frame; @@ -113,13 +117,17 @@ namespace Glitter { return; if (loop) - if (data.loop_end_time < 0.0f || frame < data.loop_end_time) { - if (frame >= data.life_time) - frame -= data.life_time; + if ((float_t)data.loop_end_time < 0.0f || frame < (float_t)data.loop_end_time) { + float_t life_time = (float_t)data.life_time; + if (frame >= life_time) + frame -= life_time; + } + else { + float_t loop_time = (float_t)(data.loop_end_time - data.loop_start_time); + float_t loop_end_time = (float_t)data.loop_end_time; + while (frame > loop_end_time) + frame -= loop_time; } - else - while (frame > data.loop_end_time) - frame -= data.loop_end_time - data.loop_start_time; if (frame < 0.0f) return; @@ -178,14 +186,16 @@ namespace Glitter { if (!(flags & EMITTER_INST_ENDED)) if (this->emission == EMITTER_EMISSION_ON_TIMER) { - if (emission_timer >= 0.0f || emission_interval >= 0.0f) { - emission_timer -= delta_frame; - if (emission_timer <= 0.0f) { - EmitParticle(GPM_VAL, GLT_VAL, emission); - if (emission_interval > 0.0f) - emission_timer += emission_interval; - else - emission_timer = -1.0f; + if (data.timer == EMITTER_TIMER_BY_TIME) { + if (emission_timer >= 0.0f || emission_interval >= 0.0f) { + emission_timer -= delta_frame; + if (emission_timer <= 0.0f) { + EmitParticle(GPM_VAL, GLT_VAL, emission); + if (emission_interval > 0.0f) + emission_timer += emission_interval; + else + emission_timer = -1.0f; + } } } } @@ -197,11 +207,46 @@ namespace Glitter { } } - if (!loop && frame >= data.life_time) + if (!loop && frame >= (float_t)data.life_time) Free(GPM_VAL, GLT_VAL, emission, false); frame += delta_frame; } + void F2EmitterInst::EmitInit(GPM, GLT, F2EffectInst* eff_inst, float_t delta_frame, float_t emission) { + if (frame < 0.0f) { + frame += delta_frame; + return; + } + + if (!(flags & EMITTER_INST_ENDED)) { + if (this->emission == EMITTER_EMISSION_ON_TIMER) { + if (data.timer == EMITTER_TIMER_BY_TIME) { + if (emission_timer >= 0.0f || emission_interval >= 0.0f) { + emission_timer -= delta_frame; + if (emission_timer <= 0.0f) { + eff_inst->CtrlMat(GPM_VAL, GLT_VAL); + EmitParticle(GPM_VAL, GLT_VAL, emission); + if (emission_interval > 0.0f) + emission_timer += emission_interval; + else + emission_timer = -1.0f; + } + } + } + } + else if (this->emission == EMITTER_EMISSION_ON_START) { + eff_inst->CtrlMat(GPM_VAL, GLT_VAL); + EmitParticle(GPM_VAL, GLT_VAL, emission); + this->emission = EMITTER_EMISSION_EMITTED; + } + } + + if (!loop && frame >= (float_t)data.life_time) + Free(GPM_VAL, GLT_VAL, emission, false); + + frame += delta_frame; + } + void F2EmitterInst::EmitParticle(GPM, GLT, float_t emission) { int32_t count; if (data.type == EMITTER_POLYGON) @@ -226,7 +271,7 @@ namespace Glitter { this->emission = EMITTER_EMISSION_EMITTED; } - if (loop && data.loop_end_time >= 0.0f) + if (loop && (float_t)data.loop_end_time >= 0.0f) loop = false; enum_or(flags, EMITTER_INST_ENDED); @@ -359,6 +404,11 @@ namespace Glitter { } } + void F2EmitterInst::RenderGroupCtrl(GLT, float_t delta_frame) { + for (F2ParticleInst*& i : particles) + i->RenderGroupCtrl(GLT_VAL, delta_frame); + } + void F2EmitterInst::Reset() { loop = data.flags & EMITTER_LOOP ? true : false; frame = -(float_t)data.start_time; @@ -416,6 +466,22 @@ namespace Glitter { delete i; } + bool XEmitterInst::CheckUseCamera() { + if (!particles.size()) + return false; + + switch (data.direction) { + case DIRECTION_BILLBOARD: + case DIRECTION_BILLBOARD_Y_AXIS: + return true; + } + + for (XParticleInst*& i : particles) + if (i->CheckUseCamera()) + return true; + return false; + } + void XEmitterInst::Copy(XEmitterInst* dst, float_t emission) { dst->translation = translation; dst->rotation = rotation; @@ -447,11 +513,11 @@ namespace Glitter { if ((float_t)data.loop_end_time < 0.0f || frame < (float_t)data.loop_end_time) { float_t life_time = (float_t)data.life_time; if (frame >= life_time) { - if (life_time <= 0.0f) - frame = 0.0f; - else + if (life_time > 0.0f) while (frame >= life_time) frame -= life_time; + else + frame = 0.0f; if (emission == EMITTER_EMISSION_EMITTED && emission_interval > 0.0f) emission = EMITTER_EMISSION_ON_TIMER; @@ -551,27 +617,16 @@ namespace Glitter { return; if (loop) { - if (data.loop_end_time < 0.0f || frame < data.loop_end_time) { - if (frame >= data.life_time) { - if (data.life_time > 0.0f) - while (frame >= data.life_time) - frame -= data.life_time; - else - frame = 0.0f; - - if (emission == EMITTER_EMISSION_EMITTED && emission_interval > 0.0f) - emission = EMITTER_EMISSION_ON_TIMER; - } + if ((float_t)data.loop_end_time < 0.0f || frame < (float_t)data.loop_end_time) { + float_t life_time = (float_t)data.life_time; + if (frame >= life_time) + frame -= life_time; } else { float_t loop_time = (float_t)(data.loop_end_time - data.loop_start_time); - if (loop_time > 0.0f) { - float_t loop_end_time = (float_t)data.loop_end_time; - while (frame >= loop_end_time) - frame -= loop_time; - } - else - frame = 0.0f; + float_t loop_end_time = (float_t)data.loop_end_time; + while (frame > loop_end_time) + frame -= loop_time; } } @@ -665,7 +720,7 @@ namespace Glitter { if (data.timer == EMITTER_TIMER_BY_DISTANCE) { if (emission_timer <= 0.0f || emission_interval >= 0.0f) while (emission_timer <= 0.0f) { - EmitParticle(emission); + EmitParticle(emission, -emission_timer); emission_timer += emission_interval; if (emission_timer < -1000000.0f) emission_timer = -1000000.0f; @@ -678,7 +733,7 @@ namespace Glitter { if (emission_timer >= 0.0f || emission_interval >= 0.0f) { emission_timer -= delta_frame; if (emission_timer <= 0.0f) { - EmitParticle(emission); + EmitParticle(emission, -emission_timer); if (emission_interval > 0.0f) emission_timer += emission_interval; else @@ -690,18 +745,61 @@ namespace Glitter { && data.timer == EMITTER_TIMER_BY_TIME) { emission_timer -= delta_frame; if (emission_timer <= 0.0f) { - EmitParticle(emission); + EmitParticle(emission, -emission_timer); this->emission = EMITTER_EMISSION_EMITTED; } } - if (!loop && frame >= data.life_time) + if (!loop && frame >= (float_t)data.life_time) Free(emission, false); frame += delta_frame; } - void XEmitterInst::EmitParticle(float_t emission) { + void XEmitterInst::EmitInit(GPM, XEffectInst* eff_inst, float_t delta_frame, float_t emission) { + if (frame < 0.0f) { + frame += delta_frame; + return; + } + + if (!(flags & EMITTER_INST_ENDED)) { + if (this->emission == EMITTER_EMISSION_ON_TIMER) { + if (data.timer == EMITTER_TIMER_BY_DISTANCE) { + if (emission_timer <= 0.0f) { + EmitParticle(emission, -emission_timer); + emission_timer += emission_timer; + if (emission_timer < -1000000.0f) + emission_timer = -1000000.0f; + } + } + else if (data.timer == EMITTER_TIMER_BY_TIME) { + if (emission_timer >= 0.0f || emission_interval >= 0.0f) { + emission_timer -= delta_frame; + if (emission_timer <= 0.0f) { + eff_inst->CtrlMat(GPM_VAL); + EmitParticle(emission, -emission_timer); + if (emission_interval > 0.0f) + emission_timer += emission_interval; + else + emission_timer = -1.0; + } + } + } + } + else if (this->emission == EMITTER_EMISSION_ON_START) { + eff_inst->CtrlMat(GPM_VAL); + EmitParticle(emission, 0.0f); + this->emission = EMITTER_EMISSION_EMITTED; + } + } + + if (!loop && frame >= (float_t)data.life_time) + Free(emission, false); + + frame += delta_frame; + } + + void XEmitterInst::EmitParticle(float_t emission, float_t frame) { int32_t count; if (data.type == EMITTER_POLYGON) count = data.polygon.count; @@ -710,7 +808,7 @@ namespace Glitter { for (XParticleInst*& i : particles) if (i) - i->Emit((int32_t)prj::roundf(particles_per_emission), count, emission); + i->Emit((int32_t)prj::roundf(particles_per_emission), count, emission, frame); } void XEmitterInst::Free(float_t emission, bool free) { @@ -722,7 +820,7 @@ namespace Glitter { } if (this->emission == EMITTER_EMISSION_ON_END) { - EmitParticle(emission); + EmitParticle(emission, 0.0f); this->emission = EMITTER_EMISSION_EMITTED; } @@ -878,6 +976,11 @@ namespace Glitter { random_ptr->SetValue(random + counter); } + void XEmitterInst::RenderGroupCtrl(float_t delta_frame) { + for (XParticleInst*& i : particles) + i->RenderGroupCtrl(delta_frame); + } + void XEmitterInst::Reset() { loop = data.flags & EMITTER_LOOP ? true : false; frame = -(float_t)data.start_time; diff --git a/src/CRE/Glitter/file_reader.cpp b/src/CRE/Glitter/file_reader.cpp index f3aef53f..20d72016 100644 --- a/src/CRE/Glitter/file_reader.cpp +++ b/src/CRE/Glitter/file_reader.cpp @@ -1038,12 +1038,12 @@ namespace Glitter { if (big_endian) { eff->data.emission = load_reverse_endianness_float_t((void*)d); eff->data.seed = load_reverse_endianness_int32_t((void*)(d + 4)); - eff->data.unk = load_reverse_endianness_float_t((void*)(d + 8)); + eff->data.ext_anim_scale_start_time = load_reverse_endianness_float_t((void*)(d + 8)); } else { eff->data.emission = *(float_t*)d; eff->data.seed = *(int32_t*)(d + 4); - eff->data.unk = *(float_t*)(d + 8); + eff->data.ext_anim_scale_start_time = *(float_t*)(d + 8); } d += 12; diff --git a/src/CRE/Glitter/file_writer.cpp b/src/CRE/Glitter/file_writer.cpp index 88b51f16..a6952089 100644 --- a/src/CRE/Glitter/file_writer.cpp +++ b/src/CRE/Glitter/file_writer.cpp @@ -771,12 +771,12 @@ namespace Glitter { if (big_endian) { store_reverse_endianness_float_t((void*)d, eff->data.emission); store_reverse_endianness_int32_t((void*)(d + 4), eff->data.seed); - store_reverse_endianness_float_t((void*)(d + 8), eff->data.unk); + store_reverse_endianness_float_t((void*)(d + 8), eff->data.ext_anim_scale_start_time); } else { *(float_t*)d = eff->data.emission; *(int32_t*)(d + 4) = eff->data.seed; - *(float_t*)(d + 8) = eff->data.unk; + *(float_t*)(d + 8) = eff->data.ext_anim_scale_start_time; } d += 12; diff --git a/src/CRE/Glitter/glitter.hpp b/src/CRE/Glitter/glitter.hpp index 4ef7e84e..a1da753d 100644 --- a/src/CRE/Glitter/glitter.hpp +++ b/src/CRE/Glitter/glitter.hpp @@ -192,32 +192,32 @@ namespace Glitter { }; enum EffectInstFlag { - EFFECT_INST_NONE = 0x0000000, - EFFECT_INST_FREE = 0x0000001, - EFFECT_INST_JUST_INIT = 0x0000002, - EFFECT_INST_HAS_EXT_ANIM = 0x0000004, - EFFECT_INST_HAS_EXT_ANIM_TRANS = 0x0000008, - EFFECT_INST_HAS_EXT_ANIM_NON_INIT = 0x0000010, - EFFECT_INST_CHARA_ANIM = 0x0000020, - EFFECT_INST_GET_EXT_ANIM_MAT = 0x0000040, - EFFECT_INST_SET_EXT_ANIM_ONCE = 0x0000080, - EFFECT_INST_SET_EXT_COLOR = 0x0000100, - EFFECT_INST_EXT_COLOR = 0x0000200, - EFFECT_INST_SET_ADD_EXT_COLOR = 0x0000400, - EFFECT_INST_HAS_EXT_ANIM_SCALE = 0x0000800, - EFFECT_INST_NO_EXT_ANIM_TRANS_X = 0x0001000, - EFFECT_INST_NO_EXT_ANIM_TRANS_Y = 0x0002000, - EFFECT_INST_NO_EXT_ANIM_TRANS_Z = 0x0004000, - EFFECT_INST_EXT_ANIM_TRANS_ONLY = 0x0008000, - EFFECT_INST_FLAG_17 = 0x0010000, - EFFECT_INST_GET_EXT_ANIM_THEN_UPDATE = 0x0020000, - EFFECT_INST_FLAG_19 = 0x0040000, - EFFECT_INST_DISP = 0x0080000, - EFFECT_INST_FLAG_21 = 0x0100000, - EFFECT_INST_HAS_MESH = 0x0200000, - EFFECT_INST_FLAG_23 = 0x0400000, - EFFECT_INST_FLAG_24 = 0x0800000, - EFFECT_INST_NOT_ENDED = 0x1000000, + EFFECT_INST_NONE = 0x0000000, + EFFECT_INST_FREE = 0x0000001, + EFFECT_INST_RESET_INIT = 0x0000002, + EFFECT_INST_HAS_EXT_ANIM = 0x0000004, + EFFECT_INST_HAS_EXT_ANIM_TRANS = 0x0000008, + EFFECT_INST_HAS_EXT_ANIM_NON_INIT = 0x0000010, + EFFECT_INST_CHARA_ANIM = 0x0000020, + EFFECT_INST_GET_EXT_ANIM_MAT = 0x0000040, + EFFECT_INST_SET_EXT_ANIM_ONCE = 0x0000080, + EFFECT_INST_SET_EXT_COLOR = 0x0000100, + EFFECT_INST_EXT_COLOR = 0x0000200, + EFFECT_INST_HAS_EXT_SCALE = 0x0000400, + EFFECT_INST_HAS_EXT_ANIM_SCALE = 0x0000800, + EFFECT_INST_NO_EXT_ANIM_TRANS_X = 0x0001000, + EFFECT_INST_NO_EXT_ANIM_TRANS_Y = 0x0002000, + EFFECT_INST_NO_EXT_ANIM_TRANS_Z = 0x0004000, + EFFECT_INST_EXT_ANIM_TRANS_ONLY = 0x0008000, + EFFECT_INST_FLAG_17 = 0x0010000, + EFFECT_INST_GET_EXT_ANIM_THEN_UPDATE = 0x0020000, + EFFECT_INST_SET_EXT_ANIM_MAT = 0x0040000, + EFFECT_INST_DISP = 0x0080000, + EFFECT_INST_DEPENDS_ON_EXT_DATA = 0x0100000, + EFFECT_INST_HAS_MESH = 0x0200000, + EFFECT_INST_FLAG_23 = 0x0400000, + EFFECT_INST_JUST_INIT = 0x0800000, + EFFECT_INST_NOT_ENDED = 0x1000000, }; enum EmitterDirection { @@ -387,6 +387,7 @@ namespace Glitter { SCENE_NOT_DISP = 0x02, SCENE_FLAG_3 = 0x04, SCENE_ENDED = 0x08, + SCENE_PAUSE = 0x10, SCENE_EDITOR = 0x80, }; @@ -696,7 +697,7 @@ namespace Glitter { EffectFlag flags; float_t emission; int32_t seed; - float_t unk; + float_t ext_anim_scale_start_time; Data(GLT); }; @@ -873,6 +874,7 @@ namespace Glitter { void CalcDispQuadDirectionRotation(XRenderGroup* rend_group, mat4* model_mat); void CalcDispQuadNormal(XRenderGroup* rend_group, mat4* model_mat, mat4* dir_mat); bool CanDisp(DispType disp_type, bool a3); + void CheckUseCamera(); void Ctrl(float_t delta_frame, bool copy_mats); void Disp(GPM, DispType disp_type); void Disp(GPM, XRenderGroup* rend_group); @@ -897,8 +899,8 @@ namespace Glitter { uint32_t random; float_t req_frame; vec4 ext_color; + float_t ext_scale; vec3 ext_anim_scale; - float_t some_scale; EffectInst(GPM, GLT, Effect* eff, size_t id, bool appear_now, bool init); @@ -906,7 +908,6 @@ namespace Glitter { virtual void CalcDisp(GPM) = 0; virtual void Copy(EffectInst* dst, float_t emission) = 0; - virtual void Ctrl(GPM, GLT, float_t delta_frame, float_t emission) = 0; virtual void Disp(GPM, DispType disp_type) = 0; virtual void Free(GPM, GLT, float_t emission, bool free) = 0; virtual size_t GetCtrlCount(ParticleType type) = 0; @@ -914,9 +915,11 @@ namespace Glitter { virtual bool HasEnded(bool a2) = 0; virtual void Reset(GPM, GLT, Scene* sc) = 0; virtual bool ResetCheckInit(GPM, GLT, Scene* sc, float_t* init_delta_frame = 0) = 0; + virtual void SetExtAnimMat(const mat4* mat) = 0; - bool GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale); - void SetExtColor(bool set, float_t r, float_t g, float_t b, float_t a); + bool GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale); + void SetExtColor(float_t r, float_t g, float_t b, float_t a, bool set); + void SetExtScale(float_t scale); static int32_t GetExtAnimBoneIndex(GPM, EffectExtAnimCharaNode node); }; @@ -955,7 +958,6 @@ namespace Glitter { virtual void CalcDisp(GPM) override; virtual void Copy(EffectInst* dst, float_t emission) override; - virtual void Ctrl(GPM, GLT, float_t delta_frame, float_t emission) override; virtual void Disp(GPM, DispType disp_type) override; virtual void Free(GPM, GLT, float_t emission, bool free) override; virtual size_t GetCtrlCount(ParticleType type) override; @@ -963,14 +965,21 @@ namespace Glitter { virtual bool HasEnded(bool a2) override; virtual void Reset(GPM, GLT, Scene* sc) override; virtual bool ResetCheckInit(GPM, GLT, Scene* sc, float_t* init_delta_frame = 0) override; + virtual void SetExtAnimMat(const mat4* mat) override; + void Ctrl(GPM, GLT, float_t delta_frame); + void CtrlInit(GPM, GLT, float_t delta_frame); void CtrlMat(GPM, GLT); + void Emit(GPM, GLT, float_t delta_frame, float_t emission); + void EmitInit(GPM, GLT, float_t delta_frame, float_t emission); DispType GetDispType(); void GetExtAnim(); bool GetExtAnimMat(mat4* mat); void GetExtColor(float_t& r, float_t& g, float_t& b, float_t& a); FogType GetFog(); void GetValue(GLT); + void InitExtAnim(); + void RenderSceneCtrl(GLT, float_t delta_frame); bool ResetInit(GPM, GLT, Scene* sc, float_t* init_delta_frame = 0); }; @@ -1012,7 +1021,6 @@ namespace Glitter { virtual void CalcDisp(GPM) override; virtual void Copy(EffectInst* dst, float_t emission) override; - virtual void Ctrl(GPM, GLT, float_t delta_frame, float_t emission) override; virtual void Disp(GPM, DispType disp_type) override; virtual void Free(GPM, GLT, float_t emission, bool free) override; virtual size_t GetCtrlCount(ParticleType type) override; @@ -1020,14 +1028,25 @@ namespace Glitter { virtual bool HasEnded(bool a2) override; virtual void Reset(GPM, GLT, Scene* sc) override; virtual bool ResetCheckInit(GPM, GLT, Scene* sc, float_t* init_delta_frame = 0) override; + virtual void SetExtAnimMat(const mat4* mat) override; + void CheckDataDependency(); + void CheckUpdate(); + void Ctrl(GPM, float_t delta_frame); + void CtrlFlags(float_t delta_frame); + void CtrlInit(GPM, float_t delta_frame); void CtrlMat(GPM); + void Emit(GPM, float_t delta_frame, float_t emission); + void EmitInit(GPM, float_t delta_frame, float_t emission); DispType GetDispType(); void GetExtAnim(); bool GetExtAnimMat(mat4* mat); void GetExtColor(float_t& r, float_t& g, float_t& b, float_t& a); FogType GetFog(); + bool GetUseCamera(); void GetValue(); + void InitExtAnim(); + void RenderSceneCtrl(float_t delta_frame); bool ResetInit(GPM, Scene* sc, float_t* init_delta_frame = 0); void SetExtAnim(const mat4* a2, const mat4* a3, const vec3* trans, bool set_flags); }; @@ -1137,6 +1156,7 @@ namespace Glitter { void Ctrl(GPM, GLT, F2EffectInst* eff_inst, float_t delta_frame); void CtrlInit(GPM, GLT, F2EffectInst* eff_inst, float_t delta_frame); void CtrlMat(GPM, GLT, F2EffectInst* eff_inst); + void EmitInit(GPM, GLT, F2EffectInst* eff_inst, float_t delta_frame, float_t emission); void Emit(GPM, GLT, float_t delta_frame, float_t emission); void EmitParticle(GPM, GLT, float_t emission); void Free(GPM, GLT, float_t emission, bool free); @@ -1144,6 +1164,7 @@ namespace Glitter { bool HasEnded(bool a2); void InitMesh(GLT, int32_t index, const vec3& scale, vec3& position, vec3& direction, Random* random); + void RenderGroupCtrl(GLT, float_t delta_frame); void Reset(); }; @@ -1156,12 +1177,14 @@ namespace Glitter { XEmitterInst(Emitter* emit, XEffectInst* eff_inst, float_t emission); virtual ~XEmitterInst() override; + bool CheckUseCamera(); void Copy(XEmitterInst* dst, float_t emission); void Ctrl(GPM, XEffectInst* eff_inst, float_t delta_frame); void CtrlInit(XEffectInst* eff_inst, float_t delta_frame); void CtrlMat(GPM, XEffectInst* eff_inst); void Emit(float_t delta_frame, float_t emission); - void EmitParticle(float_t emission); + void EmitInit(GPM, XEffectInst* eff_inst, float_t delta_frame, float_t emission); + void EmitParticle(float_t emission, float_t frame); void Free(float_t emission, bool free); void GetValue(); bool HasEnded(bool a2); @@ -1169,6 +1192,7 @@ namespace Glitter { vec3& position, vec3& direction, Random* random); uint8_t RandomGetStep(); void RandomStepValue(); + void RenderGroupCtrl(float_t delta_frame); void Reset(); }; @@ -1389,11 +1413,12 @@ namespace Glitter { void EmitParticle(GPM, GLT, RenderElement* rend_elem, F2EmitterInst* emit_inst, F2ParticleInst::Data* ptcl_inst_data, int32_t index, Random* random); void GetColor(RenderElement* rend_elem); - bool GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale); + bool GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale); void GetExtColor(float_t& r, float_t& g, float_t& b, float_t& a); bool GetValue(GLT, RenderElement* rend_elem, float_t frame, Random* random); void Free(bool free); bool HasEnded(bool a2); + void RenderGroupCtrl(GLT, float_t delta_frame); void Reset(); void StepUVParticle(GLT, RenderElement* rend_elem, float_t delta_frame, Random* random); }; @@ -1422,16 +1447,19 @@ namespace Glitter { void AccelerateParticle(RenderElement* rend_elem, float_t delta_frame, Random* random); + bool CheckUseCamera(); void Copy(XParticleInst* dst, float_t emission); - void Emit(int32_t dup_count, int32_t count, float_t emission); + void Emit(int32_t dup_count, int32_t count, float_t emission, float_t frame); void EmitParticle(RenderElement* rend_elem, XEmitterInst* emit_inst, XParticleInst::Data* ptcl_inst_data, int32_t index, uint8_t step, Random* random); void GetColor(RenderElement* rend_elem, float_t color_scale); - bool GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale); + bool GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale); void GetExtColor(float_t& r, float_t& g, float_t& b, float_t& a); + bool GetUseCamera(); bool GetValue(RenderElement* rend_elem, float_t frame, Random* random, float_t* color_scale); void Free(bool free); bool HasEnded(bool a2); + void RenderGroupCtrl(float_t delta_frame); void Reset(); void StepUVParticle(RenderElement* rend_elem, float_t delta_frame, Random* random); }; @@ -1452,7 +1480,7 @@ namespace Glitter { F2EmitterInst* emit_inst, int32_t dup_count, int32_t count); void Free(); void FreeData(); - bool GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale); + bool GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale); static mat4 RotateToEmitPosition(F2RenderGroup* rend_group, RenderElement* rend_elem, vec3* vec); @@ -1465,21 +1493,23 @@ namespace Glitter { XParticleInst* particle; uint64_t object_name_hash; bool use_culling; + bool use_camera; XRenderGroup(XParticleInst* ptcl_inst); virtual ~XRenderGroup(); bool CannotDisp(); + void CheckUseCamera(); void Copy(XRenderGroup* dst); void Ctrl(float_t delta_frame, bool copy_mats); void CtrlParticle(RenderElement* rend_elem, float_t delta_frame); void DeleteBuffers(bool free); void Emit(XParticleInst::Data* ptcl_inst_data, - XEmitterInst* emit_inst, int32_t dup_count, int32_t count); + XEmitterInst* emit_inst, int32_t dup_count, int32_t count, float_t frame); void Free(); void FreeData(); bool GetEmitterScale(vec3& emitter_scale); - bool GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale); + bool GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale); bool HasEnded(); static mat4 RotateMeshToEmitPosition(XRenderGroup* rend_group, @@ -1561,12 +1591,12 @@ namespace Glitter { uint64_t hash; SceneFlag flags; float_t emission; + float_t delta_frame_history; + float_t fade_frame_left; + float_t fade_frame; + bool skip; Type type; EffectGroup* effect_group; - float_t fade_frame; - float_t fade_frame_left; - float_t delta_frame_history; - bool skip; FrameRateControl* frame_rate; Scene(SceneCounter counter, uint64_t hash, EffectGroup* eff_group, bool a5); @@ -1574,6 +1604,7 @@ namespace Glitter { void CalcDisp(GPM); bool CanDisp(DispType disp_type, bool a3); + void CheckUpdate(float_t delta_frame); bool Copy(EffectInst* eff_inst, Scene* dst); void Ctrl(GPM, float_t delta_frame); void Disp(GPM, DispType disp_type); @@ -1587,8 +1618,11 @@ namespace Glitter { void InitEffect(GPM, Effect* eff, size_t id, bool appear_now, uint8_t load_flags = 0); bool ResetCheckInit(GPM, float_t* init_delta_frame = 0); bool ResetEffect(GPM, uint64_t effect_hash, size_t* id = 0); - bool SetExtColor(bool set, uint64_t effect_hash, float_t r, float_t g, float_t b, float_t a); - bool SetExtColorByID(bool set, size_t id, float_t r, float_t g, float_t b, float_t a); + void SetEnded(); + void SetExtAnimMat(mat4* mat, size_t id); + bool SetExtColor(float_t r, float_t g, float_t b, float_t a, bool set, uint64_t effect_hash); + bool SetExtColorByID(float_t r, float_t g, float_t b, float_t a, bool set, size_t id); + void SetExtScale(float_t scale, size_t id); void SetFrameRate(FrameRateControl* frame_rate); void SetReqFrame(size_t id, float_t req_frame); }; @@ -1660,11 +1694,13 @@ namespace Glitter { SceneCounter LoadSceneEffect(uint64_t hash, const char* name, uint8_t load_flags = 0); bool SceneHasNotEnded(SceneCounter load_counter); void SetFrame(EffectGroup* effect_group, - Scene*& scene, float_t curr_frame, float_t prev_frame, + Scene*& scene, float_t curr_frame, float_t next_frame, const Counter& counter, const Random& random, bool reset); void SetInitDeltaFrame(float_t value); - void SetSceneEffectExtColor(SceneCounter scene_counter, bool set, - uint64_t effect_hash, float_t r, float_t g, float_t b, float_t a); + void SetSceneEffectExtAnimMat(SceneCounter scene_counter, mat4* mat); + void SetSceneEffectExtColor(SceneCounter scene_counter, + float_t r, float_t g, float_t b, float_t a, bool set, uint64_t effect_hash); + void SetSceneEffectExtScale(SceneCounter scene_counter, float_t scale); void SetSceneEffectReqFrame(SceneCounter scene_counter, float_t req_frame); void SetSceneFrameRate(SceneCounter scene_counter, FrameRateControl* frame_rate); void SetSceneName(uint64_t hash, const char* name); diff --git a/src/CRE/Glitter/particle_inst.cpp b/src/CRE/Glitter/particle_inst.cpp index 35d119c1..13c19141 100644 --- a/src/CRE/Glitter/particle_inst.cpp +++ b/src/CRE/Glitter/particle_inst.cpp @@ -312,11 +312,11 @@ namespace Glitter { rend_elem->disp = false; } - bool F2ParticleInst::GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale) { + bool F2ParticleInst::GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale) { if (data.effect) - return data.effect->GetExtAnimScale(ext_anim_scale, some_scale); + return data.effect->GetExtAnimScale(ext_anim_scale, ext_scale); else if (data.parent && data.parent->data.effect) - return data.parent->data.effect->GetExtAnimScale(ext_anim_scale, some_scale); + return data.parent->data.effect->GetExtAnimScale(ext_anim_scale, ext_scale); else return false; } @@ -427,6 +427,17 @@ namespace Glitter { return true; } + void F2ParticleInst::RenderGroupCtrl(GLT, float_t delta_frame) { + if (data.parent || !(data.flags & PARTICLE_INST_NO_CHILD)) { + if (data.render_group) + data.render_group->Ctrl(GLT_VAL, delta_frame, true); + return; + } + + for (F2ParticleInst*& i : data.children) + i->RenderGroupCtrl(GLT_VAL, delta_frame); + } + void F2ParticleInst::Reset() { data.flags = (ParticleInstFlag)0; if (data.render_group) @@ -525,7 +536,7 @@ namespace Glitter { XRenderGroup* rend_group = new XRenderGroup(this); if (rend_group) { - XEffectInst* effect = (XEffectInst*)parent->data.effect; + XEffectInst* effect = parent->data.effect; rend_group->disp_type = effect->GetDispType(); rend_group->fog_type = effect->GetFog(); @@ -588,6 +599,35 @@ namespace Glitter { rend_elem->speed = max_def(speed, 0.0f); } + bool XParticleInst::CheckUseCamera() { + Particle* ptcl = data.particle; + if (!ptcl) + return false; + + switch (ptcl->data.draw_type) { + case DIRECTION_BILLBOARD: + case DIRECTION_BILLBOARD_Y_AXIS: + return true; + } + + if (ptcl->data.type != PARTICLE_QUAD || fabsf(ptcl->data.z_offset) <= 0.000001f) + return false; + + switch (ptcl->data.draw_type) { + case DIRECTION_BILLBOARD: + case DIRECTION_EMITTER_DIRECTION: + case DIRECTION_Y_AXIS: + case DIRECTION_X_AXIS: + case DIRECTION_Z_AXIS: + case DIRECTION_BILLBOARD_Y_AXIS: + case DIRECTION_EMITTER_ROTATION: + case DIRECTION_EFFECT_ROTATION: + case DIRECTION_PARTICLE_ROTATION: + return true; + } + return false; + } + void XParticleInst::Copy(XParticleInst* dst, float_t emission) { dst->data.flags = data.flags; if (data.render_group && dst->data.render_group) @@ -608,7 +648,7 @@ namespace Glitter { } } - void XParticleInst::Emit(int32_t dup_count, int32_t count, float_t emission) { + void XParticleInst::Emit(int32_t dup_count, int32_t count, float_t emission, float_t frame) { if (data.flags & PARTICLE_INST_ENDED) return; @@ -626,7 +666,7 @@ namespace Glitter { } if (ptcl->data.render_group) - ptcl->data.render_group->Emit(&ptcl->data, ptcl->data.emitter, dup_count, count); + ptcl->data.render_group->Emit(&ptcl->data, ptcl->data.emitter, dup_count, count, frame); } void XParticleInst::EmitParticle(RenderElement* rend_elem, XEmitterInst* emit_inst, @@ -794,11 +834,11 @@ namespace Glitter { rend_elem->disp = false; } - bool XParticleInst::GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale) { + bool XParticleInst::GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale) { if (data.effect) - return data.effect->GetExtAnimScale(ext_anim_scale, some_scale); + return data.effect->GetExtAnimScale(ext_anim_scale, ext_scale); else if (data.parent && data.parent->data.effect) - return data.parent->data.effect->GetExtAnimScale(ext_anim_scale, some_scale); + return data.parent->data.effect->GetExtAnimScale(ext_anim_scale, ext_scale); else return false; } @@ -810,6 +850,15 @@ namespace Glitter { data.parent->data.effect->GetExtColor(r, g, b, a); } + bool XParticleInst::GetUseCamera() { + if (data.effect) + return data.effect->GetUseCamera(); + else if (data.parent && data.parent->data.effect) + return data.parent->data.effect->GetUseCamera(); + else + return false; + } + bool XParticleInst::GetValue(RenderElement* rend_elem, float_t frame, Random* random, float_t* color_scale) { float_t value = 0.0f; vec3 translation = 0.0f; @@ -942,6 +991,17 @@ namespace Glitter { return true; } + void XParticleInst::RenderGroupCtrl(float_t delta_frame) { + if (data.parent || !(data.flags & PARTICLE_INST_NO_CHILD)) { + if (data.render_group) + data.render_group->Ctrl(delta_frame, true); + return; + } + + for (XParticleInst*& i : data.children) + i->RenderGroupCtrl(delta_frame); + } + void XParticleInst::Reset() { data.flags = (ParticleInstFlag)0; if (data.render_group) diff --git a/src/CRE/Glitter/particle_manager.cpp b/src/CRE/Glitter/particle_manager.cpp index 0424dd71..89704e3d 100644 --- a/src/CRE/Glitter/particle_manager.cpp +++ b/src/CRE/Glitter/particle_manager.cpp @@ -66,6 +66,20 @@ namespace Glitter { else delta_frame = get_delta_frame(); + for (Scene*& i : scenes) { + if (!i || i->type != Glitter::X) + continue; + + float_t delta_frame = this->delta_frame; + if (i->frame_rate) + delta_frame = i->frame_rate->get_delta_frame(); + + i->CheckUpdate(delta_frame); + + if (i->HasEnded(true)) + i->SetEnded(); + } + CtrlScenes(); } return false; @@ -128,6 +142,9 @@ namespace Glitter { bool local = false; for (auto i = scenes.begin(); i != scenes.end();) { Scene* scene = *i; + if (scene->type != Glitter::X) + continue; + if (!(scene->flags & SCENE_ENDED)) { if (!local && scene->CanDisp(DISP_LOCAL, true)) local = true; @@ -305,16 +322,13 @@ namespace Glitter { free = scene->HasEnded(true); } - if (free) { - if (!(scene->flags & SCENE_ENDED)) { - enum_or(scene->flags, SCENE_ENDED); - scene->fade_frame_left = scene->fade_frame; + if (free) + if (scene->type == Glitter::X) + scene->SetEnded(); + else { + delete scene; + i = scenes.erase(i); } - i++; - - //delete scene; - //i = scenes.erase(i); - } break; } } @@ -796,9 +810,9 @@ namespace Glitter { } void GltParticleManager::SetFrame(EffectGroup* effect_group, - Scene*& scene, float_t curr_frame, float_t prev_frame, + Scene*& scene, float_t curr_frame, float_t next_frame, const Counter& counter, const Random& random, bool reset) { - if (curr_frame < prev_frame || reset) { + if (next_frame < curr_frame || reset) { for (auto i = scenes.begin(); i != scenes.end();) { if (!*i || *i != scene) { i++; @@ -814,15 +828,16 @@ namespace Glitter { Glitter::counter = counter; Glitter::random = random; - prev_frame = 0.0f; + curr_frame = 0.0f; } - float_t frame = prev_frame; - float_t delta = curr_frame - prev_frame; + float_t remain_frame = next_frame - curr_frame; + if (curr_frame == 0.0f) + remain_frame += 1.0f; float_t delta_frame = 1.0f; while (true) { for (Effect*& i : effect_group->effects) - if ((float_t)i->data.appear_time == frame) { + if ((float_t)i->data.appear_time == curr_frame) { LoadSceneEffect(i->data.name_hash); if (!scene) { @@ -832,11 +847,11 @@ namespace Glitter { } } - if (delta <= 0.0f) + if (remain_frame <= 0.0f) break; - if (delta_frame > delta) - delta_frame = delta; + if (delta_frame > remain_frame) + delta_frame = remain_frame; Scene* s = scene; if (s && !s->HasEnded(true)) @@ -853,8 +868,8 @@ namespace Glitter { else s->Ctrl(this, delta_frame); - delta -= delta_frame; - frame += delta_frame; + remain_frame -= delta_frame; + curr_frame += delta_frame; } } @@ -864,14 +879,30 @@ namespace Glitter { init_delta_frame = -1.0f; } - void GltParticleManager::SetSceneEffectExtColor(SceneCounter scene_counter, bool set, - uint64_t effect_hash, float_t r, float_t g, float_t b, float_t a) { + void GltParticleManager::SetSceneEffectExtAnimMat(SceneCounter scene_counter, mat4* mat) { + for (Scene*& i : scenes) + if (i && i->counter.counter == scene_counter.counter) { + i->SetExtAnimMat(mat, scene_counter.index); + break; + } + } + + void GltParticleManager::SetSceneEffectExtColor(SceneCounter scene_counter, + float_t r, float_t g, float_t b, float_t a, bool set, uint64_t effect_hash) { for (Scene*& i : scenes) if (i && i->counter.counter == scene_counter.counter) { if (effect_hash == hash_fnv1a64m_empty || effect_hash == hash_murmurhash_empty) - i->SetExtColorByID(set, scene_counter.index, r, g, b, a); + i->SetExtColorByID(r, g, b, a, set, scene_counter.index); else - i->SetExtColor(set, effect_hash, r, g, b, a); + i->SetExtColor(r, g, b, a, set, effect_hash); + break; + } + } + + void GltParticleManager::SetSceneEffectExtScale(SceneCounter scene_counter, float_t scale) { + for (Scene*& i : scenes) + if (i && i->counter.counter == scene_counter.counter) { + i->SetExtScale(scale, scene_counter.index); break; } } diff --git a/src/CRE/Glitter/render_group.cpp b/src/CRE/Glitter/render_group.cpp index 4acff440..695c1480 100644 --- a/src/CRE/Glitter/render_group.cpp +++ b/src/CRE/Glitter/render_group.cpp @@ -277,9 +277,9 @@ namespace Glitter { DeleteBuffers(true); } - bool F2RenderGroup::GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale) { + bool F2RenderGroup::GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale) { if (particle) - particle->GetExtAnimScale(ext_anim_scale, some_scale); + particle->GetExtAnimScale(ext_anim_scale, ext_scale); return false; } @@ -331,7 +331,7 @@ namespace Glitter { return mat; } - XRenderGroup::XRenderGroup(XParticleInst* ptcl_inst) : particle(), use_culling() { + XRenderGroup::XRenderGroup(XParticleInst* ptcl_inst) : particle(), use_culling(), use_camera() { object_name_hash = hash_murmurhash_empty; switch (ptcl_inst->data.data.type) { @@ -409,6 +409,13 @@ namespace Glitter { return true; } + void XRenderGroup::CheckUseCamera() { + if (particle) + use_camera = particle->GetUseCamera(); + else + use_camera = false; + } + void XRenderGroup::Copy(XRenderGroup* dst) { dst->flags = flags; dst->type = type; @@ -557,8 +564,9 @@ namespace Glitter { elements = 0; } } + void XRenderGroup::Emit(XParticleInst::Data* ptcl_inst_data, - XEmitterInst* emit_inst, int32_t dup_count, int32_t count) { + XEmitterInst* emit_inst, int32_t dup_count, int32_t count, float_t frame) { RenderElement* element; int64_t i; int32_t index; @@ -573,6 +581,7 @@ namespace Glitter { break; emit_inst->RandomStepValue(); + element->frame = frame; particle->EmitParticle(element, emit_inst, ptcl_inst_data, index, step, random_ptr); } } @@ -611,9 +620,9 @@ namespace Glitter { return false; } - bool XRenderGroup::GetExtAnimScale(vec3* ext_anim_scale, float_t* some_scale) { + bool XRenderGroup::GetExtAnimScale(vec3* ext_anim_scale, float_t* ext_scale) { if (particle) - particle->GetExtAnimScale(ext_anim_scale, some_scale); + particle->GetExtAnimScale(ext_anim_scale, ext_scale); return false; } diff --git a/src/CRE/Glitter/render_scene.cpp b/src/CRE/Glitter/render_scene.cpp index 51a17cc9..2f0329d7 100644 --- a/src/CRE/Glitter/render_scene.cpp +++ b/src/CRE/Glitter/render_scene.cpp @@ -671,12 +671,12 @@ namespace Glitter { } vec3 ext_anim_scale; - float_t some_scale = 0.0f; - if (rend_group->GetExtAnimScale(&ext_anim_scale, &some_scale)) { - if (some_scale <= 0.0f) - some_scale = 1.0f; + float_t ext_scale = 0.0f; + if (rend_group->GetExtAnimScale(&ext_anim_scale, &ext_scale)) { + if (ext_scale <= 0.0f) + ext_scale = 1.0f; - ext_anim_scale += some_scale; + ext_anim_scale += ext_scale; x_vec.x *= ext_anim_scale.x; y_vec.y *= ext_anim_scale.y; } @@ -1477,15 +1477,15 @@ namespace Glitter { } vec3 ext_anim_scale; - float_t some_scale = 0.0f; - if (rend_group->GetExtAnimScale(&ext_anim_scale, &some_scale)) { + float_t ext_scale = 0.0f; + if (rend_group->GetExtAnimScale(&ext_anim_scale, &ext_scale)) { if (!has_scale) { emit_scale = 1.0f; has_scale = true; } - if (some_scale >= 0.0f) - emit_scale *= ext_anim_scale + some_scale; + if (ext_scale >= 0.0f) + emit_scale *= ext_anim_scale + ext_scale; else emit_scale += ext_anim_scale; } @@ -1781,12 +1781,12 @@ namespace Glitter { } vec3 ext_anim_scale; - float_t some_scale = 0.0f; - if (rend_group->GetExtAnimScale(&ext_anim_scale, &some_scale)) { - if (some_scale <= 0.0f) - some_scale = 1.0f; + float_t ext_scale = 0.0f; + if (rend_group->GetExtAnimScale(&ext_anim_scale, &ext_scale)) { + if (ext_scale <= 0.0f) + ext_scale = 1.0f; - ext_anim_scale += some_scale; + ext_anim_scale += ext_scale; x_vec.x *= ext_anim_scale.x; y_vec.y *= ext_anim_scale.y; } @@ -1961,6 +1961,12 @@ namespace Glitter { return false; } + void XRenderScene::CheckUseCamera() { + for (XRenderGroup*& i : groups) + if (i) + i->CheckUseCamera(); + } + void XRenderScene::Ctrl(float_t delta_frame, bool copy_mats) { ctrl_quad = 0; ctrl_line = 0; diff --git a/src/CRE/Glitter/scene.cpp b/src/CRE/Glitter/scene.cpp index 647dd908..d92f3936 100644 --- a/src/CRE/Glitter/scene.cpp +++ b/src/CRE/Glitter/scene.cpp @@ -11,12 +11,12 @@ namespace Glitter { this->hash = hash; flags = SCENE_NONE; emission = 1.0f; + delta_frame_history = 0.0f; + fade_frame_left = -1.0f; + fade_frame = -1.0f; + skip = false; type = eff_group->type; effect_group = eff_group; - delta_frame_history = 0.0f; - skip = false; - fade_frame = -1.0f; - fade_frame_left = -1.0f; frame_rate = 0; if (eff_group) { @@ -65,46 +65,74 @@ namespace Glitter { return false; } + void Scene::CheckUpdate(float_t delta_frame) { + if (delta_frame > 0.0f) + enum_and(flags, ~SCENE_PAUSE); + else + enum_or(flags, SCENE_PAUSE); + + for (SceneEffect& i : effects) + if (i.ptr && i.disp) + ((XEffectInst*)i.ptr)->CheckUpdate(); + } + void Scene::Ctrl(GPM, float_t delta_frame) { - static int32_t call_count; + if (type != Glitter::X) { + for (SceneEffect& i : effects) + if (i.ptr && i.disp) + ((F2EffectInst*)i.ptr)->Ctrl(GPM_VAL, type, delta_frame); + + for (SceneEffect& i : effects) + if (i.ptr && i.disp) + ((F2EffectInst*)i.ptr)->Emit(GPM_VAL, type, delta_frame, emission); + + for (SceneEffect& i : effects) + if (i.ptr && i.disp) + ((F2EffectInst*)i.ptr)->RenderSceneCtrl(type, delta_frame); + return; + } + + if (delta_frame < 0.0f) + return; + for (SceneEffect& i : effects) { if (!i.ptr || !i.disp) continue; - EffectInst* eff = i.ptr; - bool v13 = false; - bool v14 = false; - if (v14) - v13 = true; + XEffectInst* eff = (XEffectInst*)i.ptr; - float_t _delta_frame = delta_frame; - if (v14) - _delta_frame = 0.0f; + bool step = false; + bool just_init = !!(eff->flags & EFFECT_INST_JUST_INIT); + if (!(flags & SCENE_PAUSE) || just_init) + step = true; + + float_t _delta_frame = 0.0f; + if (!just_init) + _delta_frame = delta_frame; float_t req_frame = eff->req_frame; eff->req_frame = 0.0f; - req_frame -= _delta_frame; + float_t remain_frame = req_frame - _delta_frame; while (true) { - while (true) { - if (v13 || _delta_frame > 0.0f) - eff->Ctrl(GPM_VAL, type, _delta_frame, emission); - - if (req_frame <= 10.0f) - break; - - _delta_frame = 10.0f; - req_frame -= 10.0f; + if (step || _delta_frame > 0.0f) { + eff->CtrlFlags(_delta_frame); + eff->Ctrl(GPM_VAL, _delta_frame); + eff->Emit(GPM_VAL, _delta_frame, emission); + eff->RenderSceneCtrl(_delta_frame); } - if (req_frame <= 0.0f) + if (remain_frame > 10.0f) { + _delta_frame = 10.0f; + remain_frame -= 10.0f; + } + else if (remain_frame > 0.0f) { + _delta_frame = remain_frame; + remain_frame = -1.0f; + } + else break; - - _delta_frame = req_frame; - req_frame = -1.0f; } - - //eff->Ctrl(GPM_VAL, type, delta_frame, emission); } } @@ -295,39 +323,74 @@ namespace Glitter { return false; } - bool Scene::SetExtColor(bool set, uint64_t effect_hash, float_t r, float_t g, float_t b, float_t a) { + void Scene::SetEnded() { + if (!(flags & SCENE_ENDED)) { + enum_and(flags, SCENE_ENDED); + fade_frame_left = fade_frame; + } + } + + void Scene::SetExtAnimMat(mat4* mat, size_t id) { + if (!id) { + for (SceneEffect& i : effects) + if (i.disp && i.ptr) + i.ptr->SetExtAnimMat(mat); + } + else + for (SceneEffect& i : effects) + if (i.disp && i.ptr && i.ptr->id == id) { + i.ptr->SetExtAnimMat(mat); + break; + } + } + + bool Scene::SetExtColor(float_t r, float_t g, float_t b, float_t a, bool set, uint64_t effect_hash) { if (type == Glitter::FT && effect_hash == hash_fnv1a64m_empty || type != Glitter::FT && effect_hash == hash_murmurhash_empty) { for (SceneEffect& i : effects) if (i.disp && i.ptr) - i.ptr->SetExtColor(set, r, g, b, a); + i.ptr->SetExtColor(r, g, b, a, set); return true; } else for (SceneEffect& i : effects) if (i.disp && i.ptr && i.ptr->data.name_hash == effect_hash) { - i.ptr->SetExtColor(set, r, g, b, a); + i.ptr->SetExtColor(r, g, b, a, set); return true; } return false; } - bool Scene::SetExtColorByID(bool set, size_t id, float_t r, float_t g, float_t b, float_t a) { + bool Scene::SetExtColorByID(float_t r, float_t g, float_t b, float_t a, bool set, size_t id) { if (!id) { for (SceneEffect& i : effects) if (i.disp && i.ptr) - i.ptr->SetExtColor(set, r, g, b, a); + i.ptr->SetExtColor(r, g, b, a, set); return true; } else for (SceneEffect& i : effects) if (i.disp && i.ptr && i.ptr->id == id) { - i.ptr->SetExtColor(set, r, g, b, a); + i.ptr->SetExtColor(r, g, b, a, set); return true; } return false; } + void Scene::SetExtScale(float_t scale, size_t id) { + if (!id) { + for (SceneEffect& i : effects) + if (i.disp && i.ptr) + i.ptr->SetExtScale(scale); + } + else + for (SceneEffect& i : effects) + if (i.disp && i.ptr && i.ptr->id == id) { + i.ptr->SetExtScale(scale); + break; + } + } + void Scene::SetFrameRate(FrameRateControl* frame_rate) { this->frame_rate = frame_rate; } diff --git a/src/ReDIVA/classes/data_view/glitter.cpp b/src/ReDIVA/classes/data_view/glitter.cpp index 08e2d10e..83932694 100644 --- a/src/ReDIVA/classes/data_view/glitter.cpp +++ b/src/ReDIVA/classes/data_view/glitter.cpp @@ -95,7 +95,7 @@ void data_view_glitter_imgui(class_data* data) { ImGui::PushStyleColor(ImGuiCol_Text, eff_f2->flags & Glitter::EFFECT_INST_FREE ? 0xFF888888 : 0xFFFFFFFF); - ImGui::PushID(eff_index); + ImGui::PushID((void*)eff_f2->data.name_hash); if (!ImGui::TreeNodeEx("##Effect", tree_node_flags, "Effect %d. 0x%08X: %s; Frame: %g", eff_index, eff_f2->data.name_hash, eff_f2->name.c_str(), eff_f2->frame0)) { @@ -152,7 +152,7 @@ void data_view_glitter_imgui(class_data* data) { ImGui::PushStyleColor(ImGuiCol_Text, eff_x->flags & Glitter::EFFECT_INST_FREE ? 0xFF888888 : 0xFFFFFFFF); - ImGui::PushID(eff_index); + ImGui::PushID((void*)eff_x->data.name_hash); if (!ImGui::TreeNodeEx("##Effect", tree_node_flags, "Effect %d. 0x%08X: %s; Frame: %g", eff_index, eff_x->data.name_hash, eff_x->name.c_str(), eff_x->frame0)) { diff --git a/src/ReDIVA/data_edit/glitter_editor.cpp b/src/ReDIVA/data_edit/glitter_editor.cpp index 54ec9f4f..282b165c 100644 --- a/src/ReDIVA/data_edit/glitter_editor.cpp +++ b/src/ReDIVA/data_edit/glitter_editor.cpp @@ -1015,7 +1015,7 @@ bool GlitterEditor::ctrl() { if (input_reload) { effect_group->emission = Glitter::glt_particle_manager->emission; Glitter::glt_particle_manager->SetFrame(effect_group, scene, - frame_counter, old_frame_counter, counter, random, true); + old_frame_counter, frame_counter, counter, random, true); Glitter::glt_particle_manager->selected_effect_group = effect_group; if (scene) scene_counter = scene->counter; @@ -1032,7 +1032,7 @@ bool GlitterEditor::ctrl() { frame_counter = (float_t)start_frame; Glitter::glt_particle_manager->SetFrame(effect_group, scene, - frame_counter, old_frame_counter, counter, random, false); + old_frame_counter, frame_counter, counter, random, false); Glitter::glt_particle_manager->selected_effect_group = effect_group; if (scene) scene_counter = scene->counter; @@ -1045,7 +1045,7 @@ bool GlitterEditor::ctrl() { Glitter::counter = counter; frame_counter = (float_t)start_frame; Glitter::glt_particle_manager->SetFrame(effect_group, scene, - frame_counter, old_frame_counter, counter, random, true); + old_frame_counter, frame_counter, counter, random, true); Glitter::glt_particle_manager->selected_effect_group = effect_group; if (scene) scene_counter = scene->counter; @@ -1631,8 +1631,8 @@ static void glitter_editor_load_file(GlitterEditor* glt_edt, const char* path, c GlitterEditor::reset_disp(); eg->GetStartEndFrame(glt_edt->start_frame, glt_edt->end_frame); - glt_edt->frame_counter = 0; - glt_edt->old_frame_counter = 0; + glt_edt->frame_counter = 0.0f; + glt_edt->old_frame_counter = 0.0f; glt_edt->input_pause = true; glt_edt->counter = Glitter::counter; glt_edt->effect_group = eg; @@ -1641,6 +1641,10 @@ static void glitter_editor_load_file(GlitterEditor* glt_edt, const char* path, c glt_edt->load = false; glt_edt->load_wait = false; glt_edt->load_error_popup = false; + Glitter::glt_particle_manager->SetFrame(eg, glt_edt->scene, glt_edt->old_frame_counter, + glt_edt->frame_counter, glt_edt->counter, glt_edt->random, true); + if (glt_edt->scene) + glt_edt->scene_counter = glt_edt->scene->counter; glitter_editor_enable = false; } @@ -2979,8 +2983,8 @@ static void glitter_editor_property_effect(GlitterEditor* glt_edt) { ImGuiSliderFlags_NoRoundToFormat)) changed = true; - if (ImGui::ColumnDragFloat("Unk", - &effect->data.unk, 0.0001f, -FLT_MAX, FLT_MAX, "%g", 0)) + if (ImGui::ColumnDragFloat("Ext Anim Scale Start Time", + &effect->data.ext_anim_scale_start_time, 0.0001f, -FLT_MAX, FLT_MAX, "%g", 0)) changed = true; } diff --git a/src/ReDIVA/x_pv_game.cpp b/src/ReDIVA/x_pv_game.cpp index 6adf26e9..a75c9d1e 100644 --- a/src/ReDIVA/x_pv_game.cpp +++ b/src/ReDIVA/x_pv_game.cpp @@ -5479,14 +5479,14 @@ void x_pv_game_stage::ctrl_inner() { std::vector& glitter = eff.glitter; for (x_pv_game_stage_effect_glitter& i : glitter) { if (fabsf(i.fade_time) <= 0.000001f) - Glitter::glt_particle_manager->SetSceneEffectExtColor(i.scene_counter, 0, - hash_murmurhash_empty, -1.0f, -1.0f, -1.0f, 0.0f); + Glitter::glt_particle_manager->SetSceneEffectExtColor(i.scene_counter, + -1.0f, -1.0f, -1.0f, 0.0f, false, hash_murmurhash_empty); else if (i.fade_time > 0.001f) { i.fade_time_left -= delta_time_bar_beat * 4.0f; if (i.fade_time_left < 0.0f) i.fade_time_left = 0.0f; - Glitter::glt_particle_manager->SetSceneEffectExtColor(i.scene_counter, 0, - hash_murmurhash_empty, -1.0f, -1.0f, -1.0f, i.fade_time_left / i.fade_time); + Glitter::glt_particle_manager->SetSceneEffectExtColor(i.scene_counter, + -1.0f, -1.0f, -1.0f, i.fade_time_left / i.fade_time, false, hash_murmurhash_empty); } } } @@ -9248,7 +9248,7 @@ static void x_pv_game_item_alpha_callback(void* data, int32_t chara_id, int32_t for (x_pv_game_song_effect_glitter& j : i.glitter) Glitter::glt_particle_manager->SetSceneEffectExtColor(j.scene_counter, - false, hash_murmurhash_empty, -1.0f, -1.0f, -1.0f, alpha); + -1.0f, -1.0f, -1.0f, alpha, false, hash_murmurhash_empty); } }