mitiru::vn

Visual-novel view helpers: message-window drawing, choice buttons, texture management, and vertical-text layout.

Name	Kind	Items
`ColorBlindMode`	enum	4
`ColorTransform`	class	4
`ColorOverrides`	struct	8
`AccessibilityConfig`	struct	12
`ScreenReaderOutput`	struct	8
`AccessibilitySceneState`	struct	10
`AccessibilityManager`	class	28
`ToastPhase`	enum	4
`Achievement`	struct	8
`AchievementToastAppearance`	struct	11
`AchievementToast`	struct	21
`AchievementSystem`	class	20
`AutoSkipBinding`	class	9
`AutoSkipMode`	enum	4
`AdvanceAction`	enum	5
`AutoSkipConfig`	struct	6
`AutoSkipController`	class	22
`BackgroundLayerType`	enum	4
`BackgroundColor`	struct	2
`KenBurnsAnimation`	struct	6
`BackgroundRenderInfo`	struct	2
`BackgroundManager`	class	16
`BacklogState`	enum	7
`BacklogEntry`	struct	7
`BacklogStyle`	struct	10
`BacklogUIConfig`	struct	4
`BacklogUI`	class	27
`CGGalleryLayout`	struct	8
`CGEntry`	struct	7
`CGViewerState`	struct	10
`CGGallery`	class	25
`SceneReplayEntry`	struct	6
`SceneReplayManager`	class	10
`ChapterStatus`	enum	4
`ChapterDef`	struct	7
`EndingDef`	struct	5
`ChapterSelectInfo`	struct	7
`ChapterManager`	class	23
`CharacterPosition`	enum	6
`ShowAnimation`	enum	3
`HideAnimation`	enum	3
`CharacterSlideDirection`	enum	4
`CharAnimType`	enum	5
`CharacterPositionConfig`	struct	8
`CharacterDefinition`	struct	3
`CharacterState`	struct	2
`CharacterAnimation`	struct	5
`CharacterRenderInfo`	struct	1
`CharacterManager`	class	28
`ChoiceState`	enum	5
`ChoiceLayout`	enum	3
`ChoiceAlignment`	enum	3
`ChoiceAnimation`	enum	6
`ChoiceButtonStyle`	struct	4
`ChoiceEntry`	struct	4
`ChoiceUIConfig`	struct	15
`ChoiceUI`	class	22
`ConfigAction`	enum	4
`VNConfig`	struct	16
`ConfigScreenLayout`	struct	13
`SliderWidget`	struct	15
`ToggleWidget`	struct	5
`ConfigScreen`	class	26
`DialogResult`	enum	4
`DialogButtons`	enum	3
`DialogState`	enum	4
`DialogParams`	struct	5
`DialogButton`	struct	3
`ConfirmDialog`	class	24
`MoodType`	enum	8
`BGMTransitionType`	enum	3
`MoodTypeHash`	struct	1
`BGMTrack`	struct	3
`BGMLayer`	struct	4
`TrackPlayState`	struct	4
`BGMState`	struct	5
`MoodDetection`	struct	2
`MoodDetector`	class	6
`DynamicBGMController`	class	22
`EasingType`	enum	65
`ExprTokenKind`	enum	27
`ExprToken`	struct	3
`ExpressionLexer`	class	1
`ExpressionEvaluator`	class	11
`FlagScope`	enum	4
`FlagManager`	class	18
`FlowNodeType`	enum	3
`FlowChartNodeStyle`	struct	3
`FlowChartAppearance`	struct	8
`ChoiceRecord`	struct	3
`FlowConnection`	struct	4
`FlowNode`	struct	6
`EndingInfo`	struct	4
`FlowChartViewState`	struct	9
`FlowChart`	class	29
`FlowChartBuilder`	class	1
`LineDiffType`	enum	4
`LineDiff`	struct	5
`LabelDiff`	struct	6
`ReloadResult`	struct	10
`ScenarioDiffTracker`	class	1
`WatchedFile`	struct	4
`ScenarioHotReloader`	class	13
`WatchEntry`	struct	2
`OverlayRenderData`	struct	8
`DeveloperOverlay`	class	13
`AnimatedCharacterParam`	struct	4
`HitTestResult`	struct	2
`LipSyncConfig`	struct	4
`EyeTrackingConfig`	struct	5
`IdleMotionConfig`	struct	5
`IAnimatedCharacter`	class	13
`IAnimatedCharacterFactory`	class	3
`NullAnimatedCharacter`	class	13
`NullAnimatedCharacterFactory`	class	2
`AnimatedCharacterManager`	class	20
`MessageWindowState`	enum	6
`MessageMode`	enum	2
`WindowAnimation`	enum	3
`WindowSkinType`	enum	6
`SolidColorSkin`	struct	2
`WindowSkin`	struct	4
`ClickWaitIndicator`	struct	5
`MessageWindowConfig`	struct	15
`NvlLine`	struct	2
`MessageWindow`	class	25
`MovieState`	enum	5
`MovieFrame`	struct	4
`MovieAudioBuffer`	struct	3
`MovieFadeConfig`	struct	3
`IMovieDecoder`	class	9
`NullMovieDecoder`	class	9
`MoviePlayer`	class	22
`NineSliceConfig`	struct	10
`NineSlice`	class	5
`AnalyticsEventType`	enum	9
`AnalyticsEvent`	struct	9
`ChoiceStatEntry`	struct	3
`SceneChoiceStats`	struct	3
`DropOffPoint`	struct	4
`RingBuffer`	class	9
`PlayerAnalytics`	class	27
`ReadTracker`	class	12
`SegmentType`	enum	5
`TextColor`	struct	5
`TextStyle`	struct	3
`RichTextSegment`	struct	7
`LayoutChar`	struct	9
`TextLayout`	struct	6
`RichTextParser`	class	1
`KinsokuRules`	class	1
`RichTextEngine`	class	15
`RubySegment`	struct	6
`PositionedRubyGlyph`	struct	5
`RubyLayoutResult`	struct	5
`RubyLayoutParams`	struct	5
`RubyTextLayout`	class	5
`SaveLoadMode`	enum	2
`SaveLoadAction`	enum	5
`ThumbnailData`	struct	6
`ThumbnailCapture`	struct	1
`SaveSlotInfo`	struct	8
`SaveDataSerializer`	struct	3
`SaveLoadGridConfig`	struct	8
`SaveLoadScreen`	class	33
`MacroDefinition`	struct	3
`MacroRegistry`	class	7
`MacroPreprocessor`	class	3
`ScenarioTokenType`	enum	8
`ScenarioCommandType`	enum	23
`ScenarioToken`	struct	4
`ScenarioChoiceEntry`	struct	2
`CharacterParams`	struct	5
`BackgroundParams`	struct	3
`AudioParams`	struct	2
`IfParams`	struct	3
`SetParams`	struct	2
`TransitionParams`	struct	2
`DialogueParams`	struct	2
`ScenarioNode`	struct	14
`ScenarioLexer`	class	1
`ScenarioParser`	class	1
`InlineTag`	struct	2
`ScenarioCallback`	struct	13
`ScenarioExecutor`	class	22
`CallStackFrame`	struct	2
`ChoiceDisplayState`	struct	3
`ScenarioSaveState`	struct	12
`ColorFilterType`	enum	3
`ShakeAxis`	enum	3
`FadeDirection`	enum	2
`EffectParticle`	struct	4
`ScreenEffectResult`	struct	13
`ScreenEffect`	class	4
`ShakeEffect`	class	4
`FlashEffect`	class	4
`FadeEffect`	class	4
`RainEffect`	class	4
`SnowEffect`	class	4
`BlurEffect`	class	4
`VignetteEffect`	class	4
`ColorFilterEffect`	class	4
`LetterboxEffect`	class	4
`ZoomEffect`	class	4
`ScreenEffectManager`	class	19
`ScriptResult`	struct	9
`IScriptingEngine`	class	8
`NullScriptingEngine`	class	10
`VNScriptBridge`	class	28
`ScrollBarStyle`	struct	4
`ScrollConfig`	struct	11
`ScrollContainer`	class	29
`TextEffect`	enum	6
`EffectParams`	struct	7
`CharTransform`	struct	5
`CharAnimState`	struct	3
`TextAnimator`	class	18
`TransitionType`	enum	14
`TransitionState`	enum	3
`WipeDirection`	enum	8
`SlideDirection`	enum	4
`RulePattern`	enum	6
`FadeColor`	struct	2
`RuleImageGenerator`	class	1
`TransitionEffect`	struct	8
`TransitionBuilder`	class	11
`TransitionManager`	class	14
`Utf8Iterator`	class	4
`GlyphInfo`	struct	9
`FontMetrics`	struct	5
`GlyphCache`	class	5
`TrueTypeFont`	class	17
`WindowBackgroundType`	enum	4
`Padding`	struct	4
`MessageWindowSkin`	struct	7
`ElementState`	struct	2
`ChoiceButtonSkin`	struct	3
`SaveSlotSkin`	struct	4
`ConfigSliderSkin`	struct	5
`ScrollBarSkin`	struct	4
`FontConfig`	struct	8
`UISkin`	struct	9
`SkinValidationResult`	struct	3
`UISkinLoader`	class	10
`NineSliceRegion`	struct	2
`VNRenderer`	class	6
`ChoiceButtonState`	enum	4
`TextureLoadResult`	struct	4
`VNTextureManager`	class	21
`VerticalTextConfig`	struct	5
`PositionedGlyph`	struct	6
`VerticalRubySpan`	struct	3
`VerticalTextLayout`	class	4

enum ColorBlindMode : std::uint8_t 4

None

Protanopia

Deuteranopia

Tritanopia

class ColorTransform 4

using Matrix3x3 = std::array<float, 9>;

[[nodiscard]] static Matrix3x3 getMatrix(ColorBlindMode mode) noexcept

[[nodiscard]] static sgc::Colorf apply(const sgc::Colorf& color, const Matrix3x3& matrix) noexcept

[[nodiscard]] static sgc::Colorf applyMode(const sgc::Colorf& color, ColorBlindMode mode) noexcept

struct ColorOverrides 8

std::optional<sgc::Colorf> textColor

std::optional<sgc::Colorf> backgroundColor

std::optional<sgc::Colorf> windowColor

std::optional<sgc::Colorf> choiceNormalColor

std::optional<sgc::Colorf> choiceHighlightColor

std::optional<sgc::Colorf> choiceTextColor

std::optional<sgc::Colorf> nameTagColor

std::optional<sgc::Colorf> nameTagTextColor

struct AccessibilityConfig 12

bool highContrast = false

bool dyslexiaFont = false

bool screenReaderText = false

float textSizeMultiplier = 1.0f

bool reducedMotion = false

ColorBlindMode colorBlindMode = ColorBlindMode::None

ColorOverrides customColors

float autoAdvanceMinDelay = 3.0f

bool voiceDescriptions = false

float letterSpacingMultiplier = 1.0f

float lineSpacingMultiplier = 1.0f

void setTextSizeMultiplier(float multiplier) noexcept

struct ScreenReaderOutput 8

std::string sceneDescription

std::string speakerName

std::string dialogueText

std::string backgroundDescription

std::vector<std::string> visibleCharacters

std::vector<std::string> choiceTexts

std::string effectDescription

[[nodiscard]] std::string toPlainText() const

struct AccessibilitySceneState 10

std::string sceneId

std::string backgroundFile

std::string speakerName

std::string dialogueText

std::vector<std::string> visibleCharacterNames

std::vector<std::string> choiceTexts

bool hasShakeEffect = false

bool hasFlashEffect = false

bool hasParticleEffect = false

std::string particleType

class AccessibilityManager 28

AccessibilityManager() = default

explicit AccessibilityManager(AccessibilityConfig config) noexcept

[[nodiscard]] const AccessibilityConfig& config() const noexcept

void setConfig(AccessibilityConfig config) noexcept

void setHighContrast(bool enabled) noexcept

void setDyslexiaFont(bool enabled) noexcept

void setTextSizeMultiplier(float multiplier) noexcept

void setReducedMotion(bool enabled) noexcept

void setColorBlindMode(ColorBlindMode mode) noexcept

void setScreenReaderText(bool enabled) noexcept

void setVoiceDescriptions(bool enabled) noexcept

[[nodiscard]] bool shouldApplyShake() const noexcept

[[nodiscard]] bool shouldApplyFlash() const noexcept

[[nodiscard]] bool shouldApplyParticles() const noexcept

[[nodiscard]] bool shouldApplyTextWave() const noexcept

[[nodiscard]] bool shouldApplyTextShake() const noexcept

[[nodiscard]] bool shouldUseInstantReveal() const noexcept

[[nodiscard]] float adjustFontSize(float baseFontSize) const noexcept

[[nodiscard]] float adjustLetterSpacing(float baseSpacing) const noexcept

[[nodiscard]] float adjustLineSpacing(float baseSpacing) const noexcept

[[nodiscard]] float choiceButtonScale() const noexcept

[[nodiscard]] float adjustAutoAdvanceDelay(float baseDelay) const noexcept

[[nodiscard]] sgc::Colorf applyColorBlindTransform(const sgc::Colorf& color) const noexcept

[[nodiscard]] sgc::Colorf adjustColor(const sgc::Colorf& color, std::string_view role = "") const noexcept

[[nodiscard]] ScreenReaderOutput getScreenReaderText( const AccessibilitySceneState& state) const

void registerBackgroundDescription(const std::string& filename, const std::string& description)

