This textbook is a comprehensive reference for every single feature available in Plotagon Studio Modded. For example, commands are typed directly into text fields inside the Studio — no external tools, no file editing required. The engine intercepts recognised tokens, strips them from the visible text, and applies the described behaviour to the scene, camera, audio, or on-screen display.
There are two separate command systems, each with its own field and behaviour:
- Effects Commands — typed into a dialogue field. They are converted into
EffectsInstructionobjects on the timeline's Effect track and control post-processing, fades, audio, and timing.- TextPlate Commands — typed into a TextPlate field alongside the display text. They control how the text card looks and behaves on screen.
Both systems are documented in full below.
https://drive.google.com/file/d/1n9aRtwDZKwn87GBAx_ijQ9HzISeQohKZ/view?usp=sharing
(Read the instructions provided on readme.md to get it fully working. Make sure you already have Plotagon Studio Desktop installed for this to work.)
- How to Write an Effects Command
- Visual / Colour Grade Effects
- Fade Effects
- Camera Effects
- Timing Effects
- Audio Effects
- Combining Multiple Effects
- How the Effects Engine Processes Commands
- What is a TextPlate?
- How to Write a TextPlate Command
- Appearance Commands
- Animation Commands
- Timing Commands
- How TextPlate Duration is Calculated
- Combining TextPlate Commands
Effects commands are typed into any dialogue text field in Plotagon Studio. The command always starts with a forward slash /, is written in lowercase (except changeMusicVolume), and where a numeric value is required, the number is placed immediately after the command, separated by a single space.
/commandname
/commandname value
Rules:
- The command name must exactly match one of the recognised slash keywords listed in this section. Unrecognised commands are silently ignored.
- The
valueparameter, when required, must be a valid floating-point number (e.g.0.5,1,0.75). If the value cannot be parsed as a number, the engine falls back silently to1.0. - Commands can be combined in a single dialogue box by separating them with spaces. The engine reads all recognised tokens left-to-right in the same text block and stacks them.
- A dialogue line containing only effects commands will not produce any spoken audio — the character entry becomes a pure effect container on the Effect track.
/blur
/blur /vignette /fadeinb 0.5
These commands toggle a post-processing shader keyword on the scene's global render material. They persist until the next effects instruction resets or replaces them. All visual effects are applied via the Plotagon/PlotagonMobile-GlobalPostRender-CG shader.
Shader keyword triggered: PreviewBlit reset path
Parameters: None
Resets the post-processing material back to its default, unfiltered state. All previously enabled visual filters — colour grades, blur, bloom, and so on — are cleared in a single call. Think of this as the "undo all filters" command. Internally it calls PreviewRenderer.Instance.ResetPostprocessingMaterial(), which disables every toggle keyword on the shader and also resets animation speed and camera FOV factor to their defaults.
When to use it: Place a /normal instruction at any point in your story where you want to return to a clean, unprocessed look. For instance, after a dream sequence that used /blur and /retro, you would add /normal at the start of the next scene to strip those filters away entirely.
Typical usage:
/normal
What it resets:
- Vignette → OFF
- BlackAndWhite → OFF
- Sepia → OFF
- Bloom → OFF
- Seventies → OFF
- Blur → OFF
- Animation speed → 1.0
- Camera FOV factor → 1.0
Shader keyword triggered: BlackAndWhite_ON
Parameters: None
Converts the entire rendered frame to greyscale by enabling the BlackAndWhite shader keyword. The colour grade is applied in the post-processing pass so everything on screen — characters, backgrounds, and lighting — is desaturated uniformly.
When to use it: Use for flashbacks, memories, historical sequences, or any moment intended to feel from the past. Pair with /vignette for a classic silent-film aesthetic, or layer it with /blur to simulate a hazy, faded memory.
Typical usage:
/old
Combined example (black-and-white with vignette):
/old /vignette
Shader keyword triggered: Sepia_ON
Parameters: None
Applies a warm sepia colour grade to the entire frame. Rather than full desaturation like /old, sepia tones the image toward amber and brown, evoking early photography, aged film stock, or antique prints.
When to use it: Great for nostalgic scenes, early 20th-century settings, or old photographs and home-movie aesthetics. Combining /retro with /vignette creates a very convincing aged-photo look. Pair with /fadeinb for an opening that emerges from the past.
Typical usage:
/retro
Shader keyword triggered: Vignette_ON
Parameters: None
Renders a darkened oval vignette around the edges of the screen, drawing the viewer's eye toward the centre of the frame. The vignette texture is loaded at runtime from Resources/ScreenEffects/Vignette/Vignette.
When to use it: Useful in almost any cinematic scene — it adds production value and depth with minimal visual cost. Particularly effective alongside colour grades like /old or /retro. Also works well during intense or dramatic dialogue to increase focus on the characters and strip attention from the scene edges.
Typical usage:
/vignette
Shader keyword triggered: Bloom_ON
Parameters: None
Activates a bloom (glow) post-processing effect that causes bright areas of the frame to bleed light outward. Highlights, windows, light sources, and bright character costumes will all emit a soft luminous halo.
When to use it: Perfect for dream sequences, fantasy scenes, outdoor daylight shots, or any moment you want to feel soft, otherworldly, or magical. Can also produce a "glowing" or overexposed look in high-energy scenes. Combining /bloom with /vignette creates a distinctive look that is bright at the centre and darkly vignette at the edges.
Typical usage:
/bloom
Shader keyword triggered: Blur_ON
Parameters: None
Applies a full-screen blur filter to the rendered output. The entire frame — foreground and background — is blurred uniformly by the post-processing pass.
When to use it: Useful for transitions, confusion, drunkenness, dreams, or any moment where you want the viewer to feel disoriented or removed from reality. Because the blur affects the whole frame equally, it works best as a transitional state or for a short, purposeful scene rather than a backdrop for sustained readable dialogue.
Typical usage:
/blur
Shader keyword triggered: Sevents_ON; also sets the _Overlay shader texture to the vignette image
Parameters: None
Activates a retro 1970s-style colour grade. Like /vignette, this command also loads the vignette overlay texture into the _Overlay shader property, combining a warm, period-specific colour shift with a subtle darkened-edge overlay as part of the same single effect pass.
When to use it: Use for scenes set in or referencing the 1970s, or for any warm, filmic, slightly faded retro aesthetic. Distinct from /retro in that it targets the specific tonal signature of 1970s film stock — warmer, more saturated and gritty — rather than the desaturated amber of early photography.
Typical usage:
/seventies
Fade effects animate a transition between the current scene and a solid colour or a stylised visual effect (pixelation, blur), over a period of time. The duration of the fade is expressed as a normalised value between 0.0 and 1.0, representing a fraction of the host instruction's total play length. For example, on an instruction that is 4 seconds long, a value of 0.5 means the fade animation occupies 2 seconds.
The fade animation is handled by a coroutine (FadeToColorCoroutine) which drives the _Fade shader property from 1.0 (fully visible scene) toward 0.0 (fully covered) for fade-outs, or from 0.0 to 1.0 for fade-ins.
Tip: All fade commands take a single
valueparameter. The table below applies to all of them.
| Value | Meaning |
|---|---|
0.0 |
Instantaneous cut — no gradual animation, the transition happens at once |
0.5 |
Fade occupies exactly 50% of the instruction's total duration |
1.0 |
Fade occupies the full instruction duration (default fallback if value is omitted or unparseable) |
Shader keywords: Fade_ON, colour set to Color.black, _Fade starts at 0.0
Parameters: value — normalised fade duration (0.0–1.0)
Fades in from black. The screen starts fully black and gradually reveals the scene over the specified fraction of the instruction's duration. This is the most standard and universally understood cinematic fade-in, almost always used when opening a new scene from darkness or beginning a film.
Typical usage:
/fadeinb 0.5
Fades in from black over 50% of the instruction's play time.
Shader keywords: Fade_ON, colour set to Color.white, _Fade starts at 0.0
Parameters: value — normalised fade duration (0.0–1.0)
Fades in from white. The screen begins fully white and gradually reveals the scene. The white fade-in is often used for dream sequences, heavenly or spiritual moments, near-death recoveries, or any scene meant to feel ethereal, blinding, or transcendent.
Typical usage:
/fadeinw 0.3
Shader keywords: Fade_ON, colour set to Color.black
Parameters: value — normalised fade duration (0.0–1.0)
Fades out to black. The scene gradually darkens until the screen is completely black. This is the standard scene-ending transition in filmmaking and is the most universally understood way to signal the close of a sequence, passage of time, or end of a chapter.
Typical usage:
/fadeoutb 0.5
Shader keywords: Fade_ON, colour set to Color.white
Parameters: value — normalised fade duration (0.0–1.0)
Fades out to white. The scene brightens progressively until the screen is completely white. Use this for dramatic, overexposed endings — the moment before an explosion, a near-death experience, a divine vision, or a dream dissolving into waking life.
Typical usage:
/fadeoutw 0.4
Shader keywords: FadeP_ON, _PixelSizeFar set to 100.0, _Fade starts at 0.0
Parameters: value — normalised fade duration (0.0–1.0)
Fades in using a pixelation / mosaic transition. The scene begins as a heavily pixelated mosaic of large square blocks and gradually resolves into the full-resolution image as the fade progresses. The _PixelSizeFar property controls the initial pixel block size, which the engine sets to 100.
When to use it: Great for retro or video-game-themed scenes, digital/hacking aesthetics, glitch art transitions, or any technically-styled reveal. Also works as a stylised alternative to the standard black fade-in.
Typical usage:
/fadeinp 0.6
Shader keywords: FadeP_ON, _PixelSizeFar set to 100.0
Parameters: value — normalised fade duration (0.0–1.0)
Fades out using a pixelation / mosaic transition. The scene progressively breaks apart into increasingly large pixel blocks before cutting away entirely. This is the direct visual reverse of /fadeinp.
Typical usage:
/fadeoutp 0.5
Shader keywords: FadeBl_ON, _Fade starts at 0.0
Parameters: value — normalised fade duration (0.0–1.0)
Fades in using a blur transition. The scene starts as a heavily blurred, unrecognisable smear and gradually comes into sharp focus as the fade completes. Unlike the pixelation fades, this produces a soft, organic, camera-focus feel.
When to use it: Use for waking-up scenes, coming-into-consciousness moments, the start of a dream, or any sequence meant to feel like eyes adjusting to light. The gradual focusing effect is very cinematic and feels natural to audiences because it mirrors how real cameras (and eyes) physically focus.
Typical usage:
/fadeinbl 0.4
Shader keywords: FadeBl_ON
Parameters: value — normalised fade duration (0.0–1.0)
Fades out using a blur transition. The scene gradually blurs until it is entirely unrecognisable. The visual reverse of /fadeinbl. Useful for closing a dream, passing out, a memory dissolving, or consciousness fading away.
Typical usage:
/fadeoutbl 0.5
Internal property: CameraExtension.FOVFactor
Parameters: value — FOV multiplier, clamped between 0.5 and 1.5
Adjusts the Field of View of the preview camera by applying a multiplier to its base FOV angle. The value is hard-clamped by the engine between 0.5 (maximum zoom-in) and 1.5 (maximum zoom-out). Values outside this range are silently brought to the nearest boundary.
| Value | Visual Effect |
|---|---|
0.5 |
Maximum zoom-in — tight telephoto compression, characters appear large and backgrounds compressed |
0.75 |
Moderate zoom-in — intimate, cinematic close-up feel |
1.0 |
Default — no change to the camera's base FOV |
1.25 |
Moderate zoom-out — more environment and context visible around characters |
1.5 |
Maximum zoom-out — wide, expansive view; can feel slightly fish-eye depending on the scene |
When to use it: A value below 1.0 creates a cinematic, intimate feel — great for intense dialogue, confrontation, or moments of high emotional weight where the viewer should feel close to the characters. A value above 1.0 opens up the scene, showing more of the environment, which is useful for establishing context, comedic spatial exaggeration, or letting a large set breathe.
Typical usage:
/setfov 0.75
Tightens the FOV moderately for a dramatic close-up feel without going to an extreme telephoto.
/setfov 1.5
Maximally widens the FOV to reveal as much of the scene environment as possible.
Note:
/normalresetsCameraExtension.FOVFactorback to1.0. If you need to hold a custom FOV across multiple instructions, you must re-apply/setfovin each subsequent effects block.
Internal behaviour: Sets instruction.StartTime on the next playable instruction in the timeline
Parameters: value — normalised start offset, clamped between 0.0 and 1.0
This is one of the more advanced commands. It offsets the playback start position of the very next instruction in the timeline — specifically the instruction that immediately follows this effects block. Rather than the next instruction playing from its very beginning, the engine skips into it by the specified normalised fraction of its total duration before beginning playback.
| Value | Meaning |
|---|---|
0.0 |
Next instruction plays from the very beginning — this is the default with no /setstarttime command |
0.3 |
Next instruction begins from 30% of the way through its total length |
0.5 |
Next instruction begins from its exact halfway point |
1.0 |
Next instruction is almost entirely skipped — begins at its very end |
When to use it: Useful for cutting into a long dialogue line mid-sentence for a tight edit, skipping into an action instruction partway through an animation cycle, or fine-tuning timing when two consecutive scenes need to feel tightly joined without silence or slow build-up at the start.
How cleanup works: The engine resets the offset automatically. When the EffectsInstruction containing this command is destroyed (e.g. when the manuscript is unloaded or the instruction is deleted), OnDestroyed() fires and sets nextInstruction.StartTime back to 0.0. This prevents the start-time offset from persisting unexpectedly if the effects block is later removed from the timeline.
Typical usage:
/setstarttime 0.3
The instruction immediately after this effects block will skip its first 30% and begin playback from 30% of the way through.
Internal behaviour: Recorded as a timed volume change event, smoothly interpolated by MusicVolumeController with a 500 ms transition
Parameters: value — target volume level, clamped between 0.0 and 1.0
Changes the playback volume of the currently active music track at the moment this effects instruction is reached during playback. The change is not instantaneous — the MusicVolumeController performs a smooth linear interpolation (lerp) over 500 milliseconds by default, fading from the current volume to the target volume gradually so the transition is never jarring.
| Value | Meaning |
|---|---|
0.0 |
Complete silence — music is fully muted |
0.1–0.3 |
Very quiet background — barely audible, good underneath important dialogue |
0.4 |
Default music volume as set by the music instruction |
0.7–0.9 |
Prominently audible but not overpowering |
1.0 |
Maximum volume |
How it works under the hood: The Manuscript.GatherAudioVolumeInstructions() method scans the entire timeline before playback begins, collecting all ChangeMusicVolume effect events along with their timestamps. These are stored as [timestampMS, targetVolume] pairs and handed to MusicVolumeController as a pre-sorted schedule. Because the volume schedule is assembled up-front, the controller is always aware of upcoming transitions and can execute them exactly on time without needing to scan the timeline during playback.
When to use it:
- Quieten the music during an important dialogue line so the words stand out clearly:
/changeMusicVolume 0.1 - Bring music back up to normal after a quiet exchange:
/changeMusicVolume 0.4 - Completely mute background music for a tense, silent, pressurised scene:
/changeMusicVolume 0.0 - Swell the music to full volume for a dramatic reveal or action climax:
/changeMusicVolume 1.0
Typical usage:
/changeMusicVolume 0.2
Smoothly fades the music down to 20% volume over approximately 500 ms.
/changeMusicVolume 1.0
Smoothly fades the music back up to full volume over approximately 500 ms.
Important: This command requires a
MusicInstructionto already be active in the timeline. If no music is playing when this command is reached, it has no audible effect. Always ensure your music instruction precedes the effects instruction that changes its volume.
Multiple effects commands can coexist in the same dialogue text box, separated by spaces. The engine reads every recognised token from left to right and applies all of them to the same EffectsInstruction. The internal order of operations is:
- The engine first calls
ResetPostprocessingMaterial()— clearing all previously active shader keywords across the board. - It then iterates over every effect token in order and enables the relevant shader keywords one by one.
This means each effects instruction defines a complete, standalone state rather than layering on top of what came before. You cannot add /blur on top of an existing /vignette by writing only /blur in a new effects block. You must write both together every time you want both active simultaneously.
/fadeinb 0.4 /vignette /bloom
Scene fades in from black over 40% of its duration, with vignette and bloom both active for a moody, cinematic, glowing-centre look.
/blur /bloom /retro
(Start of dream — blurry, softly glowing, sepia-toned)
/fadeoutp 0.6 /blur /retro
(End of dream — pixelates out over 60% of instruction time while still blurred and sepia-toned)
/normal
(Return to reality — all filters cleared in one step)
/vignette /changeMusicVolume 0.1
Applies vignette for cinematic focus while ducking the music to 10% so spoken dialogue is clearly audible.
/setfov 0.6 /old /vignette
Tight telephoto compression with black-and-white grade and vignette. Perfect for a surveillance-camera or security-footage aesthetic, an interrogation scene, or a paranoid point-of-view shot.
Understanding the full pipeline helps you predict exactly how and when effects appear on screen:
-
Text entry. You type a slash command into a dialogue field and save or update the instruction.
-
ReplaceBlitShader.OnPostManuscriptUpdated()fires. This subscriber listens for anydialoguetype manuscript update. It reads the instruction's text content, splits it by spaces, and checks each resulting token against theoptimizedLookuplist of recognised commands. -
Effect objects are assembled. Each matched command becomes a
JObjectwithEffectNameandEffectValuefields. All matched effects from a single text box are collected into aJArraycalledeffectsName, ordered by their left-to-right position in the original text. -
The instruction type is changed. The original
dialogueinstruction's JSONtypefield is promoted to"effect", and the assembled effects array is embedded in its parameters. This transformed instruction is fed back into the manuscript queue viaAddRelevantEffectsInstruction(). -
Track placement. The instruction is placed on the dedicated Effect sub-track of the timeline, not the Dialogue track. It therefore has no audio output and does not participate in lipsync.
-
Runtime execution. When the playhead reaches the effect instruction during playback,
EffectsInstruction.PlayEffects()is called. This callsUpdateShaderKeywords(), which first resets all shader keywords and then enables the relevant ones. Fade effects additionally start aFadeToColorCoroutinethat drives the_Fadeshader parameter smoothly over time.
A TextPlate is an on-screen text card that appears overlaid on the rendered scene, similar to a title card, subtitle, or intertitle in film. It renders as a rectangular panel with a background colour and text rendered on top. TextPlates are their own instruction type (TextPlateInstruction) and sit on the TextPlate sub-track of the timeline.
TextPlate commands are not the same as effects commands. They are parsed directly by the TextPlateInstruction class during its InitializeParameters() call and control the visual appearance and timing of the text card itself. They are removed from the displayed text before it is shown on screen.
TextPlates can optionally be voiced — if a character is assigned to the TextPlate, the engine will request TTS (text-to-speech) audio for the text content, and the plate's duration will be driven by the length of that audio. If no character is assigned (a "silent" TextPlate), duration is either calculated from text length or overridden manually with /settime.
TextPlate commands are typed inside the TextPlate text field, mixed in with the display text. Commands are stripped from the visible output — only the non-command words remain as the displayed text.
Your displayed text here /commandname
Your displayed text here /commandname value
Unlike effects commands, TextPlate commands appear in the same string as the actual display text. The command parser extracts them using regex patterns and string matching, leaving only the clean text for display.
In a land far away... /transparent 0.5 /textColor #ffffff
The displayed text will be In a land far away.... The background will be 50% transparent, and the text colour will be white.
Internal property: textColor (type: Color)
Parameters: A 6-digit or 3-digit HTML hex colour code (with or without #), OR the literal word black
Sets the colour of the text characters on the TextPlate. The default text colour is white (Color.white). The engine accepts standard HTML hex colour notation and uses Unity's ColorUtility.TryParseHtmlString() to parse it, meaning the full range of web colours is supported.
The engine also supports the shorthand special case /textColor black for setting text to pure black without needing to type a hex code, which is useful for light-coloured or transparent backgrounds where the default white text would be invisible.
Accepted hex formats:
/textColor #FF5500— full 6-digit hex with hash/textColor FF5500— full 6-digit hex without hash (the engine adds#automatically)/textColor #F50— 3-digit shorthand hex with hash/textColor black— special keyword for pure black
When to use it: Use a dark text colour on light or transparent backgrounds, use a coloured text for stylistic title cards, or use white (the default) when your background is dark. Choosing high-contrast text-to-background combinations ensures readability.
Typical usage:
Chapter One: The Beginning /textColor #222222
Displays Chapter One: The Beginning in very dark charcoal text.
WARNING /textColor #FF0000
Displays WARNING in red text.
A new day dawns /textColor black
Displays A new day dawns in pure black text.
Internal property: backgroundColor (type: Color)
Parameters: A 6-digit or 3-digit HTML hex colour code (with or without #)
Sets the fill colour of the TextPlate's background panel. The default background colour is black (Color.black). Like /textColor, the engine uses ColorUtility.TryParseHtmlString() to parse the hex code, and the # prefix is added automatically if not provided.
The background colour's alpha (opacity) is not set by this command — it is controlled separately by /transparent. When used together, /backgroundColor sets the hue and /transparent sets how see-through the panel is.
Accepted hex formats:
/backgroundColor #1A1A2E— deep navy background/backgroundColor 1A1A2E— same without hash/backgroundColor #FFF— white background via 3-digit shorthand
When to use it: Change the background from the default black to create coloured title cards — for example a red emergency alert, a blue information panel, a white card for a clean modern look, or a scene-specific colour that matches the mood or branding of your story.
Typical usage:
ALERT: Evacuate immediately /backgroundColor #8B0000 /textColor #FFFFFF
Deep red background with white text — classic emergency or warning aesthetic.
Day 1 /backgroundColor #001F3F /textColor #7FDBFF
Dark navy background with light blue text — calm, cinematic title card.
Internal property: transparency (type: float)
Parameters: value — transparency level from 0.0 (fully opaque) to 1.0 (fully invisible background)
Controls the opacity of the TextPlate background panel. The value represents how transparent (see-through) the background is, where 0.0 means the background is completely solid and 1.0 means the background is completely invisible, leaving only the floating text visible against the scene.
Internally, the value is applied as finalColor.a = 1f - transparency — meaning the alpha of the background image component is the inverse of the transparency value. This means:
/transparent value |
Resulting background alpha | Visual result |
|---|---|---|
0.0 |
1.0 (fully opaque) | Solid background panel — scene completely hidden behind plate |
0.25 |
0.75 | Mostly opaque, slight scene bleed-through |
0.5 |
0.5 | Semi-transparent — scene and background colour equally blended |
0.75 |
0.25 | Mostly transparent — background colour is a faint tint only |
1.0 |
0.0 (fully invisible) | Background completely invisible — text floats directly over the scene |
When to use it: Use a value of 1.0 for floating subtitle-style text with no backing panel. Use 0.5 for a translucent cinematic title card that lets the scene show through. Use 0.0 (or simply omit the command) for a fully solid opaque card that blocks the scene entirely.
Typical usage:
The city never sleeps. /transparent 0.7
Text appears to float over the scene with only a very faint dark backing.
CHAPTER FIVE /transparent 0.0
Fully opaque black panel — the scene is completely covered.
[Translated subtitle text] /transparent 1.0
No background panel at all — pure floating text over the live scene, like a subtitle.
Internal property: animated (type: bool, default false)
Parameters: None
Enables a scrolling credits-style animation on the TextPlate. Instead of the text card appearing statically in the centre of the screen, the text begins below the visible frame and scrolls upward continuously, like end credits rolling at the conclusion of a film.
How the animation works: The AnimateText() coroutine runs each frame and increments the TextPlate's vertical position by a calculated interval value. The interval is derived from the panel's total height divided by a constant MOVEMENT_STEPS value of 550, multiplied by AnimationManager.Instance.Speed to respect global playback speed settings. The text begins at a position below the bottom of the frame — specifically starting at a Y offset of -(rectTransform.rect.height) - (lineCount * fontSize / FONT_SCALE_FACTOR) — so the very first line is not yet visible when the animation begins, and it scrolls all the way up until the last line has cleared the top of the frame.
Duration when /animated is used: The instruction's play length is automatically calculated to match exactly how long it takes for the full text to scroll from its starting position off the bottom to completely clearing the top — so the TextPlate stays active for exactly as long as the scroll takes, no more and no less. You do not need /settime when using /animated, though /settime will override this if both are present.
When to use it: Use for end credits, cast lists, lengthy intertitles that would not fit on screen at once, long narrative title cards at the beginning of a story, or any moment where scrolling text is more appropriate than a static card.
Note: When
/animatedis active, the TextPlate does not respect the standard static layout. Text alignment settings still apply left/right/centre, but vertical positioning is driven entirely by the scroll animation.
Typical usage:
Directed by: Jane Smith\nProduced by: John Doe\nMusic by: Alex Ray /animated
The entire credit block scrolls upward from below the frame at a smooth, continuous pace.
Internal property: userDuration (type: float, default -1)
Parameters: value — display duration in seconds (a positive floating-point number)
Manually overrides the total display duration of the TextPlate to a fixed number of seconds. This takes the highest priority in the duration calculation — if /settime is present and its value is successfully parsed as a positive number, neither TTS audio length, text-length estimation, nor scroll animation timing will be used. The TextPlate will be visible on screen for exactly the specified number of seconds.
If /settime is not present, or if its value cannot be parsed as a number, userDuration remains at its default of -1, and the engine falls through to automatic duration calculation (see the next section for details).
Important distinction: Unlike fade
valueparameters in Effects Commands, which are normalised fractions of instruction length,/settime's value is an absolute duration in real seconds.5.0means exactly five seconds regardless of anything else.
When to use it: Use whenever you need precise, predictable timing for a TextPlate — for example, a dramatic one-word title card that should appear for exactly 3 seconds, a synchronised caption timed to match a specific audio cue, or a sequence of title cards with uniform equal timing. Without /settime, silent TextPlate duration is estimated from text length, which may not match your intended pacing.
Typical usage:
TO BE CONTINUED /settime 3.0
The "TO BE CONTINUED" card remains on screen for exactly 3 seconds.
Based on a true story. /settime 5.5
Holds for 5.5 seconds.
In memory of /settime 4.0
Short, reverent hold of exactly 4 seconds.
When /settime is not used, the TextPlate's display duration is calculated automatically using one of three methods, applied in this priority order:
If the TextPlate has a character assigned and TTS audio has been successfully generated for the text, the duration is set to the length of the generated audio clip plus a small lip-sync fade-out buffer (LipSyncData.LipFadeOutTime). This ensures the TextPlate disappears shortly after the last word finishes being spoken.
If the TextPlate uses /animated and is silent (no character assigned), the duration is calculated geometrically from the full scroll distance divided by the per-frame movement rate at 30 fps. This makes the TextPlate last exactly long enough for all text to scroll completely across the frame.
If there is no TTS audio and no /animated flag, the engine estimates duration from the number of characters in the text using a decaying exponential formula:
timePerCharacter = MAX (MAX_TIME_PER_CHARACTER × e^(-textLength × DECAY), MIN_TIME_PER_CHARACTER)
presentationTimeMS = timePerCharacter × textLength × 1000
Where:
MAX_TIME_PER_CHARACTER= 0.1 secondsMIN_TIME_PER_CHARACTER= 0.05 secondsTIME_PER_CHARACTER_DECAY= 0.001
This means short texts get more time per character (up to 0.1s each), while very long texts decay toward a minimum of 0.05s per character, preventing extremely long plates from lasting an unreasonable amount of time. For reliable, predictable timing, always use /settime for silent TextPlates.
All TextPlate commands can be combined freely in a single text field. The order they appear in the text string does not matter — commands are extracted by the parser regardless of position. However, it is good practice to place commands at the end of the text string, after the display text, to keep the content readable in the editor.
She never looked back. /transparent 1.0 /textColor #EEEEEE /settime 3.0
Pure floating near-white text, no background panel, held for exactly 3 seconds.
CHAPTER THREE: THE RECKONING /backgroundColor #1A0000 /textColor #FF4444 /settime 4.0
Deep blood-red background, bright red text, held for 4 seconds — dramatic and ominous.
The names of the fallen shall be remembered forever. /animated /transparent 0.4 /textColor #F0E6C8
Warm parchment-coloured text scrolls upward over a semi-transparent dark backing.
The End /backgroundColor #FFFFFF /textColor black /settime 5.0
Clean white background, black text, held for 5 seconds — classic minimalist ending.
Every time an EffectsInstruction plays, it first calls ResetPostprocessingMaterial(), clearing all previously active shader keywords. It then applies only the effects listed in that specific instruction. If you want a visual filter to persist across multiple instructions, you must explicitly include it in every subsequent effects block.
Wrong (vignette vanishes at the second effects instruction):
Instruction 1: /vignette /blur
Instruction 2: /fadeinb 0.5
Right (vignette persists across both):
Instruction 1: /vignette /blur
Instruction 2: /vignette /fadeinb 0.5
/normal does not only clear visual filters. It also resets CameraExtension.FOVFactor to 1.0 and AnimationManager.Instance.Speed to 1.0. If you have used /setfov to set a custom field of view and later write a /normal instruction, your custom FOV will be lost. Re-apply /setfov after any /normal if you need to maintain a non-default FOV.
Fade duration values (used in /fadeinb, /fadeoutb, and all other fade commands) are not in seconds. They are fractions of the host instruction's total play time. A value of 0.5 on a 4-second instruction produces a 2-second fade. The same 0.5 on a 1-second instruction produces a 0.5-second fade. Plan your instruction durations when timing fades, and remember that /settime in a TextPlate uses real seconds — a different system entirely.
The MusicVolumeController can only modify a music source that is already playing. If no MusicInstruction is active in the timeline when /changeMusicVolume fires, the command silently does nothing. Always ensure your music instruction appears before the effects block that tries to change its volume.
If you mistype a command (e.g. /Blur with a capital B, /fade_in_black with underscores instead of letters, or /changeMusicvolume with a lowercase v), the engine will not display any error. It simply will not match the token and the effect will not be applied. Always verify exact spelling and case. /changeMusicVolume is the only command with an uppercase letter.
The engine reads the token directly after the command keyword as its value. If you place another command between a value-taking command and its number, the intermediate command string will be parsed as the value, fail to parse as a float, and fall back to 1.0 — and the number you intended as the value will be ignored.
Wrong:
/fadeinb /vignette 0.5
The engine tries to parse /vignette as the value for fadeinb, fails, and defaults to 1.0. The 0.5 is left over and ignored.
Right:
/fadeinb 0.5 /vignette
The engine reads 0.5 as the value for fadeinb, then reads /vignette as a separate standalone command.
TextPlate-specific commands like /transparent, /textColor, /backgroundColor, /animated, and /settime are parsed by TextPlateInstruction only. If you type them into a regular dialogue field, the dialogue system does not recognise them — and if those tokens happen to not match any effects keywords either, they will simply appear as literal text spoken or displayed by the character. Keep the two command systems in their respective fields.
If you use both /animated and /settime in the same TextPlate, /settime wins. The scroll animation will run, but the instruction's duration will be the fixed time you specified, not the automatically-calculated scroll completion time. If your /settime value is shorter than the scroll duration, the TextPlate will disappear before the credits have finished scrolling. If it is longer, the scroll will finish and the plate will remain stationary (empty) until the fixed time expires.
This document was generated from the Plotagon Studio Modded source code, covering EffectsInstruction.cs, ReplaceBlitShader.cs, PreviewRenderer.cs, MusicVolumeController.cs, TextPlateInstruction.cs, and related files.
(most of these are the backup system being launched in real time)
Does this mod only support English voices?
Cheers, Daniel