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

Glitter: Small overhaul

Browse Source
This commit is contained in:
korenkonder
2024-07-28 09:57:31 +03:00
parent 6656462175
commit 6eb8dffe45
14 changed files with 812 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/CRE/Glitter/effect.cpp
+2 -2
View File
@@ -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;
src/CRE/Glitter/effect_inst.cpp
+293 -162
View File
@@ -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;
}
src/CRE/Glitter/emitter_inst.cpp
+153 -50
View File
@@ -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;
src/CRE/Glitter/file_reader.cpp
+2 -2
View File
@@ -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;
src/CRE/Glitter/file_writer.cpp
+2 -2
View File
@@ -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;
src/CRE/Glitter/glitter.hpp
+85 -49
View File
@@ -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);
src/CRE/Glitter/particle_inst.cpp
+69 -9
View File
@@ -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)
src/CRE/Glitter/particle_manager.cpp
+55 -24
View File
@@ -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;
}
}
src/CRE/Glitter/render_group.cpp
+15 -6
View File
@@ -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;
}
src/CRE/Glitter/render_scene.cpp
+20 -14
View File
@@ -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;
src/CRE/Glitter/scene.cpp
+98 -35
View File
@@ -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;
}
src/ReDIVA/classes/data_view/glitter.cpp
+2 -2
View File
@@ -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)) {
src/ReDIVA/data_edit/glitter_editor.cpp
+11 -7
View File
@@ -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;
}
src/ReDIVA/x_pv_game.cpp
+5 -5
View File
@@ -5479,14 +5479,14 @@ void x_pv_game_stage::ctrl_inner() {
std::vector<x_pv_game_stage_effect_glitter>& 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);
}
}