[[nodiscard]] const HighContrastPalette& highContrastPalette() const noexcept

void setHighContrastPalette(const HighContrastPalette& palette) noexcept

enum ToastPhase : std::uint8_t 4

SlideIn

Display

FadeOut

Done

struct Achievement 8

std::string id

std::string title

std::string description

std::string iconId

bool isUnlocked = false

std::string unlockDate

bool isSecret = false

std::string unlockCondition

struct AchievementToastAppearance 11

float positionX = -1.0f

float positionY = 20.0f

float width = 300.0f

float height = 60.0f

float slideInDuration = 0.4f

float displayDuration = 3.0f

float fadeOutDuration = 0.5f

float titleFontSize = 12.0f

float descFontSize = 10.0f

float iconSize = 40.0f

float padding = 10.0f

struct AchievementToast 21

std::string achievementId

std::string title

std::string description

std::string iconId

ToastPhase phase = ToastPhase::SlideIn

float elapsed = 0.0f

float slideInDuration = 0.4f

float displayDuration = 3.0f

float fadeOutDuration = 0.5f

float positionX = -1.0f

float positionY = 20.0f

float width = 300.0f

float height = 60.0f

float titleFontSize = 12.0f

float descFontSize = 10.0f

float iconSize = 40.0f

float padding = 10.0f

[[nodiscard]] bool isDone() const noexcept

[[nodiscard]] float alpha() const noexcept

[[nodiscard]] float slideOffset() const noexcept

void update(float dt) noexcept

class AchievementSystem 20

void registerAchievement(Achievement achievement)

void registerAchievements(std::vector<Achievement> achievements)

bool unlock(const std::string& id)

void evaluateAll(const FlagManager& flags)

[[nodiscard]] const std::vector<Achievement>& achievements() const noexcept

[[nodiscard]] std::optional<Achievement> getAchievement(const std::string& id) const

[[nodiscard]] std::vector<Achievement> displayList() const

[[nodiscard]] bool isUnlocked(const std::string& id) const

[[nodiscard]] std::size_t totalCount() const noexcept

[[nodiscard]] std::size_t unlockedCount() const noexcept

[[nodiscard]] float completionPercentage() const noexcept

void update(float dt)

[[nodiscard]] std::optional<AchievementToast> currentToast() const

[[nodiscard]] bool isToastQueueEmpty() const noexcept

void setOnUnlockCallback(std::function<void(const Achievement&)> callback)

[[nodiscard]] const AchievementToastAppearance& toastAppearance() const noexcept

void setToastAppearance(const AchievementToastAppearance& appearance) noexcept

void setCurrentDate(const std::string& date)

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

class AutoSkipBinding 9

AutoSkipBinding(AutoSkipController& controller, MessageWindow& window) noexcept

AdvanceAction tick(float deltaTime) noexcept

void setText(const std::string& speaker, const std::string& text, const std::string& label = {}, int lineIndex = -1)

void notifyChoiceAppeared() noexcept

void notifyChoiceDismissed() noexcept

void cancelByUserInput() noexcept

[[nodiscard]] MessageWindowState lastObservedState() const noexcept

[[nodiscard]] AutoSkipController& controller() noexcept

[[nodiscard]] MessageWindow& window() noexcept

enum AutoSkipMode : std::uint8_t 4

Idle = 0

Auto = 1

SkipRead = 2

SkipAll = 3

enum AdvanceAction : std::uint8_t 5

None = 0

Advance = 1

Skip = 2

using ReadCheckFn = std::function<bool(std::string_view label, int lineIndex)>;

using VoicePlayingFn = std::function<bool()>;

struct AutoSkipConfig 6

float autoBaseDelay = 3.0f

float autoSpeedScale = 0.5f

float textLengthFactor = 0.02f

float skipAdvanceInterval = 0.05f

bool stopAtChoices = true

bool waitForVoice = true

class AutoSkipController 22

AutoSkipController() noexcept = default

explicit AutoSkipController(AutoSkipConfig config) noexcept

[[nodiscard]] AutoSkipMode mode() const noexcept

void setMode(AutoSkipMode mode) noexcept

void toggleAuto() noexcept

void toggleSkip(bool skipAll = false) noexcept

void cancelByUserInput() noexcept

void notifyTextComplete() noexcept

void notifyNewLine(std::size_t textLength, std::string_view scriptLabel, int lineIndex) noexcept

void notifyChoiceAppeared() noexcept

void notifyChoiceDismissed() noexcept

void setReadChecker(ReadCheckFn fn)

void setVoicePlayingChecker(VoicePlayingFn fn)

void setAutoSpeed(int speed) noexcept

[[nodiscard]] int autoSpeed() const noexcept

void setSkipInterval(float interval) noexcept

[[nodiscard]] const AutoSkipConfig& config() const noexcept

void setConfig(AutoSkipConfig config) noexcept

[[nodiscard]] AdvanceAction update(float deltaTime) noexcept

[[nodiscard]] bool isActive() const noexcept

[[nodiscard]] bool isAutoMode() const noexcept

[[nodiscard]] bool isSkipMode() const noexcept

enum BackgroundLayerType 4

Far

Main

Overlay

Foreground

struct BackgroundColor 2

[[nodiscard]] static constexpr BackgroundColor black() noexcept

[[nodiscard]] static constexpr BackgroundColor white() noexcept

struct KenBurnsAnimation 6

CameraKeyframe from

CameraKeyframe to

void update(float dt) noexcept

[[nodiscard]] float getProgress() const noexcept

[[nodiscard]] CameraKeyframe getCurrent() const noexcept

[[nodiscard]] bool isComplete() const noexcept

struct BackgroundRenderInfo 2

std::vector<LayerInfo> layers

BackgroundColor fallbackColor

class BackgroundManager 16

void setBackground(std::uint32_t textureId) noexcept

void transitionTo(std::uint32_t textureId, TransitionEffect effect)

void clearBackground() noexcept

void setFallbackColor(BackgroundColor color) noexcept

void addLayer(BackgroundLayer layer)

void removeLayer(int zOrder) noexcept

void clearLayers() noexcept

[[nodiscard]] std::size_t layerCount() const noexcept

void startKenBurns(KenBurnsAnimation animation) noexcept

void stopKenBurns() noexcept

[[nodiscard]] bool isKenBurnsActive() const noexcept

void setCamera(float x, float y, float zoom = 1.0f) noexcept

void scrollParallax(float dx, float dy) noexcept

void update(float dt) noexcept

[[nodiscard]] BackgroundRenderInfo getRenderInfo() const noexcept

[[nodiscard]] std::string toJson() const

enum BacklogState : std::uint8_t 7

Hidden

ScrollingIn

Active

ScrollingOut

using VoiceReplayCallback = std::function<void(const std::string& voiceId)>;

using JumpToCallback = std::function<void(std::size_t entryIndex)>;

`using BacklogTextRenderer = std::function< void(render::SpriteBatch& batch, const std::string& text, const sgc::Rectf& area, const sgc::Colorf& color, float fontSize)>;`

struct BacklogEntry 7

std::string speaker

std::string text

std::string voiceId

float timestamp = 0.0f

bool isChoice = false

std::string choiceText

bool isRead = true

struct BacklogStyle 10

float speakerFontSize = 16.0f

float textFontSize = 18.0f

float entryPadding = 12.0f

float entrySpacing = 4.0f

float speakerHeight = 24.0f

float textLineHeight = 22.0f

float voiceButtonSize = 20.0f

float unreadDotSize = 6.0f

float marginLeft = 60.0f

float marginRight = 30.0f

struct BacklogUIConfig 4

std::size_t maxEntries = 500

float animDurationSec = 0.3f

BacklogStyle style

ScrollConfig scrollConfig

class BacklogUI 27

explicit BacklogUI(BacklogUIConfig config = {})

[[nodiscard]] BacklogState state() const noexcept

[[nodiscard]] bool isVisible() const noexcept

[[nodiscard]] std::size_t entryCount() const noexcept

[[nodiscard]] const std::vector<BacklogEntry>& entries() const noexcept

[[nodiscard]] const BacklogEntry* entryAt(std::size_t index) const noexcept

[[nodiscard]] const BacklogUIConfig& config() const noexcept

[[nodiscard]] const ScrollContainer& scrollContainer() const noexcept

void setConfig(BacklogUIConfig config)

void onVoiceReplay(VoiceReplayCallback cb)

void onJumpTo(JumpToCallback cb)

void setTextRenderer(BacklogTextRenderer cb)

void addEntry(BacklogEntry entry)

void clearEntries()

void markAllRead()

void show()

void hide()

void toggle()

void onMouseWheel(float delta)

void onKeyScroll(float deltaPixels)

void onMouseMove(float screenX, float screenY)

void onMouseClick(float screenX, float screenY)

void onDragBegin(float x, float y)

void onDragMove(float x, float y)

void onDragEnd(float velX = 0.0f, float velY = 0.0f)

void update(float dt)

void draw(render::SpriteBatch& batch) const

struct CGGalleryLayout 8

int columnsPerRow = 4

int rowsPerPage = 3

float thumbnailWidth = 160.0f

float thumbnailHeight = 100.0f

float thumbnailSpacing = 12.0f

float categoryTabHeight = 32.0f

float lockIconSize = 32.0f

[[nodiscard]] int itemsPerPage() const noexcept

struct CGEntry 7

std::string id

std::string textureId

std::string unlockCondition

bool isUnlocked = false

std::string category

std::string thumbnailId

std::vector<std::string> variants

struct CGViewerState 10

std::string currentCgId

std::uint32_t variantIndex = 0

float zoomLevel = 1.0f

float panX = 0.0f

float panY = 0.0f

bool isOpen = false

void open(const std::string& cgId) noexcept

void close() noexcept

void applyZoom(float delta) noexcept

void applyPan(float dx, float dy) noexcept

class CGGallery 25

void addEntry(CGEntry entry)

void addEntries(std::vector<CGEntry> entries)

bool markSeen(const std::string& id)

[[nodiscard]] bool isUnlocked(const std::string& id) const

[[nodiscard]] const std::vector<CGEntry>& entries() const noexcept

[[nodiscard]] std::optional<CGEntry> getEntry(const std::string& id) const

[[nodiscard]] std::vector<std::string> categories() const

[[nodiscard]] std::vector<const CGEntry*> entriesByCategory(const std::string& category) const

[[nodiscard]] std::size_t totalCount() const noexcept

[[nodiscard]] std::size_t unlockedCount() const noexcept

[[nodiscard]] float completionPercentage() const noexcept

[[nodiscard]] float completionPercentage(const std::string& category) const

[[nodiscard]] CGViewerState& viewer() noexcept

[[nodiscard]] const CGViewerState& viewer() const noexcept

void setLayout(CGGalleryLayout layout) noexcept

[[nodiscard]] CGGalleryLayout& layout() noexcept

[[nodiscard]] const CGGalleryLayout& layout() const noexcept

[[nodiscard]] std::vector<const CGEntry*> entriesForPage(std::size_t page) const

[[nodiscard]] std::size_t pageCount() const noexcept

bool openViewer(const std::string& id)

bool nextVariant()

bool prevVariant()

[[nodiscard]] std::string currentViewerTexture() const

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

struct SceneReplayEntry 6

std::string id

std::string title

std::string chapterName

std::string scriptPosition

std::string unlockCondition

bool isUnlocked = false

class SceneReplayManager 10

void addEntry(SceneReplayEntry entry)

bool markSeen(const std::string& id)

[[nodiscard]] bool isUnlocked(const std::string& id) const

[[nodiscard]] std::string getScriptPosition(const std::string& id) const

[[nodiscard]] const std::vector<SceneReplayEntry>& entries() const noexcept

[[nodiscard]] std::vector<const SceneReplayEntry*> entriesByChapter(const std::string& chapter) const

[[nodiscard]] std::size_t unlockedCount() const noexcept

[[nodiscard]] float completionPercentage() const noexcept

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

enum ChapterStatus 4

Locked

Unlocked

InProgress

Completed

struct ChapterDef 7

std::string id

std::string title

std::string description

std::string arcId

int sortOrder = 0

std::string unlockCondition

bool unlockedByDefault = false

struct EndingDef 5

std::string id

std::string title

std::string description

std::string chapterId

bool isTrue = false

struct ChapterSelectInfo 7

std::string id

std::string title

std::string description

ChapterStatus status = ChapterStatus::Locked

float readPercentage = 0.0f

std::vector<std::string> seenEndingIds

int totalEndings = 0

class ChapterManager 23

using ConditionEvaluator = std::function<bool(const std::string& expression)>;

void defineChapter(ChapterDef def)

void defineEnding(EndingDef def)

bool startChapter(const std::string& chapterId)

void completeChapter(const std::string& chapterId)

[[nodiscard]] const std::string& currentChapterId() const noexcept

[[nodiscard]] ChapterStatus getStatus(const std::string& chapterId) const

[[nodiscard]] bool isUnlocked(const std::string& chapterId) const

[[nodiscard]] bool isCompleted(const std::string& chapterId) const

void refreshUnlockStatus(const ConditionEvaluator& evaluator)

void unlock(const std::string& chapterId)

void markEndingSeen(const std::string& endingId)

[[nodiscard]] bool isEndingSeen(const std::string& endingId) const

[[nodiscard]] std::size_t seenEndingCount() const noexcept

[[nodiscard]] std::size_t totalEndingCount() const noexcept

[[nodiscard]] float endingCompletionRate() const

