constant-text-fade-duration: refactor glyph progress calculation and add duration helper methods

Author: Enorovan

src/text/typewritereffect.cpp

@@ -10,6 +10,16 @@ namespace Impacto {
 using namespace Profile::ConfigSystem;
 using namespace Profile::Dialogue;
 
+namespace {
+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);
+}
+}  // namespace
+
 void TypewriterEffect::Start(const bool voiced) {
   DurationIn = 1.0f;
   Voiced = voiced;
@@ -90,41 +100,62 @@ TypewriterEffect::ParallelBlock TypewriterEffect::GetParallelBlock(
   }
 }
 
-std::pair<float, float> TypewriterEffect::GetGlyphWritingProgresses(
-    const size_t glyph) {
-  const ParallelBlock block = GetParallelBlock(glyph);
+float TypewriterEffect::GetTypewriterDurationSeconds() const {
+  if (Voiced && Profile::ConfigSystem::SyncVoice) {
+    return std::max(Audio::Channels[Audio::AC_VOICE0]->DurationInSeconds(),
+                    0.0f);
+  }
 
-  const size_t parallelBlockGlyphNo = glyph - block.Start;
+  if (Profile::ConfigSystem::TextSpeed >=
+      Profile::ConfigSystem::TextSpeedBounds.y) {
+    return std::max(TextFadeInDuration, 0.0f);
+  }
 
-  // We start displaying a glyph after the previous one is 25% opaque, hence
-  // totalDisplayTime = glyphCount * (0.25 * glyphDisplayTime) +
-  //                    glyphDisplayTime * 0.75
+  if (Profile::ConfigSystem::TextSpeed <= 0.0f) return 0.0f;
 
-  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;
+  return static_cast<float>(GlyphCount) / Profile::ConfigSystem::TextSpeed;
+}
 
-  const float startTime = glyphPropagateDuration * parallelBlockGlyphNo;
-  const float endTime = startTime + singleGlyphDuration;
+float TypewriterEffect::GetSingleGlyphFadeDurationSeconds(
+    float totalDurationSeconds) const {
+  if (totalDurationSeconds <= 0.0f || TextFadeInDuration <= 0.0f) return 0.0f;
 
-  return {startTime / totalDuration, endTime / totalDuration};
+  return std::min(TextFadeInDuration, totalDurationSeconds);
+}
+
+std::pair<float, float> TypewriterEffect::GetWritingProgresses(
+    const size_t glyphNo, const size_t glyphCount,
+    const float totalDurationSeconds) const {
+  if (glyphCount == 0 || totalDurationSeconds <= 0.0f) return {0.0f, 1.0f};
+
+  const float glyphFadeDuration =
+      GetSingleGlyphFadeDurationSeconds(totalDurationSeconds);
+
+  float startTime = 0.0f;
+  if (glyphCount > 1 && totalDurationSeconds > glyphFadeDuration) {
+    const float glyphStartInterval =
+        (totalDurationSeconds - glyphFadeDuration) / (glyphCount - 1);
+    startTime = glyphStartInterval * glyphNo;
+  }
+
+  const float endTime =
+      std::min(startTime + glyphFadeDuration, totalDurationSeconds);
+
+  return {startTime / totalDurationSeconds, endTime / totalDurationSeconds};
+}
+
+std::pair<float, float> TypewriterEffect::GetGlyphWritingProgresses(
+    const size_t glyph) {
+  const ParallelBlock block = GetParallelBlock(glyph);
+
+  return GetWritingProgresses(glyph - block.Start, block.Size,
+                              GetTypewriterDurationSeconds());
 }
 
 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) {
@@ -142,13 +173,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,
@@ -180,27 +210,16 @@ 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 float baseDurationSeconds =
+      GetTypewriterDurationSeconds() * baseProgressLength;
+  const auto [glyphStartProgressInBase, glyphEndProgressInBase] =
+      GetWritingProgresses(rubyGlyphId, chunk.Length, baseDurationSeconds);
 
   // 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;
@@ -210,12 +229,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

src/text/typewritereffect.h

@@ -41,7 +41,12 @@ struct TypewriterEffect : public Animation {
   };
   ParallelBlock GetParallelBlock(size_t glyph);
 
+  float GetTypewriterDurationSeconds() const;
+  float GetSingleGlyphFadeDurationSeconds(float totalDurationSeconds) const;
+  // {startProgress, endProgress} in [0, 1]
+  std::pair<float, float> GetWritingProgresses(
+      size_t glyphNo, size_t glyphCount, float totalDurationSeconds) const;
   // {startProgress, endProgress}
   std::pair<float, float> GetGlyphWritingProgresses(size_t glyph);
 };
-}  // namespace Impacto
+}  // namespace Impacto