Skip to content

constant-text-fade-duration #441

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
Enorovan wants to merge 4 commits into
base: master
Choose a base branch
from
Open

constant-text-fade-duration #441

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
0830b05
constant-text-fade-duration: refactor glyph progress calculation and …
Enorovan Apr 5, 2026
5a4ac9d
fixup! constant-text-fade-duration: refactor glyph progress calculati…
Enorovan Apr 12, 2026
b64b6e7
fixup! constant-text-fade-duration: refactor glyph progress calculati…
Enorovan Apr 14, 2026
0ef220f
fixup! constant-text-fade-duration: refactor glyph progress calculati…
Enorovan Apr 14, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
84 changes: 36 additions & 48 deletions src/text/typewritereffect.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,14 @@ namespace Impacto {
using namespace Profile::ConfigSystem;
using namespace Profile::Dialogue;

static float CalcLinearProgress(float progress, float startProgress,
float endProgress) {
if (endProgress <= startProgress)
return progress >= endProgress ? 1.0f : 0.0f;
return std::clamp((progress - startProgress) / (endProgress - startProgress),
0.0f, 1.0f);
}

void TypewriterEffect::Start(const bool voiced) {
DurationIn = 1.0f;
Voiced = voiced;
Expand Down Expand Up @@ -90,41 +98,36 @@ TypewriterEffect::ParallelBlock TypewriterEffect::GetParallelBlock(
}
}

std::pair<float, float> TypewriterEffect::GetGlyphWritingProgresses(
const size_t glyph) {
const ParallelBlock block = GetParallelBlock(glyph);
std::pair<float, float> GetWritingProgresses(const size_t glyphNo,
Comment thread
Enorovan marked this conversation as resolved.
Outdated
const size_t glyphCount,
const float totalProgress) {
if (glyphCount == 0 || totalProgress <= 0.0f) return {0.0f, 1.0f};

const size_t parallelBlockGlyphNo = glyph - block.Start;
const float glyphFadeProgress = std::min(TextFadeInDuration, totalProgress);
Copy link
Copy Markdown
Member

@PringlesGang PringlesGang Apr 13, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

TextFadeInDuration is in seconds and totalProgress is an arbitrary basis? glyphFadeProgress is completely meaningless like this


// We start displaying a glyph after the previous one is 25% opaque, hence
// totalDisplayTime = glyphCount * (0.25 * glyphDisplayTime) +
// glyphDisplayTime * 0.75
float startTime = 0.0f;
if (glyphCount > 1 && totalProgress > glyphFadeProgress) {
const float glyphStartInterval =
(totalProgress - glyphFadeProgress) / (glyphCount - 1);
startTime = glyphStartInterval * glyphNo;
}

constexpr float singleGlyphDuration = 1.0f;
constexpr float glyphPropagateProgress = 0.25f;
constexpr float glyphPropagateDuration =
singleGlyphDuration * glyphPropagateProgress;
const float totalDuration =
block.Size * glyphPropagateDuration +
(1.0f - glyphPropagateProgress) * singleGlyphDuration;
const float endTime = std::min(startTime + glyphFadeProgress, totalProgress);

const float startTime = glyphPropagateDuration * parallelBlockGlyphNo;
const float endTime = startTime + singleGlyphDuration;
return {startTime / totalProgress, endTime / totalProgress};
}

return {startTime / totalDuration, endTime / totalDuration};
std::pair<float, float> TypewriterEffect::GetGlyphWritingProgresses(
const size_t glyph) {
const ParallelBlock block = GetParallelBlock(glyph);

return GetWritingProgresses(glyph - block.Start, block.Size, 1.0f);
}

float TypewriterEffect::CalcOpacity(size_t glyph) {
if (glyph < FirstGlyph) return 1.0f;
if (glyph >= FirstGlyph + GlyphCount) return 0.0f;

if (!IsCancelled &&
Profile::ConfigSystem::TextSpeed >=
Profile::ConfigSystem::TextSpeedBounds.y &&
!(Voiced && Profile::ConfigSystem::SyncVoice)) {
return Progress;
}

const auto [startProgress, endProgress] = GetGlyphWritingProgresses(glyph);

if (IsCancelled) {
Expand All @@ -142,13 +145,12 @@ float TypewriterEffect::CalcOpacity(size_t glyph) {
// Translucent glyphs fade in further, in addition to the opacity they
// already had
const float glyphProgressBeforeCancellation =
(ProgressOnCancel - startProgress) / (endProgress - startProgress);
CalcLinearProgress(ProgressOnCancel, startProgress, endProgress);
return glyphProgressBeforeCancellation +
cancelProgress * (1.0f - glyphProgressBeforeCancellation);
}

return std::clamp((Progress - startProgress) / (endProgress - startProgress),
0.0f, 1.0f);
return CalcLinearProgress(Progress, startProgress, endProgress);
}

float TypewriterEffect::CalcRubyOpacity(const size_t rubyGlyphId,
Expand Down Expand Up @@ -180,27 +182,14 @@ float TypewriterEffect::CalcRubyOpacity(const size_t rubyGlyphId,
}

const float baseProgressLength = baseEndProgress - baseStartProgress;

// We start displaying a glyph after the previous one is 25% opaque, hence
// totalDisplayTime = glyphCount * (0.25 * glyphDisplayTime) +
// glyphDisplayTime * 0.75

constexpr float singleGlyphDuration = 1.0f;
constexpr float glyphPropagateProgress = 0.25f;
constexpr float glyphPropagateDuration =
singleGlyphDuration * glyphPropagateProgress;
const float totalDuration =
chunk.Length * glyphPropagateDuration +
(1.0f - glyphPropagateProgress) * singleGlyphDuration;

const float glyphStartTime = glyphPropagateDuration * rubyGlyphId;
const float glyphEndTime = glyphStartTime + singleGlyphDuration;
const auto [glyphStartProgressInBase, glyphEndProgressInBase] =
GetWritingProgresses(rubyGlyphId, chunk.Length, baseProgressLength);

// Convert back to progress-space
const float startProgress =
baseStartProgress + (glyphStartTime / totalDuration) * baseProgressLength;
baseStartProgress + glyphStartProgressInBase * baseProgressLength;
const float endProgress =
baseStartProgress + (glyphEndTime / totalDuration) * baseProgressLength;
baseStartProgress + glyphEndProgressInBase * baseProgressLength;

if (IsCancelled) {
if (ProgressOnCancel >= endProgress) return 1.0f;
Expand All @@ -210,12 +199,11 @@ float TypewriterEffect::CalcRubyOpacity(const size_t rubyGlyphId,
if (ProgressOnCancel <= startProgress) return cancelProgress;

const float glyphProgressBeforeCancellation =
(ProgressOnCancel - startProgress) / (endProgress - startProgress);
CalcLinearProgress(ProgressOnCancel, startProgress, endProgress);
return glyphProgressBeforeCancellation +
cancelProgress * (1.0f - glyphProgressBeforeCancellation);
}

return std::clamp((Progress - startProgress) / (endProgress - startProgress),
0.0f, 1.0f);
return CalcLinearProgress(Progress, startProgress, endProgress);
}
} // namespace Impacto
} // namespace Impacto
2 changes: 1 addition & 1 deletion src/text/typewritereffect.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,4 +44,4 @@ struct TypewriterEffect : public Animation {
// {startProgress, endProgress}
std::pair<float, float> GetGlyphWritingProgresses(size_t glyph);
};
} // namespace Impacto
} // namespace Impacto
Loading