[[nodiscard]] std::pair<std::size_t, std::size_t> chapterEndingProgress(const std::string& chapterId) const

[[nodiscard]] std::vector<ChapterSelectInfo> getChapterSelectList() const

[[nodiscard]] std::optional<ChapterDef> getChapter(const std::string& chapterId) const

[[nodiscard]] std::size_t chapterCount() const noexcept

[[nodiscard]] std::size_t completedChapterCount() const

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

enum CharacterPosition 6

Left

CenterLeft

Center

CenterRight

Right

Custom

enum ShowAnimation 3

Instant

FadeIn

SlideIn

enum HideAnimation 3

Instant

FadeOut

SlideOut

enum CharacterSlideDirection 4

Left

Right

Up

Down

enum CharAnimType 5

Show

Hide

Move

ExpressionChange

Shake

struct CharacterPositionConfig 8

float leftX = 0.15f

float centerLeftX = 0.30f

float centerX = 0.50f

float centerRightX = 0.70f

float rightX = 0.85f

float defaultY = 0.8f

float slideOffscreenLeft = -0.3f

float slideOffscreenRight = 1.3f

struct CharacterDefinition 3

std::string id

std::string name

std::unordered_map<std::string, std::uint32_t> expressions

struct CharacterState 2

std::string id

std::string expression

struct CharacterAnimation 5

std::string characterId

CharAnimType type

std::string newExpression

[[nodiscard]] float getProgress() const noexcept

[[nodiscard]] bool isComplete() const noexcept

struct CharacterRenderInfo 1

std::string id

class CharacterManager 28

void registerCharacter(CharacterDefinition definition)

void unregisterCharacter(const std::string& id)

[[nodiscard]] bool isRegistered(const std::string& id) const noexcept

void setPositionConfig(const CharacterPositionConfig& config) noexcept

[[nodiscard]] const CharacterPositionConfig& positionConfig() const noexcept

void show(const std::string& id, const std::string& expression, CharacterPosition position = CharacterPosition::Center, ShowAnimation animation = ShowAnimation::FadeIn, float duration = 0.3f, CharacterSlideDirection slideDir = CharacterSlideDirection::Left)

void showAt(const std::string& id, const std::string& expression, float x, float y, ShowAnimation animation = ShowAnimation::FadeIn, float duration = 0.3f)

void hide(const std::string& id, HideAnimation animation = HideAnimation::FadeOut, float duration = 0.3f, CharacterSlideDirection slideDir = CharacterSlideDirection::Left)

void hideAll(HideAnimation animation = HideAnimation::FadeOut, float duration = 0.3f)

void changeExpression(const std::string& id, const std::string& expression, float crossDissolveDuration = 0.0f)

void moveTo(const std::string& id, CharacterPosition position, float duration = 0.5f, EasingType easing = EasingType::EaseInOutCubic)

void moveToPosition(const std::string& id, float x, float y, float duration = 0.5f, EasingType easing = EasingType::EaseInOutCubic)

void dimInactive(const std::string& activeSpeakerId, float dimBrightness = 0.6f) noexcept

void clearDimming() noexcept

void bringToFront(const std::string& id) noexcept

void sendToBack(const std::string& id) noexcept

void setFlipped(const std::string& id, bool flipped) noexcept

void setScale(const std::string& id, float scale) noexcept

void shake(const std::string& id, float duration = 0.3f, float intensity = 5.0f, float frequency = 30.0f)

void update(float dt)

[[nodiscard]] std::vector<CharacterRenderInfo> getRenderList() const

[[nodiscard]] bool isVisible(const std::string& id) const noexcept

[[nodiscard]] const CharacterState* getState(const std::string& id) const noexcept

[[nodiscard]] std::size_t visibleCount() const noexcept

[[nodiscard]] bool isAnimating() const noexcept

[[nodiscard]] bool isAnimating(const std::string& id) const noexcept

[[nodiscard]] std::size_t registeredCount() const noexcept

[[nodiscard]] std::string toJson() const

enum ChoiceState : std::uint8_t 5

Hidden

Appearing

Active

Selected

Disappearing

enum ChoiceLayout : std::uint8_t 3

Vertical

Horizontal

Grid

enum ChoiceAlignment : std::uint8_t 3

Left

Center

Right

enum ChoiceAnimation : std::uint8_t 6

None

FadeIn

SlideIn

using ChoiceSelectedCallback = std::function<void(std::size_t index)>;

using ChoiceTimeoutCallback = std::function<void(std::size_t defaultIndex)>;

`using ChoiceTextRenderer = std::function< void(render::SpriteBatch& batch, const std::string& text, const sgc::Rectf& area, const sgc::Colorf& color, float fontSize)>;`

struct ChoiceButtonStyle 4

float borderWidth = 1.0f

float fontSize = 20.0f

float paddingH = 16.0f

float paddingV = 10.0f

struct ChoiceEntry 4

std::string text

bool enabled = true

std::function<bool()> condition

[[nodiscard]] bool isEnabled() const

struct ChoiceUIConfig 15

ChoiceLayout layout = ChoiceLayout::Vertical

ChoiceAlignment alignment = ChoiceAlignment::Center

float buttonWidth = 600.0f

float buttonHeight = 48.0f

float spacing = 8.0f

int gridColumns = 2

ChoiceAnimation entryAnimation = ChoiceAnimation::FadeIn

float animDurationSec = 0.3f

float perItemDelaySec = 0.08f

float exitDurationSec = 0.2f

bool timedChoice = false

float timeoutSec = 10.0f

std::size_t defaultChoice = 0

float timerBarHeight = 4.0f

ChoiceButtonStyle buttonStyle

class ChoiceUI 22

explicit ChoiceUI(ChoiceUIConfig config = {})

[[nodiscard]] ChoiceState state() const noexcept

[[nodiscard]] bool isActive() const noexcept

[[nodiscard]] int selectedIndex() const noexcept

[[nodiscard]] int focusedIndex() const noexcept

[[nodiscard]] float remainingTime() const noexcept

[[nodiscard]] const ChoiceUIConfig& config() const noexcept

[[nodiscard]] const std::vector<ChoiceEntry>& choices() const noexcept

void setConfig(ChoiceUIConfig config)

void setChoices(std::vector<ChoiceEntry> choices)

void onSelected(ChoiceSelectedCallback cb)

void onTimeout(ChoiceTimeoutCallback cb)

void setTextRenderer(ChoiceTextRenderer cb)

void show()

void dismiss()

void focusUp()

void focusDown()

void confirm()

void onMouseMove(float screenX, float screenY)

void onMouseClick(float screenX, float screenY)

void update(float dt)

void draw(render::SpriteBatch& batch) const

enum ConfigAction : std::uint8_t 4

None = 0

Apply = 1

Cancel = 2

Reset = 3

struct VNConfig 16

float textSpeed = 0.5f

float autoSpeed = 0.5f

float bgmVolume = 0.8f

float seVolume = 0.8f

float voiceVolume = 1.0f

float masterVolume = 1.0f

float windowAlpha = 0.8f

bool fullscreen = false

bool skipUnread = false

int textSize = 24

std::string language = "ja"

[[nodiscard]] float textCharsPerSecond() const noexcept

[[nodiscard]] float autoDelayScale() const noexcept

[[nodiscard]] static VNConfig defaults() noexcept

[[nodiscard]] std::string toJson() const

[[nodiscard]] static VNConfig fromJson(std::string_view json)

struct ConfigScreenLayout 13

float startY = 80.0f

float itemSpacing = 50.0f

float labelX = 50.0f

float sliderX = 250.0f

float sliderWidth = 300.0f

float sliderHeight = 8.0f

float handleWidth = 8.0f

float handleHeight = 16.0f

float buttonSpacing = 20.0f

float buttonWidth = 120.0f

float buttonHeight = 36.0f

float fontSize = 16.0f

float valueFontSize = 14.0f

struct SliderWidget 15

std::string label

float minValue = 0.0f

float maxValue = 1.0f

float current = 0.5f

float step = 0.05f

bool dragging = false

bool focused = false

[[nodiscard]] float normalized() const noexcept

void setFromNormalized(float norm) noexcept

void increment() noexcept

void decrement() noexcept

void beginDrag() noexcept

void endDrag() noexcept

void dragTo(float normalizedPos) noexcept

[[nodiscard]] std::string displayText() const

struct ToggleWidget 5

std::string label

bool value = false

bool focused = false

void toggle() noexcept

[[nodiscard]] std::string displayText() const

class ConfigScreen 26

ConfigScreen() noexcept = default

explicit ConfigScreen(const ui::UITheme& theme) noexcept

void open(const VNConfig& config)

void close() noexcept

[[nodiscard]] bool isVisible() const noexcept

void onFocusUp() noexcept

void onFocusDown() noexcept

void onLeft() noexcept

void onRight() noexcept

[[nodiscard]] ConfigAction onConfirm() noexcept

void onSliderDrag(int sliderIndex, float normalizedPos)

[[nodiscard]] ConfigAction applyAction() noexcept

[[nodiscard]] ConfigAction cancelAction() noexcept

[[nodiscard]] ConfigAction resetAction()

[[nodiscard]] ConfigAction update([[maybe_unused]] float deltaTime) noexcept

void setAudioMixer(audio::AudioMixer* mixer) noexcept

[[nodiscard]] const VNConfig& editingConfig() const noexcept

[[nodiscard]] const VNConfig& originalConfig() const noexcept

[[nodiscard]] const std::vector<SliderWidget>& sliders() const noexcept

[[nodiscard]] const std::vector<ToggleWidget>& toggles() const noexcept

[[nodiscard]] int focusIndex() const noexcept

[[nodiscard]] const ui::UITheme& theme() const noexcept

void setTheme(const ui::UITheme& theme) noexcept

[[nodiscard]] const ConfigScreenLayout& layout() const noexcept

void setLayout(const ConfigScreenLayout& layout) noexcept

[[nodiscard]] bool isDirty() const noexcept

enum DialogResult : std::uint8_t 4

None = 0

Ok = 1

Cancel = 2

Third = 3

enum DialogButtons : std::uint8_t 3

OkCancel = 0

YesNo = 1

YesNoCancel = 2

enum DialogState : std::uint8_t 4

Hidden = 0

FadingIn = 1

Visible = 2

FadingOut = 3

struct DialogParams 5

std::string title

std::string message

DialogButtons buttons = DialogButtons::OkCancel

float fadeInDuration = 0.15f

float fadeOutDuration = 0.1f

struct DialogButton 3

std::string label

DialogResult result

bool focused = false

class ConfirmDialog 24

ConfirmDialog() noexcept = default

explicit ConfirmDialog(const ui::UITheme& theme) noexcept

void show(DialogParams params)

void dismiss(DialogResult result) noexcept

void hide() noexcept

void onConfirmPressed() noexcept

void onCancelPressed() noexcept

void onFocusLeft() noexcept

void onFocusRight() noexcept

void onButtonClicked(int index) noexcept

void update(float deltaTime) noexcept

void setOnResult(std::function<void(DialogResult)> fn)

void setTheme(const ui::UITheme& theme) noexcept

[[nodiscard]] const ui::UITheme& theme() const noexcept

[[nodiscard]] DialogState state() const noexcept

[[nodiscard]] bool isVisible() const noexcept

[[nodiscard]] bool isModal() const noexcept

[[nodiscard]] DialogResult result() const noexcept

[[nodiscard]] float animProgress() const noexcept

[[nodiscard]] float displayScale() const noexcept

[[nodiscard]] float displayAlpha() const noexcept

[[nodiscard]] const DialogParams& params() const noexcept

[[nodiscard]] const std::vector<DialogButton>& buttons() const noexcept

[[nodiscard]] int focusIndex() const noexcept

enum MoodType : std::uint8_t 8

Calm

Happy

Sad

Tense

Romantic

Mysterious

Action

Comedy

enum BGMTransitionType : std::uint8_t 3

Crossfade

DuckAndSwap

LayerBlend

struct MoodTypeHash 1

std::size_t operator()(MoodType m) const noexcept

struct BGMTrack 3

MoodType mood = MoodType::Calm

std::string audioId

float baseVolume = 1.0f

struct BGMLayer 4

MoodType mood = MoodType::Calm

std::string audioId

float volumeCurve = 1.0f

float maxVolume = 1.0f

struct TrackPlayState 4

std::string audioId

float volume = 0.0f

float targetVolume = 0.0f

bool active = false

struct BGMState 5

MoodType currentMood = MoodType::Calm

MoodType previousMood = MoodType::Calm

float transitionProgress = 1.0f

std::vector<TrackPlayState> tracks

bool transitioning = false

struct MoodDetection 2

MoodType mood = MoodType::Calm

float confidence = 0.0f

class MoodDetector 6

MoodDetector()

void addKeyword(const std::string& keyword, MoodType mood, float weight = 1.0f)

void removeKeyword(const std::string& keyword)

[[nodiscard]] MoodDetection detect(std::string_view text) const

void clearKeywords()

void resetToDefaults()

class DynamicBGMController 22

using PlayCallback = std::function<void(const std::string& audioId, float volume, float fadeDuration)>;

using StopCallback = std::function<void(const std::string& audioId, float fadeDuration)>;

using VolumeCallback = std::function<void(const std::string& audioId, float volume)>;

DynamicBGMController() = default

void registerTrack(MoodType mood, const std::string& audioId, float baseVolume = 1.0f)

void registerLayer(MoodType mood, const std::string& audioId, float volumeCurve = 1.0f, float maxVolume = 1.0f)

void clearRegistrations()

void setPlayCallback(PlayCallback cb)

void setStopCallback(StopCallback cb)

void setVolumeCallback(VolumeCallback cb)

void setMood(MoodType mood, float transitionDuration = 1.0f, BGMTransitionType transitionType = BGMTransitionType::Crossfade)

[[nodiscard]] MoodType currentMood() const noexcept

[[nodiscard]] bool isTransitioning() const noexcept

[[nodiscard]] float transitionProgress() const noexcept

[[nodiscard]] MoodDetection detectAndSetMood( std::string_view dialogueText, float transitionDuration = 2.0f, float minConfidence = 0.5f)

[[nodiscard]] MoodDetector& moodDetector() noexcept

[[nodiscard]] const MoodDetector& moodDetector() const noexcept

bool parseMoodCommand(std::string_view commandArgs)

void update(float deltaTime)

[[nodiscard]] BGMState currentState() const

void setMasterVolume(float volume) noexcept

[[nodiscard]] float masterVolume() const noexcept

enum EasingType 65

Linear

EaseInQuad

EaseOutQuad

EaseInOutQuad

EaseInCubic

EaseOutCubic

EaseInOutCubic

EaseInQuart

EaseOutQuart

EaseInOutQuart

EaseInQuint

EaseOutQuint

EaseInOutQuint

EaseInSine

EaseOutSine

EaseInOutSine

EaseInExpo

EaseOutExpo

EaseInOutExpo

EaseInCirc

EaseOutCirc

EaseInOutCirc

EaseInElastic

EaseOutElastic

EaseInOutElastic

EaseInBack

EaseOutBack

EaseInOutBack

EaseInBounce

EaseOutBounce

EaseInOutBounce

[[nodiscard]] constexpr float linear(float t) noexcept

[[nodiscard]] constexpr float easeInQuad(float t) noexcept

[[nodiscard]] constexpr float easeOutQuad(float t) noexcept

[[nodiscard]] constexpr float easeInOutQuad(float t) noexcept

[[nodiscard]] constexpr float easeInCubic(float t) noexcept

[[nodiscard]] constexpr float easeOutCubic(float t) noexcept

[[nodiscard]] constexpr float easeInOutCubic(float t) noexcept

[[nodiscard]] constexpr float easeInQuart(float t) noexcept

[[nodiscard]] constexpr float easeOutQuart(float t) noexcept

[[nodiscard]] constexpr float easeInOutQuart(float t) noexcept

[[nodiscard]] constexpr float easeInQuint(float t) noexcept

[[nodiscard]] constexpr float easeOutQuint(float t) noexcept

[[nodiscard]] constexpr float easeInOutQuint(float t) noexcept

[[nodiscard]] inline float easeInSine(float t) noexcept

[[nodiscard]] inline float easeOutSine(float t) noexcept

[[nodiscard]] inline float easeInOutSine(float t) noexcept

[[nodiscard]] inline float easeInExpo(float t) noexcept

[[nodiscard]] inline float easeOutExpo(float t) noexcept

[[nodiscard]] inline float easeInOutExpo(float t) noexcept

[[nodiscard]] inline float easeInCirc(float t) noexcept

[[nodiscard]] inline float easeOutCirc(float t) noexcept

[[nodiscard]] inline float easeInOutCirc(float t) noexcept

[[nodiscard]] inline float easeInElastic(float t) noexcept

[[nodiscard]] inline float easeOutElastic(float t) noexcept

[[nodiscard]] inline float easeInOutElastic(float t) noexcept

[[nodiscard]] constexpr float easeInBack(float t) noexcept

[[nodiscard]] constexpr float easeOutBack(float t) noexcept

[[nodiscard]] constexpr float easeInOutBack(float t) noexcept

[[nodiscard]] constexpr float easeOutBounce(float t) noexcept

[[nodiscard]] constexpr float easeInBounce(float t) noexcept

[[nodiscard]] constexpr float easeInOutBounce(float t) noexcept

[[nodiscard]] inline float cubicBezier(float x1, float y1, float x2, float y2, float t) noexcept

[[nodiscard]] inline float spring(float damping, float frequency, float t) noexcept

[[nodiscard]] inline float apply(EasingType type, float t) noexcept

enum ExprTokenKind 27

IntLiteral

FloatLiteral

StringLiteral

BoolLiteral

Variable

Identifier

Plus

Minus

Star

Slash

Percent

EqEq

NotEq

Less

LessEq

Greater

GreaterEq

And

Or

Not

LParen

RParen

Comma

Eof

using ExpressionResult = std::variant<bool, int, float, std::string>;

[[nodiscard]] inline ExpressionResult evaluateExpression( std::string_view expression, const FlagManager& flags)

[[nodiscard]] inline bool evaluateCondition( std::string_view expression, const FlagManager& flags)

struct ExprToken 3

ExprTokenKind kind = ExprTokenKind::Eof

std::string text

double numValue = 0.0

class ExpressionLexer 1

[[nodiscard]] static std::vector<ExprToken> tokenize(std::string_view source)

class ExpressionEvaluator 11

[[nodiscard]] ExpressionResult evaluate(std::string_view expression, const FlagManager& flags) const

[[nodiscard]] bool evaluateBool(std::string_view expression, const FlagManager& flags) const

[[nodiscard]] int evaluateInt(std::string_view expression, const FlagManager& flags) const

[[nodiscard]] float evaluateFloat(std::string_view expression, const FlagManager& flags) const

[[nodiscard]] std::string evaluateString(std::string_view expression, const FlagManager& flags) const

[[nodiscard]] static bool resultToBool(const ExpressionResult& val)

[[nodiscard]] static int resultToInt(const ExpressionResult& val)

[[nodiscard]] static float resultToFloat(const ExpressionResult& val)

[[nodiscard]] static std::string resultToString(const ExpressionResult& val)

[[nodiscard]] static FlagValue resultToFlagValue(const ExpressionResult& val)

[[nodiscard]] static ExpressionResult flagValueToResult(const FlagValue& val)

enum FlagScope 4

Global

Chapter

using FlagValue = std::variant<bool, int, float, std::string>;

using FlagChangeCallback = std::function<void(const std::string& key, const FlagValue& oldValue, const FlagValue& newValue)>;

class FlagManager 18

void set(const std::string& key, FlagValue value, FlagScope scope = FlagScope::Global)

[[nodiscard]] std::optional<FlagValue> get(const std::string& key) const

[[nodiscard]] bool getBool(const std::string& key, bool defaultValue = false) const

[[nodiscard]] int getInt(const std::string& key, int defaultValue = 0) const

[[nodiscard]] float getFloat(const std::string& key, float defaultValue = 0.0f) const

[[nodiscard]] std::string getString(const std::string& key, const std::string& defaultValue = "") const

[[nodiscard]] bool has(const std::string& key) const noexcept

void remove(const std::string& key)

void setMultiple(const std::vector<std::pair<std::string, FlagValue>>& flags, FlagScope scope = FlagScope::Global)

[[nodiscard]] std::unordered_map<std::string, FlagValue> getAll() const

void clear(std::optional<FlagScope> scope = std::nullopt)

void clearChapterFlags()

[[nodiscard]] std::size_t size() const noexcept

[[nodiscard]] bool evaluate(std::string_view expression) const

std::size_t onChange(FlagChangeCallback callback)

void removeCallback(std::size_t id)

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

enum FlowNodeType : std::uint8_t 3

Scene

Choice

Ending

struct FlowChartNodeStyle 3

float width = 120.0f

float height = 40.0f

float cornerRadius = 4.0f

struct FlowChartAppearance 8

FlowChartNodeStyle sceneNode

FlowChartNodeStyle choiceNode

FlowChartNodeStyle endingNode

float connectionLineWidth = 2.0f

float autoLayoutPaddingX = 160.0f

float autoLayoutPaddingY = 80.0f

float hitTestMargin = 4.0f

[[nodiscard]] const FlowChartNodeStyle& styleFor(FlowNodeType type) const noexcept

struct ChoiceRecord 3

std::string label

std::string targetNodeId

std::uint32_t timesChosen = 0

struct FlowConnection 4

std::string fromNodeId

std::string toNodeId

std::string label

bool isTaken = false

struct FlowNode 6

std::string id

std::string title

FlowNodeType type = FlowNodeType::Scene

bool isVisited = false

bool isCurrent = false

std::vector<ChoiceRecord> choices

struct EndingInfo 4

std::string nodeId

std::string title

std::string description

bool isAchieved = false

struct FlowChartViewState 9

float zoom = 1.0f

float panX = 0.0f

float panY = 0.0f

float minZoom = 0.3f

float maxZoom = 3.0f

void applyZoom(float delta) noexcept

void applyPan(float dx, float dy) noexcept

[[nodiscard]] sgc::Vec2f worldToScreen(const sgc::Vec2f& worldPos) const noexcept

[[nodiscard]] sgc::Vec2f screenToWorld(const sgc::Vec2f& screenPos) const noexcept

class FlowChart 29

void addNode(FlowNode node)

[[nodiscard]] std::optional<FlowNode> getNode(const std::string& id) const

[[nodiscard]] const std::vector<FlowNode>& nodes() const noexcept

[[nodiscard]] const std::vector<FlowConnection>& connections() const noexcept

void addConnection(const std::string& fromId, const std::string& toId, const std::string& label = "")

[[nodiscard]] std::vector<const FlowConnection*> connectionsFrom(const std::string& nodeId) const

[[nodiscard]] std::vector<const FlowConnection*> connectionsTo(const std::string& nodeId) const

void markVisited(const std::string& id)

void setCurrentNode(const std::string& id)

void markConnectionTaken(const std::string& fromId, const std::string& toId)

void recordChoice(const std::string& choiceNodeId, std::size_t optionIndex)

[[nodiscard]] const std::string& currentNodeId() const noexcept

void addEnding(EndingInfo ending)

void markEndingAchieved(const std::string& nodeId)

[[nodiscard]] const std::vector<EndingInfo>& endings() const noexcept

[[nodiscard]] std::size_t achievedEndingCount() const noexcept

[[nodiscard]] float endingCompletionPercentage() const noexcept

[[nodiscard]] std::size_t visitedCount() const noexcept

[[nodiscard]] float routeCompletionPercentage() const noexcept

[[nodiscard]] std::size_t takenConnectionCount() const noexcept

[[nodiscard]] FlowChartViewState& viewState() noexcept

[[nodiscard]] const FlowChartViewState& viewState() const noexcept

void setAppearance(FlowChartAppearance appearance) noexcept

[[nodiscard]] FlowChartAppearance& appearance() noexcept

[[nodiscard]] const FlowChartAppearance& appearance() const noexcept

void autoLayout(float width, float height)

[[nodiscard]] std::string hitTest(const sgc::Vec2f& pos) const

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

class FlowChartBuilder 1

[[nodiscard]] FlowChart build(std::string_view script) const

enum LineDiffType : std::uint8_t 4

Unchanged

Added

Removed

Modified

struct LineDiff 5

LineDiffType type = LineDiffType::Unchanged

int oldLineNumber = -1

int newLineNumber = -1

std::string oldText

std::string newText

struct LabelDiff 6

std::string labelName

bool isNew = false

bool isRemoved = false

bool isMoved = false

int oldLine = -1

int newLine = -1

struct ReloadResult 10

bool success = false

std::string filePath

std::vector<std::string> errors

std::vector<std::string> warnings

std::vector<LineDiff> changedLines

std::vector<LabelDiff> labelChanges

std::string suggestedLabel

int suggestedLine = 0

int totalLinesOld = 0

int totalLinesNew = 0

class ScenarioDiffTracker 1

[[nodiscard]] static ReloadResult computeDiff( const std::vector<std::string>& oldScript, const std::vector<std::string>& newScript, const std::string& currentLabel, int currentLine)

struct WatchedFile 4

std::string path

std::int64_t lastModifiedTime = 0

std::vector<std::string> lastLines

bool valid = false

class ScenarioHotReloader 13

using ReloadCallback = std::function<void(const ReloadResult&)>;

using ErrorCallback = std::function<void(const std::string& path, const std::string& error)>;

explicit ScenarioHotReloader(int checkIntervalMs = 500) noexcept

bool watchFile(const std::string& path)

void unwatchFile(const std::string& path)

void unwatchAll()

void setOnReloaded(ReloadCallback callback)

void setOnError(ErrorCallback callback)

void setCurrentPosition(const std::string& label, int line) noexcept

void update()

[[nodiscard]] std::size_t watchedFileCount() const noexcept

void setCheckInterval(int intervalMs) noexcept

[[nodiscard]] ReloadResult forceReload(const std::string& path)

struct WatchEntry 2

std::string name

std::string value

struct OverlayRenderData 8

bool visible = false

float opacity = 0.7f

std::string currentLabel

int currentLine = 0

float fps = 0.0f

float frameTimeMs = 0.0f

std::vector<WatchEntry> watches

std::string lastReloadStatus

class DeveloperOverlay 13

DeveloperOverlay() noexcept = default

void toggle() noexcept

void setVisible(bool visible) noexcept

[[nodiscard]] bool isVisible() const noexcept

void setOpacity(float opacity) noexcept

void updateScriptPosition(const std::string& label, int line)

void updateFrameTiming(float deltaTime) noexcept

void setWatch(const std::string& name, const std::string& value)

void removeWatch(const std::string& name)

void clearWatches()

void setReloadStatus(const std::string& status)

[[nodiscard]] OverlayRenderData getRenderData() const

[[nodiscard]] std::string toText() const

struct AnimatedCharacterParam 4

std::string name

float minValue = 0.0f

float maxValue = 1.0f

float defaultValue = 0.0f

struct HitTestResult 2

bool hit = false

std::string areaName

struct LipSyncConfig 4

bool enabled = false

std::string parameterName = "ParamMouthOpenY"

float sensitivity = 1.0f

float smoothing = 0.1f

struct EyeTrackingConfig 5

bool enabled = true

std::string paramXName = "ParamEyeBallX"

std::string paramYName = "ParamEyeBallY"

float maxAngle = 30.0f

float speed = 5.0f

struct IdleMotionConfig 5

bool enabled = true

std::string breathingParam = "ParamBreath"

float breathingSpeed = 0.5f

float breathingAmplitude = 0.5f

std::string idleMotionName = "idle"

class IAnimatedCharacter 13

virtual ~IAnimatedCharacter() = default

[[nodiscard]] virtual bool loadModel(const std::string& path) = 0

virtual void setExpression(const std::string& name) = 0

virtual void setMotion(const std::string& name, bool loop = false) = 0

virtual void setParameter(const std::string& name, float value) = 0

[[nodiscard]] virtual std::optional<float> getParameter(const std::string& name) const = 0

[[nodiscard]] virtual std::vector<AnimatedCharacterParam> parameters() const = 0

virtual void update(float dt) = 0

[[nodiscard]] virtual render::Texture render(float x, float y, float scale) = 0

[[nodiscard]] virtual HitTestResult hitTest(float x, float y) const = 0

[[nodiscard]] virtual bool isLoaded() const = 0

[[nodiscard]] virtual std::vector<std::string> availableExpressions() const = 0

[[nodiscard]] virtual std::vector<std::string> availableMotions() const = 0

class IAnimatedCharacterFactory 3

virtual ~IAnimatedCharacterFactory() = default

[[nodiscard]] virtual std::unique_ptr<IAnimatedCharacter> create( const std::string& modelPath) = 0

[[nodiscard]] virtual bool canLoad(const std::string& modelPath) const = 0

class NullAnimatedCharacter : public IAnimatedCharacter 13

explicit NullAnimatedCharacter(int width = 256, int height = 512, std::uint8_t r = 180, std::uint8_t g = 160, std::uint8_t b = 200) noexcept

[[nodiscard]] bool loadModel([[maybe_unused]] const std::string& path) override

void setExpression(const std::string& name) override

void setMotion(const std::string& name, bool loop) override

void setParameter(const std::string& name, float value) override

[[nodiscard]] std::optional<float> getParameter(const std::string& name) const override

[[nodiscard]] std::vector<AnimatedCharacterParam> parameters() const override

void update([[maybe_unused]] float dt) override

[[nodiscard]] render::Texture render( [[maybe_unused]] float x, [[maybe_unused]] float y, [[maybe_unused]] float scale) override

[[nodiscard]] HitTestResult hitTest(float x, float y) const override

[[nodiscard]] bool isLoaded() const override

[[nodiscard]] std::vector<std::string> availableExpressions() const override

[[nodiscard]] std::vector<std::string> availableMotions() const override

class NullAnimatedCharacterFactory : public IAnimatedCharacterFactory 2

[[nodiscard]] std::unique_ptr<IAnimatedCharacter> create( [[maybe_unused]] const std::string& modelPath) override

[[nodiscard]] bool canLoad( [[maybe_unused]] const std::string& modelPath) const override

class AnimatedCharacterManager 20

using LipSyncAmplitudeCallback = std::function<float()>;

explicit AnimatedCharacterManager( std::unique_ptr<IAnimatedCharacterFactory> factory = nullptr)

void registerModel(const std::string& characterId, const std::string& modelPath)

void registerFallbackSprite(const std::string& characterId, const std::string& expression, std::uint32_t textureId)

bool show(const std::string& characterId, CharacterPosition position = CharacterPosition::Center)

void hide(const std::string& characterId)

void hideAll()

void setExpression(const std::string& characterId, const std::string& expression)

void setMotion(const std::string& characterId, const std::string& motion, bool loop = false)

void setParameter(const std::string& characterId, const std::string& paramName, float value)

void setEyeTrackingConfig(const EyeTrackingConfig& config) noexcept

void setLipSyncConfig(const LipSyncConfig& config) noexcept

void setIdleMotionConfig(const IdleMotionConfig& config) noexcept

void setLipSyncCallback(LipSyncAmplitudeCallback callback)

void update(float dt, float mouseX = 0.5f, float mouseY = 0.5f)

[[nodiscard]] render::Texture renderCharacter(const std::string& characterId) const

[[nodiscard]] HitTestResult hitTest(const std::string& characterId, float x, float y) const

[[nodiscard]] bool isAnimated(const std::string& characterId) const

[[nodiscard]] std::vector<std::string> visibleCharacters() const

[[nodiscard]] std::size_t size() const noexcept

enum MessageWindowState : std::uint8_t 6

Hidden

Appearing

Idle

Displaying

WaitingClick

Disappearing

enum MessageMode : std::uint8_t 2

ADV

NVL

enum WindowAnimation : std::uint8_t 3

None

Fade

SlideUp

enum WindowSkinType : std::uint8_t 6

SolidColor

Image9Slice

Custom

`using CustomSkinRenderer = std::function< void(render::SpriteBatch& batch, const sgc::Rectf& rect, float alpha)>;`

`using TextRenderCallback = std::function< void(render::SpriteBatch& batch, const std::string& text, std::size_t visibleChars, const sgc::Rectf& area, const sgc::Colorf& color, float fontSize)>;`

`using NameRenderCallback = std::function< void(render::SpriteBatch& batch, const std::string& name, const sgc::Rectf& area, const sgc::Colorf& color, float fontSize)>;`

struct SolidColorSkin 2

float borderWidth = 2.0f

float cornerRadius = 0.0f

struct WindowSkin 4

WindowSkinType type = WindowSkinType::SolidColor

SolidColorSkin solidColor

NineSliceConfig nineSlice

CustomSkinRenderer customRenderer

struct ClickWaitIndicator 5

bool enabled = true

float size = 12.0f

float offsetX = -20.0f

float offsetY = -20.0f

float blinkSpeed = 3.0f

struct MessageWindowConfig 15

float paddingLeft = 24.0f

float paddingRight = 24.0f

float paddingTop = 20.0f

float paddingBottom = 20.0f

bool showNamePlate = true

float nameFontSize = 18.0f

float fontSize = 22.0f

float charsPerSecond = 30.0f

MessageMode mode = MessageMode::ADV

float nvlMaxLines = 20

WindowSkin skin

WindowAnimation showAnimation = WindowAnimation::Fade

WindowAnimation hideAnimation = WindowAnimation::Fade

float animationDurationSec = 0.25f

ClickWaitIndicator clickWait

struct NvlLine 2

std::string speaker

std::string text

class MessageWindow 25

explicit MessageWindow(MessageWindowConfig config = {})

[[nodiscard]] MessageWindowState state() const noexcept

[[nodiscard]] MessageMode mode() const noexcept

[[nodiscard]] float alpha() const noexcept

[[nodiscard]] bool isTextComplete() const noexcept

[[nodiscard]] bool isVisible() const noexcept

[[nodiscard]] const std::string& speaker() const noexcept

[[nodiscard]] const std::string& text() const noexcept

[[nodiscard]] std::size_t visibleChars() const noexcept

[[nodiscard]] const MessageWindowConfig& config() const noexcept

[[nodiscard]] const sgc::Rectf& activeBounds() const noexcept

void setConfig(MessageWindowConfig config)

void setMode(MessageMode mode) noexcept

void setTextRenderer(TextRenderCallback cb)

void setNameRenderer(NameRenderCallback cb)

void show()

void hide()

void setText(const std::string& speaker, const std::string& text)

void revealAll() noexcept

void advance()

void clearNvl()

[[nodiscard]] bool scrollHistoryUp()

[[nodiscard]] bool scrollHistoryDown()

void update(float dt)

void draw(render::SpriteBatch& batch) const

enum MovieState : std::uint8_t 5

Idle

Loading

Playing

Paused

Finished

struct MovieFrame 4

int width = 0

int height = 0

std::vector<std::uint8_t> pixels

double timestamp = 0.0

struct MovieAudioBuffer 3

std::vector<float> samples

int sampleRate = 44100

int channels = 2

struct MovieFadeConfig 3

float fadeInDuration = 0.5f

float fadeOutDuration = 0.5f

bool enabled = true

class IMovieDecoder 9

virtual ~IMovieDecoder() = default

[[nodiscard]] virtual bool open(const std::string& path) = 0

[[nodiscard]] virtual std::optional<MovieFrame> readFrame() = 0

virtual void seek(double seconds) = 0

[[nodiscard]] virtual double duration() const = 0

[[nodiscard]] virtual double currentTime() const = 0

[[nodiscard]] virtual bool isFinished() const = 0

[[nodiscard]] virtual std::optional<MovieAudioBuffer> audioSamples() = 0

virtual void close() = 0

class NullMovieDecoder : public IMovieDecoder 9

explicit NullMovieDecoder(double fakeDuration = 5.0, int frameWidth = 320, int frameHeight = 240, double fps = 30.0) noexcept

[[nodiscard]] bool open([[maybe_unused]] const std::string& path) override

[[nodiscard]] std::optional<MovieFrame> readFrame() override

void seek(double seconds) override

[[nodiscard]] double duration() const override

[[nodiscard]] double currentTime() const override

[[nodiscard]] bool isFinished() const override

[[nodiscard]] std::optional<MovieAudioBuffer> audioSamples() override

void close() override

class MoviePlayer 22

using FrameReadyCallback = std::function<void(const render::Texture&)>;

using FinishedCallback = std::function<void()>;

explicit MoviePlayer(std::unique_ptr<IMovieDecoder> decoder = nullptr)

void setDecoder(std::unique_ptr<IMovieDecoder> decoder)

void setFadeConfig(const MovieFadeConfig& config) noexcept

[[nodiscard]] const MovieFadeConfig& fadeConfig() const noexcept

bool play(const std::string& path)

void pause()

void resume()

void stop()

void seek(double seconds)

void skip()

void update(float dt)

[[nodiscard]] MovieState state() const noexcept

[[nodiscard]] const render::Texture& currentFrame() const noexcept

[[nodiscard]] float fadeAlpha() const noexcept

[[nodiscard]] const std::string& currentPath() const noexcept

[[nodiscard]] double duration() const

[[nodiscard]] double currentTime() const noexcept

[[nodiscard]] bool isFinished() const noexcept

void onFrameReady(FrameReadyCallback callback)

void onFinished(FinishedCallback callback)

struct NineSliceConfig 10

std::uint32_t textureId = 0

float cornerW = 16.0f

float cornerH = 16.0f

float edgeInsetLeft = 16.0f

float edgeInsetRight = 16.0f

float edgeInsetTop = 16.0f

float edgeInsetBottom = 16.0f

float textureW = 64.0f

float textureH = 64.0f

[[nodiscard]] static NineSliceConfig uniform( std::uint32_t texId, float corner, float texW, float texH) noexcept

class NineSlice 5

explicit NineSlice(NineSliceConfig config) noexcept

[[nodiscard]] const NineSliceConfig& config() const noexcept

void setConfig(NineSliceConfig config) noexcept

void draw(render::SpriteBatch& batch, const sgc::Rectf& dest, const sgc::Colorf& tint) const

[[nodiscard]] sgc::Rectf minimumSize() const noexcept

enum AnalyticsEventType : std::uint8_t 9

Choice

LineRead

SceneEnter

SceneExit

RouteComplete

SkipUsed

AutoUsed

SessionStart

SessionEnd

struct AnalyticsEvent 9

AnalyticsEventType type = AnalyticsEventType::LineRead

std::int64_t timestampMs = 0

std::string sceneId

std::string routeId

std::string endingId

int choiceIndex = -1

int totalChoices = 0

int lineIndex = -1

int readTimeMs = 0

struct ChoiceStatEntry 3

int choiceIndex = 0

int selectionCount = 0

float percentage = 0.0f

struct SceneChoiceStats 3

std::string sceneId

int totalSelections = 0

std::vector<ChoiceStatEntry> entries

struct DropOffPoint 4

std::string sceneId

int exitCount = 0

int enterCount = 0

float exitRate = 0.0f

class RingBuffer 9

explicit RingBuffer(std::size_t capacity = 10000)

void push(const T& item)

void push(T&& item)

[[nodiscard]] std::size_t size() const noexcept

[[nodiscard]] std::size_t capacity() const noexcept

[[nodiscard]] bool empty() const noexcept

[[nodiscard]] const T& at(std::size_t index) const

[[nodiscard]] std::vector<T> toVector() const

void clear() noexcept

class PlayerAnalytics 27

explicit PlayerAnalytics(std::size_t maxEvents = 10000)

void recordChoice(const std::string& sceneId, int choiceIndex, int totalChoices)

void recordLineRead(const std::string& sceneId, int lineIndex, int readTimeMs)

void recordSceneEnter(const std::string& sceneId)

void recordSceneExit(const std::string& sceneId)

void recordRouteComplete(const std::string& routeId, const std::string& endingId)

void recordSkipUsed()

void recordAutoUsed()

void recordSessionStart()

void recordSessionEnd()

[[nodiscard]] SceneChoiceStats getChoiceStats(const std::string& sceneId) const

[[nodiscard]] std::map<std::string, SceneChoiceStats> getAllChoiceStats() const

[[nodiscard]] float getAverageReadTimeMs() const noexcept

[[nodiscard]] float getAverageReadSpeed(float avgCharsPerLine = 30.0f) const noexcept

[[nodiscard]] std::vector<DropOffPoint> getDropOffPoints(std::size_t maxResults = 10) const

[[nodiscard]] std::map<std::string, int> getRouteCompletionCounts() const

[[nodiscard]] std::map<std::string, float> getRouteCompletionRates() const

[[nodiscard]] int skipCount() const noexcept

[[nodiscard]] int autoCount() const noexcept

[[nodiscard]] std::int64_t totalPlayTimeMs() const noexcept

[[nodiscard]] std::int64_t lastSessionDurationMs() const noexcept

[[nodiscard]] int totalSessions() const noexcept

[[nodiscard]] std::int64_t totalLinesRead() const noexcept

[[nodiscard]] std::vector<ChoiceStatEntry> getMostPopularChoices(std::size_t maxResults = 10) const

[[nodiscard]] const RingBuffer<AnalyticsEvent>& events() const noexcept

[[nodiscard]] std::string toJson() const

void reset()

class ReadTracker 12

void markAsRead(const std::string& sceneId, std::size_t lineIndex)

[[nodiscard]] bool isRead(const std::string& sceneId, std::size_t lineIndex) const noexcept

void registerSceneLineCount(const std::string& sceneId, std::size_t lineCount)

[[nodiscard]] float getReadPercentage(const std::string& sceneId) const

[[nodiscard]] float getTotalReadPercentage() const

[[nodiscard]] std::size_t getReadCount(const std::string& sceneId) const

[[nodiscard]] std::size_t getTotalReadCount() const noexcept

[[nodiscard]] std::size_t sceneCount() const noexcept

void clear()

void reset()

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

enum SegmentType : std::uint8_t 5

Text

Ruby

Wait

Speed

[[nodiscard]] static bool isLineEndProhibited(std::uint32_t cp) noexcept

struct TextColor 5

std::uint8_t r = 255

std::uint8_t g = 255

std::uint8_t b = 255

std::uint8_t a = 255

[[nodiscard]] bool operator==(const TextColor& other) const noexcept

struct TextStyle 3

float fontSize = 24.0f

bool bold = false

bool italic = false

struct RichTextSegment 7

SegmentType type = SegmentType::Text

std::string text

TextStyle style

TextEffect effect = TextEffect::None

std::string rubyText

float waitMs = 0.0f

float speed = 0.0f

struct LayoutChar 9

std::uint32_t codepoint = 0

float x = 0.0f

float y = 0.0f

float advanceX = 0.0f

TextStyle style

TextEffect effect = TextEffect::None

bool isRuby = false

std::size_t segmentIndex = 0

std::size_t charIndex = 0

struct TextLayout 6

std::vector<LayoutChar> chars

float totalWidth = 0.0f

float totalHeight = 0.0f

std::size_t lineCount = 0

float cursorX = 0.0f

float cursorY = 0.0f

class RichTextParser 1

[[nodiscard]] static std::vector<RichTextSegment> parse( std::string_view input, const TextStyle& defaultStyle = {})

class KinsokuRules 1

[[nodiscard]] static bool isLineStartProhibited(std::uint32_t cp) noexcept

class RichTextEngine 15

RichTextEngine() = default

void setDefaultStyle(const TextStyle& style) noexcept

void setText(std::string_view input)

void setSegments(std::vector<RichTextSegment> segments)

void layout(TrueTypeFont& font, float maxWidth = 0.0f)

void update(float dt) noexcept

[[nodiscard]] const TextLayout& layoutResult() const noexcept

[[nodiscard]] std::vector<CharTransform> getTransforms() const

[[nodiscard]] std::size_t revealedCount() const noexcept

[[nodiscard]] bool isComplete() const noexcept

void skipToEnd() noexcept

[[nodiscard]] TextAnimator& animator() noexcept

[[nodiscard]] const TextAnimator& animator() const noexcept

[[nodiscard]] const std::vector<RichTextSegment>& segments() const noexcept

void cursorPosition(float& outX, float& outY) const noexcept

struct RubySegment 6

std::string baseText

std::string rubyText

float baseWidth = 0.0f

float rubyWidth = 0.0f

float baseStartX = 0.0f

float rubyStartX = 0.0f

struct PositionedRubyGlyph 5

std::uint32_t codepoint = 0

float x = 0.0f

float y = 0.0f

float advanceX = 0.0f

bool isRuby = false

struct RubyLayoutResult 5

std::vector<PositionedRubyGlyph> glyphs

float totalWidth = 0.0f

float baselineY = 0.0f

float rubyBaselineY = 0.0f

float totalHeight = 0.0f

struct RubyLayoutParams 5

float baseFontSize = 24.0f

float rubyFontSize = 12.0f

float rubyGap = 1.0f

float rubyOverhangMax = 0.5f

bool distributeRuby = true

class RubyTextLayout 5

RubyTextLayout() = default

static void measureSegment( TrueTypeFont& font, RubySegment& segment, const RubyLayoutParams& params)

[[nodiscard]] RubyLayoutResult calculate( TrueTypeFont& font, const std::vector<RubySegment>& segments, const RubyLayoutParams& params, float startX, float startY) const

[[nodiscard]] float measureWidth( TrueTypeFont& font, const std::vector<RubySegment>& segments, const RubyLayoutParams& params) const

[[nodiscard]] float measureHeight( TrueTypeFont& font, const RubyLayoutParams& params) const noexcept

enum SaveLoadMode : std::uint8_t 2

Save = 0

Load = 1

enum SaveLoadAction : std::uint8_t 5

None = 0

Saved = 1

Loaded = 2

Deleted = 3

Closed = 4

struct ThumbnailData 6

std::vector<std::uint8_t> pixels

int width = 0

int height = 0

[[nodiscard]] bool isValid() const noexcept

[[nodiscard]] std::string toBase64() const

[[nodiscard]] static ThumbnailData fromBase64(std::string_view encoded, int w, int h)

struct ThumbnailCapture 1

[[nodiscard]] static ThumbnailData capture( const std::uint8_t* srcPixels, int srcWidth, int srcHeight, int dstWidth = DEFAULT_WIDTH, int dstHeight = DEFAULT_HEIGHT)

struct SaveSlotInfo 8

int slotNumber = 0

std::string title

std::string dateTime

float playTime = 0.0f

std::string chapterName

ThumbnailData thumbnail

bool isEmpty = true

[[nodiscard]] std::string playTimeFormatted() const

struct SaveDataSerializer 3

[[nodiscard]] static std::string serialize( std::string_view scriptLabel, int lineIndex, std::string_view chapterName, float playTime, const std::vector<std::pair<std::string, std::string>>& flags, std::string_view bgmId, std::string_view backgroundId, const ThumbnailData& thumbnail, int readProgress)

[[nodiscard]] static SaveSlotInfo deserializeSlotInfo( std::string_view json, int slotNumber)

[[nodiscard]] static int parseVersion(std::string_view json)

struct SaveLoadGridConfig 8

int slotsPerRow = 4

int rowsPerPage = 5

int totalSlots = 100

int quickSaveSlot = 0

int thumbnailWidth = 160

int thumbnailHeight = 90

float slotSpacing = 8.0f

[[nodiscard]] int slotsPerPage() const noexcept

class SaveLoadScreen 33

SaveLoadScreen() noexcept = default

explicit SaveLoadScreen(const ui::UITheme& theme) noexcept

void setGridConfig(const SaveLoadGridConfig& config) noexcept

[[nodiscard]] const SaveLoadGridConfig& gridConfig() const noexcept

void open(SaveLoadMode mode)

void close() noexcept

[[nodiscard]] bool isVisible() const noexcept

[[nodiscard]] SaveLoadMode mode() const noexcept

void setSaveBridge(bridge::SaveBridge* bridge) noexcept

void refreshSlots()

[[nodiscard]] int currentPage() const noexcept

[[nodiscard]] int totalPages() const noexcept

void nextPage() noexcept

void prevPage() noexcept

[[nodiscard]] std::vector<const SaveSlotInfo*> currentPageSlots() const

void selectSlot(int slotNumber) noexcept

[[nodiscard]] int selectedSlot() const noexcept

void executeAction()

void deleteSelectedSlot()

void quickSave()

[[nodiscard]] bool quickLoad()

void setOnSaveRequested(std::function<void(int)> fn)

void setOnLoadRequested(std::function<void(int)> fn)

void setOnDeleteCompleted(std::function<void(int)> fn)

[[nodiscard]] SaveLoadAction update(float deltaTime)

[[nodiscard]] ConfirmDialog& confirmDialog() noexcept

[[nodiscard]] const ConfirmDialog& confirmDialog() const noexcept

[[nodiscard]] bool isDialogActive() const noexcept

[[nodiscard]] const std::vector<SaveSlotInfo>& slots() const noexcept

[[nodiscard]] const ui::UITheme& theme() const noexcept

void setTheme(const ui::UITheme& theme) noexcept

[[nodiscard]] inline std::vector<ScenarioNode> parseScenarioWithMacros(std::string_view source)

[[nodiscard]] inline std::vector<ScenarioNode> parseScenarioWithMacros( std::string_view source, MacroRegistry& registry)

struct MacroDefinition 3

std::string name

std::vector<std::string> params

std::vector<ScenarioToken> body

class MacroRegistry 7

void registerMacro(MacroDefinition definition)

[[nodiscard]] const MacroDefinition* find(const std::string& name) const

[[nodiscard]] bool has(const std::string& name) const

void remove(const std::string& name)

void clear()

[[nodiscard]] std::size_t size() const noexcept

[[nodiscard]] std::vector<std::string> names() const

class MacroPreprocessor 3

[[nodiscard]] static std::vector<ScenarioToken> process( const std::vector<ScenarioToken>& tokens, MacroRegistry& registry, std::size_t maxDepth = 32)

[[nodiscard]] static std::vector<ScenarioToken> extractMacros( const std::vector<ScenarioToken>& tokens, MacroRegistry& registry)

[[nodiscard]] static std::vector<ScenarioToken> expandMacros( const std::vector<ScenarioToken>& tokens, const MacroRegistry& registry, std::size_t maxDepth = 32)

enum ScenarioTokenType 8

Command

String

Number

Identifier

Arrow

Newline

ScriptBody

Eof

enum ScenarioCommandType 23

Scene

Background

Bgm

Se

Voice

Character

Dialogue

Choice

Label

Jump

Set

If

Else

EndIf

Wait

Transition

Script

using ConditionEvaluator = std::function<bool(const std::string& expression)>;

using ScriptExecutor = std::function<void(const std::string& code)>;

[[nodiscard]] inline std::pair<std::string, std::vector<InlineTag>> parseInlineTags(std::string_view text)

[[nodiscard]] inline std::vector<ScenarioNode> parseScenario(std::string_view source)

[[nodiscard]] inline std::pair<std::string, std::vector<InlineTag>> parseInlineTags(std::string_view text)

inline void ScenarioExecutor::applySetToFlagManager(const std::string& variable, const std::string& value)

struct ScenarioToken 4

ScenarioTokenType type = ScenarioTokenType::Eof

std::string text

double numValue = 0.0

std::size_t line = 0

struct ScenarioChoiceEntry 2

std::string text

std::string label

struct CharacterParams 5

std::string name

std::string position

std::string expression

bool show = true

std::string transition

struct BackgroundParams 3

std::string file

std::string transition

float duration = 0.0f

struct AudioParams 2

std::string file

std::string type

struct IfParams 3

std::string condition

std::vector<std::size_t> thenCommands

std::vector<std::size_t> elseCommands

struct SetParams 2

std::string variable

std::string value

struct TransitionParams 2

std::string type

float duration = 0.0f

struct DialogueParams 2

std::string speaker

std::string text

struct ScenarioNode 14

ScenarioCommandType type

std::size_t sourceLine = 0

std::string sceneName

BackgroundParams background

AudioParams audio

CharacterParams character

DialogueParams dialogue

std::vector<ScenarioChoiceEntry> choices

std::string labelName

SetParams setParams

IfParams ifParams

float waitDuration = 0.0f

TransitionParams transition

std::string scriptBody

class ScenarioLexer 1

[[nodiscard]] static std::vector<ScenarioToken> tokenize(std::string_view source)

class ScenarioParser 1

[[nodiscard]] static std::vector<ScenarioNode> parse(const std::vector<ScenarioToken>& tokens)

struct InlineTag 2

std::string name

std::string value

struct ScenarioCallback 13

virtual ~ScenarioCallback() = default

virtual void onScene(const std::string& )

virtual void onDialogue(const std::string& , const std::string& )

virtual void onDialogueParsed(const std::string& , const std::string& , const std::vector<InlineTag>& )

virtual void onBackground(const BackgroundParams& )

virtual void onCharacter(const CharacterParams& )

virtual int onChoice(const std::vector<ScenarioChoiceEntry>& )

virtual void onAudio(const AudioParams& )

virtual void onTransition(const TransitionParams& )

virtual void onWait(float )

virtual void onSetVariable(const std::string& , const std::string& )

virtual void onLabel(const std::string& )

virtual void onJump(const std::string& )

class ScenarioExecutor 22

void load(std::vector<ScenarioNode> nodes)

void loadFromSource(std::string_view source)

void setCallback(ScenarioCallback* callback) noexcept

void setConditionEvaluator(ConditionEvaluator evaluator)

void setScriptExecutor(ScriptExecutor executor)

void setFlagManager(FlagManager* manager) noexcept

std::optional<ScenarioCommandType> step()

void selectChoice(std::size_t index)

bool jumpToLabel(const std::string& label)

[[nodiscard]] bool isFinished() const noexcept

[[nodiscard]] bool isWaitingForChoice() const noexcept

[[nodiscard]] std::size_t pc() const noexcept

[[nodiscard]] std::size_t commandCount() const noexcept

[[nodiscard]] const std::string& currentScene() const noexcept

[[nodiscard]] std::size_t dialogueLineCount() const

[[nodiscard]] int currentDialogueIndex() const noexcept

[[nodiscard]] const std::vector<ScenarioNode>& nodes() const noexcept

[[nodiscard]] const std::vector<ScenarioChoiceEntry>& pendingChoices() const noexcept

void reset()

[[nodiscard]] inline ScenarioSaveState captureState(const ScenarioExecutor& executor)

inline void restoreState(ScenarioExecutor& executor, const ScenarioSaveState& state)

[[nodiscard]] inline bool saveStatesEqual(const ScenarioSaveState& a, const ScenarioSaveState& b)

struct CallStackFrame 2

std::size_t returnAddress = 0

std::string macroName

struct ChoiceDisplayState 3

bool active = false

std::vector<ScenarioChoiceEntry> choices

int selectedIndex = -1

struct ScenarioSaveState 12

std::size_t programCounter = 0

std::vector<CallStackFrame> callStack

std::unordered_map<std::string, std::string> localVariables

float waitTimer = 0.0f

ChoiceDisplayState choiceState

std::string currentSpeaker

std::string currentText

std::size_t textRevealProgress = 0

std::string currentScene

int dialogueIndex = -1

[[nodiscard]] std::string toJson() const

bool fromJson(std::string_view json)

enum ColorFilterType : std::uint8_t 3

None

Sepia

Grayscale

enum ShakeAxis : std::uint8_t 3

Both

Horizontal

Vertical

enum FadeDirection : std::uint8_t 2

In

Out

struct EffectParticle 4

float x = 0.0f

float y = 0.0f

float width = 1.0f

float height = 4.0f

struct ScreenEffectResult 13

float offsetX = 0.0f

float offsetY = 0.0f

float overlayAlpha = 0.0f

ColorFilterType colorFilter = ColorFilterType::None

float filterIntensity = 0.0f

float vignetteIntensity = 0.0f

float vignetteRadius = 0.5f

float letterboxRatio = 0.0f

float zoomFactor = 1.0f

float zoomCenterX = 0.5f

float zoomCenterY = 0.5f

float blurIntensity = 0.0f

std::vector<EffectParticle> particles

class ScreenEffect 4

virtual ~ScreenEffect() = default

virtual void update(float dt) = 0

[[nodiscard]] virtual bool isComplete() const noexcept = 0

virtual void apply(ScreenEffectResult& result, float screenW, float screenH) const = 0

class ShakeEffect : public ScreenEffect 4

ShakeEffect(float intensity, float duration, float frequency = 30.0f, bool decaying = true, ShakeAxis axis = ShakeAxis::Both) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class FlashEffect : public ScreenEffect 4

FlashEffect(const sgc::Colorf& color = {1.0f, 1.0f, 1.0f, 1.0f}, float duration = 0.3f) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class FadeEffect : public ScreenEffect 4

FadeEffect(FadeDirection direction, const sgc::Colorf& color = {0.0f, 0.0f, 0.0f, 1.0f}, float duration = 1.0f) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class RainEffect : public ScreenEffect 4

RainEffect(std::uint32_t density = 200, float speed = 800.0f, float angle = -10.0f, bool splashOnBottom = true, float duration = 0.0f) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float screenW, float screenH) const override

class SnowEffect : public ScreenEffect 4

SnowEffect(std::uint32_t density = 150, float speed = 60.0f, float wind = 20.0f, float sizeVariation = 0.5f, float duration = 0.0f) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float screenW, float screenH) const override

class BlurEffect : public ScreenEffect 4

BlurEffect(float intensity = 0.5f, float duration = 0.5f, bool fadeIn = true) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class VignetteEffect : public ScreenEffect 4

VignetteEffect(float intensity = 0.7f, float radius = 0.6f, float duration = 0.0f, float fadeInTime = 0.3f) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class ColorFilterEffect : public ScreenEffect 4

ColorFilterEffect(ColorFilterType filter, float intensity = 1.0f, float duration = 0.0f, float fadeInTime = 0.5f) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class LetterboxEffect : public ScreenEffect 4

LetterboxEffect(float barRatio = 0.1f, float duration = 0.5f, bool opening = true) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class ZoomEffect : public ScreenEffect 4

ZoomEffect(float targetZoom = 1.5f, float centerX = 0.5f, float centerY = 0.5f, float duration = 1.0f, float startZoom = 1.0f) noexcept

void update(float dt) override

[[nodiscard]] bool isComplete() const noexcept override

void apply(ScreenEffectResult& result, float , float ) const override

class ScreenEffectManager 19

void update(float dt)

[[nodiscard]] ScreenEffectResult composite(float screenW, float screenH) const

[[nodiscard]] std::size_t activeCount() const noexcept

void clear() noexcept

void addEffect(std::unique_ptr<ScreenEffect> effect)

void shake(float intensity = 10.0f, float duration = 0.4f, float frequency = 30.0f, bool decaying = true, ShakeAxis axis = ShakeAxis::Both)

void flash(const sgc::Colorf& color = {1.0f, 1.0f, 1.0f, 1.0f}, float duration = 0.3f)

void fade(FadeDirection direction, const sgc::Colorf& color = {0.0f, 0.0f, 0.0f, 1.0f}, float duration = 1.0f)

void rain(std::uint32_t density = 200, float speed = 800.0f, float angle = -10.0f, bool splashOnBottom = true, float duration = 0.0f)

void snow(std::uint32_t density = 150, float speed = 60.0f, float wind = 20.0f, float sizeVariation = 0.5f, float duration = 0.0f)

void blur(float intensity = 0.5f, float duration = 0.5f, bool fadeIn = true)

void vignette(float intensity = 0.7f, float radius = 0.6f, float duration = 0.0f, float fadeInTime = 0.3f)

void sepia(float intensity = 1.0f, float duration = 0.0f)

void grayscale(float intensity = 1.0f, float duration = 0.0f)

void showLetterbox(float barRatio = 0.1f, float duration = 0.5f)

void hideLetterbox(float barRatio = 0.1f, float duration = 0.5f)

void zoom(float targetZoom = 1.5f, float centerX = 0.5f, float centerY = 0.5f, float duration = 1.0f)

using ScriptValue = std::variant<bool, int, float, std::string, std::nullptr_t>;

using NativeFunction = std::function<ScriptResult(const std::vector<ScriptValue>& args)>;

struct ScriptResult 9

bool success = false

ScriptValue value = nullptr

std::string error

[[nodiscard]] static ScriptResult ok(ScriptValue val = nullptr)

[[nodiscard]] static ScriptResult fail(const std::string& msg)

[[nodiscard]] bool asBool(bool defaultValue = false) const

[[nodiscard]] int asInt(int defaultValue = 0) const

[[nodiscard]] float asFloat(float defaultValue = 0.0f) const

[[nodiscard]] std::string asString(const std::string& defaultValue = "") const

class IScriptingEngine 8

virtual ~IScriptingEngine() = default

[[nodiscard]] virtual ScriptResult execute(const std::string& code) = 0

[[nodiscard]] virtual bool evaluateCondition(const std::string& expression) = 0

[[nodiscard]] virtual ScriptResult callFunction(const std::string& name, const std::vector<ScriptValue>& args) = 0

virtual void registerNativeFunction(const std::string& name, NativeFunction callback) = 0

virtual void setGlobal(const std::string& name, ScriptValue value) = 0

[[nodiscard]] virtual std::optional<ScriptValue> getGlobal(const std::string& name) const = 0

virtual void reset() = 0

class NullScriptingEngine : public IScriptingEngine 10

[[nodiscard]] ScriptResult execute(const std::string& code) override

[[nodiscard]] bool evaluateCondition(const std::string& expression) override

[[nodiscard]] ScriptResult callFunction(const std::string& name, const std::vector<ScriptValue>& args) override

void registerNativeFunction(const std::string& name, NativeFunction callback) override

void setGlobal(const std::string& name, ScriptValue value) override

[[nodiscard]] std::optional<ScriptValue> getGlobal(const std::string& name) const override

void reset() override

[[nodiscard]] const std::vector<std::string>& executionLog() const noexcept

void clearLog() noexcept

[[nodiscard]] std::vector<std::string> registeredFunctions() const

class VNScriptBridge 28

using ShowCharacterCallback = std::function<void(const std::string& name, const std::string& pos)>;

using HideCharacterCallback = std::function<void(const std::string& name)>;

using SetExpressionCallback = std::function<void(const std::string& name, const std::string& expr)>;

using PlayBgmCallback = std::function<void(const std::string& file)>;

using PlaySeCallback = std::function<void(const std::string& file)>;

using StopBgmCallback = std::function<void()>;

using ShowTextCallback = std::function<void(const std::string& speaker, const std::string& text)>;

using ChangeBackgroundCallback = std::function<void(const std::string& file)>;

explicit VNScriptBridge(std::unique_ptr<IScriptingEngine> engine, FlagManager& flags)

[[nodiscard]] IScriptingEngine* engine() const noexcept

[[nodiscard]] FlagManager& flags() noexcept

void registerVNFunctions()

void onShowCharacter(ShowCharacterCallback cb)

void onHideCharacter(HideCharacterCallback cb)

void onSetExpression(SetExpressionCallback cb)

void onPlayBgm(PlayBgmCallback cb)

void onPlaySe(PlaySeCallback cb)

void onStopBgm(StopBgmCallback cb)

void onShowText(ShowTextCallback cb)

void onChangeBackground(ChangeBackgroundCallback cb)

[[nodiscard]] ScriptResult executeBlock(const std::string& code)

[[nodiscard]] bool evaluateCondition(const std::string& expression)

[[nodiscard]] ScriptResult callFunction(const std::string& name, const std::vector<ScriptValue>& args = {})

void syncFlagsToEngine()

void syncFlagsFromEngine()

void addSyncKey(const std::string& key)

void setSyncKeys(std::vector<std::string> keys)

[[nodiscard]] const std::vector<std::string>& syncKeys() const noexcept

struct ScrollBarStyle 4

float width = 6.0f

float minThumbLen = 20.0f

bool autoHide = true

float fadeDelaySec = 1.5f

struct ScrollConfig 11

bool verticalScroll = true

bool horizontalScroll = false

bool showScrollBar = true

bool showHScrollBar = false

bool bounceEffect = true

bool snapToItem = false

float snapItemHeight = 0.0f

float inertiaDamping = 0.92f

float bounceDamping = 0.6f

float wheelMultiplier = 40.0f

ScrollBarStyle scrollBar

class ScrollContainer 29

explicit ScrollContainer( const sgc::Rectf& viewport = {}, float contentW = 0.0f, float contentH = 0.0f, ScrollConfig config = {}) noexcept

[[nodiscard]] const sgc::Rectf& viewport() const noexcept

void setViewport(const sgc::Rectf& vp) noexcept

[[nodiscard]] float scrollY() const noexcept

[[nodiscard]] float scrollX() const noexcept

[[nodiscard]] float contentHeight() const noexcept

[[nodiscard]] float contentWidth() const noexcept

void setContentHeight(float h) noexcept

void setContentWidth(float w) noexcept

[[nodiscard]] const ScrollConfig& config() const noexcept

void setConfig(const ScrollConfig& cfg) noexcept

[[nodiscard]] float maxScrollY() const noexcept

[[nodiscard]] float maxScrollX() const noexcept

[[nodiscard]] bool canScrollVertically() const noexcept

[[nodiscard]] bool canScrollHorizontally() const noexcept

[[nodiscard]] float normalizedScrollY() const noexcept

[[nodiscard]] bool containsPoint(float x, float y) const noexcept

void setScrollY(float y) noexcept

void setScrollX(float x) noexcept

void scrollToTop() noexcept

void scrollToBottom() noexcept

void ensureVisible(float itemTop, float itemHeight) noexcept

void onMouseWheel(float delta)

void onMouseWheelH(float delta)

void onDragBegin(float screenX, float screenY)

void onDragMove(float screenX, float screenY)

void onDragEnd(float velocityX = 0.0f, float velocityY = 0.0f)

void update(float dt)

void drawScrollBar(render::SpriteBatch& batch) const

enum TextEffect : std::uint8_t 6

None

Typewriter

Instant

Shake

Wave

Fade

struct EffectParams 7

float shakeAmplitude = 2.0f

float shakeFrequency = 30.0f

float waveAmplitude = 3.0f

float waveFrequency = 2.0f

float wavePhaseOffset = 0.3f

float fadeDuration = 0.2f

float revealSpeed = 20.0f

struct CharTransform 5

float offsetX = 0.0f

float offsetY = 0.0f

float alpha = 1.0f

float scale = 1.0f

bool visible = true

struct CharAnimState 3

TextEffect effect = TextEffect::None

float revealTime = 0.0f

bool revealed = false

class TextAnimator 18

TextAnimator() = default

void reset(std::size_t charCount)

void setParams(const EffectParams& params) noexcept

[[nodiscard]] const EffectParams& params() const noexcept

void setRevealMode(TextEffect mode) noexcept

void setPersistentEffect(TextEffect effect) noexcept

void setCharEffect(std::size_t index, TextEffect effect)

void setCharWaitTime(std::size_t index, float waitSeconds)

void setRevealSpeed(float charsPerSecond) noexcept

void update(float dt) noexcept

[[nodiscard]] CharTransform getTransform(std::size_t index) const noexcept

[[nodiscard]] std::vector<CharTransform> getAllTransforms() const

[[nodiscard]] std::size_t revealedCount() const noexcept

[[nodiscard]] std::size_t totalChars() const noexcept

[[nodiscard]] bool isComplete() const noexcept

void revealAll() noexcept

void skipToEnd() noexcept

[[nodiscard]] float elapsed() const noexcept

enum TransitionType 14

Fade

Dissolve

WipeLeft

WipeRight

WipeUp

WipeDown

WipeDiagonal

SlideIn

SlideOut

CurtainOpen

CurtainClose

RuleImage

Pixelate

Ripple

enum TransitionState 3

Idle

Transitioning

Complete

enum WipeDirection 8

Left

Right

Up

Down

DiagonalTopLeft

DiagonalTopRight

DiagonalBottomLeft

DiagonalBottomRight

enum SlideDirection 4

Left

Right

Up

Down

enum RulePattern 6

Circle

Diamond

Blinds

Mosaic

Clock

Random

struct FadeColor 2

[[nodiscard]] static constexpr FadeColor black() noexcept

[[nodiscard]] static constexpr FadeColor white() noexcept

class RuleImageGenerator 1

[[nodiscard]] static std::vector<std::uint8_t> generate( RulePattern pattern, int width, int height) noexcept

struct TransitionEffect 8

std::vector<std::uint8_t> ruleData

void update(float dt) noexcept

[[nodiscard]] float getOverallProgress() const noexcept

[[nodiscard]] bool isComplete() const noexcept

[[nodiscard]] float getBlendFactor(float x, float y) const noexcept

[[nodiscard]] std::pair<float, float> getSlideOffset( float screenWidth, float screenHeight) const noexcept

[[nodiscard]] int getPixelateBlockSize() const noexcept

[[nodiscard]] std::pair<float, float> getRippleOffset( float x, float y) const noexcept

class TransitionBuilder 11

[[nodiscard]] static TransitionEffect fade( float duration, FadeColor color = FadeColor::black()) noexcept

[[nodiscard]] static TransitionEffect dissolve(float duration) noexcept

[[nodiscard]] static TransitionEffect wipe( float duration, WipeDirection direction = WipeDirection::Left) noexcept

[[nodiscard]] static TransitionEffect slideIn( float duration, SlideDirection direction = SlideDirection::Left) noexcept

[[nodiscard]] static TransitionEffect slideOut( float duration, SlideDirection direction = SlideDirection::Left) noexcept

[[nodiscard]] static TransitionEffect curtainOpen(float duration) noexcept

[[nodiscard]] static TransitionEffect curtainClose(float duration) noexcept

[[nodiscard]] static TransitionEffect ruleImage( float duration, RulePattern pattern, int width = 256, int height = 256, float softness = 0.05f) noexcept

[[nodiscard]] static TransitionEffect ruleImageCustom( float duration, std::vector<std::uint8_t> data, int width, int height, float softness = 0.05f)

[[nodiscard]] static TransitionEffect pixelate( float duration, int maxBlockSize = 32) noexcept

[[nodiscard]] static TransitionEffect ripple( float duration, float frequency = 3.0f, float amplitude = 20.0f) noexcept

class TransitionManager 14

using Callback = std::function<void()>;

void startTransition(TransitionEffect effect)

void update(float dt) noexcept

[[nodiscard]] TransitionState state() const noexcept

[[nodiscard]] bool isTransitioning() const noexcept

[[nodiscard]] bool isComplete() const noexcept

[[nodiscard]] const TransitionEffect& currentEffect() const noexcept

[[nodiscard]] float progress() const noexcept

void reset() noexcept

void onTransitionStart(Callback callback)

void onTransitionComplete(Callback callback)

[[nodiscard]] std::string toJson() const

[[nodiscard]] inline std::size_t utf8Length(std::string_view sv) noexcept

[[nodiscard]] inline std::vector<std::uint32_t> utf8ToCodepoints(std::string_view sv)

class Utf8Iterator 4

Utf8Iterator(const char* str, std::size_t len) noexcept

explicit Utf8Iterator(std::string_view sv) noexcept

[[nodiscard]] bool hasNext() const noexcept

[[nodiscard]] std::uint32_t next() noexcept

struct GlyphInfo 9

std::uint32_t codepoint = 0

int width = 0

int height = 0

int offsetX = 0

int offsetY = 0

float advanceX = 0.0f

int atlasX = 0

int atlasY = 0

std::vector<std::uint8_t> bitmap

struct FontMetrics 5

float ascent = 0.0f

float descent = 0.0f

float lineGap = 0.0f

float lineHeight = 0.0f

float pixelSize = 0.0f

class GlyphCache 5

explicit GlyphCache(std::size_t maxSize = 4096)

[[nodiscard]] const GlyphInfo* find(std::uint32_t codepoint, float pixelSize)

void insert(const GlyphInfo& glyph, float pixelSize)

void clear()

[[nodiscard]] std::size_t size() const noexcept

class TrueTypeFont 17

TrueTypeFont() = default

explicit TrueTypeFont(std::vector<std::uint8_t> fontData, std::size_t cacheSize = 4096)

TrueTypeFont(TrueTypeFont&& other) noexcept

TrueTypeFont& operator=(TrueTypeFont&& other) noexcept

TrueTypeFont(const TrueTypeFont&) = delete

TrueTypeFont& operator=(const TrueTypeFont&) = delete

[[nodiscard]] bool valid() const noexcept

void setUserData(void* data) noexcept

template <typename T> [[nodiscard]] T* userData() const noexcept

[[nodiscard]] FontMetrics metrics(float pixelSize) const noexcept

[[nodiscard]] float advanceWidth(std::uint32_t codepoint, float pixelSize) const noexcept

[[nodiscard]] float kerning(std::uint32_t cp1, std::uint32_t cp2, float pixelSize) const noexcept

[[nodiscard]] float measureText(std::string_view text, float pixelSize) const noexcept

[[nodiscard]] const GlyphInfo* getGlyph(std::uint32_t codepoint, float pixelSize)

[[nodiscard]] AtlasResult generateAtlas( float pixelSize, const std::vector<std::uint32_t>& codepoints, int padding = 1)

[[nodiscard]] AtlasResult generateAtlas( float pixelSize, std::string_view text, int padding = 1)

void clearCache()

enum WindowBackgroundType : std::uint8_t 4

Solid

NineSlice

Image

[[nodiscard]] inline sgc::Colorf colorFromHex(std::string_view hex) noexcept

struct Padding 4

float top = 20.0f

float bottom = 20.0f

float left = 30.0f

float right = 30.0f

struct MessageWindowSkin 7

WindowBackgroundType backgroundType = WindowBackgroundType::Solid

std::string backgroundImage

float cornerSize = 16.0f

float alpha = 0.85f

Padding padding

namePlate

waitIcon

struct ElementState 2

float borderWidth = 1.0f

std::string backgroundImage

struct ChoiceButtonSkin 3

ElementState normal

float height = 48.0f

float spacing = 8.0f

struct SaveSlotSkin 4

float thumbnailWidth = 160.0f

float thumbnailHeight = 90.0f

float slotHeight = 120.0f

float spacing = 4.0f

struct ConfigSliderSkin 5

std::string trackImage

std::string fillImage

std::string handleImage

float trackHeight = 6.0f

float handleSize = 20.0f

struct ScrollBarSkin 4

std::string trackImage

std::string thumbImage

float width = 12.0f

float thumbMinHeight = 24.0f

struct FontConfig 8

std::string mainFont

std::string nameFont

std::string choiceFont

std::string systemFont

float mainSize = 24.0f

float nameSize = 20.0f

float choiceSize = 22.0f

float systemSize = 18.0f

struct UISkin 9

std::string name = "Default"

MessageWindowSkin messageWindow

ChoiceButtonSkin choiceButton

SaveSlotSkin saveSlot

ConfigSliderSkin configSlider

ScrollBarSkin scrollBar

FontConfig fonts

TextColorConfig textColors

[[nodiscard]] static UISkin defaultSkin() noexcept

struct SkinValidationResult 3

bool isValid = true

std::vector<std::string> warnings

std::vector<std::string> errors

class UISkinLoader 10

UISkinLoader() noexcept

[[nodiscard]] const UISkin& skin() const noexcept

[[nodiscard]] UISkin loadFromJson(std::string_view json)

[[nodiscard]] UISkin loadFromJson(std::string_view json, const UISkin& baseSkin)

[[nodiscard]] static SkinValidationResult validate(const UISkin& skin)

void setReloadCallback(std::function<void(const UISkin&)> callback)

void setLoadedPath(const std::string& path)

[[nodiscard]] const std::string& lastLoadedPath() const noexcept

void reload(std::string_view json)

[[nodiscard]] static std::string toJson(const UISkin& skin)

struct NineSliceRegion 2

sgc::Rectf srcRect

sgc::Rectf dstRect

class VNRenderer 6

static void drawNineSliceImage(Screen& screen, const render::Texture& texture, const NineSliceConfig& config, const sgc::Rectf& dest, float alpha = 1.0f)

static void drawNineSliceImage(Screen& screen, const render::Texture& texture, float cornerSize, const sgc::Rectf& dest, float alpha = 1.0f)

static void drawMessageWindow(Screen& screen, const MessageWindowConfig& config, const VNTextureManager& texMgr, std::string_view text, std::string_view speaker, std::size_t visibleChars = 0, float indicatorTimer = 0.0f)

static void drawChoiceButton(Screen& screen, const sgc::Rectf& rect, std::string_view text, bool isSelected, const VNTextureManager& texMgr, const ChoiceButtonSkin& skin = {})

static void drawCharacterSprite(Screen& screen, const render::Texture& texture, const sgc::Vec2f& position, float alpha = 1.0f, float scale = 1.0f)

static void drawBacklogEntry(Screen& screen, const sgc::Rectf& rect, std::string_view text, std::string_view speaker, [[maybe_unused]] const VNTextureManager& texMgr, bool hasVoice = false, const sgc::Colorf& textColor = {1.0f, 1.0f, 1.0f, 1.0f}, const sgc::Colorf& speakerColor = {0.6f, 0.8f, 1.0f, 1.0f})

enum ChoiceButtonState : std::uint8_t 4

Normal

Hover

Selected

Disabled

struct TextureLoadResult 4

int loaded = 0

int cached = 0

int failed = 0

std::vector<std::string> failedPaths

class VNTextureManager 21

explicit VNTextureManager(std::string basePath = "")

[[nodiscard]] const std::string& basePath() const noexcept

void setBasePath(std::string path)

TextureLoadResult loadFromSkin(const UISkin& skin)

bool loadTexture(const std::string& path)

[[nodiscard]] bool hasTexture(const std::string& path) const

[[nodiscard]] const render::Texture& getTexture(const std::string& path) const

[[nodiscard]] const render::Texture* tryGetTexture(const std::string& path) const

bool unload(const std::string& path)

void clearAll()

[[nodiscard]] std::size_t cacheSize() const noexcept

[[nodiscard]] const render::Texture* messageWindowTexture() const

[[nodiscard]] const render::Texture* namePlateTexture() const

[[nodiscard]] const render::Texture* waitIconTexture() const

[[nodiscard]] const render::Texture* choiceButtonTexture(ChoiceButtonState state) const

[[nodiscard]] std::vector<std::string> loadedPaths() const

void registerTexture(const std::string& path, render::Texture texture)

[[nodiscard]] inline bool isFullwidthCodepoint(std::uint32_t cp) noexcept

[[nodiscard]] inline bool isVerticalPunctuation(std::uint32_t cp) noexcept

[[nodiscard]] inline bool isSmallKana(std::uint32_t cp) noexcept

inline void getVerticalOffset( std::uint32_t cp, float fontSize, float& outDx, float& outDy, float& outRotation) noexcept

struct VerticalTextConfig 5

float columnSpacing = 40.0f

float lineHeight = 1.5f

bool startFromRight = true

float rubyOffset = 2.0f

bool rotateHalfwidth = true

struct PositionedGlyph 6

std::uint32_t codepoint = 0

float x = 0.0f

float y = 0.0f

std::size_t columnIndex = 0

float rotation = 0.0f

bool isRuby = false

struct VerticalRubySpan 3

std::size_t startIndex = 0

std::size_t length = 0

std::string rubyText

class VerticalTextLayout 4

VerticalTextLayout() = default

[[nodiscard]] std::vector<PositionedGlyph> layout( std::string_view text, TrueTypeFont& font, float areaWidth, float areaHeight, float fontSize, const VerticalTextConfig& config = {}) const

[[nodiscard]] std::vector<PositionedGlyph> layoutWithRuby( std::string_view text, TrueTypeFont& font, float areaWidth, float areaHeight, float fontSize, const std::vector<VerticalRubySpan>& rubySpans, const VerticalTextConfig& config = {}) const

[[nodiscard]] std::size_t estimateColumnCount( std::string_view text, float areaHeight, float fontSize, const VerticalTextConfig& config = {}) const noexcept

Sourced from docs/API_CATALOG.md, auto-generated by tools/generate_api_catalog.